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

432 lines
19 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: Don't include Layout/TreeBuilder.h from DOM/Element.h
2023-05-08 07:02:43 +02:00
#include <LibWeb/CSS/Selector.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: 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: 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
#include <LibWeb/HTML/Window.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: 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;
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
DeprecatedFlyString qualified_name() const { return m_qualified_name.as_string().to_deprecated_fly_string(); }
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& 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 Node interface from DeprecatedString to String Which is fortunately quite straight forward :^)
2023-09-17 10:51:43 +12:00
virtual FlyString node_name() const final { return MUST(FlyString::from_deprecated_fly_string(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
DeprecatedFlyString local_name() const { return m_qualified_name.local_name().to_deprecated_fly_string(); }
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
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
DeprecatedFlyString prefix() const { return m_qualified_name.deprecated_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);
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
DeprecatedFlyString namespace_() const { return m_qualified_name.deprecated_namespace_(); }
LibWeb: Add namespace to Element
2020-10-10 02:48:05 +01:00
// NOTE: This is for the JS bindings
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
DeprecatedFlyString 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: Implement Element.hasAttributeNS Particularly needed by xkcd's Right Click comic. https://xkcd.com/1975/
2023-08-09 21:31:35 +01:00
bool has_attribute_ns(DeprecatedFlyString namespace_, DeprecatedFlyString 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: Rename Element::attribute to Element::deprecated_attribute This should allow us to add a Element::attribute which returns an Optional<String>. Eventually all callers should be ported to switch from the DeprecatedString version, but in the meantime, this should allow us to port some more IDL interfaces away from DeprecatedString.
2023-09-03 14:58:18 +12:00
DeprecatedString deprecated_attribute(DeprecatedFlyString 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
Optional<String> attribute(DeprecatedFlyString const& name) const
{
auto ret = deprecated_attribute(name);
if (ret.is_null())
return {};
return String::from_deprecated_string(ret).release_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
DeprecatedString get_attribute(DeprecatedFlyString const& name) const;
LibWeb: Define getting and setting an attribute value
2023-09-01 10:42:20 -04:00
DeprecatedString get_attribute_value(DeprecatedFlyString const& local_name, DeprecatedFlyString const& namespace_ = {}) const;
LibWeb: Remove virtual specifier from Element::set/remove_attribute() Only HTMLDetailsElement was overriding these methods, which has been updated to use Element::attribute_changed() instead.
2023-08-31 15:00:09 -04:00
WebIDL::ExceptionOr<void> set_attribute(DeprecatedFlyString const& name, DeprecatedString const& value);
LibWeb: Add Optional<String> overload for Element::set_attribute Which for now will just call the DeprecatedString version of this function. This is intended to be used in porting code over to using the new String equivalent with the end goal of removing the DeprecatedString version of this function. This allows us to port a whole heap of IDL interfaces from DeprecatedString to String.
2023-09-03 01:09:33 +12:00
WebIDL::ExceptionOr<void> set_attribute(DeprecatedFlyString const& name, Optional<String> 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
WebIDL::ExceptionOr<void> set_attribute_ns(DeprecatedFlyString const& namespace_, DeprecatedFlyString const& qualified_name, DeprecatedString const& value);
LibWeb: Define getting and setting an attribute value
2023-09-01 10:42:20 -04:00
void set_attribute_value(DeprecatedFlyString const& local_name, DeprecatedString const& value, DeprecatedFlyString const& prefix = {}, DeprecatedFlyString 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: 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
// FIXME: This should take a 'FlyString cosnt&'
void remove_attribute(StringView 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
WebIDL::ExceptionOr<bool> toggle_attribute(DeprecatedFlyString 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(); }
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;
LibWeb: Don't include DOM/Attr.h from DOM/Element.h This required moving Element::for_each_attribute() out of line, but that seems harmless enough.
2023-05-08 06:49:38 +02:00
void for_each_attribute(Function<void(DeprecatedFlyString const&, DeprecatedString 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
using AttributeChangeSteps = Function<void(DeprecatedFlyString const& /*local_name*/, DeprecatedString const& /*old_value*/, DeprecatedString const& /*value*/, DeprecatedFlyString const& /*namespace_*/)>;
void add_attribute_change_steps(AttributeChangeSteps steps);
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
void run_attribute_change_steps(DeprecatedFlyString const& local_name, DeprecatedString const& old_value, DeprecatedString const& value, DeprecatedFlyString const& namespace_);
LibWeb: Rename DOM::Element::parse_attribute() => attribute_changed() This is a first step towards merging attribute change and removal notifications into a single function.
2023-07-03 17:08:37 +02:00
virtual void attribute_changed(DeprecatedFlyString const& name, DeprecatedString 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: Avoid rebuilding layout tree unless CSS display property changes Before this, any style change that mutated a property we consider "layout-affecting" would trigger a complete teardown and rebuild of the layout tree. This isn't actually necessary for the vast majority of CSS properties, so this patch makes the invalidation a bit finer, and we now only rebuild the layout tree when the CSS display property changes. For other layout-affecting properties, we keep the old layout tree (if we have one) and run the layout algorithms over that once again. This is significantly faster, since we don't have to run all the CSS selectors all over again.
2023-05-22 16:09:15 +02:00
struct [[nodiscard]] RequiredInvalidationAfterStyleChange {
bool repaint { false };
bool rebuild_stacking_context_tree { false };
bool relayout { false };
bool rebuild_layout_tree { false };
void operator|=(RequiredInvalidationAfterStyleChange const& other)
{
repaint |= other.repaint;
rebuild_stacking_context_tree |= other.rebuild_stacking_context_tree;
relayout |= other.relayout;
rebuild_layout_tree |= other.rebuild_layout_tree;
}
[[nodiscard]] bool is_none() const { return !repaint && !rebuild_stacking_context_tree && !relayout && !rebuild_layout_tree; }
static RequiredInvalidationAfterStyleChange full() { return { true, true, true, true }; }
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
};
LibWeb: Avoid rebuilding layout tree unless CSS display property changes Before this, any style change that mutated a property we consider "layout-affecting" would trigger a complete teardown and rebuild of the layout tree. This isn't actually necessary for the vast majority of CSS properties, so this patch makes the invalidation a bit finer, and we now only rebuild the layout tree when the CSS display property changes. For other layout-affecting properties, we keep the old layout tree (if we have one) and run the layout algorithms over that once again. This is significantly faster, since we don't have to run all the CSS selectors all over again.
2023-05-22 16:09:15 +02:00
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: 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
virtual Optional<CSS::Selector::PseudoElement> pseudo_element() const { return {}; }
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: Rename Element::attribute to Element::deprecated_attribute This should allow us to add a Element::attribute which returns an Optional<String>. Eventually all callers should be ported to switch from the DeprecatedString version, but in the meantime, this should allow us to port some more IDL interfaces away from DeprecatedString.
2023-09-03 14:58:18 +12:00
DeprecatedString name() const { return deprecated_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(); }
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: 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;
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
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;
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
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
LibWeb: Resolve CSS custom properties on pseudo elements The resolved property sets are stored with the element in a per-pseudo-element array (same as for pseudo element layout nodes). Longer term, we should stop storing this with elements entirely and make it temporary state in StyleComputer somehow, so we don't waste memory keeping all the resolved properties around. This makes various gradients show up on https://shopify.com/ :^)
2023-05-17 17:05:36 +02:00
void set_custom_properties(Optional<CSS::Selector::PseudoElement>, HashMap<DeprecatedFlyString, CSS::StyleProperty> custom_properties);
[[nodiscard]] HashMap<DeprecatedFlyString, CSS::StyleProperty> const& custom_properties(Optional<CSS::Selector::PseudoElement>) 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: Assign a unique ID to each HTML task And return that ID when queueing an element task. This is required for some task tracking - specifically, the HTML ToggleTaskTracker struct.
2023-08-31 13:25:27 -04:00
int 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: 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: 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: 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 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
virtual bool id_reference_exists(DeprecatedString const&) const 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: 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
Vector<AttributeChangeSteps> m_attribute_change_steps;
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: Resolve CSS custom properties on pseudo elements The resolved property sets are stored with the element in a per-pseudo-element array (same as for pseudo element layout nodes). Longer term, we should stop storing this with elements entirely and make it temporary state in StyleComputer somehow, so we don't waste memory keeping all the resolved properties around. This makes various gradients show up on https://shopify.com/ :^)
2023-05-17 17:05:36 +02:00
Array<HashMap<DeprecatedFlyString, CSS::StyleProperty>, to_underlying(CSS::Selector::PseudoElement::PseudoElementCount)> m_pseudo_element_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: 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: 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;
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.
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;
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