Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-10-31 13:20:59 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Libraries/LibWeb/CSS/ResolvedCSSStyleDeclaration.h

50 lines
1.9 KiB
C
Raw Normal View History

LibWeb: Add ComputedCSSSstyleDeclaration and support 2 properties :^) getComputedStyle(element) now returns a ComputedCSSStyleDeclaration object, which is a live view of the computed style of a given element. This works by ComputedCSSStyleDeclaration being a wrapper around an element pointer. When you ask it for a CSS property, it gets the latest computed style values from the element and returns them as a CSS::StyleProperty object. This first cut adds support for computed 'color' and 'display'. In case the element doesn't have a corresponding node in the layout tree, we fall back to using specified style instead. This is achieved by performing an on-the-fly style resolution for the individual element and then grabbing the requested property from that resolved style.
2021-09-12 20:05:29 +02:00
/*
Meta: Update my e-mail address everywhere
2024-10-04 13:19:50 +02:00
* Copyright (c) 2021-2023, Andreas Kling <andreas@ladybird.org>
LibWeb: Add ComputedCSSSstyleDeclaration and support 2 properties :^) getComputedStyle(element) now returns a ComputedCSSStyleDeclaration object, which is a live view of the computed style of a given element. This works by ComputedCSSStyleDeclaration being a wrapper around an element pointer. When you ask it for a CSS property, it gets the latest computed style values from the element and returns them as a CSS::StyleProperty object. This first cut adds support for computed 'color' and 'display'. In case the element doesn't have a corresponding node in the layout tree, we fall back to using specified style instead. This is achieved by performing an on-the-fly style resolution for the individual element and then grabbing the requested property from that resolved style.
2021-09-12 20:05:29 +02:00
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <LibWeb/CSS/CSSStyleDeclaration.h>
LibWeb: Implement getComputedStyle() pseudoElement parameter Right now, we deviate from the CSSOM spec regarding our CSSStyleDeclaration classes, so this is not as close to the spec as I'd like. But it works, which means we'll be able to test pseudo-element styling a lot more easily. :^)
2024-08-06 12:48:21 +01:00
#include <LibWeb/CSS/Selector.h>
LibWeb: Add ComputedCSSSstyleDeclaration and support 2 properties :^) getComputedStyle(element) now returns a ComputedCSSStyleDeclaration object, which is a live view of the computed style of a given element. This works by ComputedCSSStyleDeclaration being a wrapper around an element pointer. When you ask it for a CSS property, it gets the latest computed style values from the element and returns them as a CSS::StyleProperty object. This first cut adds support for computed 'color' and 'display'. In case the element doesn't have a corresponding node in the layout tree, we fall back to using specified style instead. This is achieved by performing an on-the-fly style resolution for the individual element and then grabbing the requested property from that resolved style.
2021-09-12 20:05:29 +02:00
namespace Web::CSS {
LibWeb: Rename "Computed" CSSStyleDeclaration => "Resolved" The original name was based on the window.getComputedStyle() API. However, "Computed" in "getComputedStyle" is actually a misnomer that the platform is stuck with due to backwards compatibility. What getComputedStyle() returns is actually a mix of computed and used values. The spec calls it the "resolved" values. So let's call this declaration subclass "ResolvedCSSStyleDeclaration" to match.
2021-09-23 12:35:56 +02:00
class ResolvedCSSStyleDeclaration final : public CSSStyleDeclaration {
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(ResolvedCSSStyleDeclaration, CSSStyleDeclaration);
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC_DECLARE_ALLOCATOR(ResolvedCSSStyleDeclaration);
LibWeb: Make CSSStyleDeclaration GC-allocated
2022-08-07 16:21:26 +02:00
LibWeb: Add ComputedCSSSstyleDeclaration and support 2 properties :^) getComputedStyle(element) now returns a ComputedCSSStyleDeclaration object, which is a live view of the computed style of a given element. This works by ComputedCSSStyleDeclaration being a wrapper around an element pointer. When you ask it for a CSS property, it gets the latest computed style values from the element and returns them as a CSS::StyleProperty object. This first cut adds support for computed 'color' and 'display'. In case the element doesn't have a corresponding node in the layout tree, we fall back to using specified style instead. This is achieved by performing an on-the-fly style resolution for the individual element and then grabbing the requested property from that resolved style.
2021-09-12 20:05:29 +02:00
public:
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
[[nodiscard]] static GC::Ref<ResolvedCSSStyleDeclaration> create(DOM::Element&, Optional<Selector::PseudoElement::Type> = {});
LibWeb: Add ComputedCSSSstyleDeclaration and support 2 properties :^) getComputedStyle(element) now returns a ComputedCSSStyleDeclaration object, which is a live view of the computed style of a given element. This works by ComputedCSSStyleDeclaration being a wrapper around an element pointer. When you ask it for a CSS property, it gets the latest computed style values from the element and returns them as a CSS::StyleProperty object. This first cut adds support for computed 'color' and 'display'. In case the element doesn't have a corresponding node in the layout tree, we fall back to using specified style instead. This is achieved by performing an on-the-fly style resolution for the individual element and then grabbing the requested property from that resolved style.
2021-09-12 20:05:29 +02:00
Libraries: Use default constructors/destructors in LibWeb https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cother-other-default-operation-rules "The compiler is more likely to get the default semantics right and you cannot implement these functions better than the compiler."
2022-03-14 13:21:51 -06:00
virtual ~ResolvedCSSStyleDeclaration() override = default;
LibWeb: Add ComputedCSSSstyleDeclaration and support 2 properties :^) getComputedStyle(element) now returns a ComputedCSSStyleDeclaration object, which is a live view of the computed style of a given element. This works by ComputedCSSStyleDeclaration being a wrapper around an element pointer. When you ask it for a CSS property, it gets the latest computed style values from the element and returns them as a CSS::StyleProperty object. This first cut adds support for computed 'color' and 'display'. In case the element doesn't have a corresponding node in the layout tree, we fall back to using specified style instead. This is achieved by performing an on-the-fly style resolution for the individual element and then grabbing the requested property from that resolved style.
2021-09-12 20:05:29 +02:00
virtual size_t length() const override;
LibWeb: Port CSSStyleDeclaration from DeprecatedString to String
2023-09-06 19:07:24 +12:00
virtual String item(size_t index) const override;
LibWeb: Add internal use_pseudo_element to DOM Element
2023-12-10 12:42:13 +01:00
LibWeb: Add ComputedCSSSstyleDeclaration and support 2 properties :^) getComputedStyle(element) now returns a ComputedCSSStyleDeclaration object, which is a live view of the computed style of a given element. This works by ComputedCSSStyleDeclaration being a wrapper around an element pointer. When you ask it for a CSS property, it gets the latest computed style values from the element and returns them as a CSS::StyleProperty object. This first cut adds support for computed 'color' and 'display'. In case the element doesn't have a corresponding node in the layout tree, we fall back to using specified style instead. This is achieved by performing an on-the-fly style resolution for the individual element and then grabbing the requested property from that resolved style.
2021-09-12 20:05:29 +02:00
virtual Optional<StyleProperty> property(PropertyID) const override;
AK: Don't implicitly convert Optional<T&> to Optional<T> C++ will jovially select the implicit conversion operator, even if it's complete bogus, such as for unknown-size types or non-destructible types. Therefore, all such conversions (which incur a copy) must (unfortunately) be explicit so that non-copyable types continue to work. NOTE: We make an exception for trivially copyable types, since they are, well, trivially copyable. Co-authored-by: kleines Filmröllchen <filmroellchen@serenityos.org>
2024-11-25 13:23:31 +01:00
virtual Optional<StyleProperty const&> custom_property(FlyString const& custom_property_name) const override;
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
virtual WebIDL::ExceptionOr<void> set_property(PropertyID, StringView css_text, StringView priority) override;
LibWeb: Return error on modification of a computed CSS style declaration Previously, calling `setProperty` or `removeProperty` from JS on a CSSStyleDeclaration returned from `getComputedStyle()` would return null. We now return a NoModificationAllowedError instead, which aligns our implementation with the specification.
2024-08-04 22:12:31 +01:00
virtual WebIDL::ExceptionOr<void> set_property(StringView property_name, StringView css_text, StringView priority) override;
LibWeb: Port CSSStyleDeclaration from DeprecatedString to String
2023-09-06 19:07:24 +12:00
virtual WebIDL::ExceptionOr<String> remove_property(PropertyID) override;
LibWeb: Return error on modification of a computed CSS style declaration Previously, calling `setProperty` or `removeProperty` from JS on a CSSStyleDeclaration returned from `getComputedStyle()` would return null. We now return a NoModificationAllowedError instead, which aligns our implementation with the specification.
2024-08-04 22:12:31 +01:00
virtual WebIDL::ExceptionOr<String> remove_property(StringView property_name) override;
LibWeb: Add ComputedCSSSstyleDeclaration and support 2 properties :^) getComputedStyle(element) now returns a ComputedCSSStyleDeclaration object, which is a live view of the computed style of a given element. This works by ComputedCSSStyleDeclaration being a wrapper around an element pointer. When you ask it for a CSS property, it gets the latest computed style values from the element and returns them as a CSS::StyleProperty object. This first cut adds support for computed 'color' and 'display'. In case the element doesn't have a corresponding node in the layout tree, we fall back to using specified style instead. This is achieved by performing an on-the-fly style resolution for the individual element and then grabbing the requested property from that resolved style.
2021-09-12 20:05:29 +02:00
LibWeb: Port CSSStyleDeclaration from DeprecatedString to String
2023-11-21 10:39:54 +13:00
virtual String serialized() const override;
LibWeb: Implement CSSStyleDeclaration.cssText
2022-11-05 04:51:05 +00:00
virtual WebIDL::ExceptionOr<void> set_css_text(StringView) override;
LibWeb: Implement CSSRule and CSSStyleDeclaration serialization There are a handful of FIXME's here, but this seems generally good. Note that CSS *values* don't get serialized in a spec-compliant way since we currently rely on StyleValue::to_string() which is ad-hoc.
2021-10-01 19:57:45 +02:00
LibWeb: Add ComputedCSSSstyleDeclaration and support 2 properties :^) getComputedStyle(element) now returns a ComputedCSSStyleDeclaration object, which is a live view of the computed style of a given element. This works by ComputedCSSStyleDeclaration being a wrapper around an element pointer. When you ask it for a CSS property, it gets the latest computed style values from the element and returns them as a CSS::StyleProperty object. This first cut adds support for computed 'color' and 'display'. In case the element doesn't have a corresponding node in the layout tree, we fall back to using specified style instead. This is achieved by performing an on-the-fly style resolution for the individual element and then grabbing the requested property from that resolved style.
2021-09-12 20:05:29 +02:00
private:
LibWeb: Implement getComputedStyle() pseudoElement parameter Right now, we deviate from the CSSOM spec regarding our CSSStyleDeclaration classes, so this is not as close to the spec as I'd like. But it works, which means we'll be able to test pseudo-element styling a lot more easily. :^)
2024-08-06 12:48:21 +01:00
explicit ResolvedCSSStyleDeclaration(DOM::Element&, Optional<CSS::Selector::PseudoElement::Type>);
LibWeb: Remove unecessary dependence on Window from CSS classes These classes only needed Window to get at its realm. Pass a realm directly to construct CSS classes.
2022-09-24 16:34:04 -06: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: Serialize resolved CSS values in dedicated serialization mode This doesn't actually do anything differently yet, but it will in the very next commit.
2024-12-07 01:10:11 +01:00
virtual bool computed_flag() const override { return true; }
LibWeb: Rename StyleValue -> CSSStyleValue This matches the name in the CSS Typed OM spec. https://drafts.css-houdini.org/css-typed-om-1/#cssstylevalue No behaviour changes.
2024-08-14 11:10:54 +01:00
RefPtr<CSSStyleValue const> style_value_for_property(Layout::NodeWithStyle const&, PropertyID) const;
LibWeb: Simplify ComputedCSSStyleDeclaration property lookup Factor out the per-property StyleValue generation to a separate function so we don't have to repeat ourselves so much in property(). :^)
2021-09-18 13:14:40 +02:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ref<DOM::Element> m_element;
LibWeb: Implement getComputedStyle() pseudoElement parameter Right now, we deviate from the CSSOM spec regarding our CSSStyleDeclaration classes, so this is not as close to the spec as I'd like. But it works, which means we'll be able to test pseudo-element styling a lot more easily. :^)
2024-08-06 12:48:21 +01:00
Optional<CSS::Selector::PseudoElement::Type> m_pseudo_element;
LibWeb: Add ComputedCSSSstyleDeclaration and support 2 properties :^) getComputedStyle(element) now returns a ComputedCSSStyleDeclaration object, which is a live view of the computed style of a given element. This works by ComputedCSSStyleDeclaration being a wrapper around an element pointer. When you ask it for a CSS property, it gets the latest computed style values from the element and returns them as a CSS::StyleProperty object. This first cut adds support for computed 'color' and 'display'. In case the element doesn't have a corresponding node in the layout tree, we fall back to using specified style instead. This is achieved by performing an on-the-fly style resolution for the individual element and then grabbing the requested property from that resolved style.
2021-09-12 20:05:29 +02:00
};
}
Reference in a new issue Copy permalink