XamarinFormsXamlRenderer.cs

using SkiaSharp;
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content.Emoji;
using Waher.Content.Markdown.Model;
using Waher.Content.Markdown.Model.BlockElements;
using Waher.Content.Markdown.Model.SpanElements;
using Waher.Content.Markdown.Rendering;
using Waher.Events;
using Waher.Runtime.Collections;
using Waher.Script;
using Waher.Script.Graphs;
using Waher.Script.Operators.Matrices;
 
namespace Waher.Content.Markdown.Xamarin
{
    public class XamarinFormsXamlRenderer : Renderer
    {
        public readonly XmlWriter XmlOutput;
 
        public readonly XamlSettings XamlSettings;
 
        public TextAlignment Alignment = TextAlignment.Left;
 
        public bool Bold = false;
 
        public bool Italic = false;
 
        public bool StrikeThrough = false;
 
        public bool Underline = false;
 
        public bool Superscript = false;
 
        public bool Subscript = false;
 
        public bool Code = false;
 
        public bool InLabel = false;
 
        public string Hyperlink = null;
 
        public XamarinFormsXamlRenderer(XmlWriterSettings XmlSettings, XamlSettings XamlSettings)
            : base()
        {
            this.XamlSettings = XamlSettings;
            this.XmlOutput = XmlWriter.Create(this.Output, XmlSettings);
        }
 
        public XamarinFormsXamlRenderer(StringBuilder Output, XmlWriterSettings XmlSettings, XamlSettings XamlSettings)
            : base(Output)
        {
            this.XamlSettings = XamlSettings;
            this.XmlOutput = XmlWriter.Create(this.Output, XmlSettings);
        }
 
        public override void Dispose()
        {
            base.Dispose();
 
            this.XmlOutput.Dispose();
        }
 
        public override Task RenderDocument(MarkdownDocument Document, bool Inclusion)
        {
            this.Alignment = TextAlignment.Left;
            this.Bold = false;
            this.Italic = false;
            this.StrikeThrough = false;
            this.Underline = false;
            this.Superscript = false;
            this.Subscript = false;
            this.Code = false;
            this.InLabel = false;
            this.Hyperlink = null;
 
            return base.RenderDocument(Document, Inclusion);
        }
 
        public override Task RenderDocumentHeader()
        {
            this.XmlOutput.WriteStartElement("StackLayout", "http://xamarin.com/schemas/2014/forms");
            this.XmlOutput.WriteAttributeString("xmlns", "x", null, "http://schemas.microsoft.com/winfx/2009/xaml");
            this.XmlOutput.WriteAttributeString("Spacing", "0");
 
            return Task.CompletedTask;
        }
 
        public override async Task RenderFootnotes()
        {
            Footnote Footnote;
            string FootnoteMargin = "0," + this.XamlSettings.ParagraphMarginTop.ToString() + "," +
                this.XamlSettings.FootnoteSeparator.ToString() + "," +
                this.XamlSettings.ParagraphMarginBottom.ToString();
            string Scale = CommonTypes.Encode(this.XamlSettings.SuperscriptScale);
            string Offset = this.XamlSettings.SuperscriptOffset.ToString();
            int Nr;
            int Row = 0;
 
            this.XmlOutput.WriteStartElement("BoxView");
            this.XmlOutput.WriteAttributeString("HeightRequest", "1");
            this.XmlOutput.WriteAttributeString("BackgroundColor", this.XamlSettings.TableCellBorderColor);
            this.XmlOutput.WriteAttributeString("HorizontalOptions", "FillAndExpand");
            this.XmlOutput.WriteAttributeString("Margin", this.XamlSettings.ParagraphMargins);
            this.XmlOutput.WriteEndElement();
 
            this.XmlOutput.WriteStartElement("Grid");
            this.XmlOutput.WriteAttributeString("RowSpacing", "0");
            this.XmlOutput.WriteAttributeString("ColumnSpacing", "0");
 
            this.XmlOutput.WriteStartElement("Grid.ColumnDefinitions");
 
            this.XmlOutput.WriteStartElement("ColumnDefinition");
            this.XmlOutput.WriteAttributeString("Width", "Auto");
            this.XmlOutput.WriteEndElement();
 
            this.XmlOutput.WriteStartElement("ColumnDefinition");
            this.XmlOutput.WriteAttributeString("Width", "*");
            this.XmlOutput.WriteEndElement();
 
            this.XmlOutput.WriteEndElement();
            this.XmlOutput.WriteStartElement("Grid.RowDefinitions");
 
            foreach (string Key in this.Document.FootnoteOrder)
            {
                if ((this.Document?.TryGetFootnoteNumber(Key, out Nr) ?? false) &&
                    (this.Document?.TryGetFootnote(Key, out Footnote) ?? false) &&
                    Footnote.Referenced)
                {
                    this.XmlOutput.WriteStartElement("RowDefinition");
                    this.XmlOutput.WriteAttributeString("Height", "Auto");
                    this.XmlOutput.WriteEndElement();
                }
            }
 
            this.XmlOutput.WriteEndElement();
 
            foreach (string Key in this.Document.FootnoteOrder)
            {
                if ((this.Document?.TryGetFootnoteNumber(Key, out Nr) ?? false) &&
                    (this.Document?.TryGetFootnote(Key, out Footnote) ?? false) &&
                    Footnote.Referenced)
                {
                    this.XmlOutput.WriteStartElement("ContentView");
                    this.XmlOutput.WriteAttributeString("Margin", FootnoteMargin);
                    this.XmlOutput.WriteAttributeString("Grid.Column", "0");
                    this.XmlOutput.WriteAttributeString("Grid.Row", Row.ToString());
                    this.XmlOutput.WriteAttributeString("Scale", Scale);
                    this.XmlOutput.WriteAttributeString("TranslationY", Offset);
 
                    this.XmlOutput.WriteStartElement("Label");
                    this.XmlOutput.WriteAttributeString("Text", Nr.ToString());
                    this.XmlOutput.WriteEndElement();
                    this.XmlOutput.WriteEndElement();
 
                    this.XmlOutput.WriteStartElement("ContentView");
                    this.XmlOutput.WriteAttributeString("Grid.Column", "1");
                    this.XmlOutput.WriteAttributeString("Grid.Row", Row.ToString());
                    await Footnote.Render(this);
                    this.XmlOutput.WriteEndElement();
 
                    Row++;
                }
            }
 
            this.XmlOutput.WriteEndElement();
        }
 
        public override Task RenderDocumentFooter()
        {
            this.XmlOutput.WriteEndElement();
            this.XmlOutput.Flush();
 
            return Task.CompletedTask;
        }
 
        #region Span Elements
 
        public override Task Render(Abbreviation Element)
        {
            return this.RenderChildren(Element);
        }
 
        public override Task Render(AutomaticLinkMail Element)
        {
            string Bak = this.Hyperlink;
            this.Hyperlink = "mailto:" + Element.EMail;
            this.RenderSpan(this.Hyperlink);
            this.Hyperlink = Bak;
 
            return Task.CompletedTask;
        }
 
        public override Task Render(AutomaticLinkUrl Element)
        {
            string Bak = this.Hyperlink;
            this.Hyperlink = Element.URL;
            this.RenderSpan(Element.URL);
            this.Hyperlink = Bak;
 
            return Task.CompletedTask;
        }
 
        public override async Task Render(Delete Element)
        {
            bool Bak = this.StrikeThrough;
            this.StrikeThrough = true;
 
            await this.RenderChildren(Element);
 
            this.StrikeThrough = Bak;
        }
 
        public override Task Render(DetailsReference Element)
        {
            if (!(this.Document.Detail is null))
                return this.RenderDocument(this.Document.Detail, false);
            else
                return this.Render((MetaReference)Element);
        }
 
        public override async Task Render(EmojiReference Element)
        {
            if (this.InLabel)
                this.RenderSpan(Element.Emoji.Unicode);
            else
            {
                IEmojiSource EmojiSource = this.Document.EmojiSource;
 
                if (EmojiSource is null)
                    this.RenderSpan(Element.Delimiter + Element.Emoji.ShortName + Element.Delimiter);
                else if (!EmojiSource.EmojiSupported(Element.Emoji))
                    this.RenderSpan(Element.Emoji.Unicode);
                else
                {
                    IImageSource Source = await this.Document.EmojiSource.GetImageSource(Element.Emoji, Element.Level);
                    await Multimedia.ImageContent.OutputXamarinForms(this.XmlOutput, Source);
                }
            }
        }
 
        public override async Task Render(Emphasize Element)
        {
            bool Bak = this.Italic;
            this.Italic = true;
 
            await this.RenderChildren(Element);
 
            this.Italic = Bak;
        }
 
        public override async Task Render(FootnoteReference Element)
        {
            if (!(this.Document?.TryGetFootnote(Element.Key, out Footnote Footnote) ?? false))
                Footnote = null;
 
            if (Element.AutoExpand && !(Footnote is null))
                await this.Render(Footnote);
            else if (this.Document?.TryGetFootnoteNumber(Element.Key, out int Nr) ?? false)
            {
                bool Bak = this.Superscript;
                this.Superscript = true;
 
                this.RenderSpan(Nr.ToString());
 
                this.Superscript = Bak;
 
                if (!(Footnote is null))
                    Footnote.Referenced = true;
            }
        }
 
        public override Task Render(HashTag Element)
        {
            this.RenderSpan(Element.Tag);
            return Task.CompletedTask;
        }
 
        public override Task Render(HtmlEntity Element)
        {
            string s = Html.HtmlEntity.EntityToCharacter(Element.Entity);
            if (!string.IsNullOrEmpty(s))
                this.RenderSpan(s);
 
            return Task.CompletedTask;
        }
 
        public override Task Render(HtmlEntityUnicode Element)
        {
            this.RenderSpan(new string((char)Element.Code, 1));
            return Task.CompletedTask;
        }
 
        public override Task Render(InlineCode Element)
        {
            bool Bak = this.Code;
            this.Code = true;
 
            this.RenderSpan(Element.Code);
 
            this.Code = Bak;
 
            return Task.CompletedTask;
        }
 
        public override Task Render(InlineHTML Element)
        {
            this.XmlOutput.WriteComment(Element.HTML);
            return Task.CompletedTask;
        }
 
        public override async Task Render(InlineScript Element)
        {
            object Result = await Element.EvaluateExpression();
            await this.RenderObject(Result, Element.AloneInParagraph, Element.Variables);
        }
 
        public async Task RenderObject(object Result, bool AloneInParagraph, Variables Variables)
        {
            if (Result is null)
                return;
 
            string s;
 
            if (Result is XmlDocument Xml)
                Result = await MarkdownDocument.TransformXml(Xml, Variables);
            else if (Result is IToMatrix ToMatrix)
                Result = ToMatrix.ToMatrix();
 
            if (this.InLabel)
            {
                s = Result?.ToString();
                if (!string.IsNullOrEmpty(s))
                    this.RenderSpan(Result?.ToString() ?? string.Empty);
 
                return;
            }
 
            if (Result is Graph G)
            {
                PixelInformation Pixels = G.CreatePixels();
                byte[] Bin = Pixels.EncodeAsPng();
 
                s = "data:image/png;base64," + Convert.ToBase64String(Bin, 0, Bin.Length);
 
                await Multimedia.ImageContent.OutputXamarinForms(this.XmlOutput, new ImageSource()
                {
                    Url = s,
                    Width = Pixels.Width,
                    Height = Pixels.Height
                });
            }
            else if (Result is SKImage Img)
            {
                using (SKData Data = Img.Encode(SKEncodedImageFormat.Png, 100))
                {
                    byte[] Bin = Data.ToArray();
 
                    s = "data:image/png;base64," + Convert.ToBase64String(Bin, 0, Bin.Length);
 
                    await Multimedia.ImageContent.OutputXamarinForms(this.XmlOutput, new ImageSource()
                    {
                        Url = s,
                        Width = Img.Width,
                        Height = Img.Height
                    });
                }
            }
            else if (Result is MarkdownDocument Doc)
            {
                await this.RenderDocument(Doc, true);   // Does not call ProcessAsyncTasks()
                Doc.ProcessAsyncTasks();
            }
            else if (Result is MarkdownContent Markdown)
            {
                Doc = await MarkdownDocument.CreateAsync(Markdown.Markdown, Markdown.Settings ?? new MarkdownSettings());
                await this.RenderDocument(Doc, true);   // Does not call ProcessAsyncTasks()
                Doc.ProcessAsyncTasks();
            }
            else if (Result is Exception ex)
            {
                ex = Log.UnnestException(ex);
 
                if (ex is AggregateException ex2)
                {
                    foreach (Exception ex3 in ex2.InnerExceptions)
                    {
                        this.RenderContentView();
                        this.XmlOutput.WriteStartElement("Label");
                        this.XmlOutput.WriteAttributeString("LineBreakMode", "WordWrap");
                        this.XmlOutput.WriteAttributeString("TextColor", "Red");
                        this.XmlOutput.WriteValue(ex3.Message);
                        this.XmlOutput.WriteEndElement();
                        this.XmlOutput.WriteEndElement();
                    }
                }
                else
                {
                    if (AloneInParagraph)
                        this.RenderContentView();
 
                    this.XmlOutput.WriteStartElement("Label");
                    this.XmlOutput.WriteAttributeString("LineBreakMode", "WordWrap");
                    this.XmlOutput.WriteAttributeString("TextColor", "Red");
                    this.XmlOutput.WriteValue(ex.Message);
                    this.XmlOutput.WriteEndElement();
 
                    if (AloneInParagraph)
                        this.XmlOutput.WriteEndElement();
                }
            }
            else
            {
                if (AloneInParagraph)
                    this.RenderContentView();
 
                this.XmlOutput.WriteStartElement("Label");
                this.XmlOutput.WriteAttributeString("LineBreakMode", "WordWrap");
 
                this.RenderLabelAlignment();
                this.XmlOutput.WriteValue(Result.ToString());
                this.XmlOutput.WriteEndElement();
 
                if (AloneInParagraph)
                    this.XmlOutput.WriteEndElement();
            }
        }
 
        public override Task Render(InlineText Element)
        {
            this.RenderSpan(Element.Value);
            return Task.CompletedTask;
        }
 
        public override async Task Render(Insert Element)
        {
            bool Bak = this.Underline;
            this.Underline = true;
 
            await this.RenderChildren(Element);
 
            this.Underline = Bak;
        }
 
        public override Task Render(LineBreak Element)
        {
            this.RenderSpan(Environment.NewLine);
            return Task.CompletedTask;
        }
 
        public override async Task Render(Link Element)
        {
            string Bak = this.Hyperlink;
            this.Hyperlink = Element.Url;
 
            await this.RenderChildren(Element);
 
            this.Hyperlink = Bak;
        }
 
        public override async Task Render(LinkReference Element)
        {
            Model.SpanElements.Multimedia Multimedia = this.Document.GetReference(Element.Label);
 
            string Bak = this.Hyperlink;
 
            if (!(Multimedia is null))
                this.Hyperlink = Multimedia.Items[0].Url;
 
            await this.RenderChildren(Element);
 
            this.Hyperlink = Bak;
        }
 
        public override Task Render(MetaReference Element)
        {
            StringBuilder sb = new StringBuilder();
            bool FirstOnRow = true;
 
            if (Element.TryGetMetaData(out KeyValuePair<string, bool>[] Values))
            {
                foreach (KeyValuePair<string, bool> P in Values)
                {
                    if (FirstOnRow)
                        FirstOnRow = false;
                    else
                        sb.Append(' ');
 
                    sb.Append(P.Key);
                    if (P.Value)
                    {
                        sb.Append(Environment.NewLine);
                        FirstOnRow = true;
                    }
                }
            }
 
            this.RenderSpan(sb.ToString());
 
            return Task.CompletedTask;
        }
 
        public override Task Render(Model.SpanElements.Multimedia Element)
        {
            IMultimediaXamarinFormsXamlRenderer Renderer = Element.MultimediaHandler<IMultimediaXamarinFormsXamlRenderer>();
            if (Renderer is null)
                return this.RenderChildren(Element);
            else
                return Renderer.RenderXamarinFormsXaml(this, Element.Items, Element.Children, Element.AloneInParagraph, Element.Document);
        }
 
        public override Task Render(MultimediaReference Element)
        {
            Model.SpanElements.Multimedia Multimedia = Element.Document.GetReference(Element.Label);
 
            if (!(Multimedia is null))
            {
                IMultimediaXamarinFormsXamlRenderer Renderer = Multimedia.MultimediaHandler<IMultimediaXamarinFormsXamlRenderer>();
                if (!(Renderer is null))
                    return Renderer.RenderXamarinFormsXaml(this, Multimedia.Items, Element.Children, Element.AloneInParagraph, Element.Document);
            }
 
            return this.RenderChildren(Element);
        }
 
        public override async Task Render(StrikeThrough Element)
        {
            bool Bak = this.StrikeThrough;
            this.StrikeThrough = true;
 
            await this.RenderChildren(Element);
 
            this.StrikeThrough = Bak;
        }
 
        public override async Task Render(Strong Element)
        {
            bool Bak = this.Bold;
            this.Bold = true;
 
            await this.RenderChildren(Element);
 
            this.Bold = Bak;
        }
 
        public override async Task Render(SubScript Element)
        {
            bool Bak = this.Subscript;
            this.Subscript = true;
 
            await this.RenderChildren(Element);
 
            this.Subscript = Bak;
        }
 
        public override async Task Render(SuperScript Element)
        {
            bool Bak = this.Superscript;
            this.Superscript = true;
 
            await this.RenderChildren(Element);
 
            this.Superscript = Bak;
        }
 
        public override async Task Render(Underline Element)
        {
            bool Bak = this.Underline;
            this.Underline = true;
 
            await this.RenderChildren(Element);
 
            this.Underline = Bak;
        }
 
        #endregion
 
        #region Block elements
 
        public override async Task Render(BlockQuote Element)
        {
            this.XmlOutput.WriteStartElement("ContentView");
            this.XmlOutput.WriteAttributeString("Padding", this.XamlSettings.BlockQuoteMargin.ToString() + "," +
                this.XamlSettings.ParagraphMarginTop.ToString() + ",0," + this.XamlSettings.ParagraphMarginBottom.ToString());
 
            this.XmlOutput.WriteStartElement("Frame");
            this.XmlOutput.WriteAttributeString("Padding", this.XamlSettings.BlockQuotePadding.ToString() +
                ",0," + this.XamlSettings.BlockQuotePadding.ToString() + ",0");
            this.XmlOutput.WriteAttributeString("BorderColor", this.XamlSettings.BlockQuoteBorderColor);
            // TODO: Border thickness
 
            this.XmlOutput.WriteStartElement("StackLayout");
            this.XmlOutput.WriteAttributeString("Orientation", "Vertical");
 
            await this.RenderChildren(Element);
 
            this.XmlOutput.WriteEndElement();
            this.XmlOutput.WriteEndElement();
            this.XmlOutput.WriteEndElement();
        }
 
        public override async Task Render(BulletList Element)
        {
            int Row = 0;
            bool ParagraphBullet;
            int i, c;
 
            this.XmlOutput.WriteStartElement("ContentView");
            this.XmlOutput.WriteAttributeString("Padding", this.XamlSettings.ParagraphMargins);
 
            this.XmlOutput.WriteStartElement("Grid");
            this.XmlOutput.WriteAttributeString("RowSpacing", "0");
            this.XmlOutput.WriteAttributeString("ColumnSpacing", "0");
 
            this.XmlOutput.WriteStartElement("Grid.ColumnDefinitions");
 
            this.XmlOutput.WriteStartElement("ColumnDefinition");
            this.XmlOutput.WriteAttributeString("Width", "Auto");
            this.XmlOutput.WriteEndElement();
 
            this.XmlOutput.WriteStartElement("ColumnDefinition");
            this.XmlOutput.WriteAttributeString("Width", "*");
            this.XmlOutput.WriteEndElement();
 
            this.XmlOutput.WriteEndElement();
            this.XmlOutput.WriteStartElement("Grid.RowDefinitions");
 
            for (i = 0, c = Element.Children.Count; i < c; i++)
            {
                this.XmlOutput.WriteStartElement("RowDefinition");
                this.XmlOutput.WriteAttributeString("Height", "Auto");
                this.XmlOutput.WriteEndElement();
            }
 
            this.XmlOutput.WriteEndElement();
 
            ChunkNode<MarkdownElement> Loop = Element.Children.FirstChunk;
            MarkdownElement E;
 
            while (!(Loop is null))
            {
                for (i = Loop.Start, c = Loop.Pos; i < c; i++)
                {
                    E = Loop[i];
 
                    ParagraphBullet = !E.InlineSpanElement || E.OutsideParagraph;
                    this.GetMargins(E, out int TopMargin, out int BottomMargin);
 
                    this.RenderContentView("0," + TopMargin.ToString() + "," + this.XamlSettings.ListContentMargin.ToString() + "," +
                        BottomMargin.ToString());
                    this.XmlOutput.WriteAttributeString("Grid.Column", "0");
                    this.XmlOutput.WriteAttributeString("Grid.Row", Row.ToString());
 
                    this.XmlOutput.WriteElementString("Label", "•");
                    this.XmlOutput.WriteEndElement();
 
                    this.XmlOutput.WriteStartElement("StackLayout");
                    this.XmlOutput.WriteAttributeString("Grid.Column", "1");
                    this.XmlOutput.WriteAttributeString("Grid.Row", Row.ToString());
                    this.XmlOutput.WriteAttributeString("Orientation", "Vertical");
 
                    if (ParagraphBullet)
                        await E.Render(this);
                    else
                        await this.RenderLabel(E, false);
 
                    this.XmlOutput.WriteEndElement();
 
                    Row++;
                }
 
                Loop = Loop.Next;
            }
 
            this.XmlOutput.WriteEndElement();
            this.XmlOutput.WriteEndElement();
        }
 
        private void GetMargins(MarkdownElement Element, out int TopMargin, out int BottomMargin)
        {
            if (Element.InlineSpanElement && !Element.OutsideParagraph)
            {
                TopMargin = 0;
                BottomMargin = 0;
            }
            else if (Element is NestedBlock NestedBlock)
            {
                ChunkNode<MarkdownElement> Loop = Element.Children.FirstChunk;
                MarkdownElement E;
                int i, c;
                bool First = true;
 
                TopMargin = BottomMargin = 0;
 
                while (!(Loop is null))
                {
                    for (i = Loop.Start, c = Loop.Pos; i < c; i++)
                    {
                        E = Loop[i];
 
                        if (First)
                        {
                            First = false;
                            this.GetMargins(E, out TopMargin, out BottomMargin);
                        }
                        else
                            this.GetMargins(E, out int _, out BottomMargin);
                    }
 
                    Loop = Loop.Next;
                }
            }
            else if (Element is MarkdownElementSingleChild SingleChild)
                this.GetMargins(SingleChild.Child, out TopMargin, out BottomMargin);
            else
            {
                TopMargin = this.XamlSettings.ParagraphMarginTop;
                BottomMargin = this.XamlSettings.ParagraphMarginBottom;
            }
        }
 
        public override async Task Render(CenterAligned Element)
        {
            this.XmlOutput.WriteStartElement("StackLayout");
            this.XmlOutput.WriteAttributeString("Orientation", "Vertical");
 
            TextAlignment Bak = this.Alignment;
            this.Alignment = TextAlignment.Center;
 
            await this.RenderChildren(Element);
 
            this.Alignment = Bak;
            this.XmlOutput.WriteEndElement();
        }
 
        public override async Task Render(CodeBlock Element)
        {
            ICodeContentXamarinFormsXamlRenderer Renderer = Element.CodeContentHandler<ICodeContentXamarinFormsXamlRenderer>();
 
            if (!(Renderer is null))
            {
                try
                {
                    if (await Renderer.RenderXamarinFormsXaml(this, Element.Rows, Element.Language, Element.Indent, Element.Document))
                        return;
                }
                catch (Exception ex)
                {
                    ex = Log.UnnestException(ex);
 
                    if (ex is AggregateException ex2)
                    {
                        foreach (Exception ex3 in ex2.InnerExceptions)
                        {
                            this.RenderContentView();
                            this.XmlOutput.WriteStartElement("Label");
                            this.XmlOutput.WriteAttributeString("LineBreakMode", "WordWrap");
                            this.XmlOutput.WriteAttributeString("TextColor", "Red");
                            this.XmlOutput.WriteValue(ex3.Message);
                            this.XmlOutput.WriteEndElement();
                            this.XmlOutput.WriteEndElement();
                        }
                    }
                    else
                    {
                        this.RenderContentView();
                        this.XmlOutput.WriteStartElement("Label");
                        this.XmlOutput.WriteAttributeString("LineBreakMode", "WordWrap");
                        this.XmlOutput.WriteAttributeString("TextColor", "Red");
                        this.XmlOutput.WriteValue(ex.Message);
                        this.XmlOutput.WriteEndElement();
                        this.XmlOutput.WriteEndElement();
                    }
                }
            }
 
            this.RenderContentView();
            this.XmlOutput.WriteStartElement("StackLayout");
            this.XmlOutput.WriteAttributeString("Orientation", "Vertical");
 
            int i;
 
            for (i = Element.Start; i <= Element.End; i++)
            {
                this.XmlOutput.WriteStartElement("Label");
                this.XmlOutput.WriteAttributeString("LineBreakMode", "NoWrap");
                this.RenderLabelAlignment();
                this.XmlOutput.WriteAttributeString("FontFamily", "Courier New");
                this.XmlOutput.WriteAttributeString("Text", Element.Rows[i]);
                this.XmlOutput.WriteEndElement();
            }
 
            this.XmlOutput.WriteEndElement();
            this.XmlOutput.WriteEndElement();
        }
 
        public override Task Render(CommentBlock Element)
        {
            return Task.CompletedTask;
        }
 
        public override async Task Render(DefinitionDescriptions Element)
        {
            MarkdownElement Last = Element.Children.HasLastItem ? Element.Children.LastItem : null;
            ChunkNode<MarkdownElement> Loop = Element.Children.FirstChunk;
            MarkdownElement E;
            int i, c;
 
            while (!(Loop is null))
            {
                for (i = Loop.Start, c = Loop.Pos; i < c; i++)
                {
                    E = Loop[i];
 
                    if (E.InlineSpanElement && !E.OutsideParagraph)
                    {
                        this.RenderContentView();
 
                        this.XmlOutput.WriteStartElement("Label");
                        this.XmlOutput.WriteAttributeString("LineBreakMode", "WordWrap");
                        this.RenderLabelAlignment();
                        this.XmlOutput.WriteAttributeString("TextType", "Html");
 
                        using (HtmlRenderer Renderer = new HtmlRenderer(new HtmlSettings()
                        {
                            XmlEntitiesOnly = true
                        }, this.Document))
                        {
                            await E.Render(Renderer);
                            this.XmlOutput.WriteCData(Renderer.ToString());
                        }
 
                        this.XmlOutput.WriteEndElement();
                        this.XmlOutput.WriteEndElement();
                    }
                    else
                    {
                        this.XmlOutput.WriteStartElement("ContentView");
                        this.XmlOutput.WriteAttributeString("Padding", this.XamlSettings.DefinitionMargin.ToString() + ",0,0," +
                            (E == Last ? this.XamlSettings.DefinitionSeparator : 0).ToString());
 
                        this.XmlOutput.WriteStartElement("StackLayout");
                        await E.Render(this);
                        this.XmlOutput.WriteEndElement();
 
                        this.XmlOutput.WriteEndElement();
                    }
                }
 
                Loop = Loop.Next;
            }
        }
 
        public override Task Render(DefinitionList Element)
        {
            return this.RenderChildren(Element);
        }
 
        public override async Task Render(DefinitionTerms Element)
        {
            int TopMargin = this.XamlSettings.ParagraphMarginTop;
            ChunkNode<MarkdownElement> Loop = Element.Children.FirstChunk;
            int i, c;
 
            while (!(Loop is null))
            {
                for (i = Loop.Start, c = Loop.Pos; i < c; i++)
                {
                    this.RenderContentView(this.XamlSettings.ParagraphMarginLeft.ToString() + "," + TopMargin.ToString() + "," +
                        this.XamlSettings.ParagraphMarginRight.ToString() + ",0");
 
                    bool BoldBak = this.Bold;
                    this.Bold = true;
 
                    await this.RenderLabel(Loop[i], true);
 
                    this.Bold = BoldBak;
                    this.XmlOutput.WriteEndElement();
 
                    TopMargin = 0;
                }
 
                Loop = Loop.Next;
            }
        }
 
        public override async Task Render(DeleteBlocks Element)
        {
            this.XmlOutput.WriteStartElement("ContentView");
            this.XmlOutput.WriteAttributeString("Padding", this.XamlSettings.BlockQuoteMargin.ToString() + "," +
                this.XamlSettings.ParagraphMarginTop.ToString() + ",0," + this.XamlSettings.ParagraphMarginBottom.ToString());
 
            this.XmlOutput.WriteStartElement("Frame");
            this.XmlOutput.WriteAttributeString("Padding", this.XamlSettings.BlockQuotePadding.ToString() +
                ",0," + this.XamlSettings.BlockQuotePadding.ToString() + ",0");
            this.XmlOutput.WriteAttributeString("BorderColor", this.XamlSettings.DeletedBlockQuoteBorderColor);
            // TODO: Border thickness
 
            this.XmlOutput.WriteStartElement("StackLayout");
            this.XmlOutput.WriteAttributeString("Orientation", "Vertical");
 
            await this.RenderChildren(Element);
 
            this.XmlOutput.WriteEndElement();
            this.XmlOutput.WriteEndElement();
            this.XmlOutput.WriteEndElement();
        }
 
        public override Task Render(Footnote Element)
        {
            return this.RenderChildren(Element);
        }
 
        public override async Task Render(Header Element)
        {
            this.RenderContentView();
 
            this.XmlOutput.WriteStartElement("Label");
            this.XmlOutput.WriteAttributeString("LineBreakMode", "WordWrap");
            this.RenderLabelAlignment();
 
            if (Element.Level > 0 && Element.Level <= this.XamlSettings.HeaderFontSize.Length)
            {
                this.XmlOutput.WriteAttributeString("FontSize", this.XamlSettings.HeaderFontSize[Element.Level - 1].ToString());
                this.XmlOutput.WriteAttributeString("TextColor", this.XamlSettings.HeaderForegroundColor[Element.Level - 1].ToString());
            }
 
            this.XmlOutput.WriteAttributeString("TextType", "Html");
 
            using (HtmlRenderer Renderer = new HtmlRenderer(new HtmlSettings()
            {
                XmlEntitiesOnly = true
            }, this.Document))
            {
                await Renderer.RenderChildren(Element);
 
                this.XmlOutput.WriteCData(Renderer.ToString());
            }
 
            this.XmlOutput.WriteEndElement();
            this.XmlOutput.WriteEndElement();
        }
 
        public void RenderLabelAlignment()
        {
            switch (this.Alignment)
            {
                case TextAlignment.Left:
                    this.XmlOutput.WriteAttributeString("HorizontalTextAlignment", "Start");
                    break;
 
                case TextAlignment.Right:
                    this.XmlOutput.WriteAttributeString("HorizontalTextAlignment", "End");
                    break;
 
                case TextAlignment.Center:
                    this.XmlOutput.WriteAttributeString("HorizontalTextAlignment", "Center");
                    break;
            }
        }
 
        public override Task Render(HorizontalRule Element)
        {
            this.XmlOutput.WriteStartElement("BoxView");
            this.XmlOutput.WriteAttributeString("HeightRequest", "1");
            this.XmlOutput.WriteAttributeString("BackgroundColor", this.XamlSettings.TableCellBorderColor);
            this.XmlOutput.WriteAttributeString("HorizontalOptions", "FillAndExpand");
            this.XmlOutput.WriteAttributeString("Margin", this.XamlSettings.ParagraphMargins);
            this.XmlOutput.WriteEndElement();
 
            return Task.CompletedTask;
        }
 
        public override async Task Render(HtmlBlock Element)
        {
            this.RenderContentView();
 
            this.XmlOutput.WriteStartElement("Label");
            this.XmlOutput.WriteAttributeString("LineBreakMode", "WordWrap");
            this.RenderLabelAlignment();
            this.XmlOutput.WriteAttributeString("TextType", "Html");
 
            using (HtmlRenderer Renderer = new HtmlRenderer(new HtmlSettings()
            {
                XmlEntitiesOnly = true
            }, this.Document))
            {
                await Renderer.RenderChildren(Element);
 
                this.XmlOutput.WriteCData(Renderer.ToString());
 
                this.XmlOutput.WriteEndElement();
                this.XmlOutput.WriteEndElement();
            }
        }
 
        public override async Task Render(InsertBlocks Element)
        {
            this.XmlOutput.WriteStartElement("ContentView");
            this.XmlOutput.WriteAttributeString("Padding", this.XamlSettings.BlockQuoteMargin.ToString() + "," +
                this.XamlSettings.ParagraphMarginTop.ToString() + ",0," + this.XamlSettings.ParagraphMarginBottom.ToString());
 
            this.XmlOutput.WriteStartElement("Frame");
            this.XmlOutput.WriteAttributeString("Padding", this.XamlSettings.BlockQuotePadding.ToString() +
                ",0," + this.XamlSettings.BlockQuotePadding.ToString() + ",0");
            this.XmlOutput.WriteAttributeString("BorderColor", this.XamlSettings.InsertedBlockQuoteBorderColor);
            // TODO: Border thickness
 
            this.XmlOutput.WriteStartElement("StackLayout");
            this.XmlOutput.WriteAttributeString("Orientation", "Vertical");
 
            await this.RenderChildren(Element);
 
            this.XmlOutput.WriteEndElement();
            this.XmlOutput.WriteEndElement();
            this.XmlOutput.WriteEndElement();
        }
 
        public override Task Render(InvisibleBreak Element)
        {
            return Task.CompletedTask;
        }
 
        public override async Task Render(LeftAligned Element)
        {
            this.XmlOutput.WriteStartElement("StackLayout");
            this.XmlOutput.WriteAttributeString("Orientation", "Vertical");
 
            TextAlignment Bak = this.Alignment;
            this.Alignment = TextAlignment.Left;
 
            await this.RenderChildren(Element);
 
            this.Alignment = Bak;
            this.XmlOutput.WriteEndElement();
        }
 
        public override async Task Render(MarginAligned Element)
        {
            this.XmlOutput.WriteStartElement("StackLayout");
            this.XmlOutput.WriteAttributeString("Orientation", "Vertical");
 
            TextAlignment Bak = this.Alignment;
            this.Alignment = TextAlignment.Left;
 
            await this.RenderChildren(Element);
 
            this.Alignment = Bak;
            this.XmlOutput.WriteEndElement();
        }
 
        public override async Task Render(NestedBlock Element)
        {
            if (Element.HasOneChild)
                await Element.FirstChild.Render(this);
            else
            {
                HtmlSettings Settings = new HtmlSettings()
                {
                    XmlEntitiesOnly = true
                };
                HtmlRenderer Html = null;
 
                try
                {
                    ChunkNode<MarkdownElement> Loop = Element.Children.FirstChunk;
                    MarkdownElement E;
                    int i, c;
 
                    while (!(Loop is null))
                    {
                        for (i = Loop.Start, c = Loop.Pos; i < c; i++)
                        {
                            E = Loop[i];
 
                            if (E.InlineSpanElement)
                            {
                                if (Html is null)
                                    Html = new HtmlRenderer(Settings, this.Document);
 
                                await E.Render(Html);
                            }
                            else
                            {
                                if (!(Html is null))
                                {
                                    this.XmlOutput.WriteStartElement("Label");
                                    this.XmlOutput.WriteAttributeString("LineBreakMode", "WordWrap");
                                    this.RenderLabelAlignment();
                                    this.XmlOutput.WriteAttributeString("TextType", "Html");
                                    this.XmlOutput.WriteCData(Html.ToString());
                                    this.XmlOutput.WriteEndElement();
 
                                    Html.Dispose();
                                    Html = null;
                                }
 
                                await E.Render(this);
                            }
                        }
 
                        Loop = Loop.Next;
                    }
 
                    if (!(Html is null))
                    {
                        this.XmlOutput.WriteStartElement("Label");
                        this.XmlOutput.WriteAttributeString("LineBreakMode", "WordWrap");
                        this.RenderLabelAlignment();
                        this.XmlOutput.WriteAttributeString("TextType", "Html");
                        this.XmlOutput.WriteCData(Html.ToString());
                        this.XmlOutput.WriteEndElement();
                    }
                }
                finally
                {
                    Html?.Dispose();
                }
            }
        }
 
        public override Task Render(NumberedItem Element)
        {
            return this.RenderChild(Element);
        }
 
        public override async Task Render(NumberedList Element)
        {
            int Expected = 0;
            int Row = 0;
            bool ParagraphBullet;
            int i, c;
 
            this.XmlOutput.WriteStartElement("ContentView");
            this.XmlOutput.WriteAttributeString("Padding", this.XamlSettings.ParagraphMargins);
 
            this.XmlOutput.WriteStartElement("Grid");
            this.XmlOutput.WriteAttributeString("RowSpacing", "0");
            this.XmlOutput.WriteAttributeString("ColumnSpacing", "0");
 
            this.XmlOutput.WriteStartElement("Grid.ColumnDefinitions");
 
            this.XmlOutput.WriteStartElement("ColumnDefinition");
            this.XmlOutput.WriteAttributeString("Width", "Auto");
            this.XmlOutput.WriteEndElement();
 
            this.XmlOutput.WriteStartElement("ColumnDefinition");
            this.XmlOutput.WriteAttributeString("Width", "*");
            this.XmlOutput.WriteEndElement();
 
            this.XmlOutput.WriteEndElement();
            this.XmlOutput.WriteStartElement("Grid.RowDefinitions");
 
            for (i = 0, c = Element.Children.Count; i < c; i++)
            {
                this.XmlOutput.WriteStartElement("RowDefinition");
                this.XmlOutput.WriteAttributeString("Height", "Auto");
                this.XmlOutput.WriteEndElement();
            }
 
            this.XmlOutput.WriteEndElement();
 
            ChunkNode<MarkdownElement> Loop = Element.Children.FirstChunk;
            MarkdownElement E;
 
            while (!(Loop is null))
            {
                for (i = Loop.Start, c = Loop.Pos; i < c; i++)
                {
                    E = Loop[i];
                    Expected++;
 
                    ParagraphBullet = !E.InlineSpanElement || E.OutsideParagraph;
                    this.GetMargins(E, out int TopMargin, out int BottomMargin);
 
                    this.RenderContentView("0," + TopMargin.ToString() + "," + this.XamlSettings.ListContentMargin.ToString() + "," +
                        BottomMargin.ToString());
                    this.XmlOutput.WriteAttributeString("Grid.Column", "0");
                    this.XmlOutput.WriteAttributeString("Grid.Row", Row.ToString());
 
                    this.XmlOutput.WriteStartElement("Label");
 
                    if (E is NumberedItem NumberedItem)
                        this.XmlOutput.WriteValue((Expected = NumberedItem.Number).ToString());
                    else
                        this.XmlOutput.WriteValue(Expected.ToString());
 
                    this.XmlOutput.WriteValue(".");
                    this.XmlOutput.WriteEndElement();
                    this.XmlOutput.WriteEndElement();
 
                    this.XmlOutput.WriteStartElement("StackLayout");
                    this.XmlOutput.WriteAttributeString("Grid.Column", "1");
                    this.XmlOutput.WriteAttributeString("Grid.Row", Row.ToString());
                    this.XmlOutput.WriteAttributeString("Orientation", "Vertical");
 
                    if (ParagraphBullet)
                        await E.Render(this);
                    else
                        await this.RenderLabel(E, false);
 
                    this.XmlOutput.WriteEndElement();
 
                    Row++;
                }
 
                Loop = Loop.Next;
            }
 
            this.XmlOutput.WriteEndElement();
            this.XmlOutput.WriteEndElement();
        }
 
        public override async Task Render(Paragraph Element)
        {
            this.RenderContentView();
            await this.RenderLabel(Element, false);
            this.XmlOutput.WriteEndElement();
        }
 
        internal async Task RenderLabel(MarkdownElement Element, bool IncludeElement)
        {
            bool HasLink = !Element.ForEach((E, _) =>
            {
                return !(
                    E is AutomaticLinkMail ||
                    E is AutomaticLinkUrl ||
                    E is Link ||
                    E is LinkReference);
            }, null);
 
            this.XmlOutput.WriteStartElement("Label");
            this.XmlOutput.WriteAttributeString("LineBreakMode", "WordWrap");
            this.RenderLabelAlignment();
 
            if (HasLink)
            {
                if (this.InLabel)
                {
                    if (IncludeElement)
                        await Element.Render(this);
                    else
                        await this.RenderChildren(Element);
                }
                else
                {
                    this.InLabel = true;
 
                    this.XmlOutput.WriteStartElement("Label.FormattedText");
                    this.XmlOutput.WriteStartElement("FormattedString");
 
                    if (IncludeElement)
                        await Element.Render(this);
                    else
                        await this.RenderChildren(Element);
 
                    this.XmlOutput.WriteEndElement();
                    this.XmlOutput.WriteEndElement();
 
                    this.InLabel = false;
                }
            }
            else
            {
                this.XmlOutput.WriteAttributeString("TextType", "Html");
 
                if (this.Bold)
                    this.XmlOutput.WriteAttributeString("FontAttributes", "Bold");
 
                using (HtmlRenderer Renderer = new HtmlRenderer(new HtmlSettings()
                {
                    XmlEntitiesOnly = true
                }, this.Document))
                {
                    if (IncludeElement)
                        await Element.Render(Renderer);
                    else
                        await Renderer.RenderChildren(Element);
 
                    this.XmlOutput.WriteCData(Renderer.ToString());
                }
            }
 
            this.XmlOutput.WriteEndElement();
        }
 
        internal void RenderSpan(string Text)
        {
            if (!this.InLabel)
            {
                this.XmlOutput.WriteStartElement("Label");
                this.XmlOutput.WriteAttributeString("LineBreakMode", "WordWrap");
                this.RenderLabelAlignment();
                this.XmlOutput.WriteStartElement("Label.FormattedText");
                this.XmlOutput.WriteStartElement("FormattedString");
            }
 
            this.XmlOutput.WriteStartElement("Span");
 
            if (this.Superscript)
                Text = TextRenderer.ToSuperscript(Text);
            else if (this.Subscript)
                Text = TextRenderer.ToSubscript(Text);
 
            this.XmlOutput.WriteAttributeString("Text", Text);
 
            if (this.Bold && this.Italic)
                this.XmlOutput.WriteAttributeString("FontAttributes", "Italic, Bold");
            else if (this.Bold)
                this.XmlOutput.WriteAttributeString("FontAttributes", "Bold");
            else if (this.Italic)
                this.XmlOutput.WriteAttributeString("FontAttributes", "Italic");
 
            if (this.StrikeThrough && this.Underline)
                this.XmlOutput.WriteAttributeString("TextDecorations", "Strikethrough, Underline");
            else if (this.StrikeThrough)
                this.XmlOutput.WriteAttributeString("TextDecorations", "Strikethrough");
            else if (this.Underline)
                this.XmlOutput.WriteAttributeString("TextDecorations", "Underline");
 
            if (this.Code)
                this.XmlOutput.WriteAttributeString("FontFamily", "Courier New");
 
            if (!(this.Hyperlink is null))
            {
                this.XmlOutput.WriteAttributeString("TextColor", "{Binding HyperlinkColor}");
 
                this.XmlOutput.WriteStartElement("Span.GestureRecognizers");
                this.XmlOutput.WriteStartElement("TapGestureRecognizer");
                this.XmlOutput.WriteAttributeString("Command", "{Binding HyperlinkClicked}");
                this.XmlOutput.WriteAttributeString("CommandParameter", this.Hyperlink);
                this.XmlOutput.WriteEndElement();
                this.XmlOutput.WriteEndElement();
            }
 
            if (!this.InLabel)
            {
                this.XmlOutput.WriteEndElement();
                this.XmlOutput.WriteEndElement();
                this.XmlOutput.WriteEndElement();
            }
 
            this.XmlOutput.WriteEndElement();
        }
 
        internal void RenderContentView()
        {
            this.RenderContentView(this.Alignment, this.XamlSettings.ParagraphMargins);
        }
 
        internal void RenderContentView(string Margins)
        {
            this.RenderContentView(this.Alignment, Margins);
        }
 
        internal void RenderContentView(TextAlignment Alignment, string Margins)
        {
            this.XmlOutput.WriteStartElement("ContentView");
            this.XmlOutput.WriteAttributeString("Padding", Margins);
 
            switch (Alignment)
            {
                case TextAlignment.Center:
                    this.XmlOutput.WriteAttributeString("HorizontalOptions", "Center");
                    break;
 
                case TextAlignment.Left:
                    this.XmlOutput.WriteAttributeString("HorizontalOptions", "Start");
                    break;
 
                case TextAlignment.Right:
                    this.XmlOutput.WriteAttributeString("HorizontalOptions", "End");
                    break;
            }
        }
 
        public override async Task Render(RightAligned Element)
        {
            this.XmlOutput.WriteStartElement("StackLayout");
            this.XmlOutput.WriteAttributeString("Orientation", "Vertical");
 
            TextAlignment Bak = this.Alignment;
            this.Alignment = TextAlignment.Right;
 
            await this.RenderChildren(Element);
 
            this.Alignment = Bak;
            this.XmlOutput.WriteEndElement();
        }
 
        public override Task Render(Sections Element)
        {
            return this.RenderChildren(Element);
        }
 
        public override Task Render(SectionSeparator Element)
        {
            this.XmlOutput.WriteStartElement("BoxView");
            this.XmlOutput.WriteAttributeString("HeightRequest", "1");
            this.XmlOutput.WriteAttributeString("BackgroundColor", this.XamlSettings.TableCellBorderColor);
            this.XmlOutput.WriteAttributeString("HorizontalOptions", "FillAndExpand");
            this.XmlOutput.WriteAttributeString("Margin", this.XamlSettings.ParagraphMargins);
            this.XmlOutput.WriteEndElement();
 
            return Task.CompletedTask;
        }
 
        public override async Task Render(Table Element)
        {
            int Column;
            int Row, NrRows;
            int RowNr = 0;
 
            this.XmlOutput.WriteStartElement("ContentView");
            this.XmlOutput.WriteAttributeString("Padding", this.XamlSettings.ParagraphMargins);
 
            this.XmlOutput.WriteStartElement("Grid");
            this.XmlOutput.WriteAttributeString("RowSpacing", "-2");
            this.XmlOutput.WriteAttributeString("ColumnSpacing", "-2");
 
            // TODO: Tooltip/caption
 
            this.XmlOutput.WriteStartElement("Grid.ColumnDefinitions");
 
            for (Column = 0; Column < Element.Columns; Column++)
            {
                this.XmlOutput.WriteStartElement("ColumnDefinition");
                this.XmlOutput.WriteAttributeString("Width", "Auto");
                this.XmlOutput.WriteEndElement();
            }
 
            this.XmlOutput.WriteEndElement();
            this.XmlOutput.WriteStartElement("Grid.RowDefinitions");
 
            for (Row = 0, NrRows = Element.Rows.Length + Element.Headers.Length; Row < NrRows; Row++)
            {
                this.XmlOutput.WriteStartElement("RowDefinition");
                this.XmlOutput.WriteAttributeString("Height", "Auto");
                this.XmlOutput.WriteEndElement();
            }
 
            this.XmlOutput.WriteEndElement();
 
            for (Row = 0, NrRows = Element.Headers.Length; Row < NrRows; Row++, RowNr++)
                await this.Render(Element.Headers[Row], Element.HeaderCellAlignments[Row], RowNr, true, Element);
 
            for (Row = 0, NrRows = Element.Rows.Length; Row < NrRows; Row++, RowNr++)
                await this.Render(Element.Rows[Row], Element.RowCellAlignments[Row], RowNr, false, Element);
 
            this.XmlOutput.WriteEndElement();
            this.XmlOutput.WriteEndElement();
        }
 
        private void ClearState()
        {
            this.Alignment = TextAlignment.Left;
            this.Bold = false;
            this.Italic = false;
            this.StrikeThrough = false;
            this.Underline = false;
            this.Superscript = false;
            this.Subscript = false;
            this.Code = false;
            this.InLabel = false;
            this.Hyperlink = null;
        }
 
        private StateBackup Backup()
        {
            return new StateBackup()
            {
                alignment = this.Alignment,
                bold = this.Bold,
                italic = this.Italic,
                strikeThrough = this.StrikeThrough,
                underline = this.Underline,
                superscript = this.Superscript,
                subscript = this.Subscript,
                code = this.Code,
                inLabel = this.InLabel,
                hyperlink = this.Hyperlink
            };
        }
 
        private void Restore(StateBackup Backup)
        {
            this.Alignment = Backup.alignment;
            this.Bold = Backup.bold;
            this.Italic = Backup.italic;
            this.StrikeThrough = Backup.strikeThrough;
            this.Underline = Backup.underline;
            this.Superscript = Backup.superscript;
            this.Subscript = Backup.subscript;
            this.Code = Backup.code;
            this.InLabel = Backup.inLabel;
            this.Hyperlink = Backup.hyperlink;
        }
 
        private class StateBackup
        {
            public TextAlignment alignment;
            public bool bold;
            public bool italic;
            public bool strikeThrough;
            public bool underline;
            public bool superscript;
            public bool subscript;
            public bool code;
            public bool inLabel;
            public string hyperlink;
        }
 
        private async Task Render(MarkdownElement[] CurrentRow, TextAlignment?[] CellAlignments, int RowNr, bool Bold, Table Element)
        {
            MarkdownElement E;
            TextAlignment TextAlignment;
            int Column;
            int NrColumns = Element.Columns;
            int ColSpan;
            StateBackup Bak = this.Backup();
 
            this.ClearState();
 
            for (Column = 0; Column < NrColumns; Column++)
            {
                E = CurrentRow[Column];
                if (E is null)
                    continue;
 
                TextAlignment = CellAlignments[Column] ?? Element.ColumnAlignments[Column];
                ColSpan = Column + 1;
                while (ColSpan < NrColumns && CurrentRow[ColSpan] is null)
                    ColSpan++;
 
                ColSpan -= Column;
 
                this.XmlOutput.WriteStartElement("Frame");
                this.XmlOutput.WriteAttributeString("Padding", "0,0,0,0");
                this.XmlOutput.WriteAttributeString("BorderColor", this.XamlSettings.TableCellBorderColor);
                // TODO: Table-cell border thickness
 
                if ((RowNr & 1) == 0)
                {
                    if (!string.IsNullOrEmpty(this.XamlSettings.TableCellRowBackgroundColor1))
                        this.XmlOutput.WriteAttributeString("BackgroundColor", this.XamlSettings.TableCellRowBackgroundColor1);
                }
                else
                {
                    if (!string.IsNullOrEmpty(this.XamlSettings.TableCellRowBackgroundColor2))
                        this.XmlOutput.WriteAttributeString("BackgroundColor", this.XamlSettings.TableCellRowBackgroundColor2);
                }
 
                this.XmlOutput.WriteAttributeString("Grid.Column", Column.ToString());
                this.XmlOutput.WriteAttributeString("Grid.Row", RowNr.ToString());
 
                if (ColSpan > 1)
                    this.XmlOutput.WriteAttributeString("Grid.ColumnSpan", ColSpan.ToString());
 
                if (E.InlineSpanElement)
                {
                    this.RenderContentView(TextAlignment, this.XamlSettings.TableCellPadding);
 
                    this.Bold = Bold;
                    await this.RenderLabel(E, true);
                    this.Bold = false;
 
                    this.XmlOutput.WriteEndElement();   // Paragraph
                }
                else
                {
                    this.XmlOutput.WriteStartElement("ContentView");
                    this.XmlOutput.WriteAttributeString("Padding", this.XamlSettings.TableCellPadding);
 
                    this.XmlOutput.WriteStartElement("StackLayout");
                    await E.Render(this);
                    this.XmlOutput.WriteEndElement();   // StackLayout
 
                    this.XmlOutput.WriteEndElement();   // ContentView
                }
 
                this.XmlOutput.WriteEndElement();   // Frame
            }
 
            this.Restore(Bak);
        }
 
        public override Task Render(TaskItem Element)
        {
            return this.RenderChild(Element);
        }
 
        public override async Task Render(TaskList Element)
        {
            int Row = 0;
            bool ParagraphBullet;
            int i, c;
 
            this.XmlOutput.WriteStartElement("ContentView");
            this.XmlOutput.WriteAttributeString("Padding", this.XamlSettings.ParagraphMargins);
 
            this.XmlOutput.WriteStartElement("Grid");
            this.XmlOutput.WriteAttributeString("RowSpacing", "0");
            this.XmlOutput.WriteAttributeString("ColumnSpacing", "0");
 
            this.XmlOutput.WriteStartElement("Grid.ColumnDefinitions");
 
            this.XmlOutput.WriteStartElement("ColumnDefinition");
            this.XmlOutput.WriteAttributeString("Width", "Auto");
            this.XmlOutput.WriteEndElement();
 
            this.XmlOutput.WriteStartElement("ColumnDefinition");
            this.XmlOutput.WriteAttributeString("Width", "*");
            this.XmlOutput.WriteEndElement();
 
            this.XmlOutput.WriteEndElement();
            this.XmlOutput.WriteStartElement("Grid.RowDefinitions");
 
            for (i = 0, c = Element.Children.Count; i < c; i++)
            {
                this.XmlOutput.WriteStartElement("RowDefinition");
                this.XmlOutput.WriteAttributeString("Height", "Auto");
                this.XmlOutput.WriteEndElement();
            }
 
            this.XmlOutput.WriteEndElement();
 
            ChunkNode<MarkdownElement> Loop = Element.Children.FirstChunk;
            MarkdownElement E;
 
            while (!(Loop is null))
            {
                for (i = Loop.Start, c = Loop.Pos; i < c; i++)
                {
                    E = Loop[i];
 
                    ParagraphBullet = !E.InlineSpanElement || E.OutsideParagraph;
                    this.GetMargins(E, out int TopMargin, out int BottomMargin);
 
                    if (E is TaskItem Item && Item.IsChecked)
                    {
                        this.RenderContentView("0," + TopMargin.ToString() + "," + this.XamlSettings.ListContentMargin.ToString() + "," +
                            BottomMargin.ToString());
                        this.XmlOutput.WriteAttributeString("Grid.Column", "0");
                        this.XmlOutput.WriteAttributeString("Grid.Row", Row.ToString());
 
                        this.XmlOutput.WriteElementString("Label", "✓");
                        this.XmlOutput.WriteEndElement();
                    }
 
                    this.XmlOutput.WriteStartElement("StackLayout");
                    this.XmlOutput.WriteAttributeString("Grid.Column", "1");
                    this.XmlOutput.WriteAttributeString("Grid.Row", Row.ToString());
                    this.XmlOutput.WriteAttributeString("Orientation", "Vertical");
 
                    if (ParagraphBullet)
                        await E.Render(this);
                    else
                        await this.RenderLabel(E, false);
 
                    this.XmlOutput.WriteEndElement();
 
                    Row++;
                }
 
                Loop = Loop.Next;
            }
 
            this.XmlOutput.WriteEndElement();
            this.XmlOutput.WriteEndElement();
        }
 
        public override Task Render(UnnumberedItem Element)
        {
            return this.RenderChild(Element);
        }
 
        #endregion
 
    }
}