beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-22 23:50:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6
ladybird/Userland/Libraries/LibWeb/TreeNode.h

504 lines
15 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 08:38:21 +00:00
/*
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 08:24:48 +00: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 08:38:21 +00:00
*/
LibHTML: Add a simple TreeNode<T> template for making trees. We'll be making a lot of trees here, so let's share code during bootstrap. Eventually some of these classes are gonna want custom trees but for now we can just fit them all into the same clothes.
2019-06-25 17:46:01 +00:00
#pragma once
#include <AK/Assertions.h>
#include <AK/NonnullRefPtr.h>
LibWeb: Switch to using AK::is and AK::downcast
2020-07-26 15:16:18 +00:00
#include <AK/TypeCasts.h>
LibHTML: Make TreeNode inherit from Weakable by default This makes Node and LayoutNode weakable. Frame was already weakable.
2019-10-19 07:42:20 +00:00
#include <AK/Weakable.h>
LibWeb: Make DOM Nodes keep their Document alive In addition to being reference-counted, all nodes that are part of a document must also keep the document alive. This is achieved by adding a second ref-count to the Document object and incrementing/decrementing it whenever a node is created/destroyed in that document. This brings us much closer to a proper DOM lifetime model, although the JS bindings still need more work.
2020-10-11 19:52:59 +00:00
#include <LibWeb/Forward.h>
LibHTML: Add a simple TreeNode<T> template for making trees. We'll be making a lot of trees here, so let's share code during bootstrap. Eventually some of these classes are gonna want custom trees but for now we can just fit them all into the same clothes.
2019-06-25 17:46:01 +00:00
LibWeb: Move everything into the Web namespace
2020-03-07 09:27:02 +00:00
namespace Web {
LibHTML: Add a simple TreeNode<T> template for making trees. We'll be making a lot of trees here, so let's share code during bootstrap. Eventually some of these classes are gonna want custom trees but for now we can just fit them all into the same clothes.
2019-06-25 17:46:01 +00:00
template<typename T>
LibHTML: Make TreeNode inherit from Weakable by default This makes Node and LayoutNode weakable. Frame was already weakable.
2019-10-19 07:42:20 +00:00
class TreeNode : public Weakable<T> {
LibHTML: Add a simple TreeNode<T> template for making trees. We'll be making a lot of trees here, so let's share code during bootstrap. Eventually some of these classes are gonna want custom trees but for now we can just fit them all into the same clothes.
2019-06-25 17:46:01 +00:00
public:
void ref()
{
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 19:42:32 +00:00
VERIFY(!m_in_removed_last_ref);
VERIFY(m_ref_count);
LibHTML: Add a simple TreeNode<T> template for making trees. We'll be making a lot of trees here, so let's share code during bootstrap. Eventually some of these classes are gonna want custom trees but for now we can just fit them all into the same clothes.
2019-06-25 17:46:01 +00:00
++m_ref_count;
}
AK: Let's call decrementing reference counts "unref" instead of "deref" It always bothered me that we're using the overloaded "dereference" term for this. Let's call it "unreference" instead. :^)
2020-01-23 14:14:21 +00:00
void unref()
LibHTML: Add a simple TreeNode<T> template for making trees. We'll be making a lot of trees here, so let's share code during bootstrap. Eventually some of these classes are gonna want custom trees but for now we can just fit them all into the same clothes.
2019-06-25 17:46:01 +00:00
{
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 19:42:32 +00:00
VERIFY(!m_in_removed_last_ref);
VERIFY(m_ref_count);
LibHTML: Have TreeNode deref its children before deleting itself This is definitely not the ideal ownership model here, but it's something we'll have to iterate on as the engine grows. At least this prevents us from leaking the entire world. :^)
2019-10-09 19:58:38 +00:00
if (!--m_ref_count) {
AK+Everywhere: Make StdLibExtras templates less wrapper-y This commit makes the user-facing StdLibExtras templates and utilities arguably more nice-looking by removing the need to reach into the wrapper structs generated by them to get the value/type needed. The C++ standard library had to invent `_v` and `_t` variants (likely because of backwards compat), but we don't need to cater to any codebase except our own, so might as well have good things for free. :^)
2021-04-10 13:59:06 +00:00
if constexpr (IsBaseOf<DOM::Node, T>) {
LibWeb: Break reference cycles so DOM::Document actually gets deleted When a document reaches ref_count==0, we will now remove all of the descendant nodes from the document, and also break all the explicit links (such as the currently hovered element.) Basically, DOM nodes will keep the document alive even after the document reaches ref_count==0. This allows JS wrappers to stay alive and keep the document alive as well. This matches the behavior of at least some other browsers. This patch also adds a bunch of sanity checking assertions around DOM teardown, to help catch mistakes in the future. Fixes #3771.
2020-10-22 21:38:14 +00:00
m_in_removed_last_ref = true;
LibWeb: Make DOM Nodes keep their Document alive In addition to being reference-counted, all nodes that are part of a document must also keep the document alive. This is achieved by adding a second ref-count to the Document object and incrementing/decrementing it whenever a node is created/destroyed in that document. This brings us much closer to a proper DOM lifetime model, although the JS bindings still need more work.
2020-10-11 19:52:59 +00:00
static_cast<T*>(this)->removed_last_ref();
LibWeb: Break reference cycles so DOM::Document actually gets deleted When a document reaches ref_count==0, we will now remove all of the descendant nodes from the document, and also break all the explicit links (such as the currently hovered element.) Basically, DOM nodes will keep the document alive even after the document reaches ref_count==0. This allows JS wrappers to stay alive and keep the document alive as well. This matches the behavior of at least some other browsers. This patch also adds a bunch of sanity checking assertions around DOM teardown, to help catch mistakes in the future. Fixes #3771.
2020-10-22 21:38:14 +00:00
} else {
LibWeb: Make DOM Nodes keep their Document alive In addition to being reference-counted, all nodes that are part of a document must also keep the document alive. This is achieved by adding a second ref-count to the Document object and incrementing/decrementing it whenever a node is created/destroyed in that document. This brings us much closer to a proper DOM lifetime model, although the JS bindings still need more work.
2020-10-11 19:52:59 +00:00
delete static_cast<T*>(this);
LibWeb: Break reference cycles so DOM::Document actually gets deleted When a document reaches ref_count==0, we will now remove all of the descendant nodes from the document, and also break all the explicit links (such as the currently hovered element.) Basically, DOM nodes will keep the document alive even after the document reaches ref_count==0. This allows JS wrappers to stay alive and keep the document alive as well. This matches the behavior of at least some other browsers. This patch also adds a bunch of sanity checking assertions around DOM teardown, to help catch mistakes in the future. Fixes #3771.
2020-10-22 21:38:14 +00:00
}
LibWeb: Make DOM Nodes keep their Document alive In addition to being reference-counted, all nodes that are part of a document must also keep the document alive. This is achieved by adding a second ref-count to the Document object and incrementing/decrementing it whenever a node is created/destroyed in that document. This brings us much closer to a proper DOM lifetime model, although the JS bindings still need more work.
2020-10-11 19:52:59 +00:00
return;
LibHTML: Have TreeNode deref its children before deleting itself This is definitely not the ideal ownership model here, but it's something we'll have to iterate on as the engine grows. At least this prevents us from leaking the entire world. :^)
2019-10-09 19:58:38 +00:00
}
LibHTML: Add a simple TreeNode<T> template for making trees. We'll be making a lot of trees here, so let's share code during bootstrap. Eventually some of these classes are gonna want custom trees but for now we can just fit them all into the same clothes.
2019-06-25 17:46:01 +00:00
}
int ref_count() const { return m_ref_count; }
T* parent() { return m_parent; }
const T* parent() const { return m_parent; }
bool has_children() const { return m_first_child; }
T* next_sibling() { return m_next_sibling; }
T* previous_sibling() { return m_previous_sibling; }
T* first_child() { return m_first_child; }
T* last_child() { return m_last_child; }
const T* next_sibling() const { return m_next_sibling; }
const T* previous_sibling() const { return m_previous_sibling; }
const T* first_child() const { return m_first_child; }
const T* last_child() const { return m_last_child; }
LibHTML+Browser: Add a simple DOM inspector popup window LibHTML now provides a DOMTreeModel which can be used to view a given Document's DOM tree. :^)
2019-11-09 10:31:03 +00:00
int child_count() const
{
int count = 0;
for (auto* child = first_child(); child; child = child->next_sibling())
++count;
return count;
}
T* 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;
}
const T* child_at_index(int index) const
{
return const_cast<TreeNode*>(this)->child_at_index(index);
}
LibWeb: Add capabilities to find the index of a child in its parent. For Elements depending on the index they are inside their parent. Most notably the <ol> element. Also added a typed version to only count children of a certain type. This patch is work towards #2059
2021-04-17 21:05:56 +00:00
Optional<size_t> index_of_child(const T& search_child)
{
VERIFY(search_child.parent() == this);
size_t index = 0;
auto* child = first_child();
VERIFY(child);
do {
if (child == &search_child)
return index;
index++;
} while (child && (child = child->next_sibling()));
return {};
}
template<typename ChildType>
Optional<size_t> index_of_child(const T& search_child)
{
VERIFY(search_child.parent() == this);
size_t index = 0;
auto* child = first_child();
VERIFY(child);
do {
if (!is<ChildType>(child))
continue;
if (child == &search_child)
return index;
index++;
} while (child && (child = child->next_sibling()));
return {};
}
LibHTML: Move is_ancestor_of() from LayoutNode to TreeNode This way it becomes available to all the different TreeNode subclasses.
2019-10-09 19:33:34 +00:00
bool is_ancestor_of(const TreeNode&) 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 18:34:49 +00:00
bool is_inclusive_ancestor_of(const TreeNode&) const;
bool is_descendant_of(const TreeNode&) const;
bool is_inclusive_descendant_of(const TreeNode&) const;
LibHTML: Move is_ancestor_of() from LayoutNode to TreeNode This way it becomes available to all the different TreeNode subclasses.
2019-10-09 19:33:34 +00:00
LibWeb: Strip out the mutation event logic from TreeNode This will instead be done by Node, as they need to occur at precise steps of the mutation algorithms. Additionally, some of the events may need to be run multiple times. For example, the removal steps is run for all the shadow-including descendants of the node that just got removed.
2021-04-06 17:29:12 +00:00
void append_child(NonnullRefPtr<T> node);
LibWeb: Implement <script src> support for synchronous scripts Scripts loaded in this way will block the parser until they finish executing. This means that they see the DOM before the whole document has been fully parsed. This is all normal, of course. To make this work, I changed the way we notify DOM nodes about tree insertion. The inserted_into() callbacks are now incrementally invoked during parse, as each node is appended to its parent. To accomodate inline scripts and inline style sheets, we now also have a children_changed() callback which is invoked on any parent when it has children added/removed.
2020-04-03 21:06:09 +00:00
void prepend_child(NonnullRefPtr<T> node);
LibWeb: Strip out the mutation event logic from TreeNode This will instead be done by Node, as they need to occur at precise steps of the mutation algorithms. Additionally, some of the events may need to be run multiple times. For example, the removal steps is run for all the shadow-including descendants of the node that just got removed.
2021-04-06 17:29:12 +00:00
void insert_before(NonnullRefPtr<T> node, RefPtr<T> child);
void remove_child(NonnullRefPtr<T> node);
LibHTML: Add a simple TreeNode<T> template for making trees. We'll be making a lot of trees here, so let's share code during bootstrap. Eventually some of these classes are gonna want custom trees but for now we can just fit them all into the same clothes.
2019-06-25 17:46:01 +00:00
LibHTML: Add Comment and CharacterData nodes and improve HTML parsing This patch adds the CharacterData subclass of Node, which is now the parent class of Text and a new Comment class. A Comment node is one of these in HTML: <!--hello friends--> Since these occur somewhat frequently on the web, we need to be able to parse them. This patch also adds a child rejection mechanism to the DOM tree. Nodes can now override is_child_allowed(Node) and return false if they don't want a particular Node to become a child of theirs. This is used to prevent Document from taking on unwanted children.
2019-10-12 21:26:47 +00:00
bool is_child_allowed(const T&) const { return true; }
LibHTML: Add TreeNode::next_in_pre_order() This function allows you to traverse in pre-order without recursing.
2019-11-05 17:36:06 +00:00
T* next_in_pre_order()
{
if (first_child())
return first_child();
T* node;
if (!(node = next_sibling())) {
node = parent();
while (node && !node->next_sibling())
node = node->parent();
if (node)
node = node->next_sibling();
}
return node;
}
const T* next_in_pre_order() const
{
return const_cast<TreeNode*>(this)->next_in_pre_order();
}
LibWeb: Add LayoutRange::normalized() We use this to ensure that we're always working with a selection where the start() is before the end() in document order. That simplifies all the logic around this.
2020-06-28 22:24:35 +00:00
bool is_before(const T& 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;
}
LibHTML: Add TreeNode<T>::for_each_in_subtree(callback) This helper invokes a callback for the node and each of its descendants in pre-order.
2019-10-19 16:14:54 +00:00
template<typename Callback>
LibWeb: Rename "for_each_in_subtree(_of_type)" to "for_each_in_inclusive_subtree(_of_type)" This is because it includes the initial node that the function was called on, which makes it "inclusive" as according to the spec. This is important as there are non-inclusive variants, particularly used in the node mutation algorithms.
2021-04-06 17:38:10 +00:00
IterationDecision for_each_in_inclusive_subtree(Callback callback) const
LibHTML: Add TreeNode<T>::for_each_in_subtree(callback) This helper invokes a callback for the node and each of its descendants in pre-order.
2019-10-19 16:14:54 +00:00
{
LibHTML: Add Document::get_element_by_id() and get_elements_by_name() These will be useful for implementing various things. They don't do any caching at the moment, but that might become valuable in the future. To facilitate this change, I also made it possible to abort a tree walk with for_each_in_subtree() by returning IterationDecision::Break from the callback.
2019-10-21 10:01:30 +00:00
if (callback(static_cast<const T&>(*this)) == IterationDecision::Break)
return IterationDecision::Break;
LibHTML: Add TreeNode<T>::for_each_in_subtree(callback) This helper invokes a callback for the node and each of its descendants in pre-order.
2019-10-19 16:14:54 +00:00
for (auto* child = first_child(); child; child = child->next_sibling()) {
LibWeb: Rename "for_each_in_subtree(_of_type)" to "for_each_in_inclusive_subtree(_of_type)" This is because it includes the initial node that the function was called on, which makes it "inclusive" as according to the spec. This is important as there are non-inclusive variants, particularly used in the node mutation algorithms.
2021-04-06 17:38:10 +00:00
if (child->for_each_in_inclusive_subtree(callback) == IterationDecision::Break)
LibHTML: Add Document::get_element_by_id() and get_elements_by_name() These will be useful for implementing various things. They don't do any caching at the moment, but that might become valuable in the future. To facilitate this change, I also made it possible to abort a tree walk with for_each_in_subtree() by returning IterationDecision::Break from the callback.
2019-10-21 10:01:30 +00:00
return IterationDecision::Break;
LibHTML: Add TreeNode<T>::for_each_in_subtree(callback) This helper invokes a callback for the node and each of its descendants in pre-order.
2019-10-19 16:14:54 +00:00
}
LibHTML: Add Document::get_element_by_id() and get_elements_by_name() These will be useful for implementing various things. They don't do any caching at the moment, but that might become valuable in the future. To facilitate this change, I also made it possible to abort a tree walk with for_each_in_subtree() by returning IterationDecision::Break from the callback.
2019-10-21 10:01:30 +00:00
return IterationDecision::Continue;
}
template<typename Callback>
LibWeb: Rename "for_each_in_subtree(_of_type)" to "for_each_in_inclusive_subtree(_of_type)" This is because it includes the initial node that the function was called on, which makes it "inclusive" as according to the spec. This is important as there are non-inclusive variants, particularly used in the node mutation algorithms.
2021-04-06 17:38:10 +00:00
IterationDecision for_each_in_inclusive_subtree(Callback callback)
LibHTML: Add Document::get_element_by_id() and get_elements_by_name() These will be useful for implementing various things. They don't do any caching at the moment, but that might become valuable in the future. To facilitate this change, I also made it possible to abort a tree walk with for_each_in_subtree() by returning IterationDecision::Break from the callback.
2019-10-21 10:01:30 +00:00
{
if (callback(static_cast<T&>(*this)) == IterationDecision::Break)
return IterationDecision::Break;
for (auto* child = first_child(); child; child = child->next_sibling()) {
LibWeb: Rename "for_each_in_subtree(_of_type)" to "for_each_in_inclusive_subtree(_of_type)" This is because it includes the initial node that the function was called on, which makes it "inclusive" as according to the spec. This is important as there are non-inclusive variants, particularly used in the node mutation algorithms.
2021-04-06 17:38:10 +00:00
if (child->for_each_in_inclusive_subtree(callback) == IterationDecision::Break)
LibHTML: Add Document::get_element_by_id() and get_elements_by_name() These will be useful for implementing various things. They don't do any caching at the moment, but that might become valuable in the future. To facilitate this change, I also made it possible to abort a tree walk with for_each_in_subtree() by returning IterationDecision::Break from the callback.
2019-10-21 10:01:30 +00:00
return IterationDecision::Break;
}
return IterationDecision::Continue;
LibHTML: Add TreeNode<T>::for_each_in_subtree(callback) This helper invokes a callback for the node and each of its descendants in pre-order.
2019-10-19 16:14:54 +00:00
}
LibHTML: Add TreeNode::for_each_in_subtree_of_type<T>() This allows you to iterate a subtree and get a callback for every node where is<T>(node) == true. This makes for quite pleasant DOM traversal.
2019-12-18 20:34:03 +00:00
template<typename U, typename Callback>
LibWeb: Rename "for_each_in_subtree(_of_type)" to "for_each_in_inclusive_subtree(_of_type)" This is because it includes the initial node that the function was called on, which makes it "inclusive" as according to the spec. This is important as there are non-inclusive variants, particularly used in the node mutation algorithms.
2021-04-06 17:38:10 +00:00
IterationDecision for_each_in_inclusive_subtree_of_type(Callback callback)
LibHTML: Add TreeNode::for_each_in_subtree_of_type<T>() This allows you to iterate a subtree and get a callback for every node where is<T>(node) == true. This makes for quite pleasant DOM traversal.
2019-12-18 20:34:03 +00:00
{
if (is<U>(static_cast<const T&>(*this))) {
if (callback(static_cast<U&>(*this)) == IterationDecision::Break)
return IterationDecision::Break;
}
for (auto* child = first_child(); child; child = child->next_sibling()) {
LibWeb: Rename "for_each_in_subtree(_of_type)" to "for_each_in_inclusive_subtree(_of_type)" This is because it includes the initial node that the function was called on, which makes it "inclusive" as according to the spec. This is important as there are non-inclusive variants, particularly used in the node mutation algorithms.
2021-04-06 17:38:10 +00:00
if (child->template for_each_in_inclusive_subtree_of_type<U>(callback) == IterationDecision::Break)
LibHTML: Add TreeNode::for_each_in_subtree_of_type<T>() This allows you to iterate a subtree and get a callback for every node where is<T>(node) == true. This makes for quite pleasant DOM traversal.
2019-12-18 20:34:03 +00:00
return IterationDecision::Break;
}
return IterationDecision::Continue;
}
template<typename U, typename Callback>
LibWeb: Rename "for_each_in_subtree(_of_type)" to "for_each_in_inclusive_subtree(_of_type)" This is because it includes the initial node that the function was called on, which makes it "inclusive" as according to the spec. This is important as there are non-inclusive variants, particularly used in the node mutation algorithms.
2021-04-06 17:38:10 +00:00
IterationDecision for_each_in_inclusive_subtree_of_type(Callback callback) const
LibHTML: Add TreeNode::for_each_in_subtree_of_type<T>() This allows you to iterate a subtree and get a callback for every node where is<T>(node) == true. This makes for quite pleasant DOM traversal.
2019-12-18 20:34:03 +00:00
{
if (is<U>(static_cast<const T&>(*this))) {
if (callback(static_cast<const U&>(*this)) == IterationDecision::Break)
return IterationDecision::Break;
}
for (auto* child = first_child(); child; child = child->next_sibling()) {
LibWeb: Rename "for_each_in_subtree(_of_type)" to "for_each_in_inclusive_subtree(_of_type)" This is because it includes the initial node that the function was called on, which makes it "inclusive" as according to the spec. This is important as there are non-inclusive variants, particularly used in the node mutation algorithms.
2021-04-06 17:38:10 +00:00
if (child->template for_each_in_inclusive_subtree_of_type<U>(callback) == IterationDecision::Break)
LibHTML: Add TreeNode::for_each_in_subtree_of_type<T>() This allows you to iterate a subtree and get a callback for every node where is<T>(node) == true. This makes for quite pleasant DOM traversal.
2019-12-18 20:34:03 +00:00
return IterationDecision::Break;
}
return IterationDecision::Continue;
}
LibWeb: Add non-inclusive variants of subtree traversal
2021-04-06 17:49:02 +00:00
template<typename Callback>
IterationDecision for_each_in_subtree(Callback callback) const
{
for (auto* child = first_child(); child; child = child->next_sibling()) {
if (child->for_each_in_inclusive_subtree(callback) == IterationDecision::Break)
return IterationDecision::Break;
}
return IterationDecision::Continue;
}
template<typename Callback>
IterationDecision for_each_in_subtree(Callback callback)
{
for (auto* child = first_child(); child; child = child->next_sibling()) {
if (child->for_each_in_inclusive_subtree(callback) == IterationDecision::Break)
return IterationDecision::Break;
}
return IterationDecision::Continue;
}
template<typename U, typename Callback>
IterationDecision for_each_in_subtree_of_type(Callback callback)
{
for (auto* child = first_child(); child; child = child->next_sibling()) {
if (child->template for_each_in_inclusive_subtree_of_type<U>(callback) == IterationDecision::Break)
return IterationDecision::Break;
}
return IterationDecision::Continue;
}
template<typename U, typename Callback>
IterationDecision for_each_in_subtree_of_type(Callback callback) const
{
for (auto* child = first_child(); child; child = child->next_sibling()) {
if (child->template for_each_in_inclusive_subtree_of_type<U>(callback) == IterationDecision::Break)
return IterationDecision::Break;
}
return IterationDecision::Continue;
}
LibWeb: Move tree iteration helpers from Node/LayoutNode to TreeNode Since these are generally useful in our trees, let's just keep them in TreeNode instead of duplicating the helpers in subclasses.
2020-08-10 11:52:49 +00:00
template<typename Callback>
void for_each_child(Callback callback) const
{
return const_cast<TreeNode*>(this)->template for_each_child(move(callback));
}
template<typename Callback>
void for_each_child(Callback callback)
{
for (auto* node = first_child(); node; node = node->next_sibling())
callback(*node);
}
template<typename U, typename Callback>
void for_each_child_of_type(Callback callback)
{
for (auto* node = first_child(); node; node = node->next_sibling()) {
if (is<U>(node))
AK: Rename downcast<T> => verify_cast<T> This makes it much clearer what this cast actually does: it will VERIFY that the thing we're casting is a T (using is<T>()).
2021-06-24 17:53:42 +00:00
callback(verify_cast<U>(*node));
LibWeb: Move tree iteration helpers from Node/LayoutNode to TreeNode Since these are generally useful in our trees, let's just keep them in TreeNode instead of duplicating the helpers in subclasses.
2020-08-10 11:52:49 +00:00
}
}
template<typename U, typename Callback>
void for_each_child_of_type(Callback callback) const
{
return const_cast<TreeNode*>(this)->template for_each_child_of_type<U>(move(callback));
}
template<typename U>
const U* next_sibling_of_type() const
{
return const_cast<TreeNode*>(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))
AK: Rename downcast<T> => verify_cast<T> This makes it much clearer what this cast actually does: it will VERIFY that the thing we're casting is a T (using is<T>()).
2021-06-24 17:53:42 +00:00
return &verify_cast<U>(*sibling);
LibWeb: Move tree iteration helpers from Node/LayoutNode to TreeNode Since these are generally useful in our trees, let's just keep them in TreeNode instead of duplicating the helpers in subclasses.
2020-08-10 11:52:49 +00:00
}
return nullptr;
}
template<typename U>
const U* previous_sibling_of_type() const
{
return const_cast<TreeNode*>(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))
AK: Rename downcast<T> => verify_cast<T> This makes it much clearer what this cast actually does: it will VERIFY that the thing we're casting is a T (using is<T>()).
2021-06-24 17:53:42 +00:00
return &verify_cast<U>(*sibling);
LibWeb: Move tree iteration helpers from Node/LayoutNode to TreeNode Since these are generally useful in our trees, let's just keep them in TreeNode instead of duplicating the helpers in subclasses.
2020-08-10 11:52:49 +00:00
}
return nullptr;
}
template<typename U>
const U* first_child_of_type() const
{
return const_cast<TreeNode*>(this)->template first_child_of_type<U>();
}
LibWeb: Expose ParentNode.{first,last}ElementChild I needed these to write the event dispatcher test.
2020-11-21 18:49:09 +00:00
template<typename U>
const U* last_child_of_type() const
{
return const_cast<TreeNode*>(this)->template last_child_of_type<U>();
}
LibWeb: Move tree iteration helpers from Node/LayoutNode to TreeNode Since these are generally useful in our trees, let's just keep them in TreeNode instead of duplicating the helpers in subclasses.
2020-08-10 11:52:49 +00:00
template<typename U>
U* first_child_of_type()
{
for (auto* child = first_child(); child; child = child->next_sibling()) {
if (is<U>(*child))
AK: Rename downcast<T> => verify_cast<T> This makes it much clearer what this cast actually does: it will VERIFY that the thing we're casting is a T (using is<T>()).
2021-06-24 17:53:42 +00:00
return &verify_cast<U>(*child);
LibWeb: Move tree iteration helpers from Node/LayoutNode to TreeNode Since these are generally useful in our trees, let's just keep them in TreeNode instead of duplicating the helpers in subclasses.
2020-08-10 11:52:49 +00:00
}
return nullptr;
}
LibWeb: Expose ParentNode.{first,last}ElementChild I needed these to write the event dispatcher test.
2020-11-21 18:49:09 +00:00
template<typename U>
U* last_child_of_type()
{
for (auto* child = last_child(); child; child = child->previous_sibling()) {
if (is<U>(*child))
AK: Rename downcast<T> => verify_cast<T> This makes it much clearer what this cast actually does: it will VERIFY that the thing we're casting is a T (using is<T>()).
2021-06-24 17:53:42 +00:00
return &verify_cast<U>(*child);
LibWeb: Expose ParentNode.{first,last}ElementChild I needed these to write the event dispatcher test.
2020-11-21 18:49:09 +00:00
}
return nullptr;
}
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 18:34:49 +00:00
template<typename U>
bool has_child_of_type() const
{
return first_child_of_type<U>() != nullptr;
}
LibWeb: Move tree iteration helpers from Node/LayoutNode to TreeNode Since these are generally useful in our trees, let's just keep them in TreeNode instead of duplicating the helpers in subclasses.
2020-08-10 11:52:49 +00:00
template<typename U>
const U* first_ancestor_of_type() const
{
return const_cast<TreeNode*>(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))
AK: Rename downcast<T> => verify_cast<T> This makes it much clearer what this cast actually does: it will VERIFY that the thing we're casting is a T (using is<T>()).
2021-06-24 17:53:42 +00:00
return &verify_cast<U>(*ancestor);
LibWeb: Move tree iteration helpers from Node/LayoutNode to TreeNode Since these are generally useful in our trees, let's just keep them in TreeNode instead of duplicating the helpers in subclasses.
2020-08-10 11:52:49 +00:00
}
return nullptr;
}
LibWeb: Sever parent/child connections in ~TreeNode() Also make sure to unref the children if there are any. Without this it was very easy to leak TreeNodes.
2021-04-06 13:50:47 +00:00
~TreeNode()
{
VERIFY(!m_parent);
T* next_child = nullptr;
for (auto* child = m_first_child; child; child = next_child) {
next_child = child->m_next_sibling;
child->m_parent = nullptr;
child->unref();
}
}
LibHTML: Add a simple TreeNode<T> template for making trees. We'll be making a lot of trees here, so let's share code during bootstrap. Eventually some of these classes are gonna want custom trees but for now we can just fit them all into the same clothes.
2019-06-25 17:46:01 +00:00
protected:
LibWeb: Add a way to opt out of TreeNode::append_child() notifications This will be used temporarily by the new HTML parser while we're bringing it up.
2020-05-24 19:58:21 +00:00
TreeNode() { }
LibHTML: Add a simple TreeNode<T> template for making trees. We'll be making a lot of trees here, so let's share code during bootstrap. Eventually some of these classes are gonna want custom trees but for now we can just fit them all into the same clothes.
2019-06-25 17:46:01 +00:00
LibWeb: Break reference cycles so DOM::Document actually gets deleted When a document reaches ref_count==0, we will now remove all of the descendant nodes from the document, and also break all the explicit links (such as the currently hovered element.) Basically, DOM nodes will keep the document alive even after the document reaches ref_count==0. This allows JS wrappers to stay alive and keep the document alive as well. This matches the behavior of at least some other browsers. This patch also adds a bunch of sanity checking assertions around DOM teardown, to help catch mistakes in the future. Fixes #3771.
2020-10-22 21:38:14 +00:00
bool m_deletion_has_begun { false };
bool m_in_removed_last_ref { false };
LibHTML: Add a simple TreeNode<T> template for making trees. We'll be making a lot of trees here, so let's share code during bootstrap. Eventually some of these classes are gonna want custom trees but for now we can just fit them all into the same clothes.
2019-06-25 17:46:01 +00:00
private:
int m_ref_count { 1 };
T* m_parent { nullptr };
T* m_first_child { nullptr };
T* m_last_child { nullptr };
T* m_next_sibling { nullptr };
T* m_previous_sibling { nullptr };
};
LibHTML: Add TreeNode::remove_child() This removes a child from the tree and returns it to the caller. It optionally (but by default) calls removed_from(parent) on the child.
2019-11-06 19:25:40 +00:00
template<typename T>
LibWeb: Strip out the mutation event logic from TreeNode This will instead be done by Node, as they need to occur at precise steps of the mutation algorithms. Additionally, some of the events may need to be run multiple times. For example, the removal steps is run for all the shadow-including descendants of the node that just got removed.
2021-04-06 17:29:12 +00:00
inline void TreeNode<T>::remove_child(NonnullRefPtr<T> node)
LibHTML: Add TreeNode::remove_child() This removes a child from the tree and returns it to the caller. It optionally (but by default) calls removed_from(parent) on the child.
2019-11-06 19:25:40 +00:00
{
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 19:42:32 +00:00
VERIFY(node->m_parent == this);
LibHTML: Add TreeNode::remove_child() This removes a child from the tree and returns it to the caller. It optionally (but by default) calls removed_from(parent) on the child.
2019-11-06 19:25:40 +00:00
if (m_first_child == node)
m_first_child = node->m_next_sibling;
if (m_last_child == node)
m_last_child = node->m_previous_sibling;
LibHTML: Update the removed node's siblings in TreeNode::remove_child() Oops, we forgot to update the node's siblings' sibling pointers when removing a node from the tree. Thanks to Owlinated for pointing this out! :^)
2019-11-07 21:42:55 +00:00
if (node->m_next_sibling)
node->m_next_sibling->m_previous_sibling = node->m_previous_sibling;
if (node->m_previous_sibling)
node->m_previous_sibling->m_next_sibling = node->m_next_sibling;
LibHTML: Add TreeNode::remove_child() This removes a child from the tree and returns it to the caller. It optionally (but by default) calls removed_from(parent) on the child.
2019-11-06 19:25:40 +00:00
node->m_next_sibling = nullptr;
node->m_previous_sibling = nullptr;
node->m_parent = nullptr;
AK: Let's call decrementing reference counts "unref" instead of "deref" It always bothered me that we're using the overloaded "dereference" term for this. Let's call it "unreference" instead. :^)
2020-01-23 14:14:21 +00:00
node->unref();
LibHTML: Add TreeNode::remove_child() This removes a child from the tree and returns it to the caller. It optionally (but by default) calls removed_from(parent) on the child.
2019-11-06 19:25:40 +00:00
}
LibHTML: Add a simple TreeNode<T> template for making trees. We'll be making a lot of trees here, so let's share code during bootstrap. Eventually some of these classes are gonna want custom trees but for now we can just fit them all into the same clothes.
2019-06-25 17:46:01 +00:00
template<typename T>
LibWeb: Strip out the mutation event logic from TreeNode This will instead be done by Node, as they need to occur at precise steps of the mutation algorithms. Additionally, some of the events may need to be run multiple times. For example, the removal steps is run for all the shadow-including descendants of the node that just got removed.
2021-04-06 17:29:12 +00:00
inline void TreeNode<T>::append_child(NonnullRefPtr<T> node)
LibHTML: Add a simple TreeNode<T> template for making trees. We'll be making a lot of trees here, so let's share code during bootstrap. Eventually some of these classes are gonna want custom trees but for now we can just fit them all into the same clothes.
2019-06-25 17:46:01 +00:00
{
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 19:42:32 +00:00
VERIFY(!node->m_parent);
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 21:26:47 +00:00
if (!static_cast<T*>(this)->is_child_allowed(*node))
return;
LibHTML: Add a simple TreeNode<T> template for making trees. We'll be making a lot of trees here, so let's share code during bootstrap. Eventually some of these classes are gonna want custom trees but for now we can just fit them all into the same clothes.
2019-06-25 17:46:01 +00:00
if (m_last_child)
m_last_child->m_next_sibling = node.ptr();
node->m_previous_sibling = m_last_child;
node->m_parent = static_cast<T*>(this);
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 15:40:39 +00:00
m_last_child = node.ptr();
LibHTML: Add a simple TreeNode<T> template for making trees. We'll be making a lot of trees here, so let's share code during bootstrap. Eventually some of these classes are gonna want custom trees but for now we can just fit them all into the same clothes.
2019-06-25 17:46:01 +00:00
if (!m_first_child)
m_first_child = m_last_child;
Everywhere: Switch from (void) to [[maybe_unused]] (#4473) Problem: - `(void)` simply casts the expression to void. This is understood to indicate that it is ignored, but this is really a compiler trick to get the compiler to not generate a warning. Solution: - Use the `[[maybe_unused]]` attribute to indicate the value is unused. Note: - Functions taking a `(void)` argument list have also been changed to `()` because this is not needed and shows up in the same grep command.
2020-12-20 23:09:48 +00:00
[[maybe_unused]] auto& rc = node.leak_ref();
LibHTML: Add a simple TreeNode<T> template for making trees. We'll be making a lot of trees here, so let's share code during bootstrap. Eventually some of these classes are gonna want custom trees but for now we can just fit them all into the same clothes.
2019-06-25 17:46:01 +00:00
}
LibHTML: Add Document::normalize() This method wraps the document tree in <html> and <body> elements if needed.
2019-09-25 09:26:26 +00:00
LibWeb: Add Node.insertBefore(Node node, Node? child)
2020-06-21 14:45:21 +00:00
template<typename T>
LibWeb: Strip out the mutation event logic from TreeNode This will instead be done by Node, as they need to occur at precise steps of the mutation algorithms. Additionally, some of the events may need to be run multiple times. For example, the removal steps is run for all the shadow-including descendants of the node that just got removed.
2021-04-06 17:29:12 +00:00
inline void TreeNode<T>::insert_before(NonnullRefPtr<T> node, RefPtr<T> child)
LibWeb: Add Node.insertBefore(Node node, Node? child)
2020-06-21 14:45:21 +00:00
{
if (!child)
LibWeb: Strip out the mutation event logic from TreeNode This will instead be done by Node, as they need to occur at precise steps of the mutation algorithms. Additionally, some of the events may need to be run multiple times. For example, the removal steps is run for all the shadow-including descendants of the node that just got removed.
2021-04-06 17:29:12 +00:00
return append_child(move(node));
LibWeb: Add Node.insertBefore(Node node, Node? child)
2020-06-21 14:45:21 +00:00
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 19:42:32 +00:00
VERIFY(!node->m_parent);
VERIFY(child->parent() == this);
LibWeb: Add Node.insertBefore(Node node, Node? child)
2020-06-21 14:45:21 +00:00
node->m_previous_sibling = child->m_previous_sibling;
node->m_next_sibling = child;
LibWeb: Two more edge cases for TreeNode::insert_before.
2020-11-27 22:00:53 +00:00
if (child->m_previous_sibling)
child->m_previous_sibling->m_next_sibling = node;
if (m_first_child == child)
m_first_child = node;
LibWeb: Update m_previous_sibling in TreeNode::insert_before.
2020-11-27 20:06:15 +00:00
child->m_previous_sibling = node;
LibWeb: Add Node.insertBefore(Node node, Node? child)
2020-06-21 14:45:21 +00:00
node->m_parent = static_cast<T*>(this);
Everywhere: Switch from (void) to [[maybe_unused]] (#4473) Problem: - `(void)` simply casts the expression to void. This is understood to indicate that it is ignored, but this is really a compiler trick to get the compiler to not generate a warning. Solution: - Use the `[[maybe_unused]]` attribute to indicate the value is unused. Note: - Functions taking a `(void)` argument list have also been changed to `()` because this is not needed and shows up in the same grep command.
2020-12-20 23:09:48 +00:00
[[maybe_unused]] auto& rc = node.leak_ref();
LibWeb: Add Node.insertBefore(Node node, Node? child)
2020-06-21 14:45:21 +00:00
}
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 18:17:01 +00:00
template<typename T>
LibWeb: Implement <script src> support for synchronous scripts Scripts loaded in this way will block the parser until they finish executing. This means that they see the DOM before the whole document has been fully parsed. This is all normal, of course. To make this work, I changed the way we notify DOM nodes about tree insertion. The inserted_into() callbacks are now incrementally invoked during parse, as each node is appended to its parent. To accomodate inline scripts and inline style sheets, we now also have a children_changed() callback which is invoked on any parent when it has children added/removed.
2020-04-03 21:06:09 +00:00
inline void TreeNode<T>::prepend_child(NonnullRefPtr<T> 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 18:17:01 +00:00
{
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 19:42:32 +00:00
VERIFY(!node->m_parent);
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 21:26:47 +00:00
if (!static_cast<T*>(this)->is_child_allowed(*node))
return;
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 18:17:01 +00:00
if (m_first_child)
m_first_child->m_previous_sibling = node.ptr();
node->m_next_sibling = m_first_child;
node->m_parent = static_cast<T*>(this);
m_first_child = node.ptr();
if (!m_last_child)
m_last_child = m_first_child;
LibWeb: Implement <script src> support for synchronous scripts Scripts loaded in this way will block the parser until they finish executing. This means that they see the DOM before the whole document has been fully parsed. This is all normal, of course. To make this work, I changed the way we notify DOM nodes about tree insertion. The inserted_into() callbacks are now incrementally invoked during parse, as each node is appended to its parent. To accomodate inline scripts and inline style sheets, we now also have a children_changed() callback which is invoked on any parent when it has children added/removed.
2020-04-03 21:06:09 +00:00
node->inserted_into(static_cast<T&>(*this));
Everywhere: Switch from (void) to [[maybe_unused]] (#4473) Problem: - `(void)` simply casts the expression to void. This is understood to indicate that it is ignored, but this is really a compiler trick to get the compiler to not generate a warning. Solution: - Use the `[[maybe_unused]]` attribute to indicate the value is unused. Note: - Functions taking a `(void)` argument list have also been changed to `()` because this is not needed and shows up in the same grep command.
2020-12-20 23:09:48 +00:00
[[maybe_unused]] auto& rc = node.leak_ref();
LibWeb: Implement <script src> support for synchronous scripts Scripts loaded in this way will block the parser until they finish executing. This means that they see the DOM before the whole document has been fully parsed. This is all normal, of course. To make this work, I changed the way we notify DOM nodes about tree insertion. The inserted_into() callbacks are now incrementally invoked during parse, as each node is appended to its parent. To accomodate inline scripts and inline style sheets, we now also have a children_changed() callback which is invoked on any parent when it has children added/removed.
2020-04-03 21:06:09 +00:00
static_cast<T*>(this)->children_changed();
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 18:17:01 +00:00
}
LibHTML: Move is_ancestor_of() from LayoutNode to TreeNode This way it becomes available to all the different TreeNode subclasses.
2019-10-09 19:33:34 +00:00
template<typename T>
inline bool TreeNode<T>::is_ancestor_of(const TreeNode<T>& other) const
{
for (auto* ancestor = other.parent(); ancestor; ancestor = ancestor->parent()) {
if (ancestor == this)
return true;
}
return false;
}
LibWeb: Move everything into the Web namespace
2020-03-07 09:27:02 +00:00
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 18:34:49 +00:00
template<typename T>
inline bool TreeNode<T>::is_inclusive_ancestor_of(const TreeNode<T>& other) const
{
return &other == this || is_ancestor_of(other);
}
template<typename T>
inline bool TreeNode<T>::is_descendant_of(const TreeNode<T>& other) const
{
return other.is_ancestor_of(*this);
}
template<typename T>
inline bool TreeNode<T>::is_inclusive_descendant_of(const TreeNode<T>& other) const
{
return other.is_inclusive_ancestor_of(*this);
}
LibWeb: Move everything into the Web namespace
2020-03-07 09:27:02 +00:00
}
Reference in a new issue Copy permalink