Document
abstract class Document : Node, IDocument, INode, IEventTarget, IMarkupFormattable, IParentNode, IGlobalEventHandlers, IDocumentStyle, INonElementParentNode, IDisposable
Represents a document node.
using AngleSharp.Dom.Collections;
using AngleSharp.Dom.Events;
using AngleSharp.Dom.Html;
using AngleSharp.Extensions;
using AngleSharp.Html;
using AngleSharp.Network;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
namespace AngleSharp.Dom
{
[DebuggerStepThrough]
internal abstract class Document : Node, IDocument, INode, IEventTarget, IMarkupFormattable, IParentNode, IGlobalEventHandlers, IDocumentStyle, INonElementParentNode, IDisposable
{
private static readonly string AboutBlank = "about:blank";
private readonly IStyleSheetList _styleSheets;
private readonly Queue<HtmlScriptElement> _loadingScripts;
private readonly List<WeakReference<AngleSharp.Dom.Collections.Range>> _ranges;
private readonly MutationHost _mutations;
private readonly IBrowsingContext _context;
private readonly IWindow _view;
private readonly IResourceLoader _loader;
private readonly Location _location;
private readonly TextSource _source;
private readonly CancellableTasks _tasks;
private QuirksMode _quirksMode;
private Sandboxes _sandbox;
private bool _async;
private bool _designMode;
private bool _shown;
private bool _salvageable;
private bool _firedUnload;
private DocumentReadyState _ready;
private string _referrer;
private string _contentType;
private string _lastStyleSheetSet;
private string _preferredStyleSheetSet;
private IElement _focus;
private HtmlAllCollection _all;
private HtmlCollection<IHtmlAnchorElement> _anchors;
private HtmlElementCollection _children;
private DomImplementation _implementation;
private IStringList _styleSheetSets;
private HtmlCollection<IHtmlImageElement> _images;
private HtmlCollection<IHtmlScriptElement> _scripts;
private HtmlCollection<IHtmlEmbedElement> _plugins;
private HtmlElementCollection _commands;
private HtmlElementCollection _links;
public IEnumerable<Task> Requests => _tasks;
public string DesignMode {
get {
if (!_designMode)
return Keywords.Off;
return Keywords.On;
}
set {
_designMode = value.Equals(Keywords.On, StringComparison.OrdinalIgnoreCase);
}
}
public IHtmlAllCollection All => _all ?? (_all = new HtmlAllCollection(this));
public IHtmlCollection<IHtmlAnchorElement> Anchors => _anchors ?? (_anchors = new HtmlCollection<IHtmlAnchorElement>(this, true, IsAnchor));
public int ChildElementCount => base.ChildNodes.OfType<Element>().Count();
public IHtmlCollection<IElement> Children => _children ?? (_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 => _async;
public IHtmlScriptElement CurrentScript {
get {
if (_loadingScripts.Count <= 0)
return null;
return _loadingScripts.Peek();
}
}
public IImplementation Implementation => _implementation ?? (_implementation = new DomImplementation(this));
public string LastModified { get; set; }
public IDocumentType Doctype => this.FindChild<DocumentType>();
public string ContentType {
get {
return _contentType;
}
protected set {
_contentType = value;
}
}
public DocumentReadyState ReadyState {
get {
return _ready;
}
protected set {
_ready = value;
this.FireSimpleEvent(EventNames.ReadyStateChanged, false, false);
}
}
public IStyleSheetList StyleSheets => _styleSheets;
public IStringList StyleSheetSets => _styleSheetSets ?? (_styleSheetSets = new StringList(from m in _styleSheets
select m.Title));
public string Referrer {
get {
return _referrer;
}
protected set {
_referrer = value;
}
}
public ILocation Location => _location;
public string DocumentUri {
get {
return _location.Href;
}
protected 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, null)).Direction;
}
set {
((DocumentElement as IHtmlElement) ?? new HtmlHtmlElement(this, null)).Direction = value;
}
}
public string CharacterSet => _source.CurrentEncoding.WebName;
public abstract IElement DocumentElement { get; }
public IElement ActiveElement { get; set; }
public string CompatMode => _quirksMode.GetCompatiblity();
public string Url => _location.Href;
public IHtmlCollection<IHtmlFormElement> Forms => new HtmlCollection<IHtmlFormElement>(this, true, null);
public IHtmlCollection<IHtmlImageElement> Images => _images ?? (_images = new HtmlCollection<IHtmlImageElement>(this, true, null));
public IHtmlCollection<IHtmlScriptElement> Scripts => _scripts ?? (_scripts = new HtmlCollection<IHtmlScriptElement>(this, true, null));
public IHtmlCollection<IHtmlEmbedElement> Plugins => _plugins ?? (_plugins = new HtmlCollection<IHtmlEmbedElement>(this, true, null));
public IHtmlCollection<IElement> Commands => _commands ?? (_commands = new HtmlElementCollection(this, true, IsCommand));
public IHtmlCollection<IElement> Links => _links ?? (_links = new HtmlElementCollection(this, true, IsLink));
public abstract string Title { get; set; }
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(DomError.HierarchyRequest);
IHtmlElement body = Body;
if (body != value) {
if (body == null) {
IElement documentElement = DocumentElement;
if (documentElement == null)
throw new DomException(DomError.HierarchyRequest);
documentElement.AppendChild(value);
} else
ReplaceChild(value, body);
}
}
}
public IBrowsingContext Context => _context;
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 CancellableTasks Tasks => _tasks;
internal IEnumerable<AngleSharp.Dom.Collections.Range> Ranges => from range in _ranges.Select(delegate(WeakReference<AngleSharp.Dom.Collections.Range> entry) {
AngleSharp.Dom.Collections.Range target = null;
entry.TryGetTarget(out target);
return target;
})
where range != null
select range;
internal MutationHost Mutations => _mutations;
internal TextSource Source => _source;
internal IConfiguration Options => _context.Configuration;
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;
internal IResourceLoader Loader => _loader;
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, TextSource source)
: base(null, "#document", NodeType.Document, NodeFlags.None)
{
_async = true;
_designMode = false;
_firedUnload = false;
_salvageable = true;
_shown = false;
_preferredStyleSheetSet = string.Empty;
_context = context;
_source = source;
_referrer = string.Empty;
_contentType = MimeTypes.ApplicationXml;
_ready = DocumentReadyState.Loading;
_sandbox = Sandboxes.None;
_quirksMode = QuirksMode.Off;
_tasks = new CancellableTasks();
_mutations = new MutationHost(Options);
_loadingScripts = new Queue<HtmlScriptElement>();
_location = new Location(AboutBlank);
_ranges = new List<WeakReference<AngleSharp.Dom.Collections.Range>>();
_location.Changed += LocationChanged;
_styleSheets = this.CreateStyleSheets();
_view = this.CreateWindow();
_loader = this.CreateLoader();
}
internal void AddScript(HtmlScriptElement script)
{
_loadingScripts.Enqueue(script);
}
public void Dispose()
{
ReplaceAll(null, true);
_tasks.Dispose();
_loadingScripts.Clear();
_source.Dispose();
}
public void EnableStyleSheetsForSet(string name)
{
if (name != null)
_styleSheets.EnableStyleSheetSet(name);
}
public IDocument Open(string type = "text/html", string replace = null)
{
if (!string.Equals(_contentType, MimeTypes.Html, StringComparison.Ordinal))
throw new DomException(DomError.InvalidState);
if (IsInBrowsingContext && _context.Active != this)
return null;
bool flag = Keywords.Replace.Equals(replace, StringComparison.OrdinalIgnoreCase);
if (_loadingScripts.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;
}
public void Load(string url)
{
Location.Href = url;
}
void IDocument.Close()
{
if (ReadyState == DocumentReadyState.Loading)
FinishLoading().Wait();
}
public void Write(string content)
{
if (ReadyState == DocumentReadyState.Complete) {
IDocument document = Open("text/html", null);
document.Write(content ?? string.Empty);
} else
_source.InsertText(content);
}
public void WriteLine(string content)
{
Write(content + '\n');
}
public IHtmlCollection<IElement> GetElementsByName(string name)
{
List<IElement> list = new List<IElement>();
base.ChildNodes.GetElementsByName(name, list);
return new HtmlElementCollection(list);
}
public INode Import(INode externalNode, bool deep = true)
{
if (externalNode.NodeType == NodeType.Document)
throw new DomException(DomError.NotSupported);
return externalNode.Clone(deep);
}
public INode Adopt(INode externalNode)
{
if (externalNode.NodeType == NodeType.Document)
throw new DomException(DomError.NotSupported);
this.AdoptNode(externalNode);
return externalNode;
}
public Event CreateEvent(string type)
{
Event event = Factory.Events.Create(type);
if (event == null)
throw new DomException(DomError.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<AngleSharp.Dom.Collections.Range>(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(DomError.InvalidCharacter);
return Factory.HtmlElements.Create(this, localName, null);
}
public IElement CreateElement(string namespaceUri, string qualifiedName)
{
string localName = null;
string prefix = null;
Node.GetPrefixAndLocalName(qualifiedName, ref namespaceUri, out prefix, out localName);
if (string.Equals(namespaceUri, Namespaces.HtmlUri, StringComparison.Ordinal))
return Factory.HtmlElements.Create(this, localName, prefix);
if (string.Equals(namespaceUri, Namespaces.SvgUri, StringComparison.Ordinal))
return Factory.SvgElements.Create(this, localName, prefix);
if (string.Equals(namespaceUri, Namespaces.MathMlUri, StringComparison.Ordinal))
return Factory.MathElements.Create(this, localName, prefix);
return new Element(this, localName, prefix, namespaceUri, NodeFlags.None);
}
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(DomError.InvalidCharacter);
ProcessingInstruction processingInstruction = new ProcessingInstruction(this, target);
processingInstruction.Data = data;
return processingInstruction;
}
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<IElement> QuerySelectorAll(string selectors)
{
return base.ChildNodes.QuerySelectorAll(selectors);
}
public IHtmlCollection<IElement> GetElementsByClassName(string classNames)
{
return base.ChildNodes.GetElementsByClassName(classNames);
}
public IHtmlCollection<IElement> GetElementsByTagName(string tagName)
{
return base.ChildNodes.GetElementsByTagName(tagName);
}
public IHtmlCollection<IElement> GetElementsByTagName(string namespaceURI, string tagName)
{
return base.ChildNodes.GetElementsByTagName(namespaceURI, tagName);
}
public abstract override INode Clone(bool deep = true);
public override string ToHtml(IMarkupFormatter formatter)
{
return base.ChildNodes.ToHtml(formatter);
}
public bool HasFocus()
{
return _context.Active == this;
}
public IAttr CreateAttribute(string localName)
{
if (!localName.IsXmlName())
throw new DomException(DomError.InvalidCharacter);
return new Attr(localName);
}
public IAttr CreateAttribute(string namespaceUri, string qualifiedName)
{
string localName = null;
string prefix = null;
Node.GetPrefixAndLocalName(qualifiedName, ref namespaceUri, out prefix, out localName);
return new Attr(prefix, localName, string.Empty, namespaceUri);
}
internal void SetFocus(IElement element)
{
_focus = element;
}
internal IEnumerable<Task> GetScriptDownloads()
{
return _tasks.OfOriginType<HtmlScriptElement>();
}
internal IEnumerable<Task> GetStyleSheetDownloads()
{
return _tasks.OfOriginType<HtmlLinkElement>();
}
internal async Task FinishLoading()
{
ReadyState = DocumentReadyState.Interactive;
while (_loadingScripts.Count > 0) {
await this.WaitForReady().ConfigureAwait(false);
_loadingScripts.Dequeue().Run();
}
this.QueueTask(RaiseDomContentLoaded);
this.QueueTask(RaiseLoadedEvent);
if (IsInBrowsingContext)
this.QueueTask(ShowPage);
this.QueueTask(EmptyAppCache);
if (IsToBePrinted)
Print();
}
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 static bool IsCommand(IElement element)
{
if (!(element is IHtmlMenuItemElement) && !(element is IHtmlButtonElement))
return element is IHtmlAnchorElement;
return true;
}
private static bool IsLink(IElement element)
{
if (element is IHtmlAnchorElement || element is IHtmlAreaElement)
return element.Attributes.Any((IAttr m) => string.Equals(m.Name, AttributeNames.Href, StringComparison.Ordinal));
return false;
}
private static bool IsAnchor(IHtmlAnchorElement element)
{
return element.Attributes.Any((IAttr m) => string.Equals(m.Name, AttributeNames.Name, StringComparison.Ordinal));
}
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);
await BrowsingContextExtensions.OpenAsync(request: DocumentRequest.Get(url, this, DocumentUri), context: _context, cancel: CancellationToken.None);
}
}
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;
target._sandbox = source._sandbox;
target._async = source._async;
target._contentType = source._contentType;
}
}
}