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

475 lines
21 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
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: Add Animatable interface to Element
2024-02-03 12:10:21 -07:00
#include <LibWeb/Animations/Animatable.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: Don't include Window.h in Element.h and Document.h Window.h is a rather heavy file, so let's try not to include it in header files when we can! Element.h now also includes LibWeb/Bindings/Intrinsics.h, but that's just out of my laziness. Most if not all objects call `Bindings::ensure_web_prototype<>()` anyway, so I don't think we would gain much by sticking the header to source files instead.
2023-10-08 11:59:40 +02:00
#include <LibWeb/Bindings/Intrinsics.h>
LibWeb: Implement Element.attachShadow and Element.shadowRoot :^)
2023-01-28 20:37:46 +01:00
#include <LibWeb/Bindings/ShadowRootPrototype.h>
LibWeb: Don't include Layout/TreeBuilder.h from DOM/Element.h
2023-05-08 07:02:43 +02:00
#include <LibWeb/CSS/Selector.h>
LibWeb: Add fast path to calculate invalidations for animated css props - Compare only the animated properties - Clone only the hash map containing animated properties, instead of the entire StyleProperties. Reduces `KeyframeEffect::update_style_properties()` from 10% to 3% in GitHub profiles.
2024-03-19 12:02:06 +01:00
#include <LibWeb/CSS/StyleInvalidation.h>
LibWeb: Don't include CSS/CSSStyleDeclaration.h from DOM/Element.h This required splitting out CSS::StyleProperty into its own file and out-of-lining Element::layout_node().
2023-05-08 06:57:55 +02:00
#include <LibWeb/CSS/StyleProperty.h>
LibWeb: Implement ChildNode.remove
2021-09-29 16:25:48 +01:00
#include <LibWeb/DOM/ChildNode.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: Introduce the slottable concept for DOM elements and text nodes A slottable is either a DOM element or a DOM text node. They may be assigned to slots (HTMLSlotElement) either automatically or manually. Automatic assignment occurs by matching a slot's `name` attribute to a slottable's `slot` attribute. Manual assignment occurs by using the slot's (not yet implemented) `assign` API. This commit does not perform the above assignments. It just sets up the slottable concept via IDL and hooks the slottable mixin into the element and text nodes.
2023-09-05 13:07:35 -04:00
#include <LibWeb/DOM/Slottable.h>
LibWeb: 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: Extract shared lazy-loading behavior into a base class `<iframe>` and `<img>` tags share the same spec for several aspects of lazy-loading: how the `loading` attribute works, the "will lazy load element" steps, and a member for storing the lazy-load resumption steps. So let's share the implementation by using a base class. This mostly involves moving things around. However, we also change the `start_intersection_observing_a_lazy_loading_element()` method to take a LazyLoadingElement, and operate on one, instead of always casting to HTMLImageElement. We do unfortunately have to do some shenanigans to make the cast work, by adding a virtual function stub in DOM::Element.
2023-11-21 18:50:09 +00:00
#include <LibWeb/HTML/LazyLoadingElement.h>
LibWeb: Don't include HTML/Window.h from DOM/Element.h This required moving HTML::ScrollOptions to its own header file.
2023-05-08 07:39:05 +02:00
#include <LibWeb/HTML/ScrollOptions.h>
LibWeb: Update stale #includes for HTML/TagNames.* move
2020-12-13 17:54:40 +01:00
#include <LibWeb/HTML/TagNames.h>
LibWeb: Add initial implementation of IntersectionObserver The main missing features are rootMargin, proper nested browsing context support and content clip/clip-path support. This makes images appear on some sites, such as YouTube and howstuffworks.com.
2023-07-06 23:44:07 +01:00
#include <LibWeb/IntersectionObserver/IntersectionObserver.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 element slot-related attributes and settings This implements the element's slot attribute itself, and setting the slot assignment on the element's shadow root.
2023-09-01 07:25:40 -04:00
Bindings::SlotAssignmentMode slot_assignment { Bindings::SlotAssignmentMode::Named };
LibWeb: Implement Element.attachShadow and Element.shadowRoot :^)
2023-01-28 20:37:46 +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/#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: Introduce the slottable concept for DOM elements and text nodes A slottable is either a DOM element or a DOM text node. They may be assigned to slots (HTMLSlotElement) either automatically or manually. Automatic assignment occurs by matching a slot's `name` attribute to a slottable's `slot` attribute. Manual assignment occurs by using the slot's (not yet implemented) `assign` API. This commit does not perform the above assignments. It just sets up the slottable concept via IDL and hooks the slottable mixin into the element and text nodes.
2023-09-05 13:07:35 -04:00
, public SlottableMixin
LibWeb: Add Animatable interface to Element
2024-02-03 12:10:21 -07:00
, public ARIA::ARIAMixin
, public Animations::Animatable {
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;
LibWeb: Port Element interface from DeprecatedString This is the last IDL interface which was using DeprecatedString! :^)
2023-10-06 07:43:52 +13:00
FlyString const& qualified_name() const { return m_qualified_name.as_string(); }
FlyString const& html_uppercased_qualified_name() const { return m_html_uppercased_qualified_name; }
LibWeb: Port Attr interface from DeprecatedString to String There are an unfortunate number of DeprecatedString conversions required here, but these should all fall away and look much more pretty again when other places are also ported away from DeprecatedString. Leaves only the Element IDL interface left :^)
2023-09-10 16:06:58 +12:00
LibWeb: Port Element interface from DeprecatedString This is the last IDL interface which was using DeprecatedString! :^)
2023-10-06 07:43:52 +13:00
virtual FlyString node_name() const final { return html_uppercased_qualified_name(); }
LibWeb: Port Element::local_name and TagNames from Deprecated String Which pretty much needs to be done together due to the amount of places where they are compared together. This also involves porting over StackOfOpenElements over to FlyString from DeprecatedFly string to prevent a gazillion calls to `.to_deprecated_fly_string` calls in HTMLParser.
2023-10-01 20:07:44 +13:00
FlyString 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
LibWeb: Port Element interface from DeprecatedString This is the last IDL interface which was using DeprecatedString! :^)
2023-10-06 07:43:52 +13:00
FlyString 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
LibWeb: Add a non-DeprecatedString version of Element::prefix() Renaming the old DeprecatedString version of this function to deprecated_prefix().
2023-10-01 17:15:57 +13:00
Optional<FlyString> const& prefix() const { return m_qualified_name.prefix(); }
LibWeb: Port Element interface from DeprecatedString This is the last IDL interface which was using DeprecatedString! :^)
2023-10-06 07:43:52 +13:00
void set_prefix(Optional<FlyString> value);
LibWeb: Introduce CustomElementRegistry and creating custom elements The main missing feature here is form associated custom elements.
2023-03-29 23:46:18 +01:00
LibWeb: Add namespace to Element
2020-10-10 02:48:05 +01:00
// NOTE: This is for the JS bindings
LibWeb: Port Element interface from DeprecatedString This is the last IDL interface which was using DeprecatedString! :^)
2023-10-06 07:43:52 +13:00
Optional<FlyString> const& namespace_uri() const { return m_qualified_name.namespace_(); }
LibWeb: Add namespace to Element
2020-10-10 02:48:05 +01:00
LibWeb: Use FlyString where possible in NamedNodeMap We cannot port over Optional<FlyString> until the IDL generator supports passing that through as an argument (as opposed to an Optional<String>). Change to FlyString where possible, and resolve any fallout as a result.
2024-01-02 21:23:53 +13:00
bool has_attribute(FlyString const& name) const;
LibWeb: Use Optional<FlyString> const& in Element and NamedNodeMap This is enabled with the newly added IDL generator support for FlyStrings.
2024-01-02 23:49:13 +13:00
bool has_attribute_ns(Optional<FlyString> const& namespace_, FlyString const& name) const;
LibWeb: Don't include DOM/NamedNodeMap.h from DOM/Element.h
2023-05-08 07:10:24 +02:00
bool has_attributes() const;
LibWeb: Define getting and setting an attribute value
2023-09-01 10:42:20 -04:00
LibWeb: Use FlyString where possible in NamedNodeMap We cannot port over Optional<FlyString> until the IDL generator supports passing that through as an argument (as opposed to an Optional<String>). Change to FlyString where possible, and resolve any fallout as a result.
2024-01-02 21:23:53 +13:00
Optional<String> attribute(FlyString const& name) const { return get_attribute(name); }
LibWeb: Add Optional<String> version of Element::attribute As a non-deprecated alternative to DeprecatedString Element::attribute.
2023-09-03 15:25:25 +12:00
LibWeb: Use FlyString where possible in NamedNodeMap We cannot port over Optional<FlyString> until the IDL generator supports passing that through as an argument (as opposed to an Optional<String>). Change to FlyString where possible, and resolve any fallout as a result.
2024-01-02 21:23:53 +13:00
Optional<String> get_attribute(FlyString const& name) const;
LibWeb: Implement Element.getAttributeNS
2024-01-13 17:31:46 +13:00
Optional<String> get_attribute_ns(Optional<FlyString> const& namespace_, FlyString const& name) const;
LibWeb: Port Element::get_attribute_value from ByteString
2023-12-27 13:28:00 +13:00
String get_attribute_value(FlyString const& local_name, Optional<FlyString> const& namespace_ = {}) const;
LibWeb: Define getting and setting an attribute value
2023-09-01 10:42:20 -04:00
LibWeb: Port Element::set_attribute_value from DeprecatedString Removing the DeprecatedString / DeprecatedFlyString overloads of this function.
2023-11-05 12:57:54 +13:00
WebIDL::ExceptionOr<void> set_attribute(FlyString const& name, String const& value);
LibWeb: Port Element interface from DeprecatedString This is the last IDL interface which was using DeprecatedString! :^)
2023-10-06 07:43:52 +13:00
LibWeb: Port Element::set_attribute_value from ByteString Also making set_attribute_ns take a String instead of a FlyString as this is only used as an Attr value and no FlyString properties are used.
2024-01-03 12:47:38 +13:00
WebIDL::ExceptionOr<void> set_attribute_ns(Optional<FlyString> const& namespace_, FlyString const& qualified_name, String const& value);
void set_attribute_value(FlyString const& local_name, String const& value, Optional<FlyString> const& prefix = {}, Optional<FlyString> const& namespace_ = {});
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&);
LibWeb: Define getting and setting an attribute value
2023-09-01 10:42:20 -04:00
LibWeb: Expose NamedNodeMap::append_attribute in Element
2023-10-04 17:42:40 +13:00
void append_attribute(Attr&);
LibWeb: Use FlyString where possible in NamedNodeMap We cannot port over Optional<FlyString> until the IDL generator supports passing that through as an argument (as opposed to an Optional<String>). Change to FlyString where possible, and resolve any fallout as a result.
2024-01-02 21:23:53 +13:00
void remove_attribute(FlyString const& name);
LibWeb: Implement Element.removeAttributeNS
2024-01-14 18:56:28 +13:00
void remove_attribute_ns(Optional<FlyString> const& namespace_, FlyString const& name);
LibWeb: Make Element::remove_attribute take a StringView It already delegates to a function which accepts a StringView, so there is no advantage here in taking a FlyString. Ideally, both of these functions should be taking a 'FlyString const&', so leave a FIXME for that. In the meantime, this should help in porting away from DeprecatedString.
2023-09-21 20:09:51 +12:00
LibWeb: Port Element interface from DeprecatedString This is the last IDL interface which was using DeprecatedString! :^)
2023-10-06 07:43:52 +13:00
WebIDL::ExceptionOr<bool> toggle_attribute(FlyString const& name, Optional<bool> force);
LibWeb: Don't include DOM/NamedNodeMap.h from DOM/Element.h
2023-05-08 07:10:24 +02:00
size_t attribute_list_size() const;
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
NamedNodeMap const* attributes() const { return m_attributes.ptr(); }
LibWeb: Port Element interface from DeprecatedString This is the last IDL interface which was using DeprecatedString! :^)
2023-10-06 07:43:52 +13:00
Vector<String> get_attribute_names() const;
LibHTML: Basic element attribute parsing.
2019-06-15 21:08:36 +02:00
LibWeb: Port Element interface from DeprecatedString This is the last IDL interface which was using DeprecatedString! :^)
2023-10-06 07:43:52 +13:00
JS::GCPtr<Attr> get_attribute_node(FlyString const& name) const;
LibWeb: Implement Element.getAttributeNodeNS
2024-01-14 18:04:18 +13:00
JS::GCPtr<Attr> get_attribute_node_ns(Optional<FlyString> const& namespace_, FlyString 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;
Everywhere: Mark a bunch of function parameters as NOESCAPE This fixes the relevant warnings when running LibJSGCVerifier. Note that the analysis is only performed over LibJS-adjacent code, but could be performed over the entire codebase. That will have to wait for a future commit.
2024-04-07 16:30:59 -07:00
void for_each_attribute(NOESCAPE Function<void(Attr const&)>) const;
LibWeb: Add Element::for_each_attribute(Function<void(Attr const&)>) This is useful when you are wanting to interate over attributes and need more information than just the name and value.
2023-11-10 10:04:18 +13:00
Everywhere: Mark a bunch of function parameters as NOESCAPE This fixes the relevant warnings when running LibJSGCVerifier. Note that the analysis is only performed over LibJS-adjacent code, but could be performed over the entire codebase. That will have to wait for a future commit.
2024-04-07 16:30:59 -07:00
void for_each_attribute(NOESCAPE Function<void(FlyString const&, String const&)>) const;
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 { }
LibWeb: Invoke our internal attribute change handler from Attr Currently, every public DOM::Element method which changes an attribute fires this handler itself. This was missed in commit 720f7ba, so any user of that API would not fire the internal handler. To fix this, and prevent any missing invocations in the future, invoke the handler from from Attr::handle_attribute_changes. This method is reached for all attribute changes, including adding/removing attributes. This ensures the handler will always be fired, and reduces the footprint of this ad-hoc behavior. Note that our ad-hoc handler is not the "attribute change steps" noted by the spec. Those are overridden only by a couple of specific elements, e.g. HTMLSlotElement. However, we could easily make our ad-hoc handler hook into those steps in the future.
2023-09-02 10:05:15 -04:00
LibWeb: Implement the attribute-change-steps extension This is similar to the run activation behavior in that elements may define these steps themselves. HTMLSlotElement is one such element. The existing (ad-hoc) Element::attribute_changed() method is not sufficient there as the steps require knowledge of the attribute's old value and its namespace, which this extension provides. Unlike the run activation behavior, we store these steps in a list. An element may end up defining multiple attribute change steps. For example all DOM elements must define steps to handle the "slot" attribute, and HTMLSlotElement must define steps to handle the "name" attribute.
2023-09-01 17:45:22 -04:00
// https://dom.spec.whatwg.org/#concept-element-attributes-change-ext
LibWeb: Convert Element "attribute change steps" from vector to virtual By using a virtual function and overriding it on HTMLSlotElement, we shrink every DOM element by 24 bytes. :^)
2023-11-19 21:28:18 +01:00
virtual void attribute_change_steps(FlyString const& local_name, Optional<String> const& old_value, Optional<String> const& value, Optional<FlyString> const& namespace_);
LibWeb: Implement the attribute-change-steps extension This is similar to the run activation behavior in that elements may define these steps themselves. HTMLSlotElement is one such element. The existing (ad-hoc) Element::attribute_changed() method is not sufficient there as the steps require knowledge of the attribute's old value and its namespace, which this extension provides. Unlike the run activation behavior, we store these steps in a list. An element may end up defining multiple attribute change steps. For example all DOM elements must define steps to handle the "slot" attribute, and HTMLSlotElement must define steps to handle the "name" attribute.
2023-09-01 17:45:22 -04:00
LibWeb: Port Element::attribute_changed from DeprecatedString to String Which as you would expect has a bunch of fallout, but also results in a whole lot of awkward conversions falling away.
2023-11-19 18:10:36 +13:00
void run_attribute_change_steps(FlyString const& local_name, Optional<String> const& old_value, Optional<String> const& value, Optional<FlyString> const& namespace_);
virtual void attribute_changed(FlyString const& name, Optional<String> const& value);
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: Add fast path to calculate invalidations for animated css props - Compare only the animated properties - Clone only the hash map containing animated properties, instead of the entire StyleProperties. Reduces `KeyframeEffect::update_style_properties()` from 10% to 3% in GitHub profiles.
2024-03-19 12:02:06 +01:00
CSS::RequiredInvalidationAfterStyleChange 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: Wrap PseudoElements stored in SimpleSelector in a class No functional impact intended. This is just a more complicated way of writing what we have now. The goal of this commit is so that we are able to store the 'name' of a pseudo element for use in serializing 'unknown -webkit- pseudo-elements', see: https://www.w3.org/TR/selectors-4/#compat This is quite awkward, as in pretty much all cases just the selector type enum is enough, but we will need to cache the name for serializing these unknown selectors. I can't figure out any reason why we would need this name anywhere else in the engine, so pretty much everywhere is still just passing around this raw enum. But this change will allow us to easily store the name inside of this new struct for when it is needed for serialization, once those webkit unknown elements are supported by our engine.
2023-12-10 21:00:03 +13:00
Optional<CSS::Selector::PseudoElement::Type> use_pseudo_element() const { return m_use_pseudo_element; }
void set_use_pseudo_element(Optional<CSS::Selector::PseudoElement::Type> use_pseudo_element) { m_use_pseudo_element = move(use_pseudo_element); }
LibWeb: Make input element placeholders look better We now create a flex container inside the input element's UA shadow tree and add the placeholder and non-placeholder text as flex items (wrapped in elements whose style we can manipulate). This fixes the visual glitch where the placeholder would appear below the bounding box of the input element. It also allows us to align the text vertically inside the input element (like we're supposed to). In order to achieve this, I had to make two small architectural changes to layout tree building: - Elements can now report that they represent a given pseudo element. This allows us to instantiate the ::placeholder pseudo element as an actual DOM element inside the input element's UA shadow tree. - We no longer create a separate layout node for the shadow root itself. Instead, children of the shadow root are treated as if they were children of the DOM element itself for the purpose of layout tree building.
2023-05-25 12:34:54 +02:00
LibWeb: Don't include CSS/CSSStyleDeclaration.h from DOM/Element.h This required splitting out CSS::StyleProperty into its own file and out-of-lining Element::layout_node().
2023-05-08 06:57:55 +02:00
Layout::NodeWithStyle* layout_node();
Layout::NodeWithStyle const* layout_node() const;
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+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(); }
LibWeb: Don't include Layout/Node.h from DOM/Element.h This required moving the CSS::StyleProperty destruct out of line.
2023-05-08 07:51:03 +02:00
void set_computed_css_values(RefPtr<CSS::StyleProperties>);
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: Add fast path for animated style properties update Patch up existing style properties instead of using the regular style invalidation path, which requires rule matching for each element in the invalidated subtree. - !important properties: this change introduces a flag used to skip the update of animated properties overridden by !important. - inherited animated properties: for now, these are invalidated by traversing animated element's subtree to propagate the update. - StyleProperties has a separate array for animated properties that allows the removal animated properties after animation has ended, without requiring full style invalidation.
2024-03-16 07:44:48 +01:00
void reset_animated_css_properties();
LibWeb: Make Element::inline_style() return specific declaration type This removes a bunch of RTTI checks in StyleComputer.
2024-03-18 20:06:36 +01:00
JS::GCPtr<CSS::ElementInlineCSSStyleDeclaration const> inline_style() const { return m_inline_style; }
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
LibWeb: Add style sheets to the shadow root if applicable If a style element belongs to a shadow tree, its CSSStyleSheet is now added to the corresponding ShadowRoot instead of the document. Co-authored-by: Simon Wanner <simon+git@skyrising.xyz>
2023-03-19 15:13:45 +01:00
CSS::StyleSheetList& document_or_shadow_root_style_sheets();
LibWeb: Port Element interface from DeprecatedString This is the last IDL interface which was using DeprecatedString! :^)
2023-10-06 07:43:52 +13:00
WebIDL::ExceptionOr<String> inner_html() const;
LibWeb: Make Element::set_inner_html take a StringView It delegates to DOMParsing::inner_html_setter, which already takes a StringView.
2023-09-21 20:14:57 +12:00
WebIDL::ExceptionOr<void> set_inner_html(StringView);
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
LibWeb: Port Element interface from DeprecatedString This is the last IDL interface which was using DeprecatedString! :^)
2023-10-06 07:43:52 +13:00
WebIDL::ExceptionOr<void> insert_adjacent_html(String const& position, String const& 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;
LibWeb: Give Document a "target element" The target element is the one matching the URL fragment. We don't yet set it to anything.
2023-08-11 20:14:44 +01:00
bool is_target() const;
LibWeb: Add Element::is_document_element() helper This is *not* the same as `Node::is_document()`, just to be confusing. It basically means it's the root element.
2023-08-12 17:47:33 +01:00
bool is_document_element() 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
LibWeb: Make Element::get_elements_by_class_name take a StringView We only make use of the view of the view in this function.
2023-09-21 20:32:09 +12:00
JS::NonnullGCPtr<HTMLCollection> get_elements_by_class_name(StringView);
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
LibWeb: Wrap PseudoElements stored in SimpleSelector in a class No functional impact intended. This is just a more complicated way of writing what we have now. The goal of this commit is so that we are able to store the 'name' of a pseudo element for use in serializing 'unknown -webkit- pseudo-elements', see: https://www.w3.org/TR/selectors-4/#compat This is quite awkward, as in pretty much all cases just the selector type enum is enough, but we will need to cache the name for serializing these unknown selectors. I can't figure out any reason why we would need this name anywhere else in the engine, so pretty much everywhere is still just passing around this raw enum. But this change will allow us to easily store the name inside of this new struct for when it is needed for serialization, once those webkit unknown elements are supported by our engine.
2023-12-10 21:00:03 +13:00
void set_custom_properties(Optional<CSS::Selector::PseudoElement::Type>, HashMap<FlyString, CSS::StyleProperty> custom_properties);
[[nodiscard]] HashMap<FlyString, CSS::StyleProperty> const& custom_properties(Optional<CSS::Selector::PseudoElement::Type>) const;
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 EventLoop, TaskQueue, and Task GC-allocated ...and use HeapFunction instead of SafeFunction for task steps. Since there is only one EventLoop per process, it lives as a global handle in the VM custom data. This makes it much easier to reason about lifetimes of tasks, task steps, and random stuff captured by them.
2024-04-04 12:06:50 +02:00
// NOTE: The function is wrapped in a JS::HeapFunction immediately.
int queue_an_element_task(HTML::Task::Source, Function<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: Add element adjust_computed_style and move set_property() to it
2024-03-07 21:27:37 +01:00
virtual void adjust_computed_style(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: Wrap PseudoElements stored in SimpleSelector in a class No functional impact intended. This is just a more complicated way of writing what we have now. The goal of this commit is so that we are able to store the 'name' of a pseudo element for use in serializing 'unknown -webkit- pseudo-elements', see: https://www.w3.org/TR/selectors-4/#compat This is quite awkward, as in pretty much all cases just the selector type enum is enough, but we will need to cache the name for serializing these unknown selectors. I can't figure out any reason why we would need this name anywhere else in the engine, so pretty much everywhere is still just passing around this raw enum. But this change will allow us to easily store the name inside of this new struct for when it is needed for serialization, once those webkit unknown elements are supported by our engine.
2023-12-10 21:00:03 +13:00
void set_pseudo_element_node(Badge<Layout::TreeBuilder>, CSS::Selector::PseudoElement::Type, JS::GCPtr<Layout::Node>);
JS::GCPtr<Layout::Node> get_pseudo_element_node(CSS::Selector::PseudoElement::Type) 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;
LibWeb: Port Element interface from DeprecatedString This is the last IDL interface which was using DeprecatedString! :^)
2023-10-06 07:43:52 +13:00
WebIDL::ExceptionOr<JS::GCPtr<Element>> insert_adjacent_element(String const& where, JS::NonnullGCPtr<Element> element);
WebIDL::ExceptionOr<void> insert_adjacent_text(String const& where, String 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) \
LibWeb: Port Element interface from DeprecatedString This is the last IDL interface which was using DeprecatedString! :^)
2023-10-06 07:43:52 +13:00
Optional<String> name() const override \
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
{ \
LibWeb: Port Element interface from DeprecatedString This is the last IDL interface which was using DeprecatedString! :^)
2023-10-06 07:43:52 +13:00
return get_attribute(attribute); \
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
} \
\
LibWeb: Port Element interface from DeprecatedString This is the last IDL interface which was using DeprecatedString! :^)
2023-10-06 07:43:52 +13:00
WebIDL::ExceptionOr<void> set_##name(Optional<String> const& value) override \
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
{ \
LibWeb: Remove Element::set_attribute(name, value?) That API came from a mistake in the IDL compiler, where reflected nullable attributes would try to call set_attribute(name, null). This commit fixes the mistake in the IDL generator, and removes the meaningless API.
2023-10-13 23:06:47 +03:30
if (value.has_value()) \
TRY(set_attribute(attribute, *value)); \
else \
remove_attribute(attribute); \
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
return {}; \
}
// https://www.w3.org/TR/wai-aria-1.2/#accessibilityroleandproperties-correspondence
LibWeb: Port Element::set_attribute_value from DeprecatedString Removing the DeprecatedString / DeprecatedFlyString overloads of this function.
2023-11-05 12:57:54 +13:00
ARIA_IMPL(role, "role"_fly_string);
ARIA_IMPL(aria_active_descendant, "aria-activedescendant"_fly_string);
ARIA_IMPL(aria_atomic, "aria-atomic"_fly_string);
ARIA_IMPL(aria_auto_complete, "aria-autocomplete"_fly_string);
ARIA_IMPL(aria_busy, "aria-busy"_fly_string);
ARIA_IMPL(aria_checked, "aria-checked"_fly_string);
ARIA_IMPL(aria_col_count, "aria-colcount"_fly_string);
ARIA_IMPL(aria_col_index, "aria-colindex"_fly_string);
ARIA_IMPL(aria_col_span, "aria-colspan"_fly_string);
ARIA_IMPL(aria_controls, "aria-controls"_fly_string);
ARIA_IMPL(aria_current, "aria-current"_fly_string);
ARIA_IMPL(aria_described_by, "aria-describedby"_fly_string);
ARIA_IMPL(aria_details, "aria-details"_fly_string);
ARIA_IMPL(aria_drop_effect, "aria-dropeffect"_fly_string);
ARIA_IMPL(aria_error_message, "aria-errormessage"_fly_string);
ARIA_IMPL(aria_disabled, "aria-disabled"_fly_string);
ARIA_IMPL(aria_expanded, "aria-expanded"_fly_string);
ARIA_IMPL(aria_flow_to, "aria-flowto"_fly_string);
ARIA_IMPL(aria_grabbed, "aria-grabbed"_fly_string);
ARIA_IMPL(aria_has_popup, "aria-haspopup"_fly_string);
ARIA_IMPL(aria_hidden, "aria-hidden"_fly_string);
ARIA_IMPL(aria_invalid, "aria-invalid"_fly_string);
ARIA_IMPL(aria_key_shortcuts, "aria-keyshortcuts"_fly_string);
ARIA_IMPL(aria_label, "aria-label"_fly_string);
ARIA_IMPL(aria_labelled_by, "aria-labelledby"_fly_string);
ARIA_IMPL(aria_level, "aria-level"_fly_string);
ARIA_IMPL(aria_live, "aria-live"_fly_string);
ARIA_IMPL(aria_modal, "aria-modal"_fly_string);
ARIA_IMPL(aria_multi_line, "aria-multiline"_fly_string);
ARIA_IMPL(aria_multi_selectable, "aria-multiselectable"_fly_string);
ARIA_IMPL(aria_orientation, "aria-orientation"_fly_string);
ARIA_IMPL(aria_owns, "aria-owns"_fly_string);
ARIA_IMPL(aria_placeholder, "aria-placeholder"_fly_string);
ARIA_IMPL(aria_pos_in_set, "aria-posinset"_fly_string);
ARIA_IMPL(aria_pressed, "aria-pressed"_fly_string);
ARIA_IMPL(aria_read_only, "aria-readonly"_fly_string);
ARIA_IMPL(aria_relevant, "aria-relevant"_fly_string);
ARIA_IMPL(aria_required, "aria-required"_fly_string);
ARIA_IMPL(aria_role_description, "aria-roledescription"_fly_string);
ARIA_IMPL(aria_row_count, "aria-rowcount"_fly_string);
ARIA_IMPL(aria_row_index, "aria-rowindex"_fly_string);
ARIA_IMPL(aria_row_span, "aria-rowspan"_fly_string);
ARIA_IMPL(aria_selected, "aria-selected"_fly_string);
ARIA_IMPL(aria_set_size, "aria-setsize"_fly_string);
ARIA_IMPL(aria_sort, "aria-sort"_fly_string);
ARIA_IMPL(aria_value_max, "aria-valuemax"_fly_string);
ARIA_IMPL(aria_value_min, "aria-valuemin"_fly_string);
ARIA_IMPL(aria_value_now, "aria-valuenow"_fly_string);
ARIA_IMPL(aria_value_text, "aria-valuetext"_fly_string);
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
#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);
LibWeb: Allocate custom element reactions queue on demand This shrinks most DOM elements by 16 bytes.
2023-11-19 21:53:58 +01:00
using CustomElementReactionQueue = Vector<Variant<CustomElementUpgradeReaction, CustomElementCallbackReaction>>;
CustomElementReactionQueue* custom_element_reaction_queue() { return m_custom_element_reaction_queue; }
CustomElementReactionQueue const* custom_element_reaction_queue() const { return m_custom_element_reaction_queue; }
CustomElementReactionQueue& ensure_custom_element_reaction_queue();
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
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: Stub out Element.scroll() and Element.scrollTo() With this, we stop throwing exceptions in a way that makes MDN disappear and it's now possible to browse MDN in Ladybird. :^)
2023-06-07 17:11:01 +02:00
void scroll(HTML::ScrollToOptions const&);
void scroll(double x, double y);
LibWeb: Add initial implementation of IntersectionObserver The main missing features are rootMargin, proper nested browsing context support and content clip/clip-path support. This makes images appear on some sites, such as YouTube and howstuffworks.com.
2023-07-06 23:44:07 +01:00
void register_intersection_observer(Badge<IntersectionObserver::IntersectionObserver>, IntersectionObserver::IntersectionObserverRegistration);
void unregister_intersection_observer(Badge<IntersectionObserver::IntersectionObserver>, JS::NonnullGCPtr<IntersectionObserver::IntersectionObserver>);
IntersectionObserver::IntersectionObserverRegistration& get_intersection_observer_registration(Badge<DOM::Document>, IntersectionObserver::IntersectionObserver const&);
LibWeb: Move scroll offset state from layout tree to dom tree Scroll offset state should not be reset by layout tree rebuilt.
2023-08-06 02:15:21 +02:00
enum class ScrollOffsetFor {
Self,
PseudoBefore,
PseudoAfter
};
CSSPixelPoint scroll_offset(ScrollOffsetFor type) const { return m_scroll_offset[to_underlying(type)]; }
void set_scroll_offset(ScrollOffsetFor type, CSSPixelPoint offset) { m_scroll_offset[to_underlying(type)] = offset; }
LibWeb: Implement "directionality" of an Element
2023-08-21 11:47:24 +01:00
enum class Dir {
Ltr,
Rtl,
Auto,
};
Optional<Dir> dir() const { return m_dir; }
enum class Directionality {
Ltr,
Rtl,
};
Directionality directionality() const;
LibWeb: Cache the "id" attribute value on DOM::Element as FlyString This will allow us to do O(1) checks against the element ID when matching selectors, etc.
2023-11-02 14:56:48 +01:00
Optional<FlyString> const& id() const { return m_id; }
LibWeb: Port Element::name to a cached FlyString Also removing some handling of OOM while we are in the area.
2024-01-13 20:12:23 +13:00
Optional<FlyString> const& name() const { return m_name; }
LibWeb: Cache the "id" attribute value on DOM::Element as FlyString This will allow us to do O(1) checks against the element ID when matching selectors, etc.
2023-11-02 14:56:48 +01:00
LibWeb: Extract shared lazy-loading behavior into a base class `<iframe>` and `<img>` tags share the same spec for several aspects of lazy-loading: how the `loading` attribute works, the "will lazy load element" steps, and a member for storing the lazy-load resumption steps. So let's share the implementation by using a base class. This mostly involves moving things around. However, we also change the `start_intersection_observing_a_lazy_loading_element()` method to take a LazyLoadingElement, and operate on one, instead of always casting to HTMLImageElement. We do unfortunately have to do some shenanigans to make the cast work, by adding a virtual function stub in DOM::Element.
2023-11-21 18:50:09 +00:00
virtual JS::GCPtr<JS::HeapFunction<void()>> take_lazy_load_resumption_steps(Badge<DOM::Document>)
{
return nullptr;
}
LibWeb: Add basic "top layer" support Implements the "top layer" concept from "CSS Positioned Layout Module Level 4" specification. - The tree builder is modified to ensure that layout nodes created by top layer elements are children of the viewport. - Implements missing steps in `showModal()` to add an element top top layer. - Implements missing steps in `close()` to remove an element from top layer. Further steps could be: - Add support for `::backdrop` pseudo-element. - Implement the "inert" concept from HTML spec to block hit-testing when element from top layer is displayed.
2024-03-28 16:53:27 +01:00
void set_in_top_layer(bool in_top_layer) { m_in_top_layer = in_top_layer; }
bool in_top_layer() const { return m_in_top_layer; }
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: Make Cell::initialize() return void Stop worrying about tiny OOMs. Work towards #20405
2023-08-07 08:41:28 +02:00
virtual 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: Reset form association when any element with an ID changes When an element with an ID is added to or removed from the DOM, or if an ID is added, removed, or changed, then we must reset the form owner of all form-associated elements who have a form attribute. We do this in 2 steps, using the DOM document as the messenger to handle these changes: 1. All form-associated elements with a form attribute are stored on the document. If the form attribute is removed, the element is removed from that list as well. 2. When a DOM element with an ID undergoes any of the aforementioned changes, it notifies the document of the change. The document then forwards that change to the stored form-associated elements.
2024-02-03 10:29:26 -05:00
virtual void inserted() override;
virtual void removed_from(Node*) override;
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: Hide select chevron icon when `appearance: none;`
2023-12-20 18:21:32 +01:00
virtual void computed_css_values_changed() { }
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: Port AriaData from DeprecatedString to String
2023-11-20 21:59:45 +13:00
virtual bool id_reference_exists(String const&) const override;
LibWeb: Add AriaData object to parse ARIAMixin data This provides an easily serializeable interface for us to use in IPC.
2023-02-25 15:50:34 -06:00
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();
LibWeb: Port AttributeNames to FlyString
2023-10-08 11:42:00 +13:00
void invalidate_style_after_attribute_change(FlyString 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
LibWeb: Port Element::insert_adjacent from ByteString
2024-01-13 20:12:29 +13:00
WebIDL::ExceptionOr<JS::GCPtr<Node>> insert_adjacent(StringView 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;
LibWeb: Port Element interface from DeprecatedString This is the last IDL interface which was using DeprecatedString! :^)
2023-10-06 07:43:52 +13:00
FlyString 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;
LibWeb: Port custom properties to FlyString
2023-11-05 16:19:16 +13:00
HashMap<FlyString, CSS::StyleProperty> m_custom_properties;
LibWeb: Allocate storage for pseudo element custom properties on demand Most elements don't have pseudo elements with CSS custom properties. By only allocating this data structure when it's used, we can shrink most elements by 208 bytes each. :^)
2023-11-19 20:20:34 +01:00
LibWeb: Support obsolete but required -webkit- CSS parsing quirk As outlined in: https://www.w3.org/TR/selectors-4/#compat We now do not treat unknown webkit pseudo-elements as invalid at parse time, and also support serializing these elements. Fixes: #21959
2023-12-10 22:06:55 +13:00
using PseudoElementCustomProperties = Array<HashMap<FlyString, CSS::StyleProperty>, to_underlying(CSS::Selector::PseudoElement::Type::KnownPseudoElementCount)>;
LibWeb: Allocate storage for pseudo element custom properties on demand Most elements don't have pseudo elements with CSS custom properties. By only allocating this data structure when it's used, we can shrink most elements by 208 bytes each. :^)
2023-11-19 20:20:34 +01:00
mutable OwnPtr<PseudoElementCustomProperties> m_pseudo_element_custom_properties;
PseudoElementCustomProperties& pseudo_element_custom_properties() const;
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: Wrap PseudoElements stored in SimpleSelector in a class No functional impact intended. This is just a more complicated way of writing what we have now. The goal of this commit is so that we are able to store the 'name' of a pseudo element for use in serializing 'unknown -webkit- pseudo-elements', see: https://www.w3.org/TR/selectors-4/#compat This is quite awkward, as in pretty much all cases just the selector type enum is enough, but we will need to cache the name for serializing these unknown selectors. I can't figure out any reason why we would need this name anywhere else in the engine, so pretty much everywhere is still just passing around this raw enum. But this change will allow us to easily store the name inside of this new struct for when it is needed for serialization, once those webkit unknown elements are supported by our engine.
2023-12-10 21:00:03 +13:00
Optional<CSS::Selector::PseudoElement::Type> m_use_pseudo_element;
LibWeb: Add internal use_pseudo_element to DOM Element
2023-12-10 12:42:13 +01: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: Implement "directionality" of an Element
2023-08-21 11:47:24 +01:00
Optional<Dir> m_dir;
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: Cache the "id" attribute value on DOM::Element as FlyString This will allow us to do O(1) checks against the element ID when matching selectors, etc.
2023-11-02 14:56:48 +01:00
Optional<FlyString> m_id;
LibWeb: Port Element::name to a cached FlyString Also removing some handling of OOM while we are in the area.
2024-01-13 20:12:23 +13:00
Optional<FlyString> m_name;
LibWeb: Cache the "id" attribute value on DOM::Element as FlyString This will allow us to do O(1) checks against the element ID when matching selectors, etc.
2023-11-02 14:56:48 +01:00
LibWeb: Support obsolete but required -webkit- CSS parsing quirk As outlined in: https://www.w3.org/TR/selectors-4/#compat We now do not treat unknown webkit pseudo-elements as invalid at parse time, and also support serializing these elements. Fixes: #21959
2023-12-10 22:06:55 +13:00
using PseudoElementLayoutNodes = Array<JS::GCPtr<Layout::Node>, to_underlying(CSS::Selector::PseudoElement::Type::KnownPseudoElementCount)>;
LibWeb: Allocate storage for pseudo element layout nodes on demand This saves us 64 bytes for every element that doesn't have pseudo elements associated with it. Which is most of them. :^)
2023-11-19 20:30:13 +01:00
OwnPtr<PseudoElementLayoutNodes> 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.
LibWeb: Allocate custom element reactions queue on demand This shrinks most DOM elements by 16 bytes.
2023-11-19 21:53:58 +01:00
OwnPtr<CustomElementReactionQueue> m_custom_element_reaction_queue;
LibWeb: Introduce CustomElementRegistry and creating custom elements The main missing feature here is form associated custom elements.
2023-03-29 23:46:18 +01:00
// https://dom.spec.whatwg.org/#concept-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;
LibWeb: Add initial implementation of IntersectionObserver The main missing features are rootMargin, proper nested browsing context support and content clip/clip-path support. This makes images appear on some sites, such as YouTube and howstuffworks.com.
2023-07-06 23:44:07 +01:00
// https://www.w3.org/TR/intersection-observer/#dom-element-registeredintersectionobservers-slot
// Element objects have an internal [[RegisteredIntersectionObservers]] slot, which is initialized to an empty list.
LibWeb: Allocate list of registered intersection observers on demand This shrinks most DOM elements by 16 bytes.
2023-11-19 21:37:40 +01:00
OwnPtr<Vector<IntersectionObserver::IntersectionObserverRegistration>> m_registered_intersection_observers;
LibWeb: Move scroll offset state from layout tree to dom tree Scroll offset state should not be reset by layout tree rebuilt.
2023-08-06 02:15:21 +02:00
Array<CSSPixelPoint, 3> m_scroll_offset;
LibWeb: Add basic "top layer" support Implements the "top layer" concept from "CSS Positioned Layout Module Level 4" specification. - The tree builder is modified to ensure that layout nodes created by top layer elements are children of the viewport. - Implements missing steps in `showModal()` to add an element top top layer. - Implements missing steps in `close()` to remove an element from top layer. Further steps could be: - Add support for `::backdrop` pseudo-element. - Implement the "inert" concept from HTML spec to block hit-testing when element from top layer is displayed.
2024-03-28 16:53:27 +01:00
bool m_in_top_layer { false };
LibHTML: Start working on a simple HTML library. I'd like to have rich text, and we might as well use HTML for that. :^)
2019-06-15 18:55:47 +02:00
};
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
LibWeb: Make Node::parent_element() an inline function Also remove a redundant verify_cast<Element> while we're here.
2024-03-19 10:32:16 +01:00
inline Element* Node::parent_element()
{
auto* parent = this->parent();
if (!parent || !is<Element>(parent))
return nullptr;
return static_cast<Element*>(parent);
}
inline Element const* Node::parent_element() const
{
auto const* parent = this->parent();
if (!parent || !is<Element>(parent))
return nullptr;
return static_cast<Element const*>(parent);
}
LibWeb: Make Element::has_class() an inline function This is extremely hot when running CSS selectors, so let's make it easier for it to be inlined.
2024-03-19 10:33:32 +01:00
inline bool Element::has_class(FlyString const& class_name, CaseSensitivity case_sensitivity) const
{
if (case_sensitivity == CaseSensitivity::CaseSensitive) {
return any_of(m_classes, [&](auto& it) {
return it == class_name;
});
}
return any_of(m_classes, [&](auto& it) {
return it.equals_ignoring_ascii_case(class_name);
});
}
LibWeb: Port validate_and_extract from DeprecatedFlyString
2023-11-05 12:37:49 +13:00
WebIDL::ExceptionOr<QualifiedName> validate_and_extract(JS::Realm&, Optional<FlyString> namespace_, FlyString const& 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