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

358 lines
16 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+LibIDL: Fix (or paper over) various const-correctness issues There's definitely stuff to iterate on here, but this takes care of making the libraries compile with stricter RP and NNRP.
2023-02-20 18:56:08 +01:00
* Copyright (c) 2018-2023, Andreas Kling <kling@serenityos.org>
Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 09:38:21 +01:00
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 01:24:48 -07:00
* SPDX-License-Identifier: BSD-2-Clause
Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 09:38:21 +01:00
*/
LibHTML: Start working on a simple HTML library. I'd like to have rich text, and we might as well use HTML for that. :^)
2019-06-15 18:55:47 +02:00
#pragma once
AK+Everywhere: Rename FlyString to DeprecatedFlyString DeprecatedFlyString relies heavily on DeprecatedString's StringImpl, so let's rename it to A) match the name of DeprecatedString, B) write a new FlyString class that is tied to String.
2023-01-08 19:23:00 -05:00
#include <AK/DeprecatedFlyString.h>
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
#include <AK/DeprecatedString.h>
LibWeb: Move ARIA-related code into the Web::ARIA namespace ARIA has its own spec and is not part of the DOM spec, which is what the Web::DOM namespace is for (https://www.w3.org/TR/wai-aria-1.2/). This allows us to stay closer to the spec with function names and don't have to add the word "ARIA" to identifiers constantly - the namespace now provides that clarity.
2023-01-28 22:23:16 +00:00
#include <LibWeb/ARIA/ARIAMixin.h>
LibWeb: Implement a simple version of Element.scrollIntoView() We parse the arguments that come in, but since we don't yet track scrollable overflow, we can't do the full "scroll an element into view" algorithm. For now, we just call out to the PageClient and ask it to bring the nearest principal box into the visible viewport.
2022-10-04 19:52:25 +02:00
#include <LibWeb/Bindings/ElementPrototype.h>
LibWeb: Implement Element.attachShadow and Element.shadowRoot :^)
2023-01-28 20:37:46 +01:00
#include <LibWeb/Bindings/ShadowRootPrototype.h>
LibWeb/HTML: Port Window.scroll() to IDL ...with various changes required due to ScrollBehavior / ScrollOptions moving from Element.idl to Window.idl.
2023-03-06 20:53:49 +00:00
#include <LibWeb/Bindings/WindowGlobalMixin.h>
LibWeb: Improve performance of CSS custom property resolution By memoizing already resolved custom properties in the DOM::Element, we achieve a notable speed increase when loading SerenityOS on GitHub.
2021-05-28 21:21:44 +02:00
#include <LibWeb/CSS/CSSStyleDeclaration.h>
LibWeb: Rename Attribute to Attr This name is not very good, but it's what the specification calls it.
2022-09-18 01:03:58 +02:00
#include <LibWeb/DOM/Attr.h>
LibWeb: Implement ChildNode.remove
2021-09-29 16:25:48 +01:00
#include <LibWeb/DOM/ChildNode.h>
LibWeb: Reimplement Element attribute related methods with NamedNodeMap
2021-10-16 16:16:57 -04:00
#include <LibWeb/DOM/NamedNodeMap.h>
LibWeb: Move "element sibling" getters to NonDocumentTypeChildNode Here's another CRTP mixin since that's the best we can do with C++. This prepares exposing these via IDL on Element and CharacterData.
2020-08-03 20:30:02 +02:00
#include <LibWeb/DOM/NonDocumentTypeChildNode.h>
LibWeb: Rename directory LibHTML => LibWeb Let's rename this to LibWeb since it aims to provide more parts of the web platform than just HTML. :^)
2020-03-07 10:32:51 +01:00
#include <LibWeb/DOM/ParentNode.h>
LibWeb: Move QualifiedName.h into LibWeb/DOM/
2022-02-18 20:52:47 +01:00
#include <LibWeb/DOM/QualifiedName.h>
LibWeb: Fix #include <LibWeb/{DOM => HTML}/AttributeNames.h> This file has been moved from DOM/ to HTML/ in a784090b91139776b26fbac2a8426de3abdea308.
2020-08-12 14:46:53 +02:00
#include <LibWeb/HTML/AttributeNames.h>
LibWeb: Add DOM::Element::queue_an_element_task(source, steps) This roughly models the "queue an element task" algorithm from the spec. For safety, this captures a strong reference to the element, and then bundles that with a callback into a HTML::Task (that we then queue up.)
2021-09-09 00:59:09 +02:00
#include <LibWeb/HTML/EventLoop/Task.h>
LibWeb: Update stale #includes for HTML/TagNames.* move
2020-12-13 17:54:40 +01:00
#include <LibWeb/HTML/TagNames.h>
LibWeb/HTML: Port Window.scroll() to IDL ...with various changes required due to ScrollBehavior / ScrollOptions moving from Element.idl to Window.idl.
2023-03-06 20:53:49 +00:00
#include <LibWeb/HTML/Window.h>
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
#include <LibWeb/Layout/Node.h>
LibWeb: Display pseudo-elements in the DOM inspector This patch only makes them appear in the tree - they are not yet inspectable themselves.
2022-03-03 17:50:12 +00:00
#include <LibWeb/Layout/TreeBuilder.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: 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: 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 {
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 Element.attachShadow and Element.shadowRoot :^)
2023-01-28 20:37:46 +01:00
struct ShadowRootInit {
Bindings::ShadowRootMode mode;
bool delegates_focus = false;
};
LibWeb: Implement a simple version of Element.scrollIntoView() We parse the arguments that come in, but since we don't yet track scrollable overflow, we can't do the full "scroll an element into view" algorithm. For now, we just call out to the PageClient and ask it to bring the nearest principal box into the visible viewport.
2022-10-04 19:52:25 +02:00
// https://w3c.github.io/csswg-drafts/cssom-view-1/#dictdef-scrollintoviewoptions
LibWeb/HTML: Port Window.scroll() to IDL ...with various changes required due to ScrollBehavior / ScrollOptions moving from Element.idl to Window.idl.
2023-03-06 20:53:49 +00:00
struct ScrollIntoViewOptions : public HTML::ScrollOptions {
LibWeb: Implement a simple version of Element.scrollIntoView() We parse the arguments that come in, but since we don't yet track scrollable overflow, we can't do the full "scroll an element into view" algorithm. For now, we just call out to the PageClient and ask it to bring the nearest principal box into the visible viewport.
2022-10-04 19:52:25 +02:00
Bindings::ScrollLogicalPosition block { Bindings::ScrollLogicalPosition::Start };
Bindings::ScrollLogicalPosition inline_ { Bindings::ScrollLogicalPosition::Nearest };
};
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://html.spec.whatwg.org/multipage/custom-elements.html#upgrade-reaction
// An upgrade reaction, which will upgrade the custom element and contains a custom element definition; or
struct CustomElementUpgradeReaction {
JS::Handle<HTML::CustomElementDefinition> custom_element_definition;
};
// https://html.spec.whatwg.org/multipage/custom-elements.html#callback-reaction
// A callback reaction, which will call a lifecycle callback, and contains a callback function as well as a list of arguments.
struct CustomElementCallbackReaction {
JS::Handle<WebIDL::CallbackType> callback;
JS::MarkedVector<JS::Value> arguments;
};
// https://dom.spec.whatwg.org/#concept-element-custom-element-state
// An element’s custom element state is one of "undefined", "failed", "uncustomized", "precustomized", or "custom".
enum class CustomElementState {
Undefined,
Failed,
Uncustomized,
Precustomized,
Custom,
};
LibWeb: Move "element sibling" getters to NonDocumentTypeChildNode Here's another CRTP mixin since that's the best we can do with C++. This prepares exposing these via IDL on Element and CharacterData.
2020-08-03 20:30:02 +02:00
class Element
: public ParentNode
LibWeb: Implement ChildNode.remove
2021-09-29 16:25:48 +01:00
, public ChildNode<Element>
LibWeb: Add Support for the ARIA Element Properties Element now supports getting and setting ARIA properties from JS and HTML.
2022-11-28 17:58:13 -06:00
, public NonDocumentTypeChildNode<Element>
LibWeb: Move ARIA-related code into the Web::ARIA namespace ARIA has its own spec and is not part of the DOM spec, which is what the Web::DOM namespace is for (https://www.w3.org/TR/wai-aria-1.2/). This allows us to stay closer to the spec with function names and don't have to add the word "ARIA" to identifiers constantly - the namespace now provides that clarity.
2023-01-28 22:23:16 +00:00
, public ARIA::ARIAMixin {
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
WEB_PLATFORM_OBJECT(Element, ParentNode);
LibWeb: Move "element sibling" getters to NonDocumentTypeChildNode Here's another CRTP mixin since that's the best we can do with C++. This prepares exposing these via IDL on Element and CharacterData.
2020-08-03 20:30:02 +02: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
public:
virtual ~Element() override;
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
DeprecatedString const& qualified_name() const { return m_qualified_name.as_string(); }
DeprecatedString const& html_uppercased_qualified_name() const { return m_html_uppercased_qualified_name; }
AK+Everywhere: Rename FlyString to DeprecatedFlyString DeprecatedFlyString relies heavily on DeprecatedString's StringImpl, so let's rename it to A) match the name of DeprecatedString, B) write a new FlyString class that is tied to String.
2023-01-08 19:23:00 -05:00
virtual DeprecatedFlyString node_name() const final { return html_uppercased_qualified_name(); }
DeprecatedFlyString const& local_name() const { return m_qualified_name.local_name(); }
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
// NOTE: This is for the JS bindings
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
DeprecatedString const& tag_name() const { return html_uppercased_qualified_name(); }
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
AK+Everywhere: Rename FlyString to DeprecatedFlyString DeprecatedFlyString relies heavily on DeprecatedString's StringImpl, so let's rename it to A) match the name of DeprecatedString, B) write a new FlyString class that is tied to String.
2023-01-08 19:23:00 -05:00
DeprecatedFlyString const& prefix() const { return m_qualified_name.prefix(); }
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
void set_prefix(DeprecatedFlyString const& value);
AK+Everywhere: Rename FlyString to DeprecatedFlyString DeprecatedFlyString relies heavily on DeprecatedString's StringImpl, so let's rename it to A) match the name of DeprecatedString, B) write a new FlyString class that is tied to String.
2023-01-08 19:23:00 -05:00
DeprecatedFlyString const& namespace_() const { return m_qualified_name.namespace_(); }
LibWeb: Add namespace to Element
2020-10-10 02:48:05 +01:00
// NOTE: This is for the JS bindings
AK+Everywhere: Rename FlyString to DeprecatedFlyString DeprecatedFlyString relies heavily on DeprecatedString's StringImpl, so let's rename it to A) match the name of DeprecatedString, B) write a new FlyString class that is tied to String.
2023-01-08 19:23:00 -05:00
DeprecatedFlyString const& namespace_uri() const { return namespace_(); }
LibWeb: Add namespace to Element
2020-10-10 02:48:05 +01:00
AK+Everywhere: Rename FlyString to DeprecatedFlyString DeprecatedFlyString relies heavily on DeprecatedString's StringImpl, so let's rename it to A) match the name of DeprecatedString, B) write a new FlyString class that is tied to String.
2023-01-08 19:23:00 -05:00
bool has_attribute(DeprecatedFlyString const& name) const;
LibWeb: Reimplement Element attribute related methods with NamedNodeMap
2021-10-16 16:16:57 -04:00
bool has_attributes() const { return !m_attributes->is_empty(); }
AK+Everywhere: Rename FlyString to DeprecatedFlyString DeprecatedFlyString relies heavily on DeprecatedString's StringImpl, so let's rename it to A) match the name of DeprecatedString, B) write a new FlyString class that is tied to String.
2023-01-08 19:23:00 -05:00
DeprecatedString attribute(DeprecatedFlyString const& name) const { return get_attribute(name); }
DeprecatedString get_attribute(DeprecatedFlyString const& name) const;
WebIDL::ExceptionOr<void> set_attribute(DeprecatedFlyString const& name, DeprecatedString const& value);
WebIDL::ExceptionOr<void> set_attribute_ns(DeprecatedFlyString const& namespace_, DeprecatedFlyString const& qualified_name, DeprecatedString const& value);
LibWeb: Implement Element.setAttributeNode{,NS}()
2023-03-10 14:56:29 +01:00
WebIDL::ExceptionOr<JS::GCPtr<Attr>> set_attribute_node(Attr&);
WebIDL::ExceptionOr<JS::GCPtr<Attr>> set_attribute_node_ns(Attr&);
AK+Everywhere: Rename FlyString to DeprecatedFlyString DeprecatedFlyString relies heavily on DeprecatedString's StringImpl, so let's rename it to A) match the name of DeprecatedString, B) write a new FlyString class that is tied to String.
2023-01-08 19:23:00 -05:00
void remove_attribute(DeprecatedFlyString const& name);
WebIDL::ExceptionOr<bool> toggle_attribute(DeprecatedFlyString const& name, Optional<bool> force);
LibWeb: Reimplement Element attribute related methods with NamedNodeMap
2021-10-16 16:16:57 -04:00
size_t attribute_list_size() const { return m_attributes->length(); }
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
NamedNodeMap const* attributes() const { return m_attributes.ptr(); }
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
Vector<DeprecatedString> get_attribute_names() const;
LibHTML: Basic element attribute parsing.
2019-06-15 21:08:36 +02:00
AK+Everywhere: Rename FlyString to DeprecatedFlyString DeprecatedFlyString relies heavily on DeprecatedString's StringImpl, so let's rename it to A) match the name of DeprecatedString, B) write a new FlyString class that is tied to String.
2023-01-08 19:23:00 -05:00
JS::GCPtr<Attr> get_attribute_node(DeprecatedFlyString const& name) const;
LibWeb: Implement Element.getAttributeNode
2022-11-05 04:37:40 +00:00
LibWeb: Make DOMTokenList GC-allocated
2022-08-08 15:19:46 +02:00
DOMTokenList* class_list();
LibWeb: Implement the Element classList attribute And ensure it is updated (if it exists) when the 'class' attribute is changed.
2021-10-18 13:21:23 -04:00
LibWeb: Implement Element.attachShadow and Element.shadowRoot :^)
2023-01-28 20:37:46 +01:00
WebIDL::ExceptionOr<JS::NonnullGCPtr<ShadowRoot>> attach_shadow(ShadowRootInit init);
JS::GCPtr<ShadowRoot> shadow_root() const;
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
WebIDL::ExceptionOr<bool> matches(StringView selectors) const;
WebIDL::ExceptionOr<DOM::Element const*> closest(StringView selectors) const;
LibWeb: Support Element.matches(selectors) This returns whether an element matches any of a set of selectors.
2021-09-30 02:16:36 +02:00
LibWeb: Support Element.client{Top,Left,Width,Height}
2021-09-30 02:17:23 +02:00
int client_top() const;
int client_left() const;
int client_width() const;
int client_height() const;
LibHTML: Basic element attribute parsing.
2019-06-15 21:08:36 +02:00
template<typename Callback>
LibHTML: Start fleshing out a basic layout tree.
2019-06-15 22:49:44 +02:00
void for_each_attribute(Callback callback) const
LibHTML: Basic element attribute parsing.
2019-06-15 21:08:36 +02:00
{
LibWeb: Reimplement Element attribute related methods with NamedNodeMap
2021-10-16 16:16:57 -04:00
for (size_t i = 0; i < m_attributes->length(); ++i) {
auto const* attribute = m_attributes->item(i);
LibWeb: Implement Attribute closer to the spec and with an IDL file Note our Attribute class is what the spec refers to as just "Attr". The main differences between the existing implementation and the spec are just that the spec defines more fields. Attributes can contain namespace URIs and prefixes. However, note that these are not parsed in HTML documents unless the document content-type is XML. So for now, these are initialized to null. Web pages are able to set the namespace via JavaScript (setAttributeNS), so these fields may be filled in when the corresponding APIs are implemented. The main change to be aware of is that an attribute is a node. This has implications on how attributes are stored in the Element class. Nodes are non-copyable and non-movable because these constructors are deleted by the EventTarget base class. This means attributes cannot be stored in a Vector or HashMap as these containers assume copyability / movability. So for now, the Vector holding attributes is changed to hold RefPtrs to attributes instead. This might change when attribute storage is implemented according to the spec (by way of NamedNodeMap).
2021-10-15 09:57:07 -04:00
callback(attribute->name(), attribute->value());
LibWeb: Reimplement Element attribute related methods with NamedNodeMap
2021-10-16 16:16:57 -04:00
}
LibHTML: Basic element attribute parsing.
2019-06-15 21:08:36 +02:00
}
LibWeb: Convert DOM::Element::m_classes to the new AK::FlyString This makes selector matching significantly faster by not forcing us to convert from FlyString to DeprecatedFlyString when matching class selectors. :^)
2023-03-07 19:54:01 +01:00
bool has_class(FlyString const&, CaseSensitivity = CaseSensitivity::CaseSensitive) const;
Vector<FlyString> const& class_names() const { return m_classes; }
LibHTML: Implement some very simple selector matching. We walk the entire DOM and check all selectors against all elements. Only id, class and tag name are checked right now. There's no ancestor stack or compound selectors. All in good time :^)
2019-06-27 20:40:21 +02:00
LibWeb: Move CSS classes into the Web::CSS namespace
2020-07-26 20:01:35 +02:00
virtual void apply_presentational_hints(CSS::StyleProperties&) const { }
AK+Everywhere: Rename FlyString to DeprecatedFlyString DeprecatedFlyString relies heavily on DeprecatedString's StringImpl, so let's rename it to A) match the name of DeprecatedString, B) write a new FlyString class that is tied to String.
2023-01-08 19:23:00 -05:00
virtual void parse_attribute(DeprecatedFlyString const& name, DeprecatedString const& value);
virtual void did_remove_attribute(DeprecatedFlyString const&);
LibHTML: Add support for <body bgcolor="#rrggbb" text="#rrggbb"> This patch implements basic support for presentational hints, which are old-school HTML attributes that affect style. You add support for a presentational hint attribute by overriding Element::apply_presentational_hints(StyleProperties&) and setting all of the corresponding CSS properties as appropriate. To make the background color fill the entire document, not just the bounds of the <body> element's LayoutNode, we special-case it in the HtmlView::paint_event() code for now. I'm not entirely sure what the nicest solution would be, but I'm sure we'll discover it eventually.
2019-10-04 21:05:52 +02:00
LibWeb: Avoid layout invalidation for some CSS property changes Use the new CSS::property_affects_layout() helper to figure out if we actually need to perform a full relayout after recomputing style. There are three tiers of required invalidation after an element receives new style: none, repaint only, or full relayout. This avoids the need to rebuild the layout tree (and perform layout on it) when trivial properties like "color" etc are changed.
2022-03-16 17:48:50 +01:00
enum class NeedsRelayout {
No = 0,
Yes = 1,
};
NeedsRelayout recompute_style();
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: 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::NodeWithStyle* layout_node() { return static_cast<Layout::NodeWithStyle*>(Node::layout_node()); }
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
Layout::NodeWithStyle const* layout_node() const { return static_cast<Layout::NodeWithStyle const*>(Node::layout_node()); }
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
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
DeprecatedString name() const { return attribute(HTML::AttributeNames::name); }
LibHTML: Add Element::name() convenience attribute getter
2019-10-20 09:09:15 +02:00
LibWeb+LibIDL: Fix (or paper over) various const-correctness issues There's definitely stuff to iterate on here, but this takes care of making the libraries compile with stricter RP and NNRP.
2023-02-20 18:56:08 +01:00
CSS::StyleProperties* computed_css_values() { return m_computed_css_values.ptr(); }
LibWeb: Rename Element::specified_css_values() => computed_css_values() Let's make it very clear that these are *computed* values, and not at all the specified values. The specified values are currently discarded by the CSS cascade algorithm.
2022-03-15 19:41:35 +01:00
CSS::StyleProperties const* computed_css_values() const { return m_computed_css_values.ptr(); }
void set_computed_css_values(RefPtr<CSS::StyleProperties> style) { m_computed_css_values = move(style); }
LibWeb: Rename Element::computed_style() to resolved_css_values() This more accurately reflects what's actually being returned.
2022-03-15 19:32:17 +01:00
NonnullRefPtr<CSS::StyleProperties> resolved_css_values();
LibHTML: Have element keep a pointer to their resolved style This will make it easy to implement a simple element style inspector.
2020-01-02 14:52:34 +01:00
LibWeb: Implement CSS declaration block's "updating flag" This flag is used to prevent reparsing the style attribute after it is automatically updated after using the CSSOM API to mutate style.
2022-04-11 16:56:52 +02:00
CSS::CSSStyleDeclaration const* inline_style() const;
LibWeb: Cache parsed inline style of DOM elements Instead of invoking the CSS parser every time we compute the style for an element that has a "style" attribute, we now cache the result of parsing the inline style whenever the "style" attribute is set. This is a nice boost to relayout performance since we no longer hit the CSS parser at all.
2020-12-07 19:56:53 +01:00
LibWeb: Make CSSStyleDeclaration GC-allocated
2022-08-07 16:21:26 +02:00
CSS::CSSStyleDeclaration* style_for_bindings();
LibWeb: Expose barebones CSSStyleDeclaration to JavaScript You can now access an element's inline style via Element.style. The interface is not very capable yet though. :^)
2021-03-13 22:39:55 +01:00
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
WebIDL::ExceptionOr<DeprecatedString> inner_html() const;
WebIDL::ExceptionOr<void> set_inner_html(DeprecatedString const&);
LibWeb: Implement getting and setting element.innerHTML Getting the innerHTML property will recurse through the subtree inside the element and serialize it into a string as it goes. Setting it will parse the set value as an HTML fragment. It will then remove all current children of the element and replace them with all the children inside the parsed fragment. Setting element.innerHTML will currently force a complete rebuild of the document's layout tree. This is pretty neat! :^)
2020-03-25 18:53:20 +01:00
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
WebIDL::ExceptionOr<void> insert_adjacent_html(DeprecatedString position, DeprecatedString text);
LibWeb: Implement Element.insertAdjacentHTML() from DOM Parsing One edge case is left as a TODO() for now, since I'm not entirely sure how to construct an element to those specifications. With this patch, we can now run the Speedometer benchmark! :^)
2022-09-20 18:28:41 +02:00
LibWeb: Allow focusing individual (focusable) elements with Tab key You can now cycle through focusable elements (currently only hyperlinks are focusable) with the Tab key. The focus outline is rendered in a new FocusOutline paint phase.
2020-08-14 19:40:37 +02:00
bool is_focused() const;
LibWeb: Support :active pseudo-class for hyperlinks, :focus possibly Adds support for the :active pseudo-class for hyperlinks (<a> tags only). Also, since it was very similar to :focus and an element having a focused state was already implemented, I went ahead and implemented that pseudo-class too, although I cannot come up with a working example to validate it.
2021-06-18 16:42:34 -06:00
bool is_active() const;
AK+Everywhere: Rename FlyString to DeprecatedFlyString DeprecatedFlyString relies heavily on DeprecatedString's StringImpl, so let's rename it to A) match the name of DeprecatedString, B) write a new FlyString class that is tied to String.
2023-01-08 19:23:00 -05:00
JS::NonnullGCPtr<HTMLCollection> get_elements_by_class_name(DeprecatedFlyString const&);
LibWeb: Implement Element.getElementsBy{Tag,Class}Name() Just like the Document variants, but using the given Element as for_each_in_subtree_of_type() root.
2021-02-07 23:44:01 +01:00
LibWeb: Add a helper function for checking if element is a shadow host
2023-01-28 20:33:36 +01:00
bool is_shadow_host() const;
LibWeb: Rename DOM::shadow_root() to shadow_root_internal() The shadowRoot property getter that will be added in subsequent commits has an additional check that checks whether the shadow root is opened. I didn't update the function logic to match with the IDL interface, because it's very likely we don't want that check in the existing code, so that for example closed shadow root elements can still be updated.
2023-01-28 20:22:52 +01:00
ShadowRoot* shadow_root_internal() { return m_shadow_root.ptr(); }
ShadowRoot const* shadow_root_internal() const { return m_shadow_root.ptr(); }
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
void set_shadow_root(JS::GCPtr<ShadowRoot>);
LibWeb: Add a way to give DOM::Element a ShadowRoot You can now attach a shadow root to your favorite Element. It doesn't do anything yet, but you can.
2021-02-10 18:21:35 +01:00
AK+Everywhere: Rename FlyString to DeprecatedFlyString DeprecatedFlyString relies heavily on DeprecatedString's StringImpl, so let's rename it to A) match the name of DeprecatedString, B) write a new FlyString class that is tied to String.
2023-01-08 19:23:00 -05:00
void set_custom_properties(HashMap<DeprecatedFlyString, CSS::StyleProperty> custom_properties) { m_custom_properties = move(custom_properties); }
HashMap<DeprecatedFlyString, CSS::StyleProperty> const& custom_properties() const { return m_custom_properties; }
LibWeb: Improve performance of CSS custom property resolution By memoizing already resolved custom properties in the DOM::Element, we achieve a notable speed increase when loading SerenityOS on GitHub.
2021-05-28 21:21:44 +02:00
LibWeb: Make queue_an_element_task() use JS::SafeFunction
2022-09-24 12:14:53 +02:00
void queue_an_element_task(HTML::Task::Source, JS::SafeFunction<void()>);
LibWeb: Add DOM::Element::queue_an_element_task(source, steps) This roughly models the "queue an element task" algorithm from the spec. For safety, this captures a strong reference to the element, and then bundles that with a callback into a HTML::Task (that we then queue up.)
2021-09-09 00:59:09 +02:00
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
bool is_void_element() const;
bool serializes_as_void() const;
LibWeb: Make DOMRect, DOMRectReadOnly and DOMRectList GC-allocated
2022-09-04 01:59:58 +02:00
JS::NonnullGCPtr<Geometry::DOMRect> get_bounding_client_rect() const;
JS::NonnullGCPtr<Geometry::DOMRectList> get_client_rects() const;
LibWeb: Add DOMRect and Element.getBoundingClientRect() This marks our entry into the Web::Geometry namespace, based on the "Geometry" spec at https://drafts.fxtf.org/geometry/
2021-09-27 00:55:13 +02:00
LibWeb: Make the layout tree GC-allocated This removes a set of complex reference cycles between DOM, layout tree and browsing context. It also makes lifetimes much easier to reason about, as the DOM and layout trees are now free to keep each other alive.
2022-10-17 14:41:50 +02:00
virtual JS::GCPtr<Layout::Node> create_layout_node(NonnullRefPtr<CSS::StyleProperties>);
LibWeb: Compute element style in Layout::TreeBuilder Instead of making each Layout::Node compute style for itself, we now compute it in TreeBuilder before even calling create_layout_node(). For non-element DOM nodes, we create the style and layout tree node in TreeBuilder. This allows us to move create_layout_node() from DOM::Node to DOM::Element.
2022-02-05 13:17:01 +01:00
LibWeb: Make HTMLInputElement move cursor into text node when focused This mechanism feels rather awkward, but it's better than nothing.
2022-02-06 19:27:10 +01:00
virtual void did_receive_focus() { }
virtual void did_lose_focus() { }
LibWeb: Make the layout tree GC-allocated This removes a set of complex reference cycles between DOM, layout tree and browsing context. It also makes lifetimes much easier to reason about, as the DOM and layout trees are now free to keep each other alive.
2022-10-17 14:41:50 +02:00
static JS::GCPtr<Layout::Node> create_layout_node_for_display_type(DOM::Document&, CSS::Display const&, NonnullRefPtr<CSS::StyleProperties>, Element*);
LibWeb: Extract code for creating a Layout::Node based on display type We need to run the same logic for creating the ::before and ::after pseudo-elements, so this saves us from duplicating the code.
2022-02-24 11:56:03 +00:00
LibWeb: Make the layout tree GC-allocated This removes a set of complex reference cycles between DOM, layout tree and browsing context. It also makes lifetimes much easier to reason about, as the DOM and layout trees are now free to keep each other alive.
2022-10-17 14:41:50 +02:00
void set_pseudo_element_node(Badge<Layout::TreeBuilder>, CSS::Selector::PseudoElement, JS::GCPtr<Layout::Node>);
JS::GCPtr<Layout::Node> get_pseudo_element_node(CSS::Selector::PseudoElement) const;
LibWeb: Display pseudo-elements in the DOM inspector This patch only makes them appear in the tree - they are not yet inspectable themselves.
2022-03-03 17:50:12 +00:00
void clear_pseudo_element_nodes(Badge<Layout::TreeBuilder>);
void serialize_pseudo_elements_as_json(JsonArraySerializer<StringBuilder>& children_array) const;
LibWeb: Implement HTMLOrSVGElement.tabIndex
2022-11-05 03:58:14 +00:00
i32 tab_index() const;
void set_tab_index(i32 tab_index);
LibWeb: Start implementing the Element scroll attributes These are required for hit testing the document in Google Docs. If they aren't defined, the Google Docs hit test code will add undefined to certain values, causing them to turn into NaN. This causes NaNs to propagate through their hit test code, which eventually makes it infinitely loop.
2022-11-05 15:10:13 +00:00
bool is_potentially_scrollable() const;
double scroll_top() const;
double scroll_left() const;
void set_scroll_top(double y);
void set_scroll_left(double x);
int scroll_width() const;
int scroll_height() const;
LibWeb: Implement :enabled and :disabled pseudo classes to spec Previously we only considered an element disabled if it was an <input> element with the disabled attribute, but there's way more elements that apply with more nuanced disabled/enabled rules.
2022-09-30 16:21:34 +01:00
bool is_actually_disabled() const;
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
WebIDL::ExceptionOr<JS::GCPtr<Element>> insert_adjacent_element(DeprecatedString const& where, JS::NonnullGCPtr<Element> element);
WebIDL::ExceptionOr<void> insert_adjacent_text(DeprecatedString const& where, DeprecatedString const& data);
LibWeb: Implement Element.insertAdjacentElement
2022-10-01 00:30:15 +01:00
LibWeb: Implement a simple version of Element.scrollIntoView() We parse the arguments that come in, but since we don't yet track scrollable overflow, we can't do the full "scroll an element into view" algorithm. For now, we just call out to the PageClient and ask it to bring the nearest principal box into the visible viewport.
2022-10-04 19:52:25 +02:00
// https://w3c.github.io/csswg-drafts/cssom-view-1/#dom-element-scrollintoview
LibWeb: Propagate errors in Element::scroll_into_view() This patch will allow us to handle scrolling errors in the WebDriver implementation :)
2022-12-24 13:15:12 +01:00
ErrorOr<void> scroll_into_view(Optional<Variant<bool, ScrollIntoViewOptions>> = {});
LibWeb: Implement a simple version of Element.scrollIntoView() We parse the arguments that come in, but since we don't yet track scrollable overflow, we can't do the full "scroll an element into view" algorithm. For now, we just call out to the PageClient and ask it to bring the nearest principal box into the visible viewport.
2022-10-04 19:52:25 +02:00
LibWeb: Add Support for the ARIA Element Properties Element now supports getting and setting ARIA properties from JS and HTML.
2022-11-28 17:58:13 -06:00
// https://www.w3.org/TR/wai-aria-1.2/#ARIAMixin
#define ARIA_IMPL(name, attribute) \
DeprecatedString name() const override \
{ \
return get_attribute(attribute); \
} \
\
WebIDL::ExceptionOr<void> set_##name(DeprecatedString const& value) override \
{ \
TRY(set_attribute(attribute, value)); \
return {}; \
}
// https://www.w3.org/TR/wai-aria-1.2/#accessibilityroleandproperties-correspondence
ARIA_IMPL(role, "role");
ARIA_IMPL(aria_active_descendant, "aria-activedescendant");
ARIA_IMPL(aria_atomic, "aria-atomic");
ARIA_IMPL(aria_auto_complete, "aria-autocomplete");
ARIA_IMPL(aria_busy, "aria-busy");
ARIA_IMPL(aria_checked, "aria-checked");
ARIA_IMPL(aria_col_count, "aria-colcount");
ARIA_IMPL(aria_col_index, "aria-colindex");
ARIA_IMPL(aria_col_span, "aria-colspan");
ARIA_IMPL(aria_controls, "aria-controls");
ARIA_IMPL(aria_current, "aria-current");
ARIA_IMPL(aria_described_by, "aria-describedby");
ARIA_IMPL(aria_details, "aria-details");
ARIA_IMPL(aria_drop_effect, "aria-dropeffect");
ARIA_IMPL(aria_error_message, "aria-errormessage");
ARIA_IMPL(aria_disabled, "aria-disabled");
ARIA_IMPL(aria_expanded, "aria-expanded");
ARIA_IMPL(aria_flow_to, "aria-flowto");
ARIA_IMPL(aria_grabbed, "aria-grabbed");
ARIA_IMPL(aria_has_popup, "aria-haspopup");
ARIA_IMPL(aria_hidden, "aria-hidden");
ARIA_IMPL(aria_invalid, "aria-invalid");
ARIA_IMPL(aria_key_shortcuts, "aria-keyshortcuts");
ARIA_IMPL(aria_label, "aria-label");
ARIA_IMPL(aria_labelled_by, "aria-labelledby");
ARIA_IMPL(aria_level, "aria-level");
ARIA_IMPL(aria_live, "aria-live");
ARIA_IMPL(aria_modal, "aria-modal");
ARIA_IMPL(aria_multi_line, "aria-multiline");
ARIA_IMPL(aria_multi_selectable, "aria-multiselectable");
ARIA_IMPL(aria_orientation, "aria-orientation");
ARIA_IMPL(aria_owns, "aria-owns");
ARIA_IMPL(aria_placeholder, "aria-placeholder");
ARIA_IMPL(aria_pos_in_set, "aria-posinset");
ARIA_IMPL(aria_pressed, "aria-pressed");
ARIA_IMPL(aria_read_only, "aria-readonly");
ARIA_IMPL(aria_relevant, "aria-relevant");
ARIA_IMPL(aria_required, "aria-required");
ARIA_IMPL(aria_role_description, "aria-roledescription");
ARIA_IMPL(aria_row_count, "aria-rowcount");
ARIA_IMPL(aria_row_index, "aria-rowindex");
ARIA_IMPL(aria_row_span, "aria-rowspan");
ARIA_IMPL(aria_selected, "aria-selected");
ARIA_IMPL(aria_set_size, "aria-setsize");
ARIA_IMPL(aria_sort, "aria-sort");
ARIA_IMPL(aria_value_max, "aria-valuemax");
ARIA_IMPL(aria_value_min, "aria-valuemin");
ARIA_IMPL(aria_value_now, "aria-valuenow");
ARIA_IMPL(aria_value_text, "aria-valuetext");
#undef ARIA_IMPL
LibWeb: Add (exclude/include)_from_accessibility_tree These functions will be used in building the accessibility tree.
2022-12-11 10:53:37 -06:00
virtual bool exclude_from_accessibility_tree() const override;
virtual bool include_in_accessibility_tree() const override;
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
void enqueue_a_custom_element_upgrade_reaction(HTML::CustomElementDefinition& custom_element_definition);
void enqueue_a_custom_element_callback_reaction(FlyString const& callback_name, JS::MarkedVector<JS::Value> arguments);
Vector<Variant<CustomElementUpgradeReaction, CustomElementCallbackReaction>>& custom_element_reaction_queue() { return m_custom_element_reaction_queue; }
Vector<Variant<CustomElementUpgradeReaction, CustomElementCallbackReaction>> const& custom_element_reaction_queue() const { return m_custom_element_reaction_queue; }
JS::ThrowCompletionOr<void> upgrade_element(JS::NonnullGCPtr<HTML::CustomElementDefinition> custom_element_definition);
void try_to_upgrade();
bool is_defined() const;
bool is_custom() const;
Optional<String> const& is_value() const { return m_is_value; }
void set_is_value(Optional<String> const& is) { m_is_value = is; }
void set_custom_element_state(CustomElementState value) { m_custom_element_state = value; }
void setup_custom_element_from_constructor(HTML::CustomElementDefinition& custom_element_definition, Optional<String> const& is_value);
LibWeb: Add basic <object> element support This patch implements a simple <object> element with fallback content. If the URL from the data attribute fails to load (including 404), we render the DOM tree inside the <object> as fallback content. This works by generating a different layout tree for the <object> depending on the state and success of the data load. Since we cannot currently do incremental layout tree updates, we have to force a complete layout tree rebuild when the resource load finishes/fails.
2020-06-13 22:24:49 +02:00
protected:
LibWeb: Don't allocate NamedNodeMap in Element constructor Allocations should happen in the initialize() virtual, so move it there.
2022-09-03 18:47:33 +02:00
Element(Document&, DOM::QualifiedName);
LibJS+Everywhere: Allow Cell::initialize overrides to throw OOM errors Note that as of this commit, there aren't any such throwers, and the call site in Heap::allocate will drop exceptions on the floor. This commit only serves to change the declaration of the overrides, make sure they return an empty value, and to propagate OOM errors frm their base initialize invocations.
2023-01-28 12:33:35 -05:00
virtual JS::ThrowCompletionOr<void> initialize(JS::Realm&) override;
LibWeb: Don't allocate NamedNodeMap in Element constructor Allocations should happen in the initialize() virtual, so move it there.
2022-09-03 18:47:33 +02:00
LibWeb: Mark elements for style update after their children change
2021-10-12 17:53:52 +02:00
virtual void children_changed() override;
LibWeb: Implement HTMLOrSVGElement.tabIndex
2022-11-05 03:58:14 +00:00
virtual i32 default_tab_index_value() const;
LibHTML: Make Node::create_layout_node() virtual Instead of branching on the Node type, let subclasses decide how their layout nodes get constructed. This will allow elements to create custom layout nodes if they want.
2019-10-05 22:27:52 +02: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
virtual void visit_edges(Cell::Visitor&) override;
LibWeb: Add basic <object> element support This patch implements a simple <object> element with fallback content. If the URL from the data attribute fails to load (including 404), we render the DOM tree inside the <object> as fallback content. This works by generating a different layout tree for the <object> depending on the state and success of the data load. Since we cannot currently do incremental layout tree updates, we have to force a complete layout tree rebuild when the resource load finishes/fails.
2020-06-13 22:24:49 +02:00
private:
LibWeb: Use HTML-uppercased qualified name for the Element node name For regular elements, this is just the qualified name. However, for HTML elements in HTML documents, it is the qualified name uppercased. This is used by jQuery to determine the document is an HTML document. Not having this made jQuery assume the document was XML, causing weird behaviour. To do this, an internal string of qualified name is created. This is to prevent constantly regenerating it. This is allowed by the spec. This is the same for the HTML-uppercased qualified name.
2021-05-04 22:25:43 +01:00
void make_html_uppercased_qualified_name();
AK+Everywhere: Rename FlyString to DeprecatedFlyString DeprecatedFlyString relies heavily on DeprecatedString's StringImpl, so let's rename it to A) match the name of DeprecatedString, B) write a new FlyString class that is tied to String.
2023-01-08 19:23:00 -05:00
void invalidate_style_after_attribute_change(DeprecatedFlyString const& attribute_name);
LibWeb: Don't invalidate style for entire document on attribute change We now only invalidate the style of the context element and all of its descendants. It's still very aggressive, but much less than before. Note that this will need to become a lot smarter once we implement the CSS :has() selector.
2022-10-29 13:04:18 +02:00
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
WebIDL::ExceptionOr<JS::GCPtr<Node>> insert_adjacent(DeprecatedString const& where, JS::NonnullGCPtr<Node> node);
LibWeb: Implement Element.insertAdjacentElement
2022-10-01 00:30:15 +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
void enqueue_an_element_on_the_appropriate_element_queue();
LibWeb: Add namespace to Element
2020-10-10 02:48:05 +01:00
QualifiedName m_qualified_name;
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
DeprecatedString m_html_uppercased_qualified_name;
LibHTML: Have element keep a pointer to their resolved style This will make it easy to implement a simple element style inspector.
2020-01-02 14:52:34 +01:00
LibWeb: Don't allocate NamedNodeMap in Element constructor Allocations should happen in the initialize() virtual, so move it there.
2022-09-03 18:47:33 +02:00
JS::GCPtr<NamedNodeMap> m_attributes;
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
JS::GCPtr<CSS::ElementInlineCSSStyleDeclaration> m_inline_style;
JS::GCPtr<DOMTokenList> m_class_list;
JS::GCPtr<ShadowRoot> m_shadow_root;
LibWeb: Cache parsed inline style of DOM elements Instead of invoking the CSS parser every time we compute the style for an element that has a "style" attribute, we now cache the result of parsing the inline style whenever the "style" attribute is set. This is a nice boost to relayout performance since we no longer hit the CSS parser at all.
2020-12-07 19:56:53 +01:00
LibWeb: Rename Element::specified_css_values() => computed_css_values() Let's make it very clear that these are *computed* values, and not at all the specified values. The specified values are currently discarded by the CSS cascade algorithm.
2022-03-15 19:41:35 +01:00
RefPtr<CSS::StyleProperties> m_computed_css_values;
AK+Everywhere: Rename FlyString to DeprecatedFlyString DeprecatedFlyString relies heavily on DeprecatedString's StringImpl, so let's rename it to A) match the name of DeprecatedString, B) write a new FlyString class that is tied to String.
2023-01-08 19:23:00 -05:00
HashMap<DeprecatedFlyString, CSS::StyleProperty> m_custom_properties;
LibWeb: Let Element cache its list of classes Instead of string splitting every time you call Element::has_class(), we now split the "class" attribute value when it changes, and cache the individual classes as FlyStrings in Element::m_classes. This makes has_class() significantly faster and moves the pain point of selector matching somewhere else.
2020-05-26 23:07:19 +02:00
LibWeb: Convert DOM::Element::m_classes to the new AK::FlyString This makes selector matching significantly faster by not forcing us to convert from FlyString to DeprecatedFlyString when matching class selectors. :^)
2023-03-07 19:54:01 +01:00
Vector<FlyString> m_classes;
LibWeb: Add a way to give DOM::Element a ShadowRoot You can now attach a shadow root to your favorite Element. It doesn't do anything yet, but you can.
2021-02-10 18:21:35 +01:00
LibWeb: Ensure the number of pseudo elements stays up-to-date The ::placeholder pseudo element was added in commit 1fbad9c, but the total number of pseudo elements was not updated. Instead of this manual bookkeeping, add a dummy value at the end of the enumeration for the count.
2022-11-30 18:27:26 -05:00
Array<JS::GCPtr<Layout::Node>, to_underlying(CSS::Selector::PseudoElement::PseudoElementCount)> m_pseudo_element_nodes;
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://html.spec.whatwg.org/multipage/custom-elements.html#custom-element-reaction-queue
// All elements have an associated custom element reaction queue, initially empty. Each item in the custom element reaction queue is of one of two types:
// NOTE: See the structs at the top of this header.
Vector<Variant<CustomElementUpgradeReaction, CustomElementCallbackReaction>> m_custom_element_reaction_queue;
// https://dom.spec.whatwg.org/#concept-element-custom-element-state
CustomElementState m_custom_element_state { CustomElementState::Undefined };
// https://dom.spec.whatwg.org/#concept-element-custom-element-definition
JS::GCPtr<HTML::CustomElementDefinition> m_custom_element_definition;
// https://dom.spec.whatwg.org/#concept-element-is-value
Optional<String> m_is_value;
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: Specialize is<DOM::Element>() and is<Layout::Box>() These two show up in profiles, so let's add specializations for them.
2021-01-07 17:31:26 +01:00
template<>
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
inline bool Node::fast_is<Element>() const { return is_element(); }
LibWeb: Specialize is<DOM::Element>() and is<Layout::Box>() These two show up in profiles, so let's add specializations for them.
2021-01-07 17:31:26 +01:00
AK+Everywhere: Rename FlyString to DeprecatedFlyString DeprecatedFlyString relies heavily on DeprecatedString's StringImpl, so let's rename it to A) match the name of DeprecatedString, B) write a new FlyString class that is tied to String.
2023-01-08 19:23:00 -05:00
WebIDL::ExceptionOr<QualifiedName> validate_and_extract(JS::Realm&, DeprecatedFlyString namespace_, DeprecatedFlyString qualified_name);
LibWeb: Support (and validate) prefixes in Document.createElementNS() 1% progression on ACID3. :^)
2022-03-02 10:55:16 +01:00
LibWeb: Specialize is<DOM::Element>() and is<Layout::Box>() These two show up in profiles, so let's add specializations for them.
2021-01-07 17:31:26 +01:00
}
Reference in a new issue Copy permalink