Element

This represents almost everything in the DOM and offers a lot of inspection and manipulation functions. Element, or its subclasses, are what makes the dom tree.

class Element : DomParent {

ElementCollection opIndex(string selector);

Element opIndex(size_t index);

SomeElementType requireElementById(string id, string file, size_t line);

SomeElementType requireSelector(string selector, string file, size_t line);

MaybeNullElement!SomeElementType optionSelector(string selector, string file, size_t line);

string[] classes [@property getter];

struct ClassListHelper;

inout(ClassListHelper) classList [@property getter];

alias classNames = classes;

Element addClass(string c);

Element removeClass(string c);

bool hasClass(string c);

Element addChild(string tagName, string childInfo, string childInfo2);

Element addChild(Element e);

Element addChild(string tagName, Element firstChild, string info2);

Element addChild(string tagName, Html innerHtml, string info2);

Element addSibling(string tagName, string childInfo, string childInfo2);

Element addSibling(Element e);

void addChildren(T t);

void appendChildren(Element[] children);

void reparent(Element newParent);

void stripOut();

Element removeFromTree();

Element wrapIn(Element what);

Element replaceWith(Element e);

string firstInnerText();

string directText [@property getter];

string directText [@property setter];

Element[] children;

string tagName;

AttributesHolder attributes;

inout(Document) parentDocument [@property getter];

inout(Element) parentNode();

version(dom_with_events)

EventHandler[][string] bubblingEventHandlers;

version(dom_with_events)

EventHandler[][string] capturingEventHandlers;

version(dom_with_events)

EventHandler[string] defaultEventHandlers;

static Element make(string tagName, string childInfo, string childInfo2, string[] selfClosedElements);

static Element make(string tagName, Html innerHtml, string childInfo2);

static Element make(string tagName, Element child, string childInfo2);

this(Document _parentDocument, string _tagName, string[string] _attributes, bool _selfClosed);

this(string _tagName, string[string] _attributes, string[] selfClosedElements);

Element firstChild [@property getter];

Element lastChild [@property getter];

Element nextInSource();

Element previousInSource();

Element previousElementSibling [@property getter];

Element nextElementSibling [@property getter];

string previousSibling [@property setter];

string nextSibling [@property setter];

T getParent(string tagName);

Element getElementById(string id);

Element querySelector(string selector);

bool matches(string selector);

Element closest(string selector);

Element[] querySelectorAll(string selector);

alias getElementsBySelector = querySelectorAll;

Element[] getElementsByClassName(string cn);

Element[] getElementsByTagName(string tag);

string getAttribute(string name);

Element setAttribute(string name, string value);

bool hasAttribute(string name);

Element removeAttribute(string name);

string className [@property getter];

string className [@property setter];

string opDispatch [@property setter];

string opDispatch [@property setter];

inout(Element[]) childNodes [@property getter];

DataSet dataset [@property getter];

AttributeSet attrs [@property getter];

ElementStyle style [@property getter];

string style [@property setter];

CssStyle computedStyle [@property getter];

version(browser)

void* expansionHook;

version(browser)

int offsetWidth;

version(browser)

int offsetHeight;

version(browser)

int offsetLeft;

version(browser)

int offsetTop;

version(browser)

Element offsetParent;

version(browser)

bool hasLayout;

version(browser)

version(browser)

int absoluteLeft();

version(browser)

int absoluteTop();

void removeAllChildren();

Element appendSibling(Element e);

Element prependSibling(Element e);

Element appendChild(Element e);

Element insertBefore(Element where, Element what);

Element insertAfter(Element where, Element what);

Element swapNode(Element child, Element replacement);

Element appendText(string text);

string childElements [@property setter];

Element[] appendHtml(string html);

void insertChildAfter(Element child, Element where);

Element[] stealChildren(Element e, Element position);

Element prependChild(Element e);

Appender!string innerHTML [@property setter];

Element innerHTML(string html, bool strict);

Html innerHTML [@property setter];

string outerHTML [@property setter];

string outerHTML [@property getter];

string innerRawSource [@property setter];

Element replaceChild(Element find, Element replace);

void replaceChild(Element find, Element[] replace);

Element removeChild(Element c);

Element[] removeChildren();

string innerText [@property getter];

alias textContent = innerText;

string visibleText();

string innerText [@property setter];

string outerText [@property setter];

string outerText [@property getter];

Element cloned [@property getter];

Element cloneNode(bool deepClone);

string nodeValue();

int nodeType [@property getter];

string toString();

bool isEmpty();

string toPrettyString(bool insertComments, int indentationLevel, string indentWith);

string writeToAppender(Appender!string where);

ElementStream tree [@property getter];

Element addField(string label, string name, string type, FormFieldOptions fieldOptions);

Element addField(Element label, string name, string type, FormFieldOptions fieldOptions);

Element addField(string label, string name, FormFieldOptions fieldOptions);

Element addField(string label, string name, string[string] options, FormFieldOptions fieldOptions);

Element addSubmitButton(string label);

}

Constructors

this this(Document _parentDocument, string _tagName, string[string] _attributes, bool _selfClosed): Generally, you don't want to call this yourself - use Element.make or document.createElement instead.
this this(string _tagName, string[string] _attributes, string[] selfClosedElements): Convenience constructor when you don't care about the parentDocument. Note this might break things on the document. Note also that without a parent document, elements are always in strict, case-sensitive mode.

Members

Aliases

classNames alias classNames = classes: Returns a helper object to work with classes, just like javascript.
getElementsBySelector alias getElementsBySelector = querySelectorAll: Returns elements that match the given CSS selector
textContent alias textContent = innerText: Fetch the inside text, with all tags stripped out.

Functions

absoluteLeft int absoluteLeft()
absoluteTop int absoluteTop(): These properties are useless in most cases, but if you write a layout engine on top of this lib, they may be good +////ditt
addChild Element addChild(string tagName, string childInfo, string childInfo2)
Element addChild(Element e)
Element addChild(string tagName, Element firstChild, string info2)
Element addChild(string tagName, Html innerHtml, string info2): Family of convenience functions to quickly add a tag with some text or other relevant info (for example, it's a src for an <img> element instead of inner text). They forward to Element.make then calls appendChild.
addChildren void addChildren(T t): Convenience function to append text intermixed with other children. For example: div.addChildren("You can visit my website by ", new Link("mysite.com", "clicking here"), "."); or div.addChildren("Hello, ", user.name, "!"); See also: appendHtml. This might be a bit simpler though because you don't have to think about escaping.
addClass Element addClass(string c): Adds a string to the class attribute. The class attribute is used a lot in CSS.
addField Element addField(string label, string name, string type, FormFieldOptions fieldOptions)
Element addField(Element label, string name, string type, FormFieldOptions fieldOptions)
Element addField(string label, string name, FormFieldOptions fieldOptions)
Element addField(string label, string name, string[string] options, FormFieldOptions fieldOptions): Adds a form field to this element, normally a <input> but type can also be "textarea".
addSibling Element addSibling(string tagName, string childInfo, string childInfo2)
Element addSibling(Element e): Another convenience function. Adds a child directly after the current one, returning the new child.
addSubmitButton Element addSubmitButton(string label): Adds a form field to this element, normally a <input> but type can also be "textarea".
appendChild Element appendChild(Element e): Appends the given element to this one. If it already has a parent, it is removed from that tree and moved to this one.
appendChildren void appendChildren(Element[] children): Appends the list of children to this element.
appendHtml Element[] appendHtml(string html): Appends the given html to the element, returning the elements appended
appendSibling Element appendSibling(Element e): Adds a sibling element before or after this one in the dom.
appendText Element appendText(string text): Appends the given to the node.
cloneNode Element cloneNode(bool deepClone): Clones the node. If deepClone is true, clone all inner tags too. If false, only do this tag (and its attributes), but it will have no contents.
closest Element closest(string selector): Returns itself or the closest parent that matches the given selector, or null if none found
firstInnerText string firstInnerText(): Fetches the first consecutive text nodes concatenated together.
getAttribute string getAttribute(string name): Gets the given attribute value, or null if the attribute is not set.
getElementById Element getElementById(string id): Searches this element and the tree of elements under it for one matching the given id attribute.
getElementsByClassName Element[] getElementsByClassName(string cn)
getElementsByTagName Element[] getElementsByTagName(string tag): Returns child elements that have the given class name or tag name.
getParent T getParent(string tagName): Gets the nearest node, going up the chain, with the given tagName May return null or throw. The type T will specify a subclass like Form, Table, or Link, which it will cast for you when found.
hasAttribute bool hasAttribute(string name): Returns if the attribute exists.
hasClass bool hasClass(string c): Returns whether the given class appears in this element.
insertAfter Element insertAfter(Element where, Element what): Inserts the given element what as a sibling of the this element, after the element where in the parent node.
insertBefore Element insertBefore(Element where, Element what): Inserts the second element to this node, right before the first param
insertChildAfter void insertChildAfter(Element child, Element where): Inserts a child under this element after the element where.
isEmpty bool isEmpty(): Returns if the node would be printed to string as <tag /> or <tag></tag>. In other words, if it has no non-empty text nodes and no element nodes. Please note that whitespace text nodes are NOT considered empty; Html("<tag> </tag>").isEmpty == false.
matches bool matches(string selector): If the element matches the given selector. Previously known as matchesSelector.
nextInSource Element nextInSource(): the next or previous element you would encounter if you were reading it in the source. May be a text node or other special non-tag object if you enabled them.
nodeValue string nodeValue(): W3C DOM interface. Only really meaningful on TextNode instances, but the interface is present on the base class.
opIndex ElementCollection opIndex(string selector): Returns a collection of elements by selector. See: Document.opIndex
opIndex Element opIndex(size_t index): Returns the child node with the particular index.
optionSelector MaybeNullElement!SomeElementType optionSelector(string selector, string file, size_t line): If a matching selector is found, it returns that Element. Otherwise, the returned object returns null for all methods.
parentNode inout(Element) parentNode(): Returns the parent node in the tree this element is attached to.
prependChild Element prependChild(Element e): Puts the current element first in our children list. The given element must not have a parent already.
prependSibling Element prependSibling(Element e): Adds a sibling element before or after this one in the dom.
previousInSource Element previousInSource(): the next or previous element you would encounter if you were reading it in the source. May be a text node or other special non-tag object if you enabled them.
querySelector Element querySelector(string selector): Returns a child element that matches the given selector.
querySelectorAll Element[] querySelectorAll(string selector): Returns elements that match the given CSS selector
removeAllChildren void removeAllChildren(): Removes all inner content from the tag; all child text and elements are gone.
removeAttribute Element removeAttribute(string name): Removes the given attribute from the element.
removeChild Element removeChild(Element c): Removes the given child from this list.
removeChildren Element[] removeChildren(): This removes all the children from this element, returning the old list.
removeClass Element removeClass(string c): Removes a particular class name.
removeFromTree Element removeFromTree(): shorthand for this.parentNode.removeChild(this) with parentNode null check if the element already isn't in a tree, it does nothing.
reparent void reparent(Element newParent): Removes this element form its current parent and appends it to the given newParent.
replaceChild Element replaceChild(Element find, Element replace): Replaces the element find, which must be a child of this, with the element replace, which must have no parent.
replaceChild void replaceChild(Element find, Element[] replace): Replaces the given element with a whole group.
replaceWith Element replaceWith(Element e): Replaces this element with something else in the tree.
requireElementById SomeElementType requireElementById(string id, string file, size_t line): Calls getElementById, but throws instead of returning null if the element is not found. You can also ask for a specific subclass of Element to dynamically cast to, which also throws if it cannot be done.
requireSelector SomeElementType requireSelector(string selector, string file, size_t line): ditto but with selectors instead of ids
setAttribute Element setAttribute(string name, string value): Sets an attribute. Returns this for easy chaining
stealChildren Element[] stealChildren(Element e, Element position): Reparents all the child elements of e to this, leaving e childless.
stripOut void stripOut(): Strips this tag out of the document, putting its inner html as children of the parent.
swapNode Element swapNode(Element child, Element replacement): swaps one child for a new thing. Returns the old child which is now parentless.
toPrettyString string toPrettyString(bool insertComments, int indentationLevel, string indentWith): Writes out with formatting. Be warned: formatting changes the contents. Use ONLY for eyeball debugging.
toString string toString(): Turns the whole element, including tag, attributes, and children, into a string which could be pasted into an XML file.
visibleText string visibleText(): Gets the element's visible text, similar to how it would look assuming the document was HTML being displayed by a browser. This means it will attempt whitespace normalization (unless it is a <pre> tag), add \n characters for <br> tags, and I reserve the right to make it process additional css and tags in the future.
wrapIn Element wrapIn(Element what): Wraps this element inside the given element. It's like this.replaceWith(what); what.appendchild(this);
writeToAppender string writeToAppender(Appender!string where): This is the actual implementation used by toString. You can pass it a preallocated buffer to save some time. Note: the ordering of attributes in the string is undefined. Returns the string it creates.

Properties

attrs AttributeSet attrs [@property getter]: Gives dot/opIndex access to attributes
childElements string childElements [@property setter]: Returns child elements which are of a tag type (excludes text, comments, etc.).
childNodes inout(Element[]) childNodes [@property getter]: Returns the element's children.
classList inout(ClassListHelper) classList [@property getter]: Returns a helper object to work with classes, just like javascript.
className string className [@property getter]
string className [@property setter]: Gets or sets the class attribute's contents. Returns an empty string if it has no class.
classes string[] classes [@property getter]: get all the classes on this element
cloned Element cloned [@property getter]: This is a full clone of the element. Alias for cloneNode(true) now. Don't extend it.
computedStyle CssStyle computedStyle [@property getter]: Don't use this. It can try to parse out the style element but it isn't complete and if I get back to it, it won't be for a while.
dataset DataSet dataset [@property getter]: HTML5's dataset property. It is an alternate view into attributes with the data- prefix. Given <a data-my-property="cool" />, we get assert(a.dataset.myProperty == "cool");
directText string directText [@property getter]: Returns the text directly under this element.
directText string directText [@property setter]: Sets the direct text, without modifying other child nodes.
firstChild Element firstChild [@property getter]: Returns the first child of this element. If it has no children, returns null. Remember, text nodes are children too.
innerHTML Appender!string innerHTML [@property setter]: Returns a string containing all child elements, formatted such that it could be pasted into an XML file.
innerHTML Element innerHTML(string html, bool strict)
Html innerHTML [@property setter]: Takes some html and replaces the element's children with the tree made from the string.
innerRawSource string innerRawSource [@property setter]: This sets the inner content of the element *without* trying to parse it. You can inject any code in there; this serves as an escape hatch from the dom.
innerText string innerText [@property getter]: Fetch the inside text, with all tags stripped out.
innerText string innerText [@property setter]: Sets the inside text, replacing all children. You don't have to worry about entity encoding.
lastChild Element lastChild [@property getter]: Returns the last child of the element, or null if it has no children. Remember, text nodes are children too.
nextElementSibling Element nextElementSibling [@property getter]: Returns the next or previous sibling that is not a text node. Please note: the behavior with comments is subject to change. Currently, it will return a comment or other nodes if it is in the tree (if you enabled it with Document.enableAddingSpecialTagsToDom or Document.parseSawComment) and not if you didn't, but the implementation will probably change at some point to skip them regardless.
nextSibling string nextSibling [@property setter]: Returns the next or previous sibling matching the tagName filter. The default filter of null will return the first sibling it sees, even if it is a comment or text node, or anything else. A filter of "*" will match any tag with a name. Otherwise, the string must match the tagName of the sibling you want to find.
nodeType int nodeType [@property getter]: .
opDispatch string opDispatch [@property setter]: Provides easy access to common HTML attributes, object style.
opDispatch string opDispatch [@property setter]: Old access to attributes. Use attrs instead.
outerHTML string outerHTML [@property setter]: Replaces this node with the given html string, which is parsed
outerHTML string outerHTML [@property getter]: Returns all the html for this element, including the tag itself.
outerText string outerText [@property setter]: Strips this node out of the document, replacing it with the given text
outerText string outerText [@property getter]: Same result as innerText; the tag with all inner tags stripped out
parentDocument inout(Document) parentDocument [@property getter]: Get the parent Document object that contains this element. It may be null, so remember to check for that.
previousElementSibling Element previousElementSibling [@property getter]: Returns the next or previous sibling that is not a text node. Please note: the behavior with comments is subject to change. Currently, it will return a comment or other nodes if it is in the tree (if you enabled it with Document.enableAddingSpecialTagsToDom or Document.parseSawComment) and not if you didn't, but the implementation will probably change at some point to skip them regardless.
previousSibling string previousSibling [@property setter]: Returns the next or previous sibling matching the tagName filter. The default filter of null will return the first sibling it sees, even if it is a comment or text node, or anything else. A filter of "*" will match any tag with a name. Otherwise, the string must match the tagName of the sibling you want to find.
style ElementStyle style [@property getter]: Provides both string and object style (like in Javascript) access to the style attribute.
style string style [@property setter]: This sets the style attribute with a string.
tree ElementStream tree [@property getter]: Returns a lazy range of all its children, recursively.

Static functions

make Element make(string tagName, string childInfo, string childInfo2, string[] selfClosedElements)
Element make(string tagName, Html innerHtml, string childInfo2)
Element make(string tagName, Element child, string childInfo2): Convenience function to try to do the right thing for HTML. This is the main way I create elements.

Structs

ClassListHelper struct ClassListHelper: The object classList returns.

Variables

attributes AttributesHolder attributes;: This is where the attributes are actually stored. You should use getAttribute, setAttribute, and hasAttribute instead.
expansionHook void* expansionHook;: These properties are useless in most cases, but if you write a layout engine on top of this lib, they may be good +////ditt
hasLayout bool hasLayout;: These properties are useless in most cases, but if you write a layout engine on top of this lib, they may be good +////ditt
offsetHeight int offsetHeight;: These properties are useless in most cases, but if you write a layout engine on top of this lib, they may be good +////ditt
offsetLeft int offsetLeft;: These properties are useless in most cases, but if you write a layout engine on top of this lib, they may be good +////ditt
offsetParent Element offsetParent;: These properties are useless in most cases, but if you write a layout engine on top of this lib, they may be good +////ditt
offsetTop int offsetTop;: These properties are useless in most cases, but if you write a layout engine on top of this lib, they may be good +////ditt
offsetWidth int offsetWidth;: These properties are useless in most cases, but if you write a layout engine on top of this lib, they may be good +////ditt
tagName string tagName;: The name of the tag. Remember, changing this doesn't change the dynamic type of the object.
zIndex int zIndex;: These properties are useless in most cases, but if you write a layout engine on top of this lib, they may be good +////ditt

See Also

core_functionality

Meta

Source

See Implementation