dmaax/ladybird
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
ladybird/Userland/Libraries/LibWeb/DOM/Node.h

209 lines
6.7 KiB
C
Raw Normal View History

Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 05:38:21 -03:00
/*
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 05:24:48 -03:00
* SPDX-License-Identifier: BSD-2-Clause
Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 05:38:21 -03:00
*/
LibHTML: Start working on a simple HTML library. I'd like to have rich text, and we might as well use HTML for that. :^)
2019-06-15 13:55:47 -03:00
#pragma once
LibHTML: Start fleshing out a basic layout tree.
2019-06-15 17:49:44 -03:00
#include <AK/Badge.h>
LibWeb: Add JSON serialization method to DOM::Node This method builds a JSON object representing the full state of the DOM tree. The JSON that is built will be used for building the DOM Inspector widget for the OutOfProcessWebView.
2021-06-07 12:32:24 -03:00
#include <AK/JsonObjectSerializer.h>
AK: Rename RetainPtr.h => RefPtr.h, Retained.h => NonnullRefPtr.h.
2019-06-21 13:45:35 -03:00
#include <AK/RefPtr.h>
LibHTML: Add virtual Node::tag_name() This is analogous to the DOM's Node.tagName and makes it easy to ask "hey, what kinda thing is this Node?"
2019-09-28 17:59:16 -03:00
#include <AK/String.h>
LibWeb: Switch to using AK::is and AK::downcast
2020-07-26 12:16:18 -03:00
#include <AK/TypeCasts.h>
LibHTML: Start working on a simple HTML library. I'd like to have rich text, and we might as well use HTML for that. :^)
2019-06-15 13:55:47 -03:00
#include <AK/Vector.h>
LibWeb: Start implementing basic JavaScript DOM bindings This patch introduces the Wrapper and Wrappable classes. Node now inherits from Wrappable, and can be wrapped in a GC-allocated Bindings::NodeWrapper object. The only property we expose right now is the very simple nodeName property. When a Document's JS::Interpreter is first instantiated, we add a "document" property with a DocumentWrapper object to the global object. This is pretty cool! :^)
2020-03-14 09:15:11 -03:00
#include <LibWeb/Bindings/Wrappable.h>
LibWeb: Start working on DOM event support This patch adds the EventTarget class and makes Node inherit from it. You can register event listeners on an EventTarget, and when you call dispatch_event() on it, the event listeners will get invoked. An event listener is basically a wrapper around a JS::Function*. This is pretty far from how DOM events should eventually work, but it's a place to start and we'll build more on top of this. :^)
2020-03-18 11:22:31 -03:00
#include <LibWeb/DOM/EventTarget.h>
LibWeb: Make the node mutation algorithms more spec compliant The mutation algorithms now more closely follow the spec and fixes some assertion failures in tests such as Acid3 and Dromaeo. The main thing that is missing right now is passing exceptions to the bindings layer. This is because of issue #6075. I spent a while trying to work it out and got so frustrated I just left it as a FIXME. Besides that, the algorithms bail at the appropriate points. This also makes the adopting steps in the document more spec compliant as it's needed by the insertion algorithm. While I was at it, I added the adoptNode IDL binding. This adds a bunch of ancestor/descendant checks to TreeNode as well. I moved the "remove_all_children" function to Node as it needs to use the full remove algorithm instead of simply removing it from the child list.
2021-04-06 15:34:49 -03:00
#include <LibWeb/DOM/ExceptionOr.h>
LibWeb: Rename directory LibHTML => LibWeb Let's rename this to LibWeb since it aims to provide more parts of the web platform than just HTML. :^)
2020-03-07 06:32:51 -03:00
#include <LibWeb/TreeNode.h>
LibHTML: Start working on a simple HTML library. I'd like to have rich text, and we might as well use HTML for that. :^)
2019-06-15 13:55:47 -03:00
LibWeb: Move DOM classes into the Web::DOM namespace LibWeb keeps growing and the Web namespace is filling up fast. Let's put DOM stuff into Web::DOM, just like we already started doing with SVG stuff in Web::SVG.
2020-07-26 14:37:56 -03:00
namespace Web::DOM {
LibWeb: Move everything into the Web namespace
2020-03-07 06:27:02 -03:00
LibWeb: Add a couple child node operations to Node and add node types
2021-03-06 14:06:25 -03:00
enum class NodeType : u16 {
LibHTML: Start working on a simple HTML library. I'd like to have rich text, and we might as well use HTML for that. :^)
2019-06-15 13:55:47 -03:00
INVALID = 0,
ELEMENT_NODE = 1,
LibWeb: Add a couple child node operations to Node and add node types
2021-03-06 14:06:25 -03:00
ATTRIBUTE_NODE = 2,
LibHTML: Start working on a simple HTML library. I'd like to have rich text, and we might as well use HTML for that. :^)
2019-06-15 13:55:47 -03:00
TEXT_NODE = 3,
LibWeb: Add a couple child node operations to Node and add node types
2021-03-06 14:06:25 -03:00
CDATA_SECTION_NODE = 4,
ENTITY_REFERENCE_NODE = 5,
ENTITY_NODE = 6,
PROCESSING_INSTRUCTION_NODE = 7,
LibHTML: Add Comment and CharacterData nodes and improve HTML parsing This patch adds the CharacterData subclass of Node, which is now the parent class of Text and a new Comment class. A Comment node is one of these in HTML: <!--hello friends--> Since these occur somewhat frequently on the web, we need to be able to parse them. This patch also adds a child rejection mechanism to the DOM tree. Nodes can now override is_child_allowed(Node) and return false if they don't want a particular Node to become a child of theirs. This is used to prevent Document from taking on unwanted children.
2019-10-12 18:26:47 -03:00
COMMENT_NODE = 8,
LibHTML: Start working on a simple HTML library. I'd like to have rich text, and we might as well use HTML for that. :^)
2019-06-15 13:55:47 -03:00
DOCUMENT_NODE = 9,
LibHTML: Add basic <!DOCTYPE> parsing and a DocumentType class Plus, Document::fixup() will now make sure that the document always starts with a doctype node, followed by an <html> element.
2019-10-09 15:17:01 -03:00
DOCUMENT_TYPE_NODE = 10,
LibHTML: Add DocumentFragment Right now this is just a simple ParentNode subclass with its node type being DOCUMENT_FRAGMENT_NODE.
2019-11-06 16:27:53 -03:00
DOCUMENT_FRAGMENT_NODE = 11,
LibWeb: Add a couple child node operations to Node and add node types
2021-03-06 14:06:25 -03:00
NOTATION_NODE = 12
LibHTML: Start working on a simple HTML library. I'd like to have rich text, and we might as well use HTML for that. :^)
2019-06-15 13:55:47 -03:00
};
LibWeb: Start implementing basic JavaScript DOM bindings This patch introduces the Wrapper and Wrappable classes. Node now inherits from Wrappable, and can be wrapped in a GC-allocated Bindings::NodeWrapper object. The only property we expose right now is the very simple nodeName property. When a Document's JS::Interpreter is first instantiated, we add a "document" property with a DocumentWrapper object to the global object. This is pretty cool! :^)
2020-03-14 09:15:11 -03:00
class Node
: public TreeNode<Node>
LibWeb: Start working on DOM event support This patch adds the EventTarget class and makes Node inherit from it. You can register event listeners on an EventTarget, and when you call dispatch_event() on it, the event listeners will get invoked. An event listener is basically a wrapper around a JS::Function*. This is pretty far from how DOM events should eventually work, but it's a place to start and we'll build more on top of this. :^)
2020-03-18 11:22:31 -03:00
, public EventTarget
LibWeb: Start implementing basic JavaScript DOM bindings This patch introduces the Wrapper and Wrappable classes. Node now inherits from Wrappable, and can be wrapped in a GC-allocated Bindings::NodeWrapper object. The only property we expose right now is the very simple nodeName property. When a Document's JS::Interpreter is first instantiated, we add a "document" property with a DocumentWrapper object to the global object. This is pretty cool! :^)
2020-03-14 09:15:11 -03:00
, public Bindings::Wrappable {
LibHTML: Start working on a simple HTML library. I'd like to have rich text, and we might as well use HTML for that. :^)
2019-06-15 13:55:47 -03:00
public:
LibWeb: Implement Document.getElementById() This was pleasantly simple! We don't have an ElementWrapper yet, so it just returns a NodeWrapper, but it still basically works. :^)
2020-03-14 09:24:15 -03:00
using WrapperType = Bindings::NodeWrapper;
LibWeb: Start working on DOM event support This patch adds the EventTarget class and makes Node inherit from it. You can register event listeners on an EventTarget, and when you call dispatch_event() on it, the event listeners will get invoked. An event listener is basically a wrapper around a JS::Function*. This is pretty far from how DOM events should eventually work, but it's a place to start and we'll build more on top of this. :^)
2020-03-18 11:22:31 -03:00
using TreeNode<Node>::ref;
using TreeNode<Node>::unref;
LibWeb: Add DOM::Node::parent_or_shadow_host() This is useful when you want to traverse across shadow boundaries.
2021-02-10 14:22:20 -03:00
ParentNode* parent_or_shadow_host();
const ParentNode* parent_or_shadow_host() const { return const_cast<Node*>(this)->parent_or_shadow_host(); }
LibWeb: Start working on DOM event support This patch adds the EventTarget class and makes Node inherit from it. You can register event listeners on an EventTarget, and when you call dispatch_event() on it, the event listeners will get invoked. An event listener is basically a wrapper around a JS::Function*. This is pretty far from how DOM events should eventually work, but it's a place to start and we'll build more on top of this. :^)
2020-03-18 11:22:31 -03:00
// ^EventTarget
virtual void ref_event_target() final { ref(); }
virtual void unref_event_target() final { unref(); }
LibWeb: Make event dispatching spec-compliant Specification: https://dom.spec.whatwg.org/#concept-event-dispatch This also introduces shadow roots due to it being a requirement of the event dispatcher. However, it does not introduce the full shadow DOM, that can be left for future work. This changes some event dispatches which require certain attributes to be initialised to a value.
2020-11-21 15:32:39 -03:00
virtual bool dispatch_event(NonnullRefPtr<Event>) final;
LibWeb: Make the Window object "inherit" from EventTarget :^) Since Web::Bindings::WindowObject inherits from JS::GlobalObject, it cannot also inherit from Web::Bindings::EventTargetWrapper. However, that's not actually necessary. Instead, we simply set the Window object's prototype to the EventTargetPrototype, and add a little extra branch in the impl_from() function that turns the JS "this" value into a DOM::EventTarget*. With this, you can now call window.addEventListener()! Very cool :^) Fixes #4758.
2021-01-18 08:15:02 -03:00
virtual JS::Object* create_wrapper(JS::GlobalObject&) override;
LibWeb: Start working on DOM event support This patch adds the EventTarget class and makes Node inherit from it. You can register event listeners on an EventTarget, and when you call dispatch_event() on it, the event listeners will get invoked. An event listener is basically a wrapper around a JS::Function*. This is pretty far from how DOM events should eventually work, but it's a place to start and we'll build more on top of this. :^)
2020-03-18 11:22:31 -03:00
LibHTML: Start working on a simple HTML library. I'd like to have rich text, and we might as well use HTML for that. :^)
2019-06-15 13:55:47 -03:00
virtual ~Node();
LibWeb: Make DOM Nodes keep their Document alive In addition to being reference-counted, all nodes that are part of a document must also keep the document alive. This is achieved by adding a second ref-count to the Document object and incrementing/decrementing it whenever a node is created/destroyed in that document. This brings us much closer to a proper DOM lifetime model, although the JS bindings still need more work.
2020-10-11 16:52:59 -03:00
void removed_last_ref();
LibHTML: Start working on a simple HTML library. I'd like to have rich text, and we might as well use HTML for that. :^)
2019-06-15 13:55:47 -03:00
NodeType type() const { return m_type; }
bool is_element() const { return type() == NodeType::ELEMENT_NODE; }
bool is_text() const { return type() == NodeType::TEXT_NODE; }
bool is_document() const { return type() == NodeType::DOCUMENT_NODE; }
LibHTML: Add basic <!DOCTYPE> parsing and a DocumentType class Plus, Document::fixup() will now make sure that the document always starts with a doctype node, followed by an <html> element.
2019-10-09 15:17:01 -03:00
bool is_document_type() const { return type() == NodeType::DOCUMENT_TYPE_NODE; }
LibHTML: Add Comment and CharacterData nodes and improve HTML parsing This patch adds the CharacterData subclass of Node, which is now the parent class of Text and a new Comment class. A Comment node is one of these in HTML: <!--hello friends--> Since these occur somewhat frequently on the web, we need to be able to parse them. This patch also adds a child rejection mechanism to the DOM tree. Nodes can now override is_child_allowed(Node) and return false if they don't want a particular Node to become a child of theirs. This is used to prevent Document from taking on unwanted children.
2019-10-12 18:26:47 -03:00
bool is_comment() const { return type() == NodeType::COMMENT_NODE; }
bool is_character_data() const { return type() == NodeType::TEXT_NODE || type() == NodeType::COMMENT_NODE; }
LibHTML: Add DocumentFragment Right now this is just a simple ParentNode subclass with its node type being DOCUMENT_FRAGMENT_NODE.
2019-11-06 16:27:53 -03:00
bool is_document_fragment() const { return type() == NodeType::DOCUMENT_FRAGMENT_NODE; }
LibWeb: Node::is_parent_node() should return true for DocumentFragments
2020-03-25 14:48:10 -03:00
bool is_parent_node() const { return is_element() || is_document() || is_document_fragment(); }
LibWeb: Make event dispatching spec-compliant Specification: https://dom.spec.whatwg.org/#concept-event-dispatch This also introduces shadow roots due to it being a requirement of the event dispatcher. However, it does not introduce the full shadow DOM, that can be left for future work. This changes some event dispatches which require certain attributes to be initialised to a value.
2020-11-21 15:32:39 -03:00
bool is_slottable() const { return is_element() || is_text(); }
LibHTML: Start working on a simple HTML library. I'd like to have rich text, and we might as well use HTML for that. :^)
2019-06-15 13:55:47 -03:00
LibWeb: Ignore svg elements outside of <svg> when building layout tree An svg layout element without a `SVGSVGElement` ancestor caused a failed assertion before, because the svg context does not exist when `paint()` is called
2021-08-05 05:26:09 -03:00
virtual bool requires_svg_container() const { return false; }
virtual bool is_svg_container() const { return false; }
LibWeb: Add a couple child node operations to Node and add node types
2021-03-06 14:06:25 -03:00
// NOTE: This is intended for the JS bindings.
u16 node_type() const { return (u16)m_type; }
LibWeb: Only allow editing of elements with contenteditable="true" We now respect the contenteditable HTML attribute and only let you edit content inside explicitly editable elements.
2020-08-02 11:05:59 -03:00
virtual bool is_editable() const;
LibWeb: Add fast_is<HTMLTemplateElement>() This was showing up as hot in profiles, as the HTML parser calls it quite a lot.
2021-09-15 19:52:10 -03:00
virtual bool is_html_template_element() const { return false; }
LibWeb: Fix some FIXMEs related to ExceptionOr<T> This fixes a few FIXMEs mentioned in 5beacf08a2d578d0eb36d6320255d0f4634a1085, which depended on #6075 being fixed.
2021-04-13 15:33:48 -03:00
ExceptionOr<NonnullRefPtr<Node>> pre_insert(NonnullRefPtr<Node>, RefPtr<Node>);
ExceptionOr<NonnullRefPtr<Node>> pre_remove(NonnullRefPtr<Node>);
LibWeb: Make the node mutation algorithms more spec compliant The mutation algorithms now more closely follow the spec and fixes some assertion failures in tests such as Acid3 and Dromaeo. The main thing that is missing right now is passing exceptions to the bindings layer. This is because of issue #6075. I spent a while trying to work it out and got so frustrated I just left it as a FIXME. Besides that, the algorithms bail at the appropriate points. This also makes the adopting steps in the document more spec compliant as it's needed by the insertion algorithm. While I was at it, I added the adoptNode IDL binding. This adds a bunch of ancestor/descendant checks to TreeNode as well. I moved the "remove_all_children" function to Node as it needs to use the full remove algorithm instead of simply removing it from the child list.
2021-04-06 15:34:49 -03:00
LibWeb: Fix some FIXMEs related to ExceptionOr<T> This fixes a few FIXMEs mentioned in 5beacf08a2d578d0eb36d6320255d0f4634a1085, which depended on #6075 being fixed.
2021-04-13 15:33:48 -03:00
ExceptionOr<NonnullRefPtr<Node>> append_child(NonnullRefPtr<Node>);
LibWeb: Make the node mutation algorithms more spec compliant The mutation algorithms now more closely follow the spec and fixes some assertion failures in tests such as Acid3 and Dromaeo. The main thing that is missing right now is passing exceptions to the bindings layer. This is because of issue #6075. I spent a while trying to work it out and got so frustrated I just left it as a FIXME. Besides that, the algorithms bail at the appropriate points. This also makes the adopting steps in the document more spec compliant as it's needed by the insertion algorithm. While I was at it, I added the adoptNode IDL binding. This adds a bunch of ancestor/descendant checks to TreeNode as well. I moved the "remove_all_children" function to Node as it needs to use the full remove algorithm instead of simply removing it from the child list.
2021-04-06 15:34:49 -03:00
void insert_before(NonnullRefPtr<Node> node, RefPtr<Node> child, bool suppress_observers = false);
void remove(bool suppress_observers = false);
void remove_all_children(bool suppress_observers = false);
LibWeb: Add implementation of Node.compareDocumentPosition() While looking into getting Duck Duck Go loading further in the Browser, I noticed that it was complaining about the missing method Node.compareDocumentPosition. This change implements as much of the DOM spec as possible with the current implementation of the DOM to date. The implementation is validated by new tests in the Node.js.
2021-04-10 21:21:22 -03:00
u16 compare_document_position(RefPtr<Node> other);
LibWeb: Expose Node.appendChild() to the web This is a very barebones implementation of appendChild() that doesn't take any of the idiosyncratic DOM behaviors into account yet. Also teach the wrapper generator how to turn an Interpreter argument into a Node&.
2020-06-20 20:00:58 -03:00
LibWeb: Implement Node.replaceChild The `if (child->parent())` check seems to be redundant, but I'm keeping it just to match the spec.
2021-05-06 20:52:23 -03:00
ExceptionOr<NonnullRefPtr<Node>> replace_child(NonnullRefPtr<Node> node, NonnullRefPtr<Node> child);
LibWeb: Add the cloning steps in clone_node This will be used in HTMLTemplateElement later to clone template contents. This makes the clone functions non-const in the process, as the cloning steps can have side effects.
2021-07-05 01:30:24 -03:00
NonnullRefPtr<Node> clone_node(Document* document = nullptr, bool clone_children = false);
ExceptionOr<NonnullRefPtr<Node>> clone_node_binding(bool deep);
LibWeb: Implement Node.cloneNode() With this we can now successfully run a Vue.js 2 hello world! :^)
2021-04-13 20:25:10 -03:00
LibWeb: Add a couple child node operations to Node and add node types
2021-03-06 14:06:25 -03:00
// NOTE: This is intended for the JS bindings.
bool has_child_nodes() const { return has_children(); }
NonnullRefPtrVector<Node> child_nodes() const;
LibWeb: Make DOM::Node::create_layout_node() not need parent's style The StyleResolver can find the specified CSS values for the parent element via the DOM. Forcing everyone to locate specified values for their parent was completely unnecessary.
2021-01-06 10:27:40 -03:00
virtual RefPtr<Layout::Node> create_layout_node();
LibHTML: Move layout tree building to Node This also fixes another bug with inline wrappers. Namely, we should only add inline wrappers if a block node has both non-block (inline or text) and block children.
2019-09-25 06:17:29 -03:00
LibWeb: Make Element::tag_name() return a const FlyString& The more generic virtual variant is renamed to node_name() and now only Element has tag_name(). This removes a huge amount of String ctor/dtor churn in selector matching.
2020-06-16 14:09:14 -03:00
virtual FlyString node_name() const = 0;
LibHTML: Add virtual Node::tag_name() This is analogous to the DOM's Node.tagName and makes it easy to ask "hey, what kinda thing is this Node?"
2019-09-28 17:59:16 -03:00
LibWeb: Make Node.textContent more spec compliant The current implementation felt a bit ad-hoc and notably allowed textContent to operate on all node types. It also only returned the child text content of the Node instead of the descendant text content.
2021-09-05 20:21:59 -03:00
String descendant_text_content() const;
String text_content() const;
void set_text_content(String const&);
LibHTML: Add Node::text_content() This returns a String built from all of a Node's text descendants, including itself.
2019-09-29 11:22:15 -03:00
LibWeb: Implement fragment parsing and use it for Element.innerHTML This patch implements most of the HTML fragment parsing algorithm and ports Element::set_inner_html() to it. This was the last remaining user of the old HTML parser. :^)
2020-06-25 18:42:08 -03:00
Document& document() { return *m_document; }
const Document& document() const { return *m_document; }
LibHTML: Make sure every DOM Node belongs to a Document
2019-09-29 06:43:07 -03:00
LibWeb: Expose Node.ownerDocument Required by jQuery.
2021-05-02 17:03:50 -03:00
RefPtr<Document> owner_document() const;
LibWeb: Move HTML classes into the Web::HTML namespace
2020-07-28 13:20:36 -03:00
const HTML::HTMLAnchorElement* enclosing_link_element() const;
const HTML::HTMLElement* enclosing_html_element() const;
LibWeb: Get the first DOM node with a 'title' attribute for tooltip area Rather than expecting the first parent to have a 'title' attribute, search all ancestors.
2021-03-30 13:06:06 -03:00
const HTML::HTMLElement* enclosing_html_element_with_attribute(const FlyString&) const;
LibHTML: Implement basic HTMLElement.title support We now show a tooltip for the hovered node's enclosing HTML element's title attribute, if one is present. This patch also adds HTMLHeadingElement. The tags h1-h6 will now create the right kind of objects.
2019-09-29 07:24:36 -03:00
LibWeb: Add some helpers to the DOM Node class This patch adds the following things needed by the HTML spec: - Node::child_text_content() - Node::is_connected() - Node::root()
2020-05-24 16:59:24 -03:00
String child_text_content() const;
LibWeb: Make Node::root return a reference The root of a node can never be null, as "the root of an object is itself, if its parent is null, or else it is the root of its parent." https://dom.spec.whatwg.org/#concept-tree-root
2021-09-02 15:27:42 -03:00
Node& root();
const Node& root() const
LibWeb: Make event dispatching spec-compliant Specification: https://dom.spec.whatwg.org/#concept-event-dispatch This also introduces shadow roots due to it being a requirement of the event dispatcher. However, it does not introduce the full shadow DOM, that can be left for future work. This changes some event dispatches which require certain attributes to be initialised to a value.
2020-11-21 15:32:39 -03:00
{
return const_cast<Node*>(this)->root();
}
LibWeb: Make Node::root return a reference The root of a node can never be null, as "the root of an object is itself, if its parent is null, or else it is the root of its parent." https://dom.spec.whatwg.org/#concept-tree-root
2021-09-02 15:27:42 -03:00
Node& shadow_including_root();
const Node& shadow_including_root() const
LibWeb: Make event dispatching spec-compliant Specification: https://dom.spec.whatwg.org/#concept-event-dispatch This also introduces shadow roots due to it being a requirement of the event dispatcher. However, it does not introduce the full shadow DOM, that can be left for future work. This changes some event dispatches which require certain attributes to be initialised to a value.
2020-11-21 15:32:39 -03:00
{
return const_cast<Node*>(this)->shadow_including_root();
}
LibWeb: Add some helpers to the DOM Node class This patch adds the following things needed by the HTML spec: - Node::child_text_content() - Node::is_connected() - Node::root()
2020-05-24 16:59:24 -03:00
bool is_connected() const;
LibWeb: Add Node.parentNode and Node.parentElement to DOM API :^)
2020-06-20 17:26:54 -03:00
Node* parent_node() { return parent(); }
const Node* parent_node() const { return parent(); }
Element* parent_element();
const Element* parent_element() const;
LibWeb: Make the node mutation event functions spec compliant This particularly affects the insertion steps and the removed steps. The insertion steps no longer take into the parent that the node was inserted to, as per the spec. Due to this, I have renamed the function from "inserted_into" to simply "inserted". None of the users of the insertion steps was using it anyway. The removed steps now take a pointer to the old parent instead of a reference. This is because it is optional according to the spec and old parent is null when running the removal steps for the descendants of a node that just got removed. This commit does not affect HTMLScriptElement as there is a bit more to that, which is better suited for a separate commit. Also adds in the adopted steps as they will be used later.
2021-04-06 13:58:20 -03:00
virtual void inserted();
virtual void removed_from(Node*) { }
LibWeb: Switch to using AK::is and AK::downcast
2020-07-26 12:16:18 -03:00
virtual void children_changed() { }
LibWeb: Make adopted_from no longer take a const Document reference Nodes implementing the adoption steps can modify the passed in document, for example HTMLTemplateElement does so to adopt it's contents into the new document.
2021-07-05 01:33:35 -03:00
virtual void adopted_from(Document&) { }
LibWeb: Add the cloning steps in clone_node This will be used in HTMLTemplateElement later to clone template contents. This makes the clone functions non-const in the process, as the cloning steps can have side effects.
2021-07-05 01:30:24 -03:00
virtual void cloned(Node&, bool) {};
LibHTML: Add inserted_into() and removed_from() TreeNode callbacks These will be called when a Node or LayoutNode is inserted or removed from a tree. They get the parent node as an argument.
2019-09-29 12:40:39 -03:00
LibWeb: Rename LayoutNode classes and move them into Layout namespace Bring the names of various boxes closer to spec language. This should hopefully make things easier to understand and hack on. :^) Some notable changes: - LayoutNode -> Layout::Node - LayoutBox -> Layout::Box - LayoutBlock -> Layout::BlockBox - LayoutReplaced -> Layout::ReplacedBox - LayoutDocument -> Layout::InitialContainingBlockBox - LayoutText -> Layout::TextNode - LayoutInline -> Layout::InlineNode Note that this is not strictly a "box tree" as we also hang inline/text nodes in the same tree, and they don't generate boxes. (Instead, they contribute line box fragments to their containing block!)
2020-11-22 11:53:01 -03:00
const Layout::Node* layout_node() const { return m_layout_node; }
Layout::Node* layout_node() { return m_layout_node; }
LibHTML: Add support for <body bgcolor="#rrggbb" text="#rrggbb"> This patch implements basic support for presentational hints, which are old-school HTML attributes that affect style. You add support for a presentational hint attribute by overriding Element::apply_presentational_hints(StyleProperties&) and setting all of the corresponding CSS properties as appropriate. To make the background color fill the entire document, not just the bounds of the <body> element's LayoutNode, we special-case it in the HtmlView::paint_event() code for now. I'm not entirely sure what the nicest solution would be, but I'm sure we'll discover it eventually.
2019-10-04 16:05:52 -03:00
LibWeb: Rename LayoutNode classes and move them into Layout namespace Bring the names of various boxes closer to spec language. This should hopefully make things easier to understand and hack on. :^) Some notable changes: - LayoutNode -> Layout::Node - LayoutBox -> Layout::Box - LayoutBlock -> Layout::BlockBox - LayoutReplaced -> Layout::ReplacedBox - LayoutDocument -> Layout::InitialContainingBlockBox - LayoutText -> Layout::TextNode - LayoutInline -> Layout::InlineNode Note that this is not strictly a "box tree" as we also hang inline/text nodes in the same tree, and they don't generate boxes. (Instead, they contribute line box fragments to their containing block!)
2020-11-22 11:53:01 -03:00
void set_layout_node(Badge<Layout::Node>, Layout::Node*) const;
LibHTML: Add support for <body bgcolor="#rrggbb" text="#rrggbb"> This patch implements basic support for presentational hints, which are old-school HTML attributes that affect style. You add support for a presentational hint attribute by overriding Element::apply_presentational_hints(StyleProperties&) and setting all of the corresponding CSS properties as appropriate. To make the background color fill the entire document, not just the bounds of the <body> element's LayoutNode, we special-case it in the HtmlView::paint_event() code for now. I'm not entirely sure what the nicest solution would be, but I'm sure we'll discover it eventually.
2019-10-04 16:05:52 -03:00
LibHTML: Add Comment and CharacterData nodes and improve HTML parsing This patch adds the CharacterData subclass of Node, which is now the parent class of Text and a new Comment class. A Comment node is one of these in HTML: <!--hello friends--> Since these occur somewhat frequently on the web, we need to be able to parse them. This patch also adds a child rejection mechanism to the DOM tree. Nodes can now override is_child_allowed(Node) and return false if they don't want a particular Node to become a child of theirs. This is used to prevent Document from taking on unwanted children.
2019-10-12 18:26:47 -03:00
virtual bool is_child_allowed(const Node&) const { return true; }
LibHTML: Batch style updates and make them start from the root Use a zero-timer to schedule a style update after invalidating style on any node. Nodes now have a needs_style_update flag which helps us batch and coalesce the work. We also start style updates at the root and work our way through the document, updating any node that has the needs_style_update flag set. This is slower than what we were doing before, but far more correct. There is a ton of room for improvement here. :^)
2019-10-19 13:57:02 -03:00
bool needs_style_update() const { return m_needs_style_update; }
LibWeb: Make DOM::Node::set_needs_style_update() schedule the update After you mark a node as needing new style, there's no situation in which we don't want a style update to happen, so just take care of scheduling it automatically.
2020-12-13 11:19:42 -03:00
void set_needs_style_update(bool);
LibHTML: Batch style updates and make them start from the root Use a zero-timer to schedule a style update after invalidating style on any node. Nodes now have a needs_style_update flag which helps us batch and coalesce the work. We also start style updates at the root and work our way through the document, updating any node that has the needs_style_update flag set. This is slower than what we were doing before, but far more correct. There is a ton of room for improvement here. :^)
2019-10-19 13:57:02 -03:00
LibWeb: Limit style update tree traversal to dirty subtrees This patch adds a second style dirty bit that tracks whether a DOM node has one or more children with dirty style. This allows the style update to skip over entire subtrees where all nodes are clean.
2020-12-14 08:04:30 -03:00
bool child_needs_style_update() const { return m_child_needs_style_update; }
void set_child_needs_style_update(bool b) { m_child_needs_style_update = b; }
LibHTML: Implement basic partial style invalidation This patch makes it possible to call Node::invalidate_style() and have that node and all of its ancestors recompute their style. We then figure out if the new style is visually different from the old style, and if so do a paint invalidation with set_needs_display(). Note that the "are they visually different" code is very incomplete! Use this to make hover effects a lot more efficient. They no longer cause a full relayout+repaint, but only a style invalidation. Style invalidations are still quite heavy though, and there's a lot of room for improvement there. :^)
2019-10-14 13:32:02 -03:00
void invalidate_style();
LibHTML+Browser: Show target URL of hovered links in Browser statusbar HtmlView will now invoke the on_link_hover hook when the cursor enters or leaves a DOM node that has an enclosing link element. This patch also updates the meaning of Node::enclosing_link_element() to find the nearest HTMLAnchorElementAncestor *with an href attribute*.
2019-10-19 16:21:29 -03:00
bool is_link() const;
LibWeb: Implement fragment parsing and use it for Element.innerHTML This patch implements most of the HTML fragment parsing algorithm and ports Element::set_inner_html() to it. This was the last remaining user of the old HTML parser. :^)
2020-06-25 18:42:08 -03:00
void set_document(Badge<Document>, Document&);
LibWeb: Make event dispatching spec-compliant Specification: https://dom.spec.whatwg.org/#concept-event-dispatch This also introduces shadow roots due to it being a requirement of the event dispatcher. However, it does not introduce the full shadow DOM, that can be left for future work. This changes some event dispatches which require certain attributes to be initialised to a value.
2020-11-21 15:32:39 -03:00
virtual EventTarget* get_parent(const Event&) override;
LibWeb: Add fast_is<T>() for some DOM and layout node subclasses The generic is<T>() uses dynamic_cast which is fine in the majority of cases, but when one of them shows up in profiles, we can make it faster by answering the is-a question manually.
2021-01-17 05:34:01 -03:00
template<typename T>
bool fast_is() const = delete;
LibWeb: Make the node mutation algorithms more spec compliant The mutation algorithms now more closely follow the spec and fixes some assertion failures in tests such as Acid3 and Dromaeo. The main thing that is missing right now is passing exceptions to the bindings layer. This is because of issue #6075. I spent a while trying to work it out and got so frustrated I just left it as a FIXME. Besides that, the algorithms bail at the appropriate points. This also makes the adopting steps in the document more spec compliant as it's needed by the insertion algorithm. While I was at it, I added the adoptNode IDL binding. This adds a bunch of ancestor/descendant checks to TreeNode as well. I moved the "remove_all_children" function to Node as it needs to use the full remove algorithm instead of simply removing it from the child list.
2021-04-06 15:34:49 -03:00
ExceptionOr<void> ensure_pre_insertion_validity(NonnullRefPtr<Node> node, RefPtr<Node> child) const;
bool is_host_including_inclusive_ancestor_of(const Node&) const;
LibWeb: Check if scripting is disabled before running script This is not a full check, it's just enough to prevent script execution in DOMParser.
2021-07-04 23:59:47 -03:00
bool is_scripting_disabled() const;
LibWeb: Implement Node.contains Used by Web Components Polyfills.
2021-07-05 01:55:02 -03:00
bool contains(RefPtr<Node>) const;
LibWeb: Add JSON serialization method to DOM::Node This method builds a JSON object representing the full state of the DOM tree. The JSON that is built will be used for building the DOM Inspector widget for the OutOfProcessWebView.
2021-06-07 12:32:24 -03:00
// Used for dumping the DOM Tree
void serialize_tree_as_json(JsonObjectSerializer<StringBuilder>&) const;
LibWeb: Add shadow including ancestor/descendant checks
2021-09-01 22:17:13 -03:00
bool is_shadow_including_descendant_of(Node const&) const;
bool is_shadow_including_inclusive_descendant_of(Node const&) const;
bool is_shadow_including_ancestor_of(Node const&) const;
bool is_shadow_including_inclusive_ancestor_of(Node const&) const;
LibWeb: Give each Node a unique ID We maintain a directory of ID -> Node. Nodes add themselves to this directory when they are created, receiving a random ID. When a Node is destroyed, it removes itself from this directory. Anyone can request a Node from the directory by its ID using `Node::from_id()`. We reserve the `0` ID to mean "none". These IDs allow different processes to communicate about a given Node over IPC, for example the DOM Inspector.
2021-08-30 11:52:08 -03:00
i32 id() const { return m_id; }
static Node* from_id(i32 node_id);
LibWeb: Implement HTML fragment serialisation and use it in innerHTML The previous implementation was about a half implementation and was tied to Element::innerHTML. This separates it and puts it into HTMLDocumentParser, as this is in the parsing section of the spec. This provides a near finished HTML fragment serialisation algorithm, bar namespaces in attributes and the `is` value.
2021-09-13 18:42:15 -03:00
String serialize_fragment() const;
LibWeb: Implement the (string) replace all operations for Node
2021-09-05 21:25:58 -03:00
void replace_all(RefPtr<Node>);
void string_replace_all(String const&);
LibWeb: Implement Node.isSameNode(Node? otherNode)
2021-09-13 07:49:23 -03:00
bool is_same_node(Node const*) const;
LibWeb: Implement Node.isEqualNode(Node? otherNode)
2021-09-13 07:54:24 -03:00
bool is_equal_node(Node const*) const;
LibWeb: Implement Node.isSameNode(Node? otherNode)
2021-09-13 07:49:23 -03:00
LibHTML: Start working on a simple HTML library. I'd like to have rich text, and we might as well use HTML for that. :^)
2019-06-15 13:55:47 -03:00
protected:
LibHTML: Make sure every DOM Node belongs to a Document
2019-09-29 06:43:07 -03:00
Node(Document&, NodeType);
LibHTML: Start working on a simple HTML library. I'd like to have rich text, and we might as well use HTML for that. :^)
2019-06-15 13:55:47 -03:00
LibWeb: Implement fragment parsing and use it for Element.innerHTML This patch implements most of the HTML fragment parsing algorithm and ports Element::set_inner_html() to it. This was the last remaining user of the old HTML parser. :^)
2020-06-25 18:42:08 -03:00
Document* m_document { nullptr };
LibWeb: Rename LayoutNode classes and move them into Layout namespace Bring the names of various boxes closer to spec language. This should hopefully make things easier to understand and hack on. :^) Some notable changes: - LayoutNode -> Layout::Node - LayoutBox -> Layout::Box - LayoutBlock -> Layout::BlockBox - LayoutReplaced -> Layout::ReplacedBox - LayoutDocument -> Layout::InitialContainingBlockBox - LayoutText -> Layout::TextNode - LayoutInline -> Layout::InlineNode Note that this is not strictly a "box tree" as we also hang inline/text nodes in the same tree, and they don't generate boxes. (Instead, they contribute line box fragments to their containing block!)
2020-11-22 11:53:01 -03:00
mutable WeakPtr<Layout::Node> m_layout_node;
LibHTML: Start working on a simple HTML library. I'd like to have rich text, and we might as well use HTML for that. :^)
2019-06-15 13:55:47 -03:00
NodeType m_type { NodeType::INVALID };
LibWeb: Limit style update tree traversal to dirty subtrees This patch adds a second style dirty bit that tracks whether a DOM node has one or more children with dirty style. This allows the style update to skip over entire subtrees where all nodes are clean.
2020-12-14 08:04:30 -03:00
bool m_needs_style_update { false };
bool m_child_needs_style_update { false };
LibWeb: Give each Node a unique ID We maintain a directory of ID -> Node. Nodes add themselves to this directory when they are created, receiving a random ID. When a Node is destroyed, it removes itself from this directory. Anyone can request a Node from the directory by its ID using `Node::from_id()`. We reserve the `0` ID to mean "none". These IDs allow different processes to communicate about a given Node over IPC, for example the DOM Inspector.
2021-08-30 11:52:08 -03:00
i32 m_id;
LibHTML: Start working on a simple HTML library. I'd like to have rich text, and we might as well use HTML for that. :^)
2019-06-15 13:55:47 -03:00
};
LibHTML: Add is<ElementType> and to<ElementType> helper functions These will help us write node-type-aware template functions.
2019-10-06 15:37:39 -03:00
LibWeb: Move everything into the Web namespace
2020-03-07 06:27:02 -03:00
}
Reference in a new issue Copy permalink