HtmlElement.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Xml;
 
namespace Waher.Content.Html
{
    public class HtmlElement : HtmlNode
    {
        private Dictionary<string, HtmlAttribute> attributesByName = null;
        private LinkedList<HtmlAttribute> attributes = null;
        private LinkedList<HtmlNode> children = null;
        private readonly string name;
        private string @namespace;
 
        public HtmlElement(HtmlDocument Document, HtmlElement Parent, int StartPosition, string Name)
            : base(Document, Parent, StartPosition)
        {
            this.name = Name;
            this.@namespace = null;
        }
 
        public string Name => this.name;
 
        public string Namespace => this.@namespace;
 
        internal void Add(HtmlNode Node)
        {
            if (this.children is null)
                this.children = new LinkedList<HtmlNode>();
 
            this.children.AddLast(Node);
        }
 
        internal void AddAttribute(HtmlAttribute Attribute)
        {
            if (Attribute.Name == "xmlns")
            {
                if (string.IsNullOrEmpty(this.@namespace))
                    this.@namespace = Attribute.Value;
            }
            else
            {
                if (this.attributes is null)
                {
                    this.attributes = new LinkedList<HtmlAttribute>();
                    this.attributesByName = new Dictionary<string, HtmlAttribute>(StringComparer.OrdinalIgnoreCase);
                }
 
                if (!this.attributesByName.ContainsKey(Attribute.Name))
                {
                    this.attributes.AddLast(Attribute);
                    this.attributesByName[Attribute.Name] = Attribute;
                }
            }
        }
 
        public bool HasChildren => !(this.children is null);
 
        public bool HasAttributes => !(this.attributes is null);
 
        public IEnumerable<HtmlNode> Children => this.children;
 
        public IEnumerable<HtmlAttribute> Attributes => this.attributes;
 
        public bool TryGetAttribute(string Name, out HtmlAttribute Attribute)
        {
            if (this.attributesByName is null)
            {
                Attribute = null;
                return false;
            }
            else
                return this.attributesByName.TryGetValue(Name, out Attribute);
        }
 
        public string InnerHtml
        {
            get
            {
                int? Start = null;
                int? End = null;
 
                if (!(this.children is null))
                {
                    foreach (HtmlNode N in this.children)
                    {
                        if (!Start.HasValue)
                            Start = N.StartPosition;
 
                        End = N.EndPosition;
                    }
                }
 
                if (Start.HasValue && End.HasValue)
                    return this.Document.HtmlText.Substring(Start.Value, End.Value - Start.Value + 1);
                else
                    return string.Empty;
            }
        }
 
        public string InnerText
        {
            get
            {
                StringBuilder sb = new StringBuilder();
 
                if (!(this.children is null))
                {
                    foreach (HtmlNode N in this.children)
                    {
                        if (N is HtmlText Text)
                            sb.Append(Text.InlineText);
                        else if (N is HtmlElement Element)
                            sb.Append(Element.InnerText);
                        else if (N is HtmlEntity Entity)
                            sb.Append(Entity.ToString());
                        else if (N is CDATA CDATA)
                            sb.Append(CDATA.Content);
                    }
                }
 
                return sb.ToString();
            }
        }
 
        public string StartTag
        {
            get
            {
                if (!(this.children is null))
                {
                    foreach (HtmlNode N in this.children)
                        return this.Document.HtmlText.Substring(this.StartPosition, N.StartPosition - this.StartPosition);
                }
 
                return this.OuterHtml;
            }
        }
 
        public int EndPositionOfStartTag
        {
            get
            {
                if (!(this.children is null))
                {
                    foreach (HtmlNode N in this.children)
                        return N.StartPosition - 1;
                }
 
                return this.EndPosition;
            }
        }
 
        public override string ToString()
        {
            return this.StartTag;
        }
 
        public override void Export(XmlWriter Output)
        {
            if (this.@namespace is null)
                Output.WriteStartElement(this.name);
            else
                Output.WriteStartElement(this.name, this.@namespace);
 
            if (!(this.attributes is null))
            {
                foreach (HtmlAttribute Attr in this.attributes)
                    Attr.Export(Output);
            }
 
            if (!(this.children is null))
            {
                foreach (HtmlNode Child in this.children)
                    Child.Export(Output);
            }
 
            Output.WriteEndElement();
        }
 
        public override void Export(StringBuilder Output)
        {
            Output.Append('<');
            Output.Append(this.name);
 
            if (!(this.attributes is null))
            {
                foreach (HtmlAttribute Attr in this.attributes)
                    Attr.Export(Output);
            }
 
            if (!(this.@namespace is null))
            {
                Output.Append(" xmlns=\"");
                Output.Append(Xml.XML.Encode(this.@namespace));
                Output.Append('"');
            }
 
            if (this.children is null)
                Output.Append("/>");
            else
            {
                Output.Append('>');
 
                foreach (HtmlNode Child in this.children)
                    Child.Export(Output);
 
                Output.Append("</");
                Output.Append(this.name);
                Output.Append('>');
            }
        }
 
        public virtual bool IsEmptyElement => false;
 
        public bool HasAttribute(string Name)
        {
            if (Name == "xmlns")
                return !(this.@namespace is null);
 
            if (this.attributes is null)
                return false;
 
            foreach (HtmlAttribute Attr in this.attributes)
            {
                if (string.Compare(Attr.Name, Name, true) == 0)
                    return true;
            }
 
            return false;
        }
 
        public string GetAttribute(string Name)
        {
            if (Name == "xmlns")
                return this.@namespace;
 
            if (this.attributes is null)
                return string.Empty;
 
            foreach (HtmlAttribute Attr in this.attributes)
            {
                if (string.Compare(Attr.Name, Name, true) == 0)
                    return Attr.Value;
            }
 
            return string.Empty;
        }
    }
}