Document
class Document : Node, IDocument, INode, IEventTarget, IParentNode, IGlobalEventHandlers, IDocumentStyle, INonElementParentNode, IDisposable
Represents a document node.
using AngleSharp.Dom.Collections;
using AngleSharp.Dom.Events;
using AngleSharp.Dom.Html;
using AngleSharp.Dom.Svg;
using AngleSharp.Extensions;
using AngleSharp.Html;
using AngleSharp.Network;
using AngleSharp.Parser.Html;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
namespace AngleSharp.Dom
{
[DebuggerStepThrough]
internal class Document : Node, IDocument, INode, IEventTarget, IParentNode, IGlobalEventHandlers, IDocumentStyle, INonElementParentNode, IDisposable
{
private static readonly string AboutBlank = "about:blank";
private readonly StyleSheetList _styleSheets;
private readonly Queue<HtmlScriptElement> _scripts;
private readonly List<WeakReference> _ranges;
private readonly MutationHost _mutations;
private readonly IBrowsingContext _context;
private readonly IWindow _view;
private QuirksMode _quirksMode;
private Sandboxes _sandbox;
private bool _designMode;
private bool _shown;
private bool _salvageable;
private bool _firedUnload;
private DocumentReadyState _ready;
private TextSource _source;
private string _referrer;
private string _contentType;
private string _lastStyleSheetSet;
private string _preferredStyleSheetSet;
private Location _location;
private IElement _focus;
public string DesignMode {
get {
if (!_designMode)
return Keywords.Off;
return Keywords.On;
}
set {
_designMode = value.Equals(Keywords.On, StringComparison.OrdinalIgnoreCase);
}
}
public IHtmlAllCollection All => new HtmlAllCollection(this);
public IHtmlCollection Anchors => new HtmlCollection<IHtmlAnchorElement>(this, true, (IHtmlAnchorElement element) => element.Attributes.Any((IAttr m) => m.Name == AttributeNames.Name));
public int ChildElementCount => base.ChildNodes.OfType<Element>().Count();
public IHtmlCollection Children => new HtmlElementCollection(base.ChildNodes.OfType<Element>());
public IElement FirstElementChild {
get {
NodeList childNodes = base.ChildNodes;
int length = childNodes.Length;
for (int i = 0; i < length; i++) {
IElement element = childNodes[i] as IElement;
if (element != null)
return element;
}
return null;
}
}
public IElement LastElementChild {
get {
NodeList childNodes = base.ChildNodes;
for (int num = childNodes.Length - 1; num >= 0; num--) {
IElement element = childNodes[num] as IElement;
if (element != null)
return element;
}
return null;
}
}
public bool IsAsync { get; set; }
public IHtmlScriptElement CurrentScript {
get {
if (_scripts.Count <= 0)
return null;
return _scripts.Peek();
}
}
public IImplementation Implementation => new DomImplementation(this);
public string LastModified { get; set; }
public IDocumentType Doctype => this.FindChild<DocumentType>();
public string ContentType {
get {
return _contentType;
}
internal set {
_contentType = value;
}
}
public DocumentReadyState ReadyState {
get {
return _ready;
}
internal set {
_ready = value;
this.FireSimpleEvent(EventNames.ReadyStateChanged, false, false);
}
}
public IStyleSheetList StyleSheets => _styleSheets;
public IStringList StyleSheetSets => new StringList(from m in _styleSheets
select m.Title);
public string Referrer {
get {
return _referrer;
}
protected internal set {
_referrer = value;
}
}
public ILocation Location {
get {
return _location;
}
set {
LoadHtml(value.Href);
}
}
public string DocumentUri {
get {
return _location.Href;
}
internal set {
_location.Changed -= LocationChanged;
_location.Href = value;
_location.Changed += LocationChanged;
}
}
public Url DocumentUrl => _location.Original;
public IWindow DefaultView => _view;
public string Direction {
get {
return ((DocumentElement as IHtmlElement) ?? new HtmlHtmlElement(this)).Direction;
}
set {
((DocumentElement as IHtmlElement) ?? new HtmlHtmlElement(this)).Direction = value;
}
}
public string CharacterSet => _source.CurrentEncoding.WebName;
public IElement DocumentElement => this.FindChild<HtmlHtmlElement>();
public IElement ActiveElement { get; set; }
public string CompatMode => _quirksMode.GetCompatiblity();
public string Url => _location.Href;
public IHtmlCollection Forms => new HtmlCollection<IHtmlFormElement>(this, true, null);
public IHtmlCollection Images => new HtmlCollection<IHtmlImageElement>(this, true, null);
public IHtmlCollection Scripts => new HtmlCollection<IHtmlScriptElement>(this, true, null);
public IHtmlCollection Plugins => new HtmlCollection<IHtmlEmbedElement>(this, true, null);
public IHtmlCollection Commands => new HtmlElementCollection(this, true, delegate(IElement element) {
if (!(element is IHtmlMenuItemElement) && !(element is IHtmlButtonElement))
return element is IHtmlAnchorElement;
return true;
});
public IHtmlCollection Links => new HtmlElementCollection(this, true, delegate(IElement element) {
if (element is IHtmlAnchorElement || element is IHtmlAreaElement)
return element.Attributes.Any((IAttr m) => m.Name == AttributeNames.Href);
return false;
});
public string Title {
get {
object element2;
if (!(DocumentElement is ISvgSvgElement)) {
IElement element = DocumentElement.FindDescendant<IHtmlTitleElement>();
element2 = element;
} else {
IElement element = DocumentElement.FindChild<ISvgTitleElement>();
element2 = element;
}
IElement element3 = (IElement)element2;
if (element3 != null)
return element3.TextContent.CollapseAndStrip();
return string.Empty;
}
set {
if (DocumentElement is ISvgSvgElement) {
ISvgTitleElement svgTitleElement = DocumentElement.FindChild<ISvgTitleElement>();
if (svgTitleElement == null) {
svgTitleElement = new SvgTitleElement(this);
DocumentElement.AppendChild(svgTitleElement);
}
svgTitleElement.TextContent = value;
} else if (DocumentElement is IHtmlElement) {
IHtmlTitleElement htmlTitleElement = DocumentElement.FindDescendant<IHtmlTitleElement>();
if (htmlTitleElement == null) {
IHtmlHeadElement head = Head;
if (head == null)
return;
htmlTitleElement = new HtmlTitleElement(this);
head.AppendChild(htmlTitleElement);
}
htmlTitleElement.TextContent = value;
}
}
}
public IHtmlHeadElement Head => DocumentElement.FindChild<IHtmlHeadElement>();
public IHtmlElement Body {
get {
IElement documentElement = DocumentElement;
if (documentElement != null) {
foreach (INode childNode in documentElement.ChildNodes) {
HtmlBodyElement htmlBodyElement = childNode as HtmlBodyElement;
if (htmlBodyElement != null)
return htmlBodyElement;
HtmlFrameSetElement htmlFrameSetElement = childNode as HtmlFrameSetElement;
if (htmlFrameSetElement != null)
return htmlFrameSetElement;
}
}
return null;
}
set {
if (!(value is IHtmlBodyElement) && !(value is HtmlFrameSetElement))
throw new DomException(ErrorCode.HierarchyRequest);
IHtmlElement body = Body;
if (body != value) {
if (body == null) {
IElement documentElement = DocumentElement;
if (documentElement == null)
throw new DomException(ErrorCode.HierarchyRequest);
documentElement.AppendChild(value);
} else
ReplaceChild(value, body);
}
}
}
public string Cookie {
get {
return Options.GetCookie(_location.Origin);
}
set {
Options.SetCookie(_location.Origin, value);
}
}
public string Domain {
get {
if (!string.IsNullOrEmpty(DocumentUri))
return new Uri(DocumentUri).Host;
return string.Empty;
}
set {
if (_location != null)
_location.Host = value;
}
}
public string Origin => _location.Origin;
public string SelectedStyleSheetSet {
get {
IEnumerable<string> enabledStyleSheetSets = _styleSheets.GetEnabledStyleSheetSets();
string enabledName = enabledStyleSheetSets.FirstOrDefault();
IEnumerable<IStyleSheet> source = _styleSheets.Where(delegate(IStyleSheet m) {
if (!string.IsNullOrEmpty(m.Title))
return !m.IsDisabled;
return false;
});
if (enabledStyleSheetSets.Count() == 1 && !source.Any((IStyleSheet m) => m.Title != enabledName))
return enabledName;
if (source.Any())
return null;
return string.Empty;
}
set {
if (value != null) {
_styleSheets.EnableStyleSheetSet(value);
_lastStyleSheetSet = value;
}
}
}
public string LastStyleSheetSet => _lastStyleSheetSet;
public string PreferredStyleSheetSet => _preferredStyleSheetSet;
internal IEnumerable<AngleSharp.Dom.Collections.Range> Ranges => (from m in _ranges
where m.IsAlive
select m.Target).OfType<AngleSharp.Dom.Collections.Range>();
internal MutationHost Mutations => _mutations;
internal TextSource Source => _source;
internal IConfiguration Options => _context.Configuration;
internal IBrowsingContext Context => _context;
internal QuirksMode QuirksMode {
get {
return _quirksMode;
}
set {
_quirksMode = value;
}
}
internal Sandboxes ActiveSandboxing {
get {
return _sandbox;
}
set {
_sandbox = value;
}
}
internal bool IsInBrowsingContext => _context.Active != null;
internal bool IsToBePrinted => false;
internal IElement FocusElement => _focus;
public event DomEventHandler ReadyStateChanged {
add {
AddEventListener(EventNames.ReadyStateChanged, value, false);
}
remove {
RemoveEventListener(EventNames.ReadyStateChanged, value, false);
}
}
public event DomEventHandler Aborted {
add {
AddEventListener(EventNames.Abort, value, false);
}
remove {
RemoveEventListener(EventNames.Abort, value, false);
}
}
public event DomEventHandler Blurred {
add {
AddEventListener(EventNames.Blur, value, false);
}
remove {
RemoveEventListener(EventNames.Blur, value, false);
}
}
public event DomEventHandler Cancelled {
add {
AddEventListener(EventNames.Cancel, value, false);
}
remove {
RemoveEventListener(EventNames.Cancel, value, false);
}
}
public event DomEventHandler CanPlay {
add {
AddEventListener(EventNames.CanPlay, value, false);
}
remove {
RemoveEventListener(EventNames.CanPlay, value, false);
}
}
public event DomEventHandler CanPlayThrough {
add {
AddEventListener(EventNames.CanPlayThrough, value, false);
}
remove {
RemoveEventListener(EventNames.CanPlayThrough, value, false);
}
}
public event DomEventHandler Changed {
add {
AddEventListener(EventNames.Change, value, false);
}
remove {
RemoveEventListener(EventNames.Change, value, false);
}
}
public event DomEventHandler Clicked {
add {
AddEventListener(EventNames.Click, value, false);
}
remove {
RemoveEventListener(EventNames.Click, value, false);
}
}
public event DomEventHandler CueChanged {
add {
AddEventListener(EventNames.CueChange, value, false);
}
remove {
RemoveEventListener(EventNames.CueChange, value, false);
}
}
public event DomEventHandler DoubleClick {
add {
AddEventListener(EventNames.DblClick, value, false);
}
remove {
RemoveEventListener(EventNames.DblClick, value, false);
}
}
public event DomEventHandler Drag {
add {
AddEventListener(EventNames.Drag, value, false);
}
remove {
RemoveEventListener(EventNames.Drag, value, false);
}
}
public event DomEventHandler DragEnd {
add {
AddEventListener(EventNames.DragEnd, value, false);
}
remove {
RemoveEventListener(EventNames.DragEnd, value, false);
}
}
public event DomEventHandler DragEnter {
add {
AddEventListener(EventNames.DragEnter, value, false);
}
remove {
RemoveEventListener(EventNames.DragEnter, value, false);
}
}
public event DomEventHandler DragExit {
add {
AddEventListener(EventNames.DragExit, value, false);
}
remove {
RemoveEventListener(EventNames.DragExit, value, false);
}
}
public event DomEventHandler DragLeave {
add {
AddEventListener(EventNames.DragLeave, value, false);
}
remove {
RemoveEventListener(EventNames.DragLeave, value, false);
}
}
public event DomEventHandler DragOver {
add {
AddEventListener(EventNames.DragOver, value, false);
}
remove {
RemoveEventListener(EventNames.DragOver, value, false);
}
}
public event DomEventHandler DragStart {
add {
AddEventListener(EventNames.DragStart, value, false);
}
remove {
RemoveEventListener(EventNames.DragStart, value, false);
}
}
public event DomEventHandler Dropped {
add {
AddEventListener(EventNames.Drop, value, false);
}
remove {
RemoveEventListener(EventNames.Drop, value, false);
}
}
public event DomEventHandler DurationChanged {
add {
AddEventListener(EventNames.DurationChange, value, false);
}
remove {
RemoveEventListener(EventNames.DurationChange, value, false);
}
}
public event DomEventHandler Emptied {
add {
AddEventListener(EventNames.Emptied, value, false);
}
remove {
RemoveEventListener(EventNames.Emptied, value, false);
}
}
public event DomEventHandler Ended {
add {
AddEventListener(EventNames.Ended, value, false);
}
remove {
RemoveEventListener(EventNames.Ended, value, false);
}
}
public event DomEventHandler Error {
add {
AddEventListener(EventNames.Error, value, false);
}
remove {
RemoveEventListener(EventNames.Error, value, false);
}
}
public event DomEventHandler Focused {
add {
AddEventListener(EventNames.Focus, value, false);
}
remove {
RemoveEventListener(EventNames.Focus, value, false);
}
}
public event DomEventHandler Input {
add {
AddEventListener(EventNames.Input, value, false);
}
remove {
RemoveEventListener(EventNames.Input, value, false);
}
}
public event DomEventHandler Invalid {
add {
AddEventListener(EventNames.Invalid, value, false);
}
remove {
RemoveEventListener(EventNames.Invalid, value, false);
}
}
public event DomEventHandler KeyDown {
add {
AddEventListener(EventNames.Keydown, value, false);
}
remove {
RemoveEventListener(EventNames.Keydown, value, false);
}
}
public event DomEventHandler KeyPress {
add {
AddEventListener(EventNames.Keypress, value, false);
}
remove {
RemoveEventListener(EventNames.Keypress, value, false);
}
}
public event DomEventHandler KeyUp {
add {
AddEventListener(EventNames.Keyup, value, false);
}
remove {
RemoveEventListener(EventNames.Keyup, value, false);
}
}
public event DomEventHandler Loaded {
add {
AddEventListener(EventNames.Load, value, false);
}
remove {
RemoveEventListener(EventNames.Load, value, false);
}
}
public event DomEventHandler LoadedData {
add {
AddEventListener(EventNames.LoadedData, value, false);
}
remove {
RemoveEventListener(EventNames.LoadedData, value, false);
}
}
public event DomEventHandler LoadedMetadata {
add {
AddEventListener(EventNames.LoadedMetaData, value, false);
}
remove {
RemoveEventListener(EventNames.LoadedMetaData, value, false);
}
}
public event DomEventHandler Loading {
add {
AddEventListener(EventNames.LoadStart, value, false);
}
remove {
RemoveEventListener(EventNames.LoadStart, value, false);
}
}
public event DomEventHandler MouseDown {
add {
AddEventListener(EventNames.Mousedown, value, false);
}
remove {
RemoveEventListener(EventNames.Mousedown, value, false);
}
}
public event DomEventHandler MouseEnter {
add {
AddEventListener(EventNames.Mouseenter, value, false);
}
remove {
RemoveEventListener(EventNames.Mouseenter, value, false);
}
}
public event DomEventHandler MouseLeave {
add {
AddEventListener(EventNames.Mouseleave, value, false);
}
remove {
RemoveEventListener(EventNames.Mouseleave, value, false);
}
}
public event DomEventHandler MouseMove {
add {
AddEventListener(EventNames.Mousemove, value, false);
}
remove {
RemoveEventListener(EventNames.Mousemove, value, false);
}
}
public event DomEventHandler MouseOut {
add {
AddEventListener(EventNames.Mouseout, value, false);
}
remove {
RemoveEventListener(EventNames.Mouseout, value, false);
}
}
public event DomEventHandler MouseOver {
add {
AddEventListener(EventNames.Mouseover, value, false);
}
remove {
RemoveEventListener(EventNames.Mouseover, value, false);
}
}
public event DomEventHandler MouseUp {
add {
AddEventListener(EventNames.Mouseup, value, false);
}
remove {
RemoveEventListener(EventNames.Mouseup, value, false);
}
}
public event DomEventHandler MouseWheel {
add {
AddEventListener(EventNames.Wheel, value, false);
}
remove {
RemoveEventListener(EventNames.Wheel, value, false);
}
}
public event DomEventHandler Paused {
add {
AddEventListener(EventNames.Pause, value, false);
}
remove {
RemoveEventListener(EventNames.Pause, value, false);
}
}
public event DomEventHandler Played {
add {
AddEventListener(EventNames.Play, value, false);
}
remove {
RemoveEventListener(EventNames.Play, value, false);
}
}
public event DomEventHandler Playing {
add {
AddEventListener(EventNames.Playing, value, false);
}
remove {
RemoveEventListener(EventNames.Playing, value, false);
}
}
public event DomEventHandler Progress {
add {
AddEventListener(EventNames.Progress, value, false);
}
remove {
RemoveEventListener(EventNames.Progress, value, false);
}
}
public event DomEventHandler RateChanged {
add {
AddEventListener(EventNames.RateChange, value, false);
}
remove {
RemoveEventListener(EventNames.RateChange, value, false);
}
}
public event DomEventHandler Resetted {
add {
AddEventListener(EventNames.Reset, value, false);
}
remove {
RemoveEventListener(EventNames.Reset, value, false);
}
}
public event DomEventHandler Resized {
add {
AddEventListener(EventNames.Resize, value, false);
}
remove {
RemoveEventListener(EventNames.Resize, value, false);
}
}
public event DomEventHandler Scrolled {
add {
AddEventListener(EventNames.Scroll, value, false);
}
remove {
RemoveEventListener(EventNames.Scroll, value, false);
}
}
public event DomEventHandler Seeked {
add {
AddEventListener(EventNames.Seeked, value, false);
}
remove {
RemoveEventListener(EventNames.Seeked, value, false);
}
}
public event DomEventHandler Seeking {
add {
AddEventListener(EventNames.Seeking, value, false);
}
remove {
RemoveEventListener(EventNames.Seeking, value, false);
}
}
public event DomEventHandler Selected {
add {
AddEventListener(EventNames.Select, value, false);
}
remove {
RemoveEventListener(EventNames.Select, value, false);
}
}
public event DomEventHandler Shown {
add {
AddEventListener(EventNames.Show, value, false);
}
remove {
RemoveEventListener(EventNames.Show, value, false);
}
}
public event DomEventHandler Stalled {
add {
AddEventListener(EventNames.Stalled, value, false);
}
remove {
RemoveEventListener(EventNames.Stalled, value, false);
}
}
public event DomEventHandler Submitted {
add {
AddEventListener(EventNames.Submit, value, false);
}
remove {
RemoveEventListener(EventNames.Submit, value, false);
}
}
public event DomEventHandler Suspended {
add {
AddEventListener(EventNames.Suspend, value, false);
}
remove {
RemoveEventListener(EventNames.Suspend, value, false);
}
}
public event DomEventHandler TimeUpdated {
add {
AddEventListener(EventNames.TimeUpdate, value, false);
}
remove {
RemoveEventListener(EventNames.TimeUpdate, value, false);
}
}
public event DomEventHandler Toggled {
add {
AddEventListener(EventNames.Toggle, value, false);
}
remove {
RemoveEventListener(EventNames.Toggle, value, false);
}
}
public event DomEventHandler VolumeChanged {
add {
AddEventListener(EventNames.VolumeChange, value, false);
}
remove {
RemoveEventListener(EventNames.VolumeChange, value, false);
}
}
public event DomEventHandler Waiting {
add {
AddEventListener(EventNames.Waiting, value, false);
}
remove {
RemoveEventListener(EventNames.Waiting, value, false);
}
}
internal Document(IBrowsingContext context = null)
: this(context, new TextSource(string.Empty))
{
}
internal Document(IBrowsingContext context, TextSource source)
: base(null, "#document", NodeType.Document, NodeFlags.None)
{
IsAsync = true;
_context = (context ?? new SimpleBrowsingContext(Configuration.Default, Sandboxes.None));
_source = source;
_referrer = string.Empty;
_contentType = MimeTypes.ApplicationXml;
_ready = DocumentReadyState.Loading;
_styleSheets = new StyleSheetList(this);
_mutations = new MutationHost(this);
_preferredStyleSheetSet = string.Empty;
_scripts = new Queue<HtmlScriptElement>();
_quirksMode = QuirksMode.Off;
_designMode = false;
_location = new Location(AboutBlank);
_location.Changed += LocationChanged;
_ranges = new List<WeakReference>();
_view = this.CreateWindow();
_firedUnload = false;
_salvageable = true;
_shown = false;
_sandbox = Sandboxes.None;
_context.NavigateTo(this);
}
internal void AddScript(HtmlScriptElement script)
{
_scripts.Enqueue(script);
}
public void Dispose()
{
ReplaceAll(null, true);
_scripts.Clear();
if (_source != null) {
_source.Dispose();
_source = null;
}
}
public void EnableStyleSheetsForSet(string name)
{
if (name != null)
_styleSheets.EnableStyleSheetSet(name);
}
public IWindow OpenNew(string url, string name, string features, string replace = null)
{
IWindow defaultView = DefaultView;
if (defaultView == null)
throw new DomException(ErrorCode.InvalidAccess);
return defaultView.Open(url, name, features, replace);
}
public IDocument Open(string type = "text/html", string replace = null)
{
if (_contentType != MimeTypes.Html)
throw new DomException(ErrorCode.InvalidState);
if (IsInBrowsingContext && _context.Active != this)
return null;
bool flag = Keywords.Replace.Equals(replace, StringComparison.OrdinalIgnoreCase);
if (_scripts.Count > 0)
return this;
if (flag)
type = MimeTypes.Html;
int num = type.IndexOf(';');
if (num >= 0)
type = type.Substring(0, num);
type = type.StripLeadingTailingSpaces();
_contentType = type;
ReplaceAll(null, false);
return this;
}
void IDocument.Close()
{
if (ReadyState == DocumentReadyState.Loading)
FinishLoading();
}
public void Write(string content)
{
if (ReadyState == DocumentReadyState.Complete)
Open("text/html", null).Write(content);
else
_source.InsertText(content);
}
public void WriteLine(string content)
{
Write(content + '\n');
}
public IHtmlCollection GetElementsByName(string name)
{
List<IElement> list = new List<IElement>();
base.ChildNodes.GetElementsByName(name, list);
return new HtmlElementCollection(list);
}
public void LoadHtml(string url)
{
_location.Href = url;
}
public INode Import(INode externalNode, bool deep = true)
{
if (externalNode is IDocument)
throw new DomException(ErrorCode.NotSupported);
return externalNode.Clone(deep);
}
public INode Adopt(INode externalNode)
{
if (externalNode is IDocument)
throw new DomException(ErrorCode.NotSupported);
this.AdoptNode(externalNode);
return externalNode;
}
public Event CreateEvent(string type)
{
Event event = Factory.Events.Create(type);
if (event == null)
throw new DomException(ErrorCode.NotSupported);
return event;
}
public INodeIterator CreateNodeIterator(INode root, FilterSettings settings = FilterSettings.All, NodeFilter filter = null)
{
return new NodeIterator(root, settings, filter);
}
public ITreeWalker CreateTreeWalker(INode root, FilterSettings settings = FilterSettings.All, NodeFilter filter = null)
{
return new TreeWalker(root, settings, filter);
}
public IRange CreateRange()
{
AngleSharp.Dom.Collections.Range range = new AngleSharp.Dom.Collections.Range(this);
_ranges.Add(new WeakReference(range));
return range;
}
public void Prepend(params INode[] nodes)
{
this.PrependNodes(nodes);
}
public void Append(params INode[] nodes)
{
this.AppendNodes(nodes);
}
public IElement CreateElement(string localName)
{
if (!localName.IsXmlName())
throw new DomException(ErrorCode.InvalidCharacter);
return Factory.HtmlElements.Create(localName, this);
}
public IElement CreateElement(string namespaceUri, string qualifiedName)
{
if (string.IsNullOrEmpty(namespaceUri))
namespaceUri = null;
if (!qualifiedName.IsXmlName())
throw new DomException(ErrorCode.InvalidCharacter);
if (!qualifiedName.IsQualifiedName())
throw new DomException(ErrorCode.Namespace);
string[] array = qualifiedName.Split(new char[1] {
':'
});
string text = (array.Length == 2) ? array[0] : null;
string text2 = (array.Length == 2) ? array[1] : qualifiedName;
if (text == Namespaces.XmlPrefix && namespaceUri != Namespaces.XmlUri)
throw new DomException(ErrorCode.Namespace);
if ((qualifiedName == Namespaces.XmlNsPrefix || text == Namespaces.XmlNsPrefix) && namespaceUri != Namespaces.XmlNsUri)
throw new DomException(ErrorCode.Namespace);
if (namespaceUri == Namespaces.XmlNsUri && (qualifiedName != Namespaces.XmlNsPrefix || text != Namespaces.XmlNsPrefix))
throw new DomException(ErrorCode.Namespace);
Element element = null;
element = ((namespaceUri == Namespaces.HtmlUri) ? Factory.HtmlElements.Create(text2, this) : ((namespaceUri == Namespaces.SvgUri) ? Factory.SvgElements.Create(text2, this) : ((!(namespaceUri == Namespaces.MathMlUri)) ? new Element(this, text2, NodeFlags.None) {
NamespaceUri = namespaceUri
} : Factory.MathElements.Create(text2, this))));
element.Prefix = text;
return element;
}
public IComment CreateComment(string data)
{
return new Comment(this, data);
}
public IDocumentFragment CreateDocumentFragment()
{
return new DocumentFragment(this);
}
public IProcessingInstruction CreateProcessingInstruction(string target, string data)
{
if (!target.IsXmlName() || data.Contains("?>"))
throw new DomException(ErrorCode.InvalidCharacter);
return new ProcessingInstruction(this, target) {
Data = data
};
}
public IText CreateTextNode(string data)
{
return new TextNode(this, data);
}
public IElement GetElementById(string elementId)
{
return base.ChildNodes.GetElementById(elementId);
}
public IElement QuerySelector(string selectors)
{
return base.ChildNodes.QuerySelector(selectors);
}
public IHtmlCollection QuerySelectorAll(string selectors)
{
return base.ChildNodes.QuerySelectorAll(selectors);
}
public IHtmlCollection GetElementsByClassName(string classNames)
{
return base.ChildNodes.GetElementsByClassName(classNames);
}
public IHtmlCollection GetElementsByTagName(string tagName)
{
return base.ChildNodes.GetElementsByTagName(tagName);
}
public IHtmlCollection GetElementsByTagName(string namespaceURI, string tagName)
{
return base.ChildNodes.GetElementsByTagName(namespaceURI, tagName);
}
public override INode Clone(bool deep = true)
{
Document document = new Document(_context, new TextSource(Source.Text));
Node.CopyProperties(this, document, deep);
CopyDocumentProperties(this, document, deep);
return document;
}
public override string ToHtml()
{
return base.ChildNodes.ToHtml();
}
public bool HasFocus()
{
return _context.Active == this;
}
internal void SetFocus(IElement element)
{
_focus = element;
}
internal bool IsWaitingForScript()
{
if (_scripts.Count > 0)
return !_scripts.Peek().IsReady;
return false;
}
internal void FinishLoading()
{
ReadyState = DocumentReadyState.Interactive;
while (_scripts.Count > 0) {
this.WaitForReady();
_scripts.Dequeue().Run();
}
this.QueueTask(RaiseDomContentLoaded);
this.QueueTask(RaiseLoadedEvent);
if (IsInBrowsingContext)
this.QueueTask(ShowPage);
this.QueueTask(EmptyAppCache);
if (IsToBePrinted)
Print();
}
internal Task<IDocument> LoadAsync(IResponse response, CancellationToken cancelToken)
{
_contentType = MimeTypes.Html;
Open(response.Headers[HeaderNames.ContentType], null);
DocumentUri = response.Address.Href;
ReadyState = DocumentReadyState.Loading;
_source = new TextSource(response.Content, Options.DefaultEncoding());
return new HtmlParser(this).ParseAsync(cancelToken);
}
internal void Unload(bool recycle, CancellationToken cancelToken)
{
EventTarget eventTarget = DefaultView as EventTarget;
if (_shown) {
_shown = false;
this.Fire(delegate(PageTransitionEvent ev) {
ev.Init(EventNames.PageHide, false, false, _salvageable);
}, eventTarget);
}
if (!_firedUnload)
eventTarget.FireSimpleEvent(EventNames.Unload, false, false);
this.ReleaseStorageMutex();
if (eventTarget.HasEventListener(EventNames.Unload)) {
_firedUnload = true;
_salvageable = false;
}
}
bool IDocument.ExecuteCommand(string commandId, bool showUserInterface, string value)
{
return Options.GetCommand(commandId)?.Execute(this, showUserInterface, value) ?? false;
}
bool IDocument.IsCommandEnabled(string commandId)
{
return Options.GetCommand(commandId)?.IsEnabled(this) ?? false;
}
bool IDocument.IsCommandIndeterminate(string commandId)
{
return Options.GetCommand(commandId)?.IsIndeterminate(this) ?? false;
}
bool IDocument.IsCommandExecuted(string commandId)
{
return Options.GetCommand(commandId)?.IsExecuted(this) ?? false;
}
bool IDocument.IsCommandSupported(string commandId)
{
return Options.GetCommand(commandId)?.IsSupported(this) ?? false;
}
string IDocument.GetCommandValue(string commandId)
{
return Options.GetCommand(commandId)?.GetValue(this);
}
private void RaiseDomContentLoaded()
{
this.FireSimpleEvent(EventNames.DomContentLoaded, false, false);
}
private void RaiseLoadedEvent()
{
ReadyState = DocumentReadyState.Complete;
this.FireSimpleEvent(EventNames.Load, false, false);
}
private void EmptyAppCache()
{
}
private void Print()
{
this.FireSimpleEvent(EventNames.BeforePrint, false, false);
this.FireSimpleEvent(EventNames.AfterPrint, false, false);
}
private void ShowPage()
{
if (!_shown && _view != null) {
_shown = true;
this.Fire(delegate(PageTransitionEvent ev) {
ev.Init(EventNames.PageShow, false, false, false);
}, _view as EventTarget);
}
}
private async void LocationChanged(object sender, Location.LocationChangedEventArgs e)
{
if (e.IsHashChanged) {
HashChangedEvent hashChangedEvent = new HashChangedEvent();
hashChangedEvent.Init(EventNames.HashChange, false, false, e.PreviousLocation, e.CurrentLocation);
hashChangedEvent.IsTrusted = true;
hashChangedEvent.Dispatch(this);
} else {
Url url = new Url(e.CurrentLocation);
IRequester requester = Options.GetRequester(url.Scheme);
if (requester != null) {
IResponse response = await requester.LoadAsync(url).ConfigureAwait(false);
if (response != null) {
await LoadAsync(response, CancellationToken.None).ConfigureAwait(false);
response.Dispose();
}
}
}
}
protected sealed override string LocateNamespace(string prefix)
{
return DocumentElement.LocateNamespace(prefix);
}
protected sealed override string LocatePrefix(string namespaceUri)
{
return DocumentElement.LocatePrefix(namespaceUri);
}
protected static void CopyDocumentProperties(Document source, Document target, bool deep)
{
target._ready = source._ready;
target._referrer = source._referrer;
target._location.Href = source._location.Href;
target._quirksMode = source._quirksMode;
}
}
}
