mirrors/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-01-23 17:52:26 -05:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Libraries/LibWeb/DOM/Node.h

797 lines
28 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: Make DOM Node unique IDs strongly typed (and 64 bit) This is strictly nicer than passing them around as i32 everywhere, and by switching to i64 as the underlying type, ID allocation becomes as simple as incrementing an integer.
2024-10-20 10:37:44 +02:00
* Copyright (c) 2018-2024, Andreas Kling <andreas@ladybird.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: Make DOM Node unique IDs strongly typed (and 64 bit) This is strictly nicer than passing them around as i32 everywhere, and by switching to i64 as the underlying type, ID allocation becomes as simple as incrementing an integer.
2024-10-20 10:37:44 +02:00
#include <AK/DistinctNumeric.h>
LibWeb: Port MutationRecord types to FlyString Co-authored-by: Luke Wilde <lukew@serenityos.org>
2023-03-18 10:59:48 -04:00
#include <AK/FlyString.h>
LibWeb: Calculate length for all `CharacterData` type nodes correctly We now ensure that `Node::is_character_data()` returns true for all nodes of type character data. Previously, calling `Node::length()` on `CDataSection` or `ProcessingInstruction` nodes would return an incorrect value.
2024-07-23 21:55:48 +01:00
#include <AK/GenericShorthands.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>
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: Add Functionality to Dump to Accessibility Tree This will be used to display the accessibility tree in the inspector.
2022-12-11 10:56:37 -06:00
#include <LibWeb/DOM/AccessibilityTreeNode.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: Introduce the slottable concept for DOM elements and text nodes A slottable is either a DOM element or a DOM text node. They may be assigned to slots (HTMLSlotElement) either automatically or manually. Automatic assignment occurs by matching a slot's `name` attribute to a slottable's `slot` attribute. Manual assignment occurs by using the slot's (not yet implemented) `assign` API. This commit does not perform the above assignments. It just sets up the slottable concept via IDL and hooks the slottable mixin into the element and text nodes.
2023-09-05 13:07:35 -04:00
#include <LibWeb/DOM/Slottable.h>
LibWeb: Fully implement the fragment serializing algorithm Rather than assuming the node's node document is an HTML document, handle XML documents as well.
2022-11-02 19:14:27 -04:00
#include <LibWeb/DOMParsing/XMLSerializer.h>
LibWeb: Use `TraversalDecision` for multi level Node traversal methods This adds the `SkipChildrenAndContinue` option, where traversal continues but child nodes are not included.
2024-05-04 14:47:04 +01:00
#include <LibWeb/TraversalDecision.h>
LibWeb: Move ExceptionOr from DOM/ to WebIDL/ This is a concept fully defined in the Web IDL spec and doesn't belong in the DOM directory/namespace - not even DOMException, despite the name :^)
2022-09-25 17:03:42 +01:00
#include <LibWeb/WebIDL/ExceptionOr.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 Accessible Name and Description Calculation This is an initial implementation of the accname standard. There is still some of the algorithm left unimplemented that we will need to implement in the future. However, as is, this implementation is sufficient for basic pages.
2023-02-05 11:21:59 -06:00
enum class NameOrDescription {
Name,
Description
};
LibWeb: Implement Node.getRootNode
2021-10-16 03:04:55 +01:00
struct GetRootNodeOptions {
bool composed { false };
};
LibWeb: Implement Element.outerHTML This piggybacks on the same fragment serialization code that innerHTML uses, but instead of constructing an imaginary parent element like the spec asks us to, we just add a separate serialization mode that includes the context element in the serialized markup. This makes the image carousel on https://utah.edu/ show up :^)
2024-04-09 14:44:58 +02:00
enum class FragmentSerializationMode {
Inner,
Outer,
};
LibWeb: Correctly descend element nodes when computing accessible name This change implements the “is a descendant of a native host language text alternative element” condition in the “F: Name From Content” step at https://w3c.github.io/accname/#step2F in the “Accessible Name and Description Computation” spec — to ensure that all descendant nodes get included as expected in computations for accessible names for elements. Otherwise, without this change, Ladybird unexpectedly skips descendant element nodes when computing accessible names — which can result in the wrong accessible name being returned.
2024-11-01 21:11:32 +09:00
enum class IsDescendant {
No,
Yes,
};
LibWeb: Allow accessible-name computation to skip role-attribute lookup Per https://w3c.github.io/aria/#document-handling_author-errors_roles, determining whether to ignore certain specified landmark roles requires first determining whether the element for which the role is specified has an accessible name. But if we then try to retrieve a role for such elements, we end up calling right back into the accessible-name computation code — which would cause the calls to loop infinitely. So to avoid that — and to have handling for any other future cases the spec may introduce of such recursive calls that will loop indefinitely — this change introduces a parameter that callers can pass to cause role-attribute lookup to be skipped during accessible-name computation.
2024-12-19 23:21:48 +09:00
enum class ShouldComputeRole {
No,
Yes,
};
LibWeb: Note what's causing a style invalidation to happen You can now build with STYLE_INVALIDATION_DEBUG and get a debug stream of reasons why style invalidations are happening and where. I've rewritten this code many times, so instead of throwing it away once again, I figured we should at least have it behind a flag.
2024-09-04 10:01:08 +02:00
#define ENUMERATE_STYLE_INVALIDATION_REASONS(X) \
LibWeb: Add style invalidation for :target, :focus, :active and :link
2024-11-06 18:00:18 +01:00
X(ActiveElementChange) \
LibWeb: Note what's causing a style invalidation to happen You can now build with STYLE_INVALIDATION_DEBUG and get a debug stream of reasons why style invalidations are happening and where. I've rewritten this code many times, so instead of throwing it away once again, I figured we should at least have it behind a flag.
2024-09-04 10:01:08 +02:00
X(AdoptedStyleSheetsList) \
X(CSSFontLoaded) \
X(CSSImportRule) \
LibWeb: Add style invalidation for :defined selector
2024-11-06 15:49:22 +01:00
X(CustomElementStateChange) \
LibWeb: Note what's causing a style invalidation to happen You can now build with STYLE_INVALIDATION_DEBUG and get a debug stream of reasons why style invalidations are happening and where. I've rewritten this code many times, so instead of throwing it away once again, I figured we should at least have it behind a flag.
2024-09-04 10:01:08 +02:00
X(DidLoseFocus) \
X(DidReceiveFocus) \
X(EditingInsertion) \
X(ElementAttributeChange) \
X(ElementSetShadowRoot) \
LibWeb: Add style invalidation for :target, :focus, :active and :link
2024-11-06 18:00:18 +01:00
X(FocusedElementChange) \
X(HTMLHyperlinkElementHrefChange) \
LibWeb: Avoid many style invalidations on DOM attribute mutation Many times, attribute mutation doesn't necessitate a full style invalidation on the element. However, the conditions are pretty elaborate, so this first version has a lot of false positives. We only need to invalidate style when any of these things apply: 1. The change may affect the match state of a selector somewhere. 2. The change may affect presentational hints applied to the element. For (1) in this first version, we have a fixed list of attribute names that may affect selectors. We also collect all names referenced by attribute selectors anywhere in the document. For (2), we add a new Element::is_presentational_hint() virtual that tells us whether a given attribute name is a presentational hint. This drastically reduces style work on many websites. As an example, https://cnn.com/ is once again browseable.
2024-12-23 17:51:10 +01:00
X(HTMLIFrameElementGeometryChange) \
LibWeb: Note what's causing a style invalidation to happen You can now build with STYLE_INVALIDATION_DEBUG and get a debug stream of reasons why style invalidations are happening and where. I've rewritten this code many times, so instead of throwing it away once again, I figured we should at least have it behind a flag.
2024-09-04 10:01:08 +02:00
X(HTMLInputElementSetChecked) \
X(HTMLObjectElementUpdateLayoutAndChildObjects) \
LibWeb: Avoid invalidation on .textContent setter no-op When setting the textContent of an element with no children to null or the empty string, nothing happens. Even so, we were still invalidating style, layout and collections, causing pointless churn. Skipping invalidation in this case also revealed that we were missing invalidation when changing the selected state of HTMLOptionElement. This was all caught by existing tests already in-tree. :^)
2025-01-03 14:46:24 +01:00
X(HTMLOptionElementSelectedChange) \
LibWeb: Note what's causing a style invalidation to happen You can now build with STYLE_INVALIDATION_DEBUG and get a debug stream of reasons why style invalidations are happening and where. I've rewritten this code many times, so instead of throwing it away once again, I figured we should at least have it behind a flag.
2024-09-04 10:01:08 +02:00
X(HTMLSelectElementSetIsOpen) \
X(Hover) \
X(MediaQueryChangedMatchState) \
X(NavigableSetViewportSize) \
X(NodeInsertBefore) \
X(NodeRemove) \
X(NodeSetTextContent) \
X(Other) \
LibWeb: Distinguish parent/child on style invalidation for DOM insertion
2024-09-22 13:27:02 +02:00
X(ParentOfInsertedNode) \
LibWeb: Note what's causing a style invalidation to happen You can now build with STYLE_INVALIDATION_DEBUG and get a debug stream of reasons why style invalidations are happening and where. I've rewritten this code many times, so instead of throwing it away once again, I figured we should at least have it behind a flag.
2024-09-04 10:01:08 +02:00
X(SetSelectorText) \
X(SettingsChange) \
X(StyleSheetDeleteRule) \
X(StyleSheetInsertRule) \
X(StyleSheetListAddSheet) \
LibWeb: Add style invalidation for :target, :focus, :active and :link
2024-11-06 18:00:18 +01:00
X(StyleSheetListRemoveSheet) \
X(TargetElementChange)
LibWeb: Note what's causing a style invalidation to happen You can now build with STYLE_INVALIDATION_DEBUG and get a debug stream of reasons why style invalidations are happening and where. I've rewritten this code many times, so instead of throwing it away once again, I figured we should at least have it behind a flag.
2024-09-04 10:01:08 +02:00
enum class StyleInvalidationReason {
#define __ENUMERATE_STYLE_INVALIDATION_REASON(reason) reason,
ENUMERATE_STYLE_INVALIDATION_REASONS(__ENUMERATE_STYLE_INVALIDATION_REASON)
#undef __ENUMERATE_STYLE_INVALIDATION_REASON
};
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
class Node : public EventTarget {
WEB_PLATFORM_OBJECT(Node, EventTarget);
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
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
public:
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: Add DOM::Node::parent_or_shadow_host_element() This will be used in style computation to inherit style across shadow tree boundaries.
2022-11-05 17:06:19 +01:00
Element* parent_or_shadow_host_element();
Element const* parent_or_shadow_host_element() const { return const_cast<Node*>(this)->parent_or_shadow_host_element(); }
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();
NodeType type() const { return m_type; }
bool is_element() const { return type() == NodeType::ELEMENT_NODE; }
LibWeb: Make Node::is_text() return true for CDATASection nodes CDATASection inherits from Text, and so it was incorrect for them to claim not to be Text nodes. This fixes at least two WPT subtests. :^) It also exposed a bug in the DOM Parsing and Serialization spec, where we're not told how to serialize CDATASection nodes. Spec bug: https://github.com/w3c/DOM-Parsing/issues/38
2024-11-19 15:35:31 +01:00
bool is_text() const { return type() == NodeType::TEXT_NODE || type() == NodeType::CDATA_SECTION_NODE; }
LibWeb: Make Node.normalize() ignore CDATASection nodes We hadn't modeled the "exclusive text node" concept correctly.
2024-11-20 11:31:59 +01:00
bool is_exclusive_text() const { return type() == NodeType::TEXT_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
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; }
LibWeb: Calculate length for all `CharacterData` type nodes correctly We now ensure that `Node::is_character_data()` returns true for all nodes of type character data. Previously, calling `Node::length()` on `CDataSection` or `ProcessingInstruction` nodes would return an incorrect value.
2024-07-23 21:55:48 +01:00
bool is_character_data() const { return first_is_one_of(type(), NodeType::TEXT_NODE, NodeType::COMMENT_NODE, NodeType::CDATA_SECTION_NODE, NodeType::PROCESSING_INSTRUCTION_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: Don't crash when querying the CDataSection.assignedSlot property
2024-03-23 15:46:08 +00:00
bool is_slottable() const { return is_element() || is_text() || is_cdata_section(); }
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 CDATASection Not used for anything currently other than exposing it on the Window object. This allows Web Components Polyfills to patch its prototype.
2022-06-27 21:20:59 +01:00
bool is_cdata_section() const { return type() == NodeType::CDATA_SECTION_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 way to check if a DOM node is an SVG element
2023-05-24 05:41:55 +02:00
virtual bool is_svg_element() const { return false; }
LibWeb: Add fast_is<SVGGraphicsElement>() This dynamic_cast was ~6% of runtime when mousing around on Discord.
2023-08-03 13:26:29 +02:00
virtual bool is_svg_graphics_element() const { return false; }
LibWeb: Add IDL definition for SVGScriptElement It does not currently handle any of the actual scripting, but this should at least allow us to create an instance of the element. The test being added here isn't actually testing much, but before the previous commit we used to crash parsing the page due to a TODO().
2023-09-23 08:56:49 +12:00
virtual bool is_svg_script_element() const { return false; }
LibWeb: Add method for listing all style sheets on a page This will be used by the inspector, for showing style sheet contents. Identifying a specific style sheet is a bit tricky. Depending on where it came from, a style sheet may have a URL, it might be associated with a DOM element, both, or neither. This varied information is wrapped in a new StyleSheetIdentifier struct.
2024-08-23 10:42:35 +01:00
virtual bool is_svg_style_element() 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: Add fast_is<T>() for SVGUseElement is<SVGUseElement> quite hot in profiles
2023-06-23 02:15:03 +03:00
virtual bool is_svg_use_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: Refactor "editable" and "editing host" concepts The DOM spec defines what it means for an element to be an "editing host", and the Editing spec does the same for the "editable" concept. Replace our `Node::is_editable()` implementation with these spec-compliant algorithms. An editing host is an element that has the properties to make its contents effectively editable. Editable elements are descendants of an editing host. Concepts like the inheritable contenteditable attribute are propagated through the editable algorithm.
2024-12-06 11:41:20 +01:00
bool is_editable() const;
bool is_editing_host() const;
bool is_editable_or_editing_host() const { return is_editable() || is_editing_host(); }
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
LibJS+LibWeb: Add fast_is<DOM::Node> for JS::Object Solves problem that is<DOM::Node, JS::Object>() is quite hot in profiles while loading https://www.postgresql.org/about/featurematrix/.
2023-07-13 19:54:03 +02:00
virtual bool is_dom_node() const final { return true; }
LibWeb: Add fast_is<HTMLElement>() This avoids slow RTTI lookups in selector matching.
2022-07-27 16:04:31 +02:00
virtual bool is_html_element() const { return false; }
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<HTMLBaseElement>() This avoids slow RTTI lookups in Document::base_url().
2022-07-27 16:03:43 +02:00
virtual bool is_html_base_element() const { return false; }
LibWeb: Add fast_is<T>() for various types stood out in a profile
2023-03-10 21:16:18 +01:00
virtual bool is_html_body_element() const { return false; }
virtual bool is_html_input_element() const { return false; }
LibWeb: Add method for listing all style sheets on a page This will be used by the inspector, for showing style sheet contents. Identifying a specific style sheet is a bit tricky. Depending on where it came from, a style sheet may have a URL, it might be associated with a DOM element, both, or neither. This varied information is wrapped in a new StyleSheetIdentifier struct.
2024-08-23 10:42:35 +01:00
virtual bool is_html_link_element() const { return false; }
LibWeb: Add fast_is<T>() for various types stood out in a profile
2023-03-10 21:16:18 +01:00
virtual bool is_html_progress_element() const { return false; }
LibWeb: Add fast_is<T>() helper for HTMLScriptElement This makes loading Google Groups quite a bit faster, as 20% of runtime while loading was spent asking if DOM nodes are HTMLScriptElement.
2023-05-07 07:43:21 +02:00
virtual bool is_html_script_element() const { return false; }
LibWeb: Add method for listing all style sheets on a page This will be used by the inspector, for showing style sheet contents. Identifying a specific style sheet is a bit tricky. Depending on where it came from, a style sheet may have a URL, it might be associated with a DOM element, both, or neither. This varied information is wrapped in a new StyleSheetIdentifier struct.
2024-08-23 10:42:35 +01:00
virtual bool is_html_style_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: Support fast_is<T>() for table, table sections, rows and cells 3.2x speed-up on WebKit/PerformanceTests/DOM/GridSort.html
2023-08-22 14:55:10 +02:00
virtual bool is_html_table_element() const { return false; }
virtual bool is_html_table_section_element() const { return false; }
virtual bool is_html_table_row_element() const { return false; }
virtual bool is_html_table_cell_element() const { return false; }
LibWeb: Never blockify HTML <br> elements This is a bit iffy, but since <br> elements can't be implemented in "just CSS" today, we should also exclude them from the blockification algorithm. This is important, since <br> is expected to always have inline-like behavior.
2023-09-01 09:55:56 +02:00
virtual bool is_html_br_element() const { return false; }
LibWeb: Use fit-content width if button's computed width is "auto" Implements following line from the spec: "If the computed value of 'inline-size' is 'auto', then the used value is the fit-content inline size."
2023-09-09 17:13:41 +02:00
virtual bool is_html_button_element() const { return false; }
LibWeb: Add fast_is<T>() for HTMLSlotElement 2.4x speed-up on StyleBench :^)
2023-09-23 13:03:59 +02:00
virtual bool is_html_slot_element() const { return false; }
LibWeb: Add fast_is<T> for form, embed, image, and object elements These are used by Window::supported_property_names(), which can get very hot.
2023-12-24 14:41:33 +01:00
virtual bool is_html_embed_element() const { return false; }
virtual bool is_html_object_element() const { return false; }
virtual bool is_html_form_element() const { return false; }
virtual bool is_html_image_element() const { return false; }
LibWeb: Rename BrowsingContextContainer => NavigableContainer The "browsing context container" concept in the HTML spec has been replaced with "navigable container". Renaming this is the first step of many towards implementing the new world. Co-authored-by: Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
2022-12-12 12:20:02 +01:00
virtual bool is_navigable_container() const { return false; }
LibWeb: Extract shared lazy-loading behavior into a base class `<iframe>` and `<img>` tags share the same spec for several aspects of lazy-loading: how the `loading` attribute works, the "will lazy load element" steps, and a member for storing the lazy-load resumption steps. So let's share the implementation by using a base class. This mostly involves moving things around. However, we also change the `start_intersection_observing_a_lazy_loading_element()` method to take a LazyLoadingElement, and operate on one, instead of always casting to HTMLImageElement. We do unfortunately have to do some shenanigans to make the cast work, by adding a virtual function stub in DOM::Element.
2023-11-21 18:50:09 +00:00
virtual bool is_lazy_loading() 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
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
WebIDL::ExceptionOr<GC::Ref<Node>> pre_insert(GC::Ref<Node>, GC::Ptr<Node>);
WebIDL::ExceptionOr<GC::Ref<Node>> pre_remove(GC::Ref<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
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
WebIDL::ExceptionOr<GC::Ref<Node>> append_child(GC::Ref<Node>);
WebIDL::ExceptionOr<GC::Ref<Node>> remove_child(GC::Ref<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
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
void insert_before(GC::Ref<Node> node, GC::Ptr<Node> child, bool suppress_observers = false);
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 remove(bool suppress_observers = false);
void remove_all_children(bool suppress_observers = false);
LibWeb: Make the Node.compareDocumentPosition() return value enum public This will allow other parts of LibWeb to understand these values.
2023-03-30 11:14:26 +02:00
enum DocumentPosition : u16 {
DOCUMENT_POSITION_EQUAL = 0,
DOCUMENT_POSITION_DISCONNECTED = 1,
DOCUMENT_POSITION_PRECEDING = 2,
DOCUMENT_POSITION_FOLLOWING = 4,
DOCUMENT_POSITION_CONTAINS = 8,
DOCUMENT_POSITION_CONTAINED_BY = 16,
DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 32,
};
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
u16 compare_document_position(GC::Ptr<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
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
WebIDL::ExceptionOr<GC::Ref<Node>> replace_child(GC::Ref<Node> node, GC::Ref<Node> child);
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
LibWeb/DOM: Update node cloning to latest spec Main difference is that a chunk of the "clone a node" steps are pulled out into a "clone a single node" algorithm. Reflects these spec PRs: https://github.com/whatwg/dom/pull/1332 https://github.com/whatwg/dom/pull/1334 Though this code is quite old so there may also be older spec changes included here.
2025-01-03 15:24:30 +00:00
WebIDL::ExceptionOr<GC::Ref<Node>> clone_node(Document* document = nullptr, bool subtree = false, Node* parent = nullptr);
WebIDL::ExceptionOr<GC::Ref<Node>> clone_single_node(Document&);
WebIDL::ExceptionOr<GC::Ref<Node>> clone_node_binding(bool subtree);
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(); }
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ref<NodeList> child_nodes();
Vector<GC::Root<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: Port Node interface from DeprecatedString to String Which is fortunately quite straight forward :^)
2023-09-17 10:51:43 +12: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: Port Node interface from DeprecatedString to String Which is fortunately quite straight forward :^)
2023-09-17 10:51:43 +12:00
String base_uri() const;
LibWeb: Bring Node closer to spec Node::base_uri() correct implementation was left as a FIXME.
2022-04-12 13:20:13 -03:00
LibWeb: Add an alternative_text() getter This change adds an alternative_text()·getter, for use in computing accessible names.
2024-11-09 23:45:09 +09:00
virtual Optional<String> alternative_text() const;
LibWeb: Port Node interface from DeprecatedString to String Which is fortunately quite straight forward :^)
2023-09-17 10:51:43 +12:00
String descendant_text_content() const;
Optional<String> text_content() const;
void set_text_content(Optional<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.normalize()` This method puts the given node and all of its sub-tree into a normalized form. A normalized sub-tree has no empty text nodes and no adjacent text nodes.
2024-07-11 21:52:03 +01:00
WebIDL::ExceptionOr<void> normalize();
LibWeb: Port Node interface from DeprecatedString to String Which is fortunately quite straight forward :^)
2023-09-17 10:51:43 +12:00
Optional<String> node_value() const;
void set_node_value(Optional<String> const&);
LibWeb: Implement `Node.nodeValue` DOM attribute
2022-02-18 22:11:43 +00:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ptr<HTML::Navigable> navigable() const;
LibWeb: Implement Node::navigable() https://html.spec.whatwg.org/multipage/document-sequences.html#node-navigable
2023-04-23 00:21:59 +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 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
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ptr<Document> owner_document() const;
LibWeb: Expose Node.ownerDocument Required by jQuery.
2021-05-02 21:03:50 +01:00
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;
LibWeb: Port AttributeNames to FlyString
2023-10-08 11:42:00 +13: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: Port DOM::Node from DeprecatedString
2023-12-03 08:24:04 +13:00
String child_text_content() const;
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
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: Only react to link element attribute changes when BC connected Link elements that aren't "browsing-context connected" should not trigger a resource fetch when their attributes change. This fixes an issue where we'd waste time by loading every style sheet twice! :^)
2024-04-26 09:29:27 +02:00
[[nodiscard]] bool is_browsing_context_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();
LibWeb/DOM: Implement the DOM post connection steps See: https://github.com/whatwg/dom/commit/0616094
2024-12-10 19:34:50 +13:00
virtual void post_connection();
LibWeb: Null layout and paintable pointers of removed DOM::Node When a node is removed from the DOM tree, its paintable needs to be removed to ensure that it is not used to obtain sizes that are no longer valid. This change enables the ResizeObserver to send a notification if a node is removed, as it should, because a removed node now has a size of zero It should be okay to nullify pointers without concerning parent/sibling/child relationships because the layout and paintable trees will be rebuilt following any DOM mutation anyway.
2024-02-19 02:22:15 +01:00
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: Update DOM cloning algorithm for declarative shadow DOM
2024-06-25 11:06:41 +02:00
virtual WebIDL::ExceptionOr<void> cloned(Node&, bool) { return {}; }
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/DOM: Rename Node::{paint => paintable}_box() It returns a PaintableBox, not a 'PaintBox'.
2023-04-20 16:01:16 +01:00
Painting::PaintableBox const* paintable_box() const;
LibWeb: Add non-const version of paintable_box() in DOM::Node
2023-08-07 00:59:23 +02:00
Painting::PaintableBox* paintable_box();
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: Make Document::paintable() return a ViewportPaintable
2023-08-19 09:29:04 +02:00
Painting::Paintable* paintable();
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
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
void set_paintable(GC::Ptr<Painting::Paintable>);
LibWeb: Allow layout nodes to have multiple paintables CSS fragmentation implies 1:N relationship between layout nodes and paintables. This change is a preparation for implementation of inline fragmentation where InlinePaintable will be replaced with PaintableWithLines corresponding to each line.
2024-10-14 16:07:56 +02:00
void clear_paintable();
LibWeb: Give DOM::Node a direct pointer to its Paintable Instead of going via the layout tree.
2023-08-19 12:00:42 +02:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
void set_layout_node(Badge<Layout::Node>, GC::Ref<Layout::Node>);
LibWeb: Detach stale layout nodes from DOM during layout tree build When toggling `display: none` on an element, it can go from having a layout subtree to not having one. In the `none` case, we were previously leaving stale layout nodes hanging off DOM nodes in the subtree. These layout nodes could be queried for outdated information and probably other things that we shouldn't allow. Fix this by having TreeBuilder prune any old layout nodes hanging off nodes in a subtree after its subtree root doesn't produce a layout node.
2023-08-01 08:23:13 +02:00
void detach_layout_node(Badge<Layout::TreeBuilder>);
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: Add mechanism to invalidate only inherited styles We can now mark an element as needing an "inherited style update" rather than a full "style update". This effectively means that the next style update will visit the element and pull all of its inherited properties from the relevant ancestor element. This is now used for descendants of elements with animated style.
2024-12-22 11:59:58 +01:00
bool needs_inherited_style_update() const { return m_needs_inherited_style_update; }
void set_needs_inherited_style_update(bool);
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; }
LibWeb: Note what's causing a style invalidation to happen You can now build with STYLE_INVALIDATION_DEBUG and get a debug stream of reasons why style invalidations are happening and where. I've rewritten this code many times, so instead of throwing it away once again, I figured we should at least have it behind a flag.
2024-09-04 10:01:08 +02:00
void invalidate_style(StyleInvalidationReason);
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
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;
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
WebIDL::ExceptionOr<void> ensure_pre_insertion_validity(GC::Ref<Node> node, GC::Ptr<Node> child) 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
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;
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
bool contains(GC::Ptr<Node>) const;
LibWeb: Implement Node.contains Used by Web Components Polyfills.
2021-07-05 05:55:02 +01:00
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: Make DOM Node unique IDs strongly typed (and 64 bit) This is strictly nicer than passing them around as i32 everywhere, and by switching to i64 as the underlying type, ID allocation becomes as simple as incrementing an integer.
2024-10-20 10:37:44 +02:00
[[nodiscard]] UniqueNodeID unique_id() const { return m_unique_id; }
static Node* from_unique_id(UniqueNodeID);
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
LibWeb: Implement Element.outerHTML This piggybacks on the same fragment serialization code that innerHTML uses, but instead of constructing an imaginary parent element like the spec asks us to, we just add a separate serialization mode that includes the context element in the serialized markup. This makes the image carousel on https://utah.edu/ show up :^)
2024-04-09 14:44:58 +02:00
WebIDL::ExceptionOr<String> serialize_fragment(DOMParsing::RequireWellFormed, FragmentSerializationMode = FragmentSerializationMode::Inner) const;
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
LibWeb: Implement unsafe HTML parsing methods Both Element's and ShadowRoot's setHTMLUnsafe, and Document's static parseHTMLUnsafe methods are implemented.
2024-06-25 20:55:58 +01:00
WebIDL::ExceptionOr<void> unsafely_set_html(Element&, StringView);
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
void replace_all(GC::Ptr<Node>);
LibWeb: Port DOM::Node from DeprecatedString
2023-12-03 08:24:04 +13:00
void string_replace_all(String const&);
LibWeb: Implement the (string) replace all operations for Node
2021-09-06 01:25:58 +01:00
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
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ref<Node> get_root_node(GetRootNodeOptions const& options = {});
LibWeb: Implement Node.getRootNode
2021-10-16 03:04:55 +01:00
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: Port DOM::Node from DeprecatedString
2023-12-03 08:24:04 +13:00
String debug_description() 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
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;
LibWeb: Only allocate DOM::Node registered observer list on demand Most DOM nodes don't have registered mutation observers, so let's put the metadata about them behind an OwnPtr to save space in the common case. Saves 16 bytes per DOM node that doesn't have registered observers.
2023-11-18 11:22:51 +01:00
auto& registered_observer_list() { return m_registered_observer_list; }
auto const& registered_observer_list() const { return m_registered_observer_list; }
LibWeb: Introduce Mutation{Record,Observer} and observer microtasks
2022-07-11 16:37:51 +01:00
LibWeb: Only allocate DOM::Node registered observer list on demand Most DOM nodes don't have registered mutation observers, so let's put the metadata about them behind an OwnPtr to save space in the common case. Saves 16 bytes per DOM node that doesn't have registered observers.
2023-11-18 11:22:51 +01:00
void add_registered_observer(RegisteredObserver&);
LibWeb: Introduce Mutation{Record,Observer} and observer microtasks
2022-07-11 16:37:51 +01:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
void queue_mutation_record(FlyString const& type, Optional<FlyString> const& attribute_name, Optional<FlyString> const& attribute_namespace, Optional<String> const& old_value, Vector<GC::Root<Node>> added_nodes, Vector<GC::Root<Node>> removed_nodes, Node* previous_sibling, Node* next_sibling) const;
LibWeb: Implement all "childList" mutation records for MutationObserver
2022-07-11 16:39:14 +01:00
LibWeb: Introduce CustomElementRegistry and creating custom elements The main missing feature here is form associated custom elements.
2023-03-29 23:46:18 +01:00
// https://dom.spec.whatwg.org/#concept-shadow-including-inclusive-descendant
template<typename Callback>
LibWeb: Use `TraversalDecision` for multi level Node traversal methods This adds the `SkipChildrenAndContinue` option, where traversal continues but child nodes are not included.
2024-05-04 14:47:04 +01:00
TraversalDecision for_each_shadow_including_inclusive_descendant(Callback);
LibWeb: Introduce CustomElementRegistry and creating custom elements The main missing feature here is form associated custom elements.
2023-03-29 23:46:18 +01:00
LibWeb: Traverse shadow-including subtree when adopting DOM nodes This takes care of two FIXMEs and fixes an issue on Google Docs where we'd mix boxes from different documents in the same layout tree. (This happened because shadow trees remained attached to their old document when their host was adopted.)
2022-07-12 23:13:57 +02:00
// https://dom.spec.whatwg.org/#concept-shadow-including-descendant
template<typename Callback>
LibWeb: Use `TraversalDecision` for multi level Node traversal methods This adds the `SkipChildrenAndContinue` option, where traversal continues but child nodes are not included.
2024-05-04 14:47:04 +01:00
TraversalDecision for_each_shadow_including_descendant(Callback);
LibWeb: Traverse shadow-including subtree when adopting DOM nodes This takes care of two FIXMEs and fixes an issue on Google Docs where we'd mix boxes from different documents in the same layout tree. (This happened because shadow trees remained attached to their old document when their host was adopted.)
2022-07-12 23:13:57 +02:00
LibWeb: Introduce the slottable concept for DOM elements and text nodes A slottable is either a DOM element or a DOM text node. They may be assigned to slots (HTMLSlotElement) either automatically or manually. Automatic assignment occurs by matching a slot's `name` attribute to a slottable's `slot` attribute. Manual assignment occurs by using the slot's (not yet implemented) `assign` API. This commit does not perform the above assignments. It just sets up the slottable concept via IDL and hooks the slottable mixin into the element and text nodes.
2023-09-05 13:07:35 -04:00
Slottable as_slottable();
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
Node* parent() { return m_parent.ptr(); }
Node const* parent() const { return m_parent.ptr(); }
bool has_children() const { return m_first_child; }
Node* next_sibling() { return m_next_sibling.ptr(); }
Node* previous_sibling() { return m_previous_sibling.ptr(); }
Node* first_child() { return m_first_child.ptr(); }
Node* last_child() { return m_last_child.ptr(); }
Node const* next_sibling() const { return m_next_sibling.ptr(); }
Node const* previous_sibling() const { return m_previous_sibling.ptr(); }
Node const* first_child() const { return m_first_child.ptr(); }
Node const* last_child() const { return m_last_child.ptr(); }
size_t child_count() const
{
size_t count = 0;
for (auto* child = first_child(); child; child = child->next_sibling())
++count;
return count;
}
Node* child_at_index(int index)
{
int count = 0;
for (auto* child = first_child(); child; child = child->next_sibling()) {
if (count == index)
return child;
++count;
}
return nullptr;
}
Node const* child_at_index(int index) const
{
return const_cast<Node*>(this)->child_at_index(index);
}
// https://dom.spec.whatwg.org/#concept-tree-index
size_t index() const
{
// The index of an object is its number of preceding siblings, or 0 if it has none.
size_t index = 0;
for (auto* node = previous_sibling(); node; node = node->previous_sibling())
++index;
return index;
}
bool is_ancestor_of(Node const&) const;
bool is_inclusive_ancestor_of(Node const&) const;
bool is_descendant_of(Node const&) const;
bool is_inclusive_descendant_of(Node const&) const;
bool is_following(Node const&) const;
Node* next_in_pre_order()
{
if (first_child())
return first_child();
Node* node;
if (!(node = next_sibling())) {
node = parent();
while (node && !node->next_sibling())
node = node->parent();
if (node)
node = node->next_sibling();
}
return node;
}
Node* next_in_pre_order(Node const* stay_within)
{
if (first_child())
return first_child();
Node* node = static_cast<Node*>(this);
Node* next = nullptr;
while (!(next = node->next_sibling())) {
node = node->parent();
if (!node || node == stay_within)
return nullptr;
}
return next;
}
Node const* next_in_pre_order() const
{
return const_cast<Node*>(this)->next_in_pre_order();
}
Node const* next_in_pre_order(Node const* stay_within) const
{
return const_cast<Node*>(this)->next_in_pre_order(stay_within);
}
Node* previous_in_pre_order()
{
if (auto* node = previous_sibling()) {
while (node->last_child())
node = node->last_child();
return node;
}
return parent();
}
Node const* previous_in_pre_order() const
{
return const_cast<Node*>(this)->previous_in_pre_order();
}
bool is_before(Node const& other) const
{
if (this == &other)
return false;
for (auto* node = this; node; node = node->next_in_pre_order()) {
if (node == &other)
return true;
}
return false;
}
// https://dom.spec.whatwg.org/#concept-tree-preceding (Object A is 'typename U' and Object B is 'this')
template<typename U>
bool has_preceding_node_of_type_in_tree_order() const
{
for (auto* node = previous_in_pre_order(); node; node = node->previous_in_pre_order()) {
if (is<U>(node))
return true;
}
return false;
}
// https://dom.spec.whatwg.org/#concept-tree-following (Object A is 'typename U' and Object B is 'this')
template<typename U>
bool has_following_node_of_type_in_tree_order() const
{
for (auto* node = next_in_pre_order(); node; node = node->next_in_pre_order()) {
if (is<U>(node))
return true;
}
return false;
}
template<typename Callback>
LibWeb: Use `TraversalDecision` for multi level Node traversal methods This adds the `SkipChildrenAndContinue` option, where traversal continues but child nodes are not included.
2024-05-04 14:47:04 +01:00
TraversalDecision for_each_in_inclusive_subtree(Callback callback) const
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
{
LibWeb: Use `TraversalDecision` for multi level Node traversal methods This adds the `SkipChildrenAndContinue` option, where traversal continues but child nodes are not included.
2024-05-04 14:47:04 +01:00
if (auto decision = callback(static_cast<Node const&>(*this)); decision != TraversalDecision::Continue)
return decision;
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
for (auto* child = first_child(); child; child = child->next_sibling()) {
LibWeb: Use `TraversalDecision` for multi level Node traversal methods This adds the `SkipChildrenAndContinue` option, where traversal continues but child nodes are not included.
2024-05-04 14:47:04 +01:00
if (child->for_each_in_inclusive_subtree(callback) == TraversalDecision::Break)
return TraversalDecision::Break;
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
}
LibWeb: Use `TraversalDecision` for multi level Node traversal methods This adds the `SkipChildrenAndContinue` option, where traversal continues but child nodes are not included.
2024-05-04 14:47:04 +01:00
return TraversalDecision::Continue;
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
}
template<typename Callback>
LibWeb: Use `TraversalDecision` for multi level Node traversal methods This adds the `SkipChildrenAndContinue` option, where traversal continues but child nodes are not included.
2024-05-04 14:47:04 +01:00
TraversalDecision for_each_in_inclusive_subtree(Callback callback)
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
{
LibWeb: Use `TraversalDecision` for multi level Node traversal methods This adds the `SkipChildrenAndContinue` option, where traversal continues but child nodes are not included.
2024-05-04 14:47:04 +01:00
if (auto decision = callback(static_cast<Node&>(*this)); decision != TraversalDecision::Continue)
return decision;
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
for (auto* child = first_child(); child; child = child->next_sibling()) {
LibWeb: Use `TraversalDecision` for multi level Node traversal methods This adds the `SkipChildrenAndContinue` option, where traversal continues but child nodes are not included.
2024-05-04 14:47:04 +01:00
if (child->for_each_in_inclusive_subtree(callback) == TraversalDecision::Break)
return TraversalDecision::Break;
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
}
LibWeb: Use `TraversalDecision` for multi level Node traversal methods This adds the `SkipChildrenAndContinue` option, where traversal continues but child nodes are not included.
2024-05-04 14:47:04 +01:00
return TraversalDecision::Continue;
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
}
template<typename U, typename Callback>
LibWeb: Use `TraversalDecision` for multi level Node traversal methods This adds the `SkipChildrenAndContinue` option, where traversal continues but child nodes are not included.
2024-05-04 14:47:04 +01:00
TraversalDecision for_each_in_inclusive_subtree_of_type(Callback callback)
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
{
LibWeb: Fix a few const-ness issues
2023-02-25 10:44:51 -07:00
if (is<U>(static_cast<Node&>(*this))) {
LibWeb: Use `TraversalDecision` for multi level Node traversal methods This adds the `SkipChildrenAndContinue` option, where traversal continues but child nodes are not included.
2024-05-04 14:47:04 +01:00
if (auto decision = callback(static_cast<U&>(*this)); decision != TraversalDecision::Continue)
return decision;
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
}
for (auto* child = first_child(); child; child = child->next_sibling()) {
LibWeb: Use `TraversalDecision` for multi level Node traversal methods This adds the `SkipChildrenAndContinue` option, where traversal continues but child nodes are not included.
2024-05-04 14:47:04 +01:00
if (child->template for_each_in_inclusive_subtree_of_type<U>(callback) == TraversalDecision::Break)
return TraversalDecision::Break;
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
}
LibWeb: Use `TraversalDecision` for multi level Node traversal methods This adds the `SkipChildrenAndContinue` option, where traversal continues but child nodes are not included.
2024-05-04 14:47:04 +01:00
return TraversalDecision::Continue;
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
}
template<typename U, typename Callback>
LibWeb: Use `TraversalDecision` for multi level Node traversal methods This adds the `SkipChildrenAndContinue` option, where traversal continues but child nodes are not included.
2024-05-04 14:47:04 +01:00
TraversalDecision for_each_in_inclusive_subtree_of_type(Callback callback) const
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
{
if (is<U>(static_cast<Node const&>(*this))) {
LibWeb: Use `TraversalDecision` for multi level Node traversal methods This adds the `SkipChildrenAndContinue` option, where traversal continues but child nodes are not included.
2024-05-04 14:47:04 +01:00
if (auto decision = callback(static_cast<U const&>(*this)); decision != TraversalDecision::Continue)
return decision;
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
}
for (auto* child = first_child(); child; child = child->next_sibling()) {
LibWeb: Use `TraversalDecision` for multi level Node traversal methods This adds the `SkipChildrenAndContinue` option, where traversal continues but child nodes are not included.
2024-05-04 14:47:04 +01:00
if (child->template for_each_in_inclusive_subtree_of_type<U>(callback) == TraversalDecision::Break)
return TraversalDecision::Break;
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
}
LibWeb: Use `TraversalDecision` for multi level Node traversal methods This adds the `SkipChildrenAndContinue` option, where traversal continues but child nodes are not included.
2024-05-04 14:47:04 +01:00
return TraversalDecision::Continue;
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
}
template<typename Callback>
LibWeb: Use `TraversalDecision` for multi level Node traversal methods This adds the `SkipChildrenAndContinue` option, where traversal continues but child nodes are not included.
2024-05-04 14:47:04 +01:00
TraversalDecision for_each_in_subtree(Callback callback) const
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
{
for (auto* child = first_child(); child; child = child->next_sibling()) {
LibWeb: Use `TraversalDecision` for multi level Node traversal methods This adds the `SkipChildrenAndContinue` option, where traversal continues but child nodes are not included.
2024-05-04 14:47:04 +01:00
if (child->for_each_in_inclusive_subtree(callback) == TraversalDecision::Break)
return TraversalDecision::Break;
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
}
LibWeb: Use `TraversalDecision` for multi level Node traversal methods This adds the `SkipChildrenAndContinue` option, where traversal continues but child nodes are not included.
2024-05-04 14:47:04 +01:00
return TraversalDecision::Continue;
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
}
template<typename Callback>
LibWeb: Use `TraversalDecision` for multi level Node traversal methods This adds the `SkipChildrenAndContinue` option, where traversal continues but child nodes are not included.
2024-05-04 14:47:04 +01:00
TraversalDecision for_each_in_subtree(Callback callback)
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
{
for (auto* child = first_child(); child; child = child->next_sibling()) {
LibWeb: Use `TraversalDecision` for multi level Node traversal methods This adds the `SkipChildrenAndContinue` option, where traversal continues but child nodes are not included.
2024-05-04 14:47:04 +01:00
if (child->for_each_in_inclusive_subtree(callback) == TraversalDecision::Break)
return TraversalDecision::Break;
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
}
LibWeb: Use `TraversalDecision` for multi level Node traversal methods This adds the `SkipChildrenAndContinue` option, where traversal continues but child nodes are not included.
2024-05-04 14:47:04 +01:00
return TraversalDecision::Continue;
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
}
template<typename U, typename Callback>
LibWeb: Use `TraversalDecision` for multi level Node traversal methods This adds the `SkipChildrenAndContinue` option, where traversal continues but child nodes are not included.
2024-05-04 14:47:04 +01:00
TraversalDecision for_each_in_subtree_of_type(Callback callback)
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
{
for (auto* child = first_child(); child; child = child->next_sibling()) {
LibWeb: Use `TraversalDecision` for multi level Node traversal methods This adds the `SkipChildrenAndContinue` option, where traversal continues but child nodes are not included.
2024-05-04 14:47:04 +01:00
if (child->template for_each_in_inclusive_subtree_of_type<U>(callback) == TraversalDecision::Break)
return TraversalDecision::Break;
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
}
LibWeb: Use `TraversalDecision` for multi level Node traversal methods This adds the `SkipChildrenAndContinue` option, where traversal continues but child nodes are not included.
2024-05-04 14:47:04 +01:00
return TraversalDecision::Continue;
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
}
template<typename U, typename Callback>
LibWeb: Use `TraversalDecision` for multi level Node traversal methods This adds the `SkipChildrenAndContinue` option, where traversal continues but child nodes are not included.
2024-05-04 14:47:04 +01:00
TraversalDecision for_each_in_subtree_of_type(Callback callback) const
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
{
for (auto* child = first_child(); child; child = child->next_sibling()) {
LibWeb: Use `TraversalDecision` for multi level Node traversal methods This adds the `SkipChildrenAndContinue` option, where traversal continues but child nodes are not included.
2024-05-04 14:47:04 +01:00
if (child->template for_each_in_inclusive_subtree_of_type<U>(callback) == TraversalDecision::Break)
return TraversalDecision::Break;
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
}
LibWeb: Use `TraversalDecision` for multi level Node traversal methods This adds the `SkipChildrenAndContinue` option, where traversal continues but child nodes are not included.
2024-05-04 14:47:04 +01:00
return TraversalDecision::Continue;
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
}
template<typename Callback>
void for_each_child(Callback callback) const
{
Everywhere: Remove usages of `template` keyword with no parameter list These were made invalid with P1787, and Clang (19) trunk started warning on them with https://github.com/llvm/llvm-project/pull/80801.
2024-06-04 22:19:15 +02:00
return const_cast<Node*>(this)->for_each_child(move(callback));
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
}
template<typename Callback>
void for_each_child(Callback callback)
{
LibWeb: Use `IterationDecision` in single level Node iteration methods `Node::for_each_child()` and `Node::for_each_child_of_type()` callbacks now return an `IterationDecision`, which allows us to break early if required.
2024-05-04 14:59:52 +01:00
for (auto* node = first_child(); node; node = node->next_sibling()) {
if (callback(*node) == IterationDecision::Break)
return;
}
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
}
template<typename U, typename Callback>
void for_each_child_of_type(Callback callback)
{
for (auto* node = first_child(); node; node = node->next_sibling()) {
LibWeb: Use `IterationDecision` in single level Node iteration methods `Node::for_each_child()` and `Node::for_each_child_of_type()` callbacks now return an `IterationDecision`, which allows us to break early if required.
2024-05-04 14:59:52 +01:00
if (is<U>(node)) {
if (callback(verify_cast<U>(*node)) == IterationDecision::Break)
return;
}
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
}
}
template<typename U, typename Callback>
void for_each_child_of_type(Callback callback) const
{
return const_cast<Node*>(this)->template for_each_child_of_type<U>(move(callback));
}
LibWeb: Add pseudoElement parameter to GetAnimationsOptions This corresponds to: https://github.com/w3c/csswg-drafts/pull/11050 For now, we don't do anything useful with this parameter, because we don't yet support animating pseudo-elements.
2024-11-08 15:41:49 +00:00
template<typename U, typename Callback>
WebIDL::ExceptionOr<void> for_each_child_of_type_fallible(Callback callback)
{
for (auto* node = first_child(); node; node = node->next_sibling()) {
if (is<U>(node)) {
if (TRY(callback(verify_cast<U>(*node))) == IterationDecision::Break)
return {};
}
}
return {};
}
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
template<typename U>
U const* next_sibling_of_type() const
{
return const_cast<Node*>(this)->template next_sibling_of_type<U>();
}
template<typename U>
inline U* next_sibling_of_type()
{
for (auto* sibling = next_sibling(); sibling; sibling = sibling->next_sibling()) {
if (is<U>(*sibling))
return &verify_cast<U>(*sibling);
}
return nullptr;
}
template<typename U>
U const* previous_sibling_of_type() const
{
return const_cast<Node*>(this)->template previous_sibling_of_type<U>();
}
template<typename U>
U* previous_sibling_of_type()
{
for (auto* sibling = previous_sibling(); sibling; sibling = sibling->previous_sibling()) {
if (is<U>(*sibling))
return &verify_cast<U>(*sibling);
}
return nullptr;
}
template<typename U>
U const* first_child_of_type() const
{
return const_cast<Node*>(this)->template first_child_of_type<U>();
}
template<typename U>
U const* last_child_of_type() const
{
return const_cast<Node*>(this)->template last_child_of_type<U>();
}
template<typename U>
U* first_child_of_type()
{
for (auto* child = first_child(); child; child = child->next_sibling()) {
if (is<U>(*child))
return &verify_cast<U>(*child);
}
return nullptr;
}
template<typename U>
U* last_child_of_type()
{
for (auto* child = last_child(); child; child = child->previous_sibling()) {
if (is<U>(*child))
return &verify_cast<U>(*child);
}
return nullptr;
}
template<typename U>
bool has_child_of_type() const
{
return first_child_of_type<U>() != nullptr;
}
template<typename U>
U const* first_ancestor_of_type() const
{
return const_cast<Node*>(this)->template first_ancestor_of_type<U>();
}
template<typename U>
U* first_ancestor_of_type()
{
for (auto* ancestor = parent(); ancestor; ancestor = ancestor->parent()) {
if (is<U>(*ancestor))
return &verify_cast<U>(*ancestor);
}
return nullptr;
}
LibWeb: Allow SVG painting to escape out of a shadow tree The spec for the `<use>` element requires a shadow tree for the rendered content, so we need to be able to escape shadow trees when rendering svg content.
2023-05-28 18:27:35 +01:00
template<typename U>
U const* shadow_including_first_ancestor_of_type() const
{
return const_cast<Node*>(this)->template shadow_including_first_ancestor_of_type<U>();
}
template<typename U>
U* shadow_including_first_ancestor_of_type();
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
bool is_parent_of(Node const& other) const
{
for (auto* child = first_child(); child; child = child->next_sibling()) {
if (&other == child)
return true;
}
return false;
}
LibWeb: Allow accessible-name computation to skip role-attribute lookup Per https://w3c.github.io/aria/#document-handling_author-errors_roles, determining whether to ignore certain specified landmark roles requires first determining whether the element for which the role is specified has an accessible name. But if we then try to retrieve a role for such elements, we end up calling right back into the accessible-name computation code — which would cause the calls to loop infinitely. So to avoid that — and to have handling for any other future cases the spec may introduce of such recursive calls that will loop indefinitely — this change introduces a parameter that callers can pass to cause role-attribute lookup to be skipped during accessible-name computation.
2024-12-19 23:21:48 +09:00
ErrorOr<String> accessible_name(Document const&, ShouldComputeRole = ShouldComputeRole::Yes) const;
LibWeb: Implement Accessible Name and Description Calculation This is an initial implementation of the accname standard. There is still some of the algorithm left unimplemented that we will need to implement in the future. However, as is, this implementation is sufficient for basic pages.
2023-02-05 11:21:59 -06:00
ErrorOr<String> accessible_description(Document const&) const;
LibWeb: Implement `Node.lookupNamespaceURI()` This method takes a prefix and returns the namespace URI associated with it on the given node, or null if no namespace is found.
2024-07-14 22:50:38 +01:00
Optional<String> locate_a_namespace(Optional<String> const& prefix) const;
Optional<String> lookup_namespace_uri(Optional<String> prefix) const;
LibWeb/DOM: Implement Node.lookupPrefix Adds https://dom.spec.whatwg.org/#dom-node-lookupprefix
2024-07-27 12:51:36 -06:00
Optional<String> lookup_prefix(Optional<String> namespace_) const;
LibWeb: Implement `Node.isDefaultNamespace()` This method accepts a namespace URI as an argument and returns true if the given URI is the default namespace on the given node, false otherwise.
2024-07-17 14:42:45 +01:00
bool is_default_namespace(Optional<String> namespace_) const;
LibWeb: Implement `Node.lookupNamespaceURI()` This method takes a prefix and returns the namespace URI associated with it on the given node, or null if no namespace is found.
2024-07-14 22:50:38 +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
protected:
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
Node(JS::Realm&, Document&, NodeType);
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/DOM: Update node cloning to latest spec Main difference is that a chunk of the "clone a node" steps are pulled out into a "clone a single node" algorithm. Reflects these spec PRs: https://github.com/whatwg/dom/pull/1332 https://github.com/whatwg/dom/pull/1334 Though this code is quite old so there may also be older spec changes included here.
2025-01-03 15:24:30 +00:00
void set_document(Document&);
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
virtual void visit_edges(Cell::Visitor&) override;
LibWeb: Add GC finalizer for DOM::Node Now that the layout tree is also GC-allocated, we can't be messing with it from the DOM::Node destructor. Move everything to a GC finalizer so we know it runs before the GC sweep phase.
2022-10-20 19:30:29 +02:00
virtual void finalize() override;
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ptr<Document> m_document;
GC::Ptr<Layout::Node> m_layout_node;
GC::Ptr<Painting::Paintable> m_paintable;
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 };
LibWeb: Add mechanism to invalidate only inherited styles We can now mark an element as needing an "inherited style update" rather than a full "style update". This effectively means that the next style update will visit the element and pull all of its inherited properties from the relevant ancestor element. This is now used for descendants of elements with animated style.
2024-12-22 11:59:58 +01:00
bool m_needs_inherited_style_update { false };
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_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
LibWeb: Make DOM Node unique IDs strongly typed (and 64 bit) This is strictly nicer than passing them around as i32 everywhere, and by switching to i64 as the underlying type, ID allocation becomes as simple as incrementing an integer.
2024-10-20 10:37:44 +02:00
UniqueNodeID m_unique_id;
LibWeb: Introduce Mutation{Record,Observer} and observer microtasks
2022-07-11 16:37:51 +01:00
// https://dom.spec.whatwg.org/#registered-observer-list
// "Nodes have a strong reference to registered observers in their registered observer list." https://dom.spec.whatwg.org/#garbage-collection
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
OwnPtr<Vector<GC::Ref<RegisteredObserver>>> m_registered_observer_list;
LibWeb: Implement all "childList" mutation records for MutationObserver
2022-07-11 16:39:14 +01:00
LibWeb: Fix a few const-ness issues
2023-02-25 10:44:51 -07:00
void build_accessibility_tree(AccessibilityTreeNode& parent);
LibWeb: Add Functionality to Dump to Accessibility Tree This will be used to display the accessibility tree in the inspector.
2022-12-11 10:56:37 -06:00
LibWeb: Allow accessible-name computation to skip role-attribute lookup Per https://w3c.github.io/aria/#document-handling_author-errors_roles, determining whether to ignore certain specified landmark roles requires first determining whether the element for which the role is specified has an accessible name. But if we then try to retrieve a role for such elements, we end up calling right back into the accessible-name computation code — which would cause the calls to loop infinitely. So to avoid that — and to have handling for any other future cases the spec may introduce of such recursive calls that will loop indefinitely — this change introduces a parameter that callers can pass to cause role-attribute lookup to be skipped during accessible-name computation.
2024-12-19 23:21:48 +09:00
ErrorOr<String> name_or_description(NameOrDescription, Document const&, HashTable<UniqueNodeID>&, IsDescendant = IsDescendant::No, ShouldComputeRole = ShouldComputeRole::Yes) const;
LibWeb: Implement Accessible Name and Description Calculation This is an initial implementation of the accname standard. There is still some of the algorithm left unimplemented that we will need to implement in the future. However, as is, this implementation is sufficient for basic pages.
2023-02-05 11:21:59 -06:00
LibWeb: Implement all "childList" mutation records for MutationObserver
2022-07-11 16:39:14 +01:00
private:
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
void queue_tree_mutation_record(Vector<GC::Root<Node>> added_nodes, Vector<GC::Root<Node>> removed_nodes, Node* previous_sibling, Node* next_sibling);
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
void insert_before_impl(GC::Ref<Node>, GC::Ptr<Node> child);
void append_child_impl(GC::Ref<Node>);
void remove_child_impl(GC::Ref<Node>);
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
LibWeb: Port DOM::Node from DeprecatedString
2023-12-03 08:24:04 +13:00
static Optional<StringView> first_valid_id(StringView, Document const&);
LibWeb: Implement Accessible Name and Description Calculation This is an initial implementation of the accname standard. There is still some of the algorithm left unimplemented that we will need to implement in the future. However, as is, this implementation is sufficient for basic pages.
2023-02-05 11:21:59 -06:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ptr<Node> m_parent;
GC::Ptr<Node> m_first_child;
GC::Ptr<Node> m_last_child;
GC::Ptr<Node> m_next_sibling;
GC::Ptr<Node> m_previous_sibling;
LibWeb: Make Node.childNodes vend the same NodeList every time
2022-09-21 13:49:31 +02:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ptr<NodeList> m_child_nodes;
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
}
LibJS+LibWeb: Add fast_is<DOM::Node> for JS::Object Solves problem that is<DOM::Node, JS::Object>() is quite hot in profiles while loading https://www.postgresql.org/about/featurematrix/.
2023-07-13 19:54:03 +02:00
template<>
inline bool JS::Object::fast_is<Web::DOM::Node>() const { return is_dom_node(); }
Reference in a new issue Copy permalink