Sample header file:
//
// Element.h
//
// Copyright (c) Silicon Beach Software, Inc.
// Poway, CA U.S.A.
// All Rights Reserved.
//
// This software is the confidential and proprietary information of
// Silicon Beach Software, Inc. ("Confidential Information"). You shall not
// disclose such Confidential Information and shall use it only in
// accordance with the terms of the license agreement you entered into
// with Silicon Beach Software, Inc.
//
#pragma once
#include <Node.h>
#include <Collections.h>
#include <CharacterData.h>
#include <../CSS/CSSValue.h>
#include <../CSS/CSSUtilities.h>
#include <../CSS/CSSStyleDeclaration.h>
#include <../SVG/Geometry.h>
#include <../UndoManager/UndoManager.h>
#include <Document.h>
#include <../HTML/CustomElementRegistry.h>
#include <unordered_map>
#include <memory>
#include <unordered_set>
namespace azuti
{
struct ShadowRootInit;
class ShadowRoot;
class UndoManager;
// For Element::insertAdjacentElement
extern const DOMString INSERT_BEFORE_BEGIN;
extern const DOMString INSERT_AFTER_BEGIN;
extern const DOMString INSERT_BEFORE_END;
extern const DOMString INSERT_AFTER_END;
//
// Element Class
//
class Element : public Node, public NamedNodeMap,
public std::enable_shared_from_this<Element>
{
public:
static std::shared_ptr<Element> makeShared(const DOMString& localName,
boost::optional<DOMString> namespaceURI = boost::none,
boost::optional<DOMString> prefix = boost::none,
std::shared_ptr<PropertyParsingMapContainer> parser = nullptr);
static std::shared_ptr<Element> makeShared(std::shared_ptr<PropertyParsingMapContainer> parser = nullptr);
protected:
Element(const DOMString& localName, boost::optional<DOMString> namespaceURI = boost::none, boost::optional<DOMString> prefix = boost::none, std::shared_ptr<PropertyParsingMapContainer> parser = nullptr);
Element(std::shared_ptr<PropertyParsingMapContainer> parser = nullptr);
static void addParsingInfo(DOMToken key, std::shared_ptr<PropertyParsingInfo> parsingInfo, const std::shared_ptr<PropertyParsingMap> parsingMap);
static void getAttributeParsingMapImpl(std::shared_ptr<PropertyParsingMap> parsingMap);
static const std::shared_ptr<PropertyParsingMapContainer> getAttributeParsingMap()
{
static std::shared_ptr<PropertyParsingMapContainer> parsingMap = std::make_shared<PropertyParsingMapContainer>(&Element::getAttributeParsingMapImpl);
return parsingMap;
}
private:
void* operator new(std::size_t) = delete;
void* operator new[](std::size_t) = delete;
public:
virtual ~Element();
//
// Operators
//
// NOTE: Operators use naked references to the nodes since using one wrapped in a
// std::shared_ptr will result in the standard library's pointer compare
// operators being called. Use the dereference operater * to trigger these.
//
// Example:
// nodeA == nodeB Calls the standard library operator to compare the pointers.
// *nodeA == *nodeB Calls these operators to compare the contents.
// Equivalence relation operator (uses IsEqualNode result).
bool operator==(const Element& rhs) const
{
return doIsEqualNode(&rhs);
}
// Non-equivalence relation operator (uses IsEqualNode not-result).
bool operator!=(const Element& rhs) const
{
return !doIsEqualNode(&rhs);
}
//
// Overrides from Node
//
// The textContent attribute must return the following, depending on the context object :
// DocumentFragment, Element:
// The concatenation of data of all the Text node descendants of the context object, in tree order.
// Text, ProcessingInstruction, Comment:
// The context object's data.
// Any other node:
// Null.
//
// The textContent attribute must, on setting, if the new value is null, act as if it was the empty string instead, and then do as described below, depending on the context object :
//
// DocumentFragment, Element:
// 1. Let node be null.
// 2. If new value is not the empty string, set node to a new Text node whose data is new value.
// 3. Replace all with node within the context object.
//
// Text, ProcessingInstruction, Comment:
// Replace data with node context object, offset 0, count length attribute value, and data new value.
// Any other node:
// Do nothing.
boost::optional<DOMString> get_textContent() override;
void set_textContent(const DOMString& content) override;
// Look up the prefix associated to the given namespace URI, starting from this node. The default namespace declarations are ignored by this method.
// Parameters:
// namespaceURI - The namespace URI to look for.
// Returns:
// Returns an associated namespace prefix if found or null if none is found. If more than one prefix are associated to the namespace prefix,
// the returned namespace prefix is implementation dependent.
boost::optional<DOMString> lookupPrefix(boost::optional<DOMString> namespaceURI) override;
// Look up the namespace URI associated to the given prefix, starting from this node.
// Parameters:
// prefix - The prefix to look for. If this parameter is null, the method will return the default namespace URI if any.
// Returns:
// Returns the associated namespace URI or null if none is found.
boost::optional<DOMString> lookupNamespaceURI(boost::optional<DOMString> prefix = boost::none) override;
// This method checks if the specified namespaceURI is the default namespace or not.
// Parameters:
// namespaceURI - The namespace URI to look for.
// Returns:
// Returns true if the specified namespaceURI is the default namespace, false otherwise.
bool isDefaultNamespace(boost::optional<DOMString> namespaceURI) override;
//
// DOM 4 Element Implementation
//
// Returns the context object's namespace.
boost::optional<DOMString> namespaceURI()
{
return m_NamespaceURI;
}
// Returns the context object's namespace prefix.
boost::optional<DOMString> prefix()
{
return m_Prefix;
}
// The raw name of the tag without namespaces or case change.
const DOMString& localName()
{
return m_NodeName;
}
// An XML-based document will preserve the the case. However, an HTML DOM returns the tagName
// of an HTML element in the canonical uppercase form regardless of the case in the source HTML document.
DOMString tagName();
// Corresponds to attribute ‘id’ on the given element.
boost::optional<DOMString> id();
// Corresponds to attribute ‘class’ on the given element.
// 'className' is used because 'class' conflicts with the C++ reserved word.
boost::optional<DOMString> className();
// Returns a static list of the element's classes.
std::shared_ptr<DOMTokenList> classList();
// Returns a DOMString that represents the name of the slot to which the element is assigned
// when used as a slotted element within a shadow DOM.
boost::optional<DOMString> slot();
// Returns true if this element has attributes, false if it doesn't.
bool hasAttributes();
// A static, read-only array of this element's attribute list.
std::shared_ptr<NamedNodeMap> attributes();
// Returns the qualified names of the attributes in this’s attribute list, in order; otherwise a new list.
std::vector<DOMString> getAttributeNames();
// Retrieves an attribute value by name.
// Parameters:
// name - The name of the attribute to retrieve.
// Returns:
// The Attr value as a string, or the empty string if that attribute does not have a specified or default value.
boost::optional<DOMString> getAttribute(const DOMString& name);
// Retrieves an attribute value by local name and namespace URI.
// Per[XML Namespaces], applications must use the value null as the namespaceURI parameter for methods if they wish to have no namespace.
// Parameters:
// namespaceURI - The namespace URI of the attribute to retrieve.
// localName - The local name of the attribute to retrieve.
// Returns:
// The Attr value as a string, or the empty string if that attribute does not have a specified or default value.
boost::optional<DOMString> getAttributeNS(boost::optional<DOMString> namespaceUri, const DOMString& name);
// Adds a new attribute.
// To set an attribute with a qualified name and namespace URI, use the setAttributeNS method.
// Parameters:
// name - The name of the attribute to create or alter.
// value - Value to set in string form.
void setAttribute(const DOMString& name, const DOMString& value);
// Adds a new attribute.
// Parameters:
// namespaceUri - The namespace URI of the attribute to create or alter.
// name - The qualified name of the attribute to create or alter.
// value - Value to set in string form.
void setAttributeNS(boost::optional<DOMString> namespaceUri, const DOMString& name, const DOMString& value);
// Removes an attribute by name.
// Parameters:
// name - The name of the attribute to remove.
void removeAttribute(const DOMString& name);
// Removes an attribute by local name and namespace URI.
// Parameters:
// namespaceUri - The namespace URI of the attribute to remove.
// name - The local name of the attribute to remove.
void removeAttributeNS(boost::optional<DOMString> namespaceUri, const DOMString& name);
// Toggles the existence of a specified attribute on an element:
// If the attribute is currently present on the element, toggleAttribute() will remove it.
// If the attribute is currently absent from the element, toggleAttribute() will add it.
// Parameters:
// qualifiedName - The name of the attribute to toggle.
// force - true or boost::none = Create the attribute if it is not present.
// false or boost::none = Remove the attribute if it is present.
bool toggleAttribute(DOMString qualifiedName, boost::optional<bool> force = boost::none);
// Returns true when an attribute with a given name is specified on this element or has a default value, false otherwise.
// Parameters:
// name - The name of the attribute to look for.
// Returns:
// True if the attribute is present and false of it isn't.
bool hasAttribute(const DOMString& name);
// Returns true when an attribute with a given local name and namespace URI is specified on this element or has a default value, false otherwise.
// Per[XML Namespaces], applications must use the value null as the namespaceURI parameter for methods if they wish to have no namespace.
// Parameters:
// namespaceUri - The namespace URI of the attribute to look for.
// name - The local name of the attribute to look for.
// Returns:
// True if the attribute is present and false of it isn't.
bool hasAttributeNS(boost::optional<DOMString> namespaceUri, const DOMString& name);
// Retrieves an attribute by name.
// Parameters:
// name - The name of the attribute to retrieve.
// Returns:
// The Attr, or null if that attribute does not exist.
std::shared_ptr<Attr> getAttributeNode(const DOMString& name);
// Retrieves an attribute by local name and namespace URI.
// Parameters:
// namespaceURI - The namespace URI of the attribute to retrieve.
// localName - The local name of the attribute to retrieve.
// Returns:
// The Attr, or null if that attribute does not exist.
std::shared_ptr<Attr> getAttributeNodeNS(boost::optional<DOMString> namespaceUri, const DOMString& name);
// Adds a new attribute by local name.
// Parameters:
// attr - The new attribute.
// Returns:
// The old attribute.
// NOTE: It looks like both methods do the same thing?
std::shared_ptr<Attr> setAttributeNode(std::shared_ptr<Attr> attr);
// Adds a new attribute by local name and namespace URI.
// Parameters:
// attr - The new attribute.
// Returns:
// The old attribute.
// NOTE: It looks like both methods do the same thing?
std::shared_ptr<Attr> setAttributeNodeNS(std::shared_ptr<Attr> attr);
// Removes an attribute by instance.
// Parameters:
// attr - The attribute to remove.
// Returns:
// The removed attribute.
std::shared_ptr<Attr> removeAttributeNode(std::shared_ptr<Attr> attr);
//
// ShadowRoot methods
//
// Attaches a shadow root to the element.
std::shared_ptr<ShadowRoot> attachShadow(ShadowRootInit init);
// returns the shadow root for this element if defined.
std::shared_ptr<ShadowRoot> shadowRoot();
// Returns the ShadowRoot's custom registry, if defined.
// Otherwise, if the Element has an owner document, then the registry from the owner
// docment will be retured.
// nullptr is returned if there is no registry to be found anywhere.
std::shared_ptr<CustomElementRegistry> get_customRegistry();
// Implementation extension
CustomElementFactory resolveCustomElement(const DOMString& name);
// Returns the closest ancestor of the current element(or the current element itself)
// which matches the selectors given in parameter.If there isn't such an ancestor, it returns null.
std::shared_ptr<Element> closest(const DOMString& selectors);
// Returns true if the context object is in the result of running match a selectors string selectors against a set consisting of context object, and false otherwise.
// Returns:
// True if the element matches and false of it doesn't.
virtual bool matches(const DOMString& selectors);
// legacy alias of .matches
bool webkitMatchesSelector(DOMString selectors)
{
return matches(selectors);
}
// Return the list of elements with local name localName for the context object.
// Parameters:
// localName - The local name of the element to look for.
// Returns:
// An HTMLCollection of the matching elements.
std::shared_ptr<HTMLCollection> getElementsByTagName(const DOMString& localName);
// Returns the list of elements with namespace namespace and local name localName for the context object.
// Parameters:
// namespaceUri - The namespace URI of the elements to match on. The special value "*" matches all namespaces.
// localName - The name of the tag to match on. The special value "*" matches all tags.
// Returns:
// An HTMLCollection of the matching elements.
std::shared_ptr<HTMLCollection> getElementsByTagNameNS(boost::optional<DOMString> namespaceUri, const DOMString& localName);
// Returns the list of elements with className for the context object.
// Parameters:
// className - The list of class names (selectors) to match against.
// Returns:
// An HTMLCollection of the matching elements.
std::shared_ptr<HTMLCollection> getElementsByClassName(const DOMString& className);
// Inserts a specified element relative to the calling element (the element on which the method is invoked),
// as per the HTML Standard.
// Positional options:
// "beforebegin" — sibling before
// "afterbegin" — first child
// "beforeend" — last child
// "afterend" — sibling after
// Returns - the element that was inserted if successful.
std::shared_ptr<Element> insertAdjacentElement(DOMString where, std::shared_ptr<Element> elem);
// Legacy: Inserts a text node where
// Returns - the textnode that was inserted if successful.
std::shared_ptr<Text> insertAdjacentText(DOMString where, DOMString& data);
// These two methods are public for unit testing.
// To validate and extract a namespace and qualifiedName, run these steps :
// 1. If namespace is the empty string, set it to null.
// 2. Validate qualifiedName.Rethrow any exceptions.
// 3. Let prefix be null.
// 4. Let localName be qualifiedName.
// 5. If qualifiedName contains a ":" (U + 003E), then split the string on it and set prefix to the part before and localName to the part after.
// 6. If prefix is non - null and namespace is null, throw a NamespaceError exception.
// 7. If prefix is "xml" and namespace is not the XML namespace, throw a NamespaceError exception.
// 8. If either qualifiedName or prefix is "xmlns" and namespace is not the XMLNS namespace, throw a NamespaceError exception.
// 9. If namespace is the XMLNS namespace and neither qualifiedName nor prefix is "xmlns", throw a NamespaceError exception.
// 10. Return namespace, prefix, localName, and qualifiedName.
void parseAttributeDescription(const DOMString& qualifiedName, boost::optional<DOMString>& namespaceUri, boost::optional<DOMString>& prefix, DOMString& localName);
void parseAttributeDescriptionNS(const DOMString& name, boost::optional<DOMString> namespaceUri, boost::optional<DOMString>& prefix, DOMString& localName);
//
// NamedNodeMap Implementation
//
// The length attribute’s getter must return the attribute list’s size.
unsigned long length() override;
//The item(index) method, when invoked, must run these steps :
// 1. If index is equal to or greater than context object’s attribute list’s size, then return null.
// 2. Otherwise, return context object’s attribute list[index].
std::shared_ptr<Attr> item(unsigned long index) override;
// The getNamedItem(qualifiedName) method, when invoked, must return the result of getting an attribute given qualifiedName and element.
std::shared_ptr<Attr> getNamedItem(const DOMString& qualifiedName) override;
// The getNamedItemNS(namespace, name) method, when invoked, must return the result of getting an attribute given namespace, name, and element.
std::shared_ptr<Attr> getNamedItemNS(boost::optional<DOMString> namespaceUri, const DOMString& name) override;
// The setNamedItem(attr) and setNamedItemNS(attr) methods, when invoked, must return the result of setting an attribute given attr and element.
std::shared_ptr<Attr> setNamedItem(std::shared_ptr<Attr> attr, bool insert = false) override;
std::shared_ptr<Attr> setNamedItemNS(std::shared_ptr<Attr> attr, bool insert = false) override;
// The removeNamedItem(qualifiedName) method, when invoked, must run these steps:
// 1. Let attr be the result of removing an attribute given qualifiedName and element.
// 2. If attr is null, then throw a "NotFoundError" DOMException.
// 3. Return attr.
std::shared_ptr<Attr> removeNamedItem(const DOMString& qualifiedName) override;
// The removeNamedItemNS(namespace, name) method, when invoked, must run these steps :
// 1. Let attr be the result of removing an attribute given namespace, name, and element.
// 2. If attr is null, throw a NotFoundError exception.
// 3. Return attr.
std::shared_ptr<Attr> removeNamedItemNS(boost::optional<DOMString> namespaceUri, DOMString name) override;
// Added for future use.
NamedNodeMapIterator iterable() override;
//
// ElementCSSInlineStyle Implementation
//
std::shared_ptr<CSSStyleDeclaration> style();
//
// Implementation extensions
//
DOMToken namespaceURIHash() const
{
return m_NamespaceURIHash;
}
DOMToken prefixHash() const
{
return m_PrefixHash;
}
const DOMToken localNameHash() const
{
return m_NodeNameHash;
}
void setStyleProperty(const DOMString& name, const DOMString& value);
DOMString getStyleProperty(const DOMString& name);
std::shared_ptr<CSSValue> getStylePropertyCSSValue(DOMToken hash);
void removeStyleProperty(const DOMString& name);
void queuePropertyMutation(const DOMString& name);
bool isInHTMLNamespace();
bool isInHTMLDocumentAndNamespace();
bool propertyIsInheritableInSet(DOMToken hash, PropertySet set = PropertySet::PRESENTATION_ATTRIBUTES);
// Returns true if the property name is: supported by the element, inheritable
std::shared_ptr<CSSValue> resolvePropertyValue(DOMToken key, std::shared_ptr<PropertyParsingInfo>& parsingInfo, bool resolveInheritableProperties = true);
std::shared_ptr<CSSValue> getComputedPropertyValue(DOMToken key);
unsigned long elementIndex();
std::shared_ptr<CSSValue> parseCSSValue(DOMToken name, const DOMString& value);
void invalidateComputedPropertyValue(DOMToken name, bool postNotification = false);
void invalidateComputedPropertyValues(const std::unique_ptr<std::vector<DOMToken>>& properties, bool postNotification = false);
void invalidateAllComputedPropertyValues(bool postNotification = false);
ImplementationContextType implementationContext() const
{
return m_ImplementationContext;
}
//
// Scoped undo/redo
//
// If force = false, an undo manager will be returned if it exists.
// If force = true, an UndoManager will be attached to this element if one does not yet exist.
// Element becomes an undo scope host.
// Does not add the "undoscope" attribute to this element.
// Returns a referecne to the UndoManager.
std::shared_ptr<UndoManager> undoManager(bool force = true);
// Returns true if this element is an undo scope host and false otherwise.
bool undoScope() const
{
return (m_UndoManager != nullptr);
}
// Removes the undo scope from this element.
// Also removes the "undoscope" attribute if defined this element and programatic = true.
void removeUndoScope(bool programatic = true);
// Returns the undo scope of this element.
// The undo scope is the nearest ancestor, excluding this element, that is an undo scope host.
// nullptr is returned if there is no undo scope found.
std::shared_ptr<UndoManager> findUndoScope();
//
// XML markup I/O
//
// Writes this element to the given text markup stream.
virtual void writeElementToMarkup(std::shared_ptr<DOMWriterState> state);
// Writes the element's attributes into the opening tag.
virtual void writeElementAttributes(std::shared_ptr<DOMWriterState> state);
virtual bool isAttributeDefaultValue(std::shared_ptr<Attr> attr);
//
// Property helpers
//
// Finds an Attr without all the validation testing.
std::shared_ptr<Attr> getKnownItem(DOMToken token);
// Take a snapshot of what properties are defined in the hierarchy for this element.
void getPropertiesSnapshot(std::shared_ptr<std::unordered_set<DOMToken>> snapshot);
std::shared_ptr<std::unordered_set<DOMToken>> getLocalPropertiesSnapshot();
std::shared_ptr<PropertyParsingMap> attributeParsingMap();
protected:
boost::optional<DOMString> m_NamespaceURI;
DOMToken m_NamespaceURIHash = 0;
boost::optional<DOMString> m_Prefix;
DOMToken m_PrefixHash = 0;
std::vector<std::shared_ptr<Attr>> m_Attributes;
std::shared_ptr<UndoManager> m_UndoManager = nullptr;
std::unordered_map<DOMToken, std::shared_ptr<CSSValue>> m_ComputedPropertyValues;
std::shared_ptr<PropertyParsingMap> m_AttributeParsingMap = nullptr;
std::shared_ptr<PropertyParsingMap> m_StyleParsingMap = nullptr;
std::unique_ptr<std::vector<DOMToken>> m_InvalidStyles;
ImplementationContextType m_ImplementationContext;
std::shared_ptr<Attr> m_StyleAttr = nullptr;
std::shared_ptr<ShadowRoot> m_ShadowRoot = nullptr;
void set_namespaceURI(const boost::optional<DOMString>& value);
void set_prefix(const boost::optional<DOMString>& value);
struct SelectorMatchResult
{
SelectorMatchResult(uint32_t r, std::shared_ptr<CSSStyleDeclaration> d)
{
rank = r;
styledecl = d;
}
uint32_t rank = 0L;
std::shared_ptr<CSSStyleDeclaration> styledecl = nullptr;
};
std::shared_ptr<std::vector<SelectorMatchResult>> m_StyleSheetMatches = nullptr;
std::shared_ptr<std::vector<SelectorMatchResult>> styleSheetMatches();
void onOwnerDocumentChanged() override;
void clearAttributeOutputFlags();
void writeElementAttribute(std::shared_ptr<DOMWriterState> state, std::shared_ptr<Attr> attr);
void writeElementAttributesImpl(std::shared_ptr<DOMWriterState> state, std::vector<DOMString>& attrs);
//
// Back end processing for equivalence operations.
//
// Compares the contents of the nodes as opposed to the pointers.
bool doIsEqualNode(const Node* other) const override;
//
// Back end processing for cloning operations.
//
// Make an instance of the new clone class
// This is a pure virtual function that must be implemented by subclass.
std::shared_ptr<Node> makeCloneTarget() override;
// Copy properties from this instance to the cloned instance.
// Optional, only if there are class-specific properties to copy.
void copyClonedProperties(std::shared_ptr<Node>& clone, bool deep) override;
//
// Implementation-specific back end processing
//
std::vector<std::shared_ptr<Attr>>::const_iterator locateSpecifiedAttributeIterator(const boost::optional<DOMString>& namespaceUri, const boost::optional<DOMString>& prefix, const DOMString& localName);
std::shared_ptr<Attr> locateSpecifiedAttribute(const boost::optional<DOMString>& namespaceUri, const boost::optional<DOMString>& prefix, const DOMString& localName);
//
// Internal attribute notification change
//
void onAttributeUpdated(const std::shared_ptr<Attr>& attribute);
virtual void onComputedPropertyValueInvalidated(DOMToken name);
friend Attr;
};
}
