Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-10-31 13:20:59 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Userland/Libraries/LibWeb/DOM/Node.h

236 lines
7.6 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 09:38:21 +01:00
/*
LibWeb: Compute element style in Layout::TreeBuilder Instead of making each Layout::Node compute style for itself, we now compute it in TreeBuilder before even calling create_layout_node(). For non-element DOM nodes, we create the style and layout tree node in TreeBuilder. This allows us to move create_layout_node() from DOM::Node to DOM::Element.
2022-02-05 13:17:01 +01:00
* Copyright (c) 2018-2022, Andreas Kling <kling@serenityos.org>
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 09:38:21 +01:00
*
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 01:24:48 -07: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 09:38:21 +01: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 18:55:47 +02:00
#pragma once
LibHTML: Start fleshing out a basic layout tree.
2019-06-15 22:49:44 +02: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 16:32:24 +01:00
#include <AK/JsonObjectSerializer.h>
AK: Rename RetainPtr.h => RefPtr.h, Retained.h => NonnullRefPtr.h.
2019-06-21 18:45:35 +02: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 22:59:16 +02:00
#include <AK/String.h>
LibWeb: Switch to using AK::is and AK::downcast
2020-07-26 17:16:18 +02: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 18:55:47 +02: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 13:15:11 +01: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 15:22:31 +01: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 19:34:49 +01: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 10:32:51 +01: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 18:55:47 +02: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 19:37:56 +02:00
namespace Web::DOM {
LibWeb: Move everything into the Web namespace
2020-03-07 10:27:02 +01:00
LibWeb: Add a couple child node operations to Node and add node types
2021-03-06 17:06:25 +00: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 18:55:47 +02:00
INVALID = 0,
ELEMENT_NODE = 1,
LibWeb: Add a couple child node operations to Node and add node types
2021-03-06 17:06:25 +00: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 18:55:47 +02:00
TEXT_NODE = 3,
LibWeb: Add a couple child node operations to Node and add node types
2021-03-06 17:06:25 +00: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 23:26:47 +02: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 18:55:47 +02: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 20:17:01 +02: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 20:27:53 +01:00
DOCUMENT_FRAGMENT_NODE = 11,
LibWeb: Add a couple child node operations to Node and add node types
2021-03-06 17:06:25 +00: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 18:55:47 +02:00
};
LibWeb: Implement Node.getRootNode
2021-10-16 03:04:55 +01:00
struct GetRootNodeOptions {
bool composed { false };
};
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 13:15:11 +01: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 15:22:31 +01: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 13:15:11 +01: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 18:55:47 +02: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 13:24:15 +01: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 15:22:31 +01: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 18:22:20 +01:00
ParentNode* parent_or_shadow_host();
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
ParentNode const* parent_or_shadow_host() const { return const_cast<Node*>(this)->parent_or_shadow_host(); }
LibWeb: Add DOM::Node::parent_or_shadow_host() This is useful when you want to traverse across shadow boundaries.
2021-02-10 18:22:20 +01:00
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 15:22:31 +01:00
// ^EventTarget
virtual void ref_event_target() final { ref(); }
virtual void unref_event_target() final { unref(); }
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 12:15:02 +01: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 15:22:31 +01: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 18:55:47 +02: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 21:52:59 +02: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 18:55:47 +02: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 20:17:01 +02: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 23:26:47 +02: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 20:27:53 +01: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 18:48:10 +01: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 18:32:39 +00:00
bool is_slottable() const { return is_element() || is_text(); }
LibWeb: Make Range.setStart and Range.setEnd spec compliant These functions are way more involved than simply setting their respective boundary points :^)
2022-01-31 18:05:54 +00:00
bool is_attribute() const { return type() == NodeType::ATTRIBUTE_NODE; }
LibWeb: Add some fast_is<T> helpers for hot classes on GitHub :^)
2022-03-13 17:21:27 +01:00
virtual bool is_shadow_root() const { return false; }
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 18:55:47 +02: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 10:26:09 +02:00
virtual bool requires_svg_container() const { return false; }
virtual bool is_svg_container() const { return false; }
LibWeb: Add fast_is<SVG::SVGSVGElement>()
2022-03-12 16:08:40 +01:00
virtual bool is_svg_svg_element() const { return false; }
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 10:26:09 +02:00
LibWeb: Add Node::in_a_document_tree() This is "in a document tree" from the DOM spec.
2021-09-29 22:23:28 +02:00
bool in_a_document_tree() const;
LibWeb: Add a couple child node operations to Node and add node types
2021-03-06 17:06:25 +00: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 16:05:59 +02:00
virtual bool is_editable() const;
LibWeb: Add fast_is<T>() for HTML::HTMLHtmlElement Another one spotted in a scroll-up-and-down profile.
2021-10-27 17:58:57 +02:00
virtual bool is_html_html_element() const { return false; }
LibWeb: Add fast_is<T> for HTML::HTMLAnchorElement We were spending 20% of style computation time on the HTML spec on deciding whether DOM nodes were HTML anchor (a) tags or not.
2022-03-02 15:14:38 +01:00
virtual bool is_html_anchor_element() const { return false; }
LibWeb: Add fast_is<HTMLTemplateElement>() This was showing up as hot in profiles, as the HTML parser calls it quite a lot.
2021-09-16 00:52:10 +02:00
virtual bool is_html_template_element() const { return false; }
LibWeb: Add JSON serialization for nested browsing contexts This changes allows for nested browser contexts to be embedded in the serialized JSON of their container element (like `iframe`) and enables their inspection in the DOM Inspector.
2021-11-24 19:15:04 +03:00
virtual bool is_browsing_context_container() const { return false; }
LibWeb: Add fast_is<HTMLTemplateElement>() This was showing up as hot in profiles, as the HTML parser calls it quite a lot.
2021-09-16 00:52:10 +02: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 23:03:48 +04:30
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 19:34:49 +01: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 23:03:48 +04:30
ExceptionOr<NonnullRefPtr<Node>> append_child(NonnullRefPtr<Node>);
LibWeb: Implement Node.removeChild() in terms of "pre-remove" This is what the spec wants us to do.
2022-02-21 22:21:59 +01:00
ExceptionOr<NonnullRefPtr<Node>> remove_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 19:34:49 +01: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 17:21:22 -07: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-21 01:00:58 +02: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-07 00:52:23 +01: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 05:30:24 +01: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-14 01:25:10 +02:00
LibWeb: Add a couple child node operations to Node and add node types
2021-03-06 17:06:25 +00:00
// NOTE: This is intended for the JS bindings.
bool has_child_nodes() const { return has_children(); }
LibWeb: Convert Node.childNodes to NodeList This changes the old child_nodes implementation to children_as_vector so that can still be used in insert_before.
2021-10-02 20:37:45 +01:00
NonnullRefPtr<NodeList> child_nodes();
NonnullRefPtrVector<Node> children_as_vector() const;
LibWeb: Add a couple child node operations to Node and add node types
2021-03-06 17:06:25 +00: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 19:09:14 +02: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 22:59:16 +02: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-06 00:21:59 +01: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 16:22:15 +02:00
LibWeb: Implement `Node.nodeValue` DOM attribute
2022-02-18 22:11:43 +00:00
String node_value() const;
void set_node_value(String 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 23:42:08 +02:00
Document& document() { return *m_document; }
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
Document const& document() const { return *m_document; }
LibHTML: Make sure every DOM Node belongs to a Document
2019-09-29 11:43:07 +02:00
LibWeb: Expose Node.ownerDocument Required by jQuery.
2021-05-02 21:03:50 +01:00
RefPtr<Document> owner_document() const;
LibWeb: Move HTML classes into the Web::HTML namespace
2020-07-28 18:20:36 +02:00
const HTML::HTMLAnchorElement* enclosing_link_element() const;
const HTML::HTMLElement* enclosing_html_element() const;
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
const HTML::HTMLElement* enclosing_html_element_with_attribute(FlyString const&) 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 12:24:36 +02: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 21:59:24 +02: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 19:27:42 +01:00
Node& root();
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
Node const& 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 18:32:39 +00: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 19:27:42 +01:00
Node& shadow_including_root();
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
Node const& 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 18:32:39 +00: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 21:59:24 +02:00
bool is_connected() const;
LibWeb: Add Node.parentNode and Node.parentElement to DOM API :^)
2020-06-20 22:26:54 +02:00
Node* parent_node() { return parent(); }
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
Node const* parent_node() const { return parent(); }
LibWeb: Add Node.parentNode and Node.parentElement to DOM API :^)
2020-06-20 22:26:54 +02:00
Element* parent_element();
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
Element const* parent_element() const;
LibWeb: Add Node.parentNode and Node.parentElement to DOM API :^)
2020-06-20 22:26:54 +02:00
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 17:58:20 +01:00
virtual void inserted();
virtual void removed_from(Node*) { }
LibWeb: Switch to using AK::is and AK::downcast
2020-07-26 17:16:18 +02: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 05:33:35 +01: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 05:30:24 +01: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 17:40:39 +02:00
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
Layout::Node const* layout_node() const { return m_layout_node; }
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 15:53:01 +01:00
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 21:05:52 +02:00
LibWeb: Split Paintable into Paintable and PaintableBox To prepare for paintable inline content, we take the basic painting functionality and hoist it into a base class.
2022-03-10 15:50:57 +01:00
Painting::PaintableBox const* paint_box() const;
LibWeb: Move mouse event and label logic from layout to painting tree Input events have nothing to do with layout, so let's not send them to layout nodes. The job of Paintable starts to become clear. It represents a paintable item that can be rendered into the viewport, which means it can also be targeted by the mouse cursor.
2022-03-10 22:46:35 +01:00
Painting::Paintable const* paintable() const;
LibWeb: Add Painting::Box and move things from Layout::Box into it The "paintable" state in Layout::Box was actually not safe to access until after layout had been performed. As a first step towards making this harder to mess up accidentally, this patch moves painting information from Layout::Box to a new class: Painting::Box. Every layout can have a corresponding paint box, and it holds the final used metrics determined by layout. The paint box is created and populated by FormattingState::commit(). I've also added DOM::Node::paint_box() as a convenient way to access the paint box (if available) of a given DOM node. Going forward, I believe this will allow us to better separate data that belongs to layout vs painting, and also open up opportunities for naturally invalidating caches in the paint box (since it's reconstituted by every layout.)
2022-03-09 23:53:41 +01: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 15:53:01 +01: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 21:05:52 +02:00
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
virtual bool is_child_allowed(Node const&) const { return true; }
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 23:26:47 +02:00
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 18:57:02 +02: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 15:19:42 +01: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 18:57:02 +02: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 12:04:30 +01: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 18:32:02 +02: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 21:21:29 +02: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 23:42:08 +02:00
void set_document(Badge<Document>, Document&);
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
virtual EventTarget* get_parent(Event const&) override;
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 18:32:39 +00:00
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 09:34:01 +01: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 19:34:49 +01:00
ExceptionOr<void> ensure_pre_insertion_validity(NonnullRefPtr<Node> node, RefPtr<Node> child) const;
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
bool is_host_including_inclusive_ancestor_of(Node const&) const;
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 19:34:49 +01:00
LibWeb: Remove Document::is_scripting_enabled() and use Node's There's no need to have a custom is_scripting_enabled() for the Document class, as it (indirectly) inherits from Node. Also, let's not hardcode false here :^)
2022-03-30 22:28:28 +01:00
bool is_scripting_enabled() 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-05 03:59:47 +01:00
bool is_scripting_disabled() const;
LibWeb: Implement Node.contains Used by Web Components Polyfills.
2021-07-05 05:55:02 +01: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 16:32:24 +01:00
// Used for dumping the DOM Tree
void serialize_tree_as_json(JsonObjectSerializer<StringBuilder>&) const;
LibWeb: Add shadow including ancestor/descendant checks
2021-09-02 02:17:13 +01: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 15:52:08 +01: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 22:42:15 +01:00
String serialize_fragment() const;
LibWeb: Implement the (string) replace all operations for Node
2021-09-06 01:25:58 +01:00
void replace_all(RefPtr<Node>);
void string_replace_all(String const&);
LibWeb: Implement Node.isSameNode(Node? otherNode)
2021-09-13 12:49:23 +02:00
bool is_same_node(Node const*) const;
LibWeb: Implement Node.isEqualNode(Node? otherNode)
2021-09-13 12:54:24 +02:00
bool is_equal_node(Node const*) const;
LibWeb: Implement Node.isSameNode(Node? otherNode)
2021-09-13 12:49:23 +02:00
LibWeb: Implement Node.getRootNode
2021-10-16 03:04:55 +01:00
NonnullRefPtr<Node> get_root_node(GetRootNodeOptions const& options = {});
LibWeb: Hide uninteresting whitespace text nodes from DOM inspector Use a simple heuristic to exclude uninteresting whitespace and de-clutter the inspector's DOM tree. Uninteresting whitespace is currently one of these: - Non-rendered whitespace-only text nodes - Rendered whitespace-only text nodes between block-level elements
2021-11-02 19:20:57 +01:00
bool is_uninteresting_whitespace_node() const;
LibWeb: Make DOM inspector overlay rects a little nicer Instead of just the outline, fill them with some semi-transparent color. Also add tag name, ID, classes and coordinates to the little tooltip. Finally, use the border box instead of the context box for metrics, same as other browsers.
2022-02-26 08:18:14 +01:00
String debug_description() const;
LibWeb: Make Range.setStart and Range.setEnd spec compliant These functions are way more involved than simply setting their respective boundary points :^)
2022-01-31 18:05:54 +00:00
size_t length() const;
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 18:55:47 +02:00
protected:
LibHTML: Make sure every DOM Node belongs to a Document
2019-09-29 11:43:07 +02: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 18:55:47 +02: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 23:42:08 +02: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 15:53:01 +01: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 18:55:47 +02: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 12:04:30 +01: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 15:52:08 +01: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 18:55:47 +02:00
};
LibHTML: Add is<ElementType> and to<ElementType> helper functions These will help us write node-type-aware template functions.
2019-10-06 20:37:39 +02:00
LibWeb: Move everything into the Web namespace
2020-03-07 10:27:02 +01:00
}
Reference in a new issue Copy permalink