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/Libraries/LibWeb/CSS/ComputedProperties.h

298 lines
12 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: Make :hover invalidation logic reusable for all pseudo classes We achieve this by keeping track of all checked pseudo class selectors in the SelectorEngine code. We also give StyleComputer per-pseudo-class rule caches.
2025-04-17 13:39:30 +02:00
* Copyright (c) 2018-2025, Andreas Kling <andreas@ladybird.org>
LibWeb/CSS: Stop returning Optional for enum properties While keyword_to_foo() does return Optional<Foo>, in practice the invalid keywords get rejected at parse-time, so we don't have to worry about them here. This simplifies the user code quite a bit.
2025-02-05 12:55:02 +00:00
* Copyright (c) 2023-2025, Sam Atkins <sam@ladybird.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: Get rid of the style tree We now create a layout tree directly from the DOM tree. This way we don't actually lose text nodes ^)
2019-09-21 15:32:17 +03:00
#pragma once
#include <AK/HashMap.h>
#include <AK/NonnullRefPtr.h>
LibWeb: Make CSS::ComputedProperties GC-allocated
2024-12-20 16:35:12 +01:00
#include <LibGC/CellAllocator.h>
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
#include <LibGC/Ptr.h>
LibGfx: Move other font-related files to LibGfx/Font/
2022-04-09 09:28:38 +02:00
#include <LibGfx/Font/Font.h>
LibGfx+LibWeb: Produce font cascade list in CSS font matching algorithm According to the CSS font matching algorithm specification, it is supposed to be executed for each glyph instead of each text run, as is currently done. This change partially implements this by having the font matching algorithm produce a list of fonts against which each glyph will be tested to find its suitable font. Now, it becomes possible to have per-glyph fallback fonts: if the needed glyph is not present in a font, we can check the subsequent fonts in the list.
2023-12-09 23:42:02 +01:00
#include <LibGfx/FontCascadeList.h>
LibGfx: Replace manual forward declarations with <LibGfx/Forward.h>
2020-02-15 00:10:34 +01:00
#include <LibGfx/Forward.h>
LibWeb: Make CSS::ComputedProperties GC-allocated
2024-12-20 16:35:12 +01:00
#include <LibJS/Heap/Cell.h>
LibWeb: Parse flex-basis Flex-basis accepts either 'content' or a Length.
2021-05-30 14:23:43 +02:00
#include <LibWeb/CSS/ComputedValues.h>
LibWeb: Move the offset, margin and padding boxes into LayoutStyle
2020-06-24 17:45:42 +02:00
#include <LibWeb/CSS/LengthBox.h>
LibWeb: Remove now-unused includes from StyleValue.cpp And add them to all the places that relied on getting them transitively.
2023-03-25 14:11:11 +00:00
#include <LibWeb/CSS/PropertyID.h>
LibWeb: Make :hover invalidation logic reusable for all pseudo classes We achieve this by keeping track of all checked pseudo class selectors in the SelectorEngine code. We also give StyleComputer per-pseudo-class rule caches.
2025-04-17 13:39:30 +02:00
#include <LibWeb/CSS/PseudoClass.h>
#include <LibWeb/CSS/PseudoClassBitmap.h>
LibWeb: Use bitmaps for important/inherited bits in StyleProperties This avoids padding the style value array, shrinking StyleProperties from 4368 bytes to 2288 bytes per instance.
2024-08-02 13:59:19 +02:00
#include <LibWeb/CSS/StyleProperty.h>
LibWeb: Enable EXPLICIT_SYMBOL_EXPORT
2025-07-19 19:35:33 -07:00
#include <LibWeb/Export.h>
LibHTML: Get rid of the style tree We now create a layout tree directly from the DOM tree. This way we don't actually lose text nodes ^)
2019-09-21 15:32:17 +03:00
LibWeb: Move CSS classes into the Web::CSS namespace
2020-07-26 20:01:35 +02:00
namespace Web::CSS {
LibWeb: Move everything into the Web namespace
2020-03-07 10:27:02 +01:00
LibWeb: Enable EXPLICIT_SYMBOL_EXPORT
2025-07-19 19:35:33 -07:00
class WEB_API ComputedProperties final : public JS::Cell {
LibWeb: Make CSS::ComputedProperties GC-allocated
2024-12-20 16:35:12 +01:00
GC_CELL(ComputedProperties, JS::Cell);
GC_DECLARE_ALLOCATOR(ComputedProperties);
LibWeb: Make CSS::StyleProperties copy-on-write internally This makes the way we've implemented the CSS `revert` keyword a lot less expensive. Until now, we were making a deep copy of all property values at the start of each cascade origin. (Those are the values that `revert` would bring us back to if encountered.) With this patch, the revert property set becomes a shallow copy, and we only clone the property set if the cascade ends up writing something. This knocks a 5% profile item down to 1.3% on https://tailwindcss.com
2024-09-10 11:46:32 +02:00
public:
LibWeb: Scale font size by 1.15 for `line-height: normal` Browsers such as Chrome and Firefox apply an arbitrary scale to the current font size if `normal` is used for `line-height`. Firefox uses 1.2 while Chrome uses 1.15. Let's go with the latter for now, it's relatively easy to change if we ever want to go back on that decision. This also requires updating the expectations for a lot of layout tests. The upside of this is that it's a bit easier to compare our layout results to other browsers', especially Chrome.
2025-04-04 15:08:15 +02:00
static constexpr double normal_line_height_scale = 1.15;
LibWeb: Make CSS::StyleProperties copy-on-write internally This makes the way we've implemented the CSS `revert` keyword a lot less expensive. Until now, we were making a deep copy of all property values at the start of each cascade origin. (Those are the values that `revert` would bring us back to if encountered.) With this patch, the revert property set becomes a shallow copy, and we only clone the property set if the cascade ends up writing something. This knocks a 5% profile item down to 1.3% on https://tailwindcss.com
2024-09-10 11:46:32 +02:00
LibWeb: Make CSS::ComputedProperties GC-allocated
2024-12-20 16:35:12 +01:00
virtual ~ComputedProperties() override;
LibHTML: Replace StyleProperties::create(StyleProperties) with clone()
2020-01-05 16:54:38 +01:00
LibHTML: Get rid of the style tree We now create a layout tree directly from the DOM tree. This way we don't actually lose text nodes ^)
2019-09-21 15:32:17 +03:00
template<typename Callback>
inline void for_each_property(Callback callback) const
{
LibWeb: Make CSS::ComputedProperties GC-allocated
2024-12-20 16:35:12 +01:00
for (size_t i = 0; i < m_property_values.size(); ++i) {
if (m_property_values[i])
LibWeb: Don't allocate space for shorthands in ComputedProperties Only longhands have computed values so allocating space for shorthands is just wasted memory
2025-08-25 16:04:32 +12:00
callback(static_cast<PropertyID>(i + to_underlying(first_longhand_property_id)), *m_property_values[i]);
LibWeb: Turn StyleProperties::m_property_values into an Array After style computation, every StyleProperties has a value for every PropertyID. Given this, it's simpler, faster and less memory-heavy to use an Array instead of a HashMap. :^)
2022-02-18 20:21:49 +01:00
}
LibHTML: Get rid of the style tree We now create a layout tree directly from the DOM tree. This way we don't actually lose text nodes ^)
2019-09-21 15:32:17 +03: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
enum class Inherited {
No,
Yes
};
LibWeb: Move and rename CSSStyleValue to StyleValues/StyleValue.{h,cpp} This reverts 0e3487b9ab455a7648185995363bb3b487551d40. Back when I made that change, I thought we could make our StyleValue classes match the typed-om definitions directly. However, they have different requirements. Typed-om types need to be mutable and GCed, whereas StyleValues are immutable and ideally wouldn't require a JS VM. While I was already making such a cataclysmic change, I've moved it into the StyleValues directory, because it *not* being there has bothered me for a long time. 😅
2025-08-08 10:11:51 +01:00
HashMap<PropertyID, NonnullRefPtr<StyleValue const>> const& animated_property_values() const { return m_animated_property_values; }
LibWeb: Reset animated CSS properties for pseudo elements Previously we were resetting animated properties if animation effect's target is not a pseudo element.
2025-05-28 15:12:37 +02:00
void reset_animated_properties(Badge<Animations::KeyframeEffect>);
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
LibWeb/CSS: Remove redundant CSS:: namespaces from ComputedProperties We're already in the CSS namespace, so let's remove the clutter.
2025-02-05 12:57:41 +00:00
bool is_property_important(PropertyID property_id) const;
bool is_property_inherited(PropertyID property_id) const;
LibWeb: Propagate animated values in `recompute_inherited_style` As `recompute_inherited_style` works in-place rather than building ComputedProperties from scratch we need to keep track of which animated properties are inherited to know whether we should remove them when we have no more inherited value.
2025-08-20 23:30:31 +12:00
bool is_animated_property_inherited(PropertyID property_id) const;
LibWeb/CSS: Remove redundant CSS:: namespaces from ComputedProperties We're already in the CSS namespace, so let's remove the clutter.
2025-02-05 12:57:41 +00:00
void set_property_important(PropertyID, Important);
void set_property_inherited(PropertyID, Inherited);
LibWeb: Propagate animated values in `recompute_inherited_style` As `recompute_inherited_style` works in-place rather than building ComputedProperties from scratch we need to keep track of which animated properties are inherited to know whether we should remove them when we have no more inherited value.
2025-08-20 23:30:31 +12:00
void set_animated_property_inherited(PropertyID, Inherited);
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
LibWeb: Move and rename CSSStyleValue to StyleValues/StyleValue.{h,cpp} This reverts 0e3487b9ab455a7648185995363bb3b487551d40. Back when I made that change, I thought we could make our StyleValue classes match the typed-om definitions directly. However, they have different requirements. Typed-om types need to be mutable and GCed, whereas StyleValues are immutable and ideally wouldn't require a JS VM. While I was already making such a cataclysmic change, I've moved it into the StyleValues directory, because it *not* being there has bothered me for a long time. 😅
2025-08-08 10:11:51 +01:00
void set_property(PropertyID, NonnullRefPtr<StyleValue const> value, Inherited = Inherited::No, Important = Important::No);
LibWeb: Propagate animated values in `recompute_inherited_style` As `recompute_inherited_style` works in-place rather than building ComputedProperties from scratch we need to keep track of which animated properties are inherited to know whether we should remove them when we have no more inherited value.
2025-08-20 23:30:31 +12:00
void set_animated_property(PropertyID, NonnullRefPtr<StyleValue const> value, Inherited = Inherited::No);
void remove_animated_property(PropertyID);
LibWeb/CSS: Allow getting a property's computed value without animations The algorithm for starting a transition requires us to examine the before-change and after-change values of the property, without taking any current animations into account.
2024-09-19 10:46:32 +01:00
enum class WithAnimationsApplied {
No,
Yes,
};
LibWeb: Move and rename CSSStyleValue to StyleValues/StyleValue.{h,cpp} This reverts 0e3487b9ab455a7648185995363bb3b487551d40. Back when I made that change, I thought we could make our StyleValue classes match the typed-om definitions directly. However, they have different requirements. Typed-om types need to be mutable and GCed, whereas StyleValues are immutable and ideally wouldn't require a JS VM. While I was already making such a cataclysmic change, I've moved it into the StyleValues directory, because it *not* being there has bothered me for a long time. 😅
2025-08-08 10:11:51 +01:00
StyleValue const& property(PropertyID, WithAnimationsApplied = WithAnimationsApplied::Yes) const;
LibWeb/CSS: Remove redundant CSS:: namespaces from ComputedProperties We're already in the CSS namespace, so let's remove the clutter.
2025-02-05 12:57:41 +00:00
void revert_property(PropertyID, ComputedProperties const& style_for_revert);
GC::Ptr<CSSStyleDeclaration const> animation_name_source() const { return m_animation_name_source; }
void set_animation_name_source(GC::Ptr<CSSStyleDeclaration const> declaration) { m_animation_name_source = declaration; }
GC::Ptr<CSSStyleDeclaration const> transition_property_source() const { return m_transition_property_source; }
void set_transition_property_source(GC::Ptr<CSSStyleDeclaration const> declaration) { m_transition_property_source = declaration; }
Size size_value(PropertyID) const;
[[nodiscard]] Variant<LengthPercentage, NormalGap> gap_value(PropertyID) const;
LibWeb: Store `border-*-width` in computed form in ComputedProperties Gains us 112 new passes since we now interpolate keywords (thick, thin, etc) correctly. Also loses us 4 WPT tests as we longer clamp negative values produced by interpolation from the point of view of getComputedStyle (although the 'used' value is still clamped).
2025-08-28 02:07:57 +12:00
Length length(PropertyID) const;
LibWeb: Clamp negative computed values for `padding-*` properties Interpolation can leave `padding-*` values as negative - this should be handled by interpolation clamping it to the allowed range of values but we don't yet do that. As a stop gap we can clamp this before setting it in ComputedValues. This fixes 3 crashes and gains us 11 passes in the imported WPT tests
2025-08-22 03:41:19 +12:00
enum class ClampNegativeLengths {
No,
Yes,
};
Optional<LengthPercentage> length_percentage(PropertyID, Layout::NodeWithStyle const&, ClampNegativeLengths) const;
LibWeb: Make LengthBox hold LengthPercentageOrAuto Not every user of this requires an `auto` state, but most do. This has quite a big diff but most of that is mechanical: LengthPercentageOrAuto has `resolved_or_auto()` instead of `resolved()`, and `to_px_or_zero()` instead of `to_px()`, to make their output clearer.
2025-09-01 12:51:52 +01:00
LengthBox length_box(PropertyID left_id, PropertyID top_id, PropertyID right_id, PropertyID bottom_id, Layout::NodeWithStyle const&, ClampNegativeLengths, LengthPercentageOrAuto const& default_value) const;
LibWeb: Take a ColorResolutionContext in `color_or_fallback` Taking a ColorResolutionContext directly instead of creating one from a layout node allows us to call this from places where we don't have a layout node.
2025-07-19 13:28:14 +12:00
Color color_or_fallback(PropertyID, ColorResolutionContext, Color fallback) const;
LibWeb: Implement the `color-interpolation` property for SVG gradients This changes the operating color space for gradient `<linearGradient>` and `<radialGradient>` elements.
2025-08-15 23:53:15 +01:00
ColorInterpolation color_interpolation() const;
LibWeb/CSS: Remove redundant CSS:: namespaces from ComputedProperties We're already in the CSS namespace, so let's remove the clutter.
2025-02-05 12:57:41 +00:00
PreferredColorScheme color_scheme(PreferredColorScheme, Optional<Vector<String> const&> document_supported_schemes) const;
LibWeb/CSS: Stop returning Optional for enum properties While keyword_to_foo() does return Optional<Foo>, in practice the invalid keywords get rejected at parse-time, so we don't have to worry about them here. This simplifies the user code quite a bit.
2025-02-05 12:55:02 +00:00
TextAnchor text_anchor() const;
TextAlign text_align() const;
TextJustify text_justify() const;
TextOverflow text_overflow() const;
LibWeb/CSS: Add the `text-rendering` property
2025-06-27 07:03:05 +01:00
TextRendering text_rendering() const;
LibWeb: Respect `text-underline-offset` when rendering underlines
2025-09-12 12:21:16 +12:00
CSSPixels text_underline_offset() const;
LibWeb: Support `text-underline-position: under`
2025-09-14 16:04:26 +12:00
TextUnderlinePosition text_underline_position() const;
LibWeb/CSS: Remove redundant CSS:: namespaces from ComputedProperties We're already in the CSS namespace, so let's remove the clutter.
2025-02-05 12:57:41 +00:00
Length border_spacing_horizontal(Layout::Node const&) const;
Length border_spacing_vertical(Layout::Node const&) const;
LibWeb/CSS: Stop returning Optional for enum properties While keyword_to_foo() does return Optional<Foo>, in practice the invalid keywords get rejected at parse-time, so we don't have to worry about them here. This simplifies the user code quite a bit.
2025-02-05 12:55:02 +00:00
CaptionSide caption_side() const;
LibWeb/CSS: Remove redundant CSS:: namespaces from ComputedProperties We're already in the CSS namespace, so let's remove the clutter.
2025-02-05 12:57:41 +00:00
Clip clip() const;
Display display() const;
LibWeb/CSS: Stop returning Optional for enum properties While keyword_to_foo() does return Optional<Foo>, in practice the invalid keywords get rejected at parse-time, so we don't have to worry about them here. This simplifies the user code quite a bit.
2025-02-05 12:55:02 +00:00
Float float_() const;
LibWeb/CSS: Implement the `caret-color` property
2025-03-09 13:59:33 +00:00
Color caret_color(Layout::NodeWithStyle const&) const;
LibWeb/CSS: Stop returning Optional for enum properties While keyword_to_foo() does return Optional<Foo>, in practice the invalid keywords get rejected at parse-time, so we don't have to worry about them here. This simplifies the user code quite a bit.
2025-02-05 12:55:02 +00:00
Clear clear() const;
ColumnSpan column_span() const;
LibWeb: Track quote-nesting level while building the layout tree This makes multiple levels of quote actually use different quotation marks, instead of always the first available pair of them. Each Layout::Node remembers what the quote-nesting level was before its content was evaluated, so that we can re-use this number in `apply_style()`. This is a bit hacky, since we end up converting the `content` value into a string twice. `StyleProperties::content()` now takes an initial quote-nesting level, and returns the final level after that content.
2023-09-18 15:41:17 +01:00
struct ContentDataAndQuoteNestingLevel {
LibWeb/CSS: Remove redundant CSS:: namespaces from ComputedProperties We're already in the CSS namespace, so let's remove the clutter.
2025-02-05 12:57:41 +00:00
ContentData content_data;
LibWeb: Track quote-nesting level while building the layout tree This makes multiple levels of quote actually use different quotation marks, instead of always the first available pair of them. Each Layout::Node remembers what the quote-nesting level was before its content was evaluated, so that we can re-use this number in `apply_style()`. This is a bit hacky, since we end up converting the `content` value into a string twice. `StyleProperties::content()` now takes an initial quote-nesting level, and returns the final level after that content.
2023-09-18 15:41:17 +01:00
u32 final_quote_nesting_level { 0 };
};
LibWeb: Support counter-* properties on pseudo-elements There are multiple things happening here which are interconnected: - We now use AbstractElement to refer to the source of a counter, which means we also need to pass that around to compute `content`. - Give AbstractElement new helper methods that are needed by CountersSet, so it doesn't have to care whether it's dealing with a true Element or PseudoElement. - The CountersSet algorithms now walk the layout tree instead of DOM tree, so TreeBuilder needs to wait until the layout node exists before it resolves counters for it. - Resolve counters when creating a pseudo-element's layout node. We awkwardly compute the `content` value up to twice: Once to figure out what kind of node we need to make, and then if it's a string, we do so again after counters are resolved so we can get the true value of any `counter()` functions. This will need adjusting in the future but it works for now.
2025-06-17 16:33:23 +01:00
ContentDataAndQuoteNestingLevel content(DOM::AbstractElement&, u32 initial_quote_nesting_level) const;
LibWeb/CSS: Stop returning Optional for enum properties While keyword_to_foo() does return Optional<Foo>, in practice the invalid keywords get rejected at parse-time, so we don't have to worry about them here. This simplifies the user code quite a bit.
2025-02-05 12:55:02 +00:00
ContentVisibility content_visibility() const;
LibWeb+WebContent+UI: Support image cursors The `cursor` property accepts a list of possible cursors, which behave as a fallback: We use whichever cursor is the first available one. This is a little complicated because initially, any remote images have not loaded, so we need to use the fallback standard cursor, and then switch to another when it loads. So, ComputedValues stores a Vector of cursors, and then in EventHandler we scan down that list until we find a cursor that's ready for use. The spec defines cursors as being `<url>`, but allows for `<image>` instead. That includes functions like `linear-gradient()`. This commit implements image cursors in the Qt UI, but not AppKit.
2025-02-20 12:17:29 +00:00
Vector<CursorData> cursor() const;
LibWeb/CSS: Parse the tab-size property
2024-10-01 13:07:06 +01:00
Variant<LengthOrCalculated, NumberOrCalculated> tab_size() const;
LibWeb: Parse and propagate `white-space-collapse` CSS property
2025-05-16 18:32:31 +12:00
WhiteSpaceCollapse white_space_collapse() const;
LibWeb: Parse and propagate `white-space-trim` CSS property
2025-05-18 02:21:42 +12:00
WhiteSpaceTrimData white_space_trim() const;
LibWeb/CSS: Stop returning Optional for enum properties While keyword_to_foo() does return Optional<Foo>, in practice the invalid keywords get rejected at parse-time, so we don't have to worry about them here. This simplifies the user code quite a bit.
2025-02-05 12:55:02 +00:00
WordBreak word_break() const;
LibWeb: Return `word-spacing` computed value as CSSPixels
2025-09-09 16:59:30 +01:00
CSSPixels word_spacing() const;
LibWeb: Return `letter-spacing` computed value as CSSPixels
2025-09-09 09:56:53 +01:00
CSSPixels letter_spacing() const;
LibWeb/CSS: Remove redundant CSS:: namespaces from ComputedProperties We're already in the CSS namespace, so let's remove the clutter.
2025-02-05 12:57:41 +00:00
LineStyle line_style(PropertyID) const;
LibWeb/CSS: Stop returning Optional for enum properties While keyword_to_foo() does return Optional<Foo>, in practice the invalid keywords get rejected at parse-time, so we don't have to worry about them here. This simplifies the user code quite a bit.
2025-02-05 12:55:02 +00:00
OutlineStyle outline_style() const;
LibWeb/CSS: Remove redundant CSS:: namespaces from ComputedProperties We're already in the CSS namespace, so let's remove the clutter.
2025-02-05 12:57:41 +00:00
Vector<TextDecorationLine> text_decoration_line() const;
LibWeb/CSS: Stop returning Optional for enum properties While keyword_to_foo() does return Optional<Foo>, in practice the invalid keywords get rejected at parse-time, so we don't have to worry about them here. This simplifies the user code quite a bit.
2025-02-05 12:55:02 +00:00
TextDecorationStyle text_decoration_style() const;
LibWeb: Stop pretending text-decoration-thickness is a LengthPercentage It has two keywords: auto and from-font. from-font isn't handled properly yet, but at least we have a FIXME for it now. :^)
2025-08-27 15:12:17 +01:00
TextDecorationThickness text_decoration_thickness() const;
LibWeb/CSS: Stop returning Optional for enum properties While keyword_to_foo() does return Optional<Foo>, in practice the invalid keywords get rejected at parse-time, so we don't have to worry about them here. This simplifies the user code quite a bit.
2025-02-05 12:55:02 +00:00
TextTransform text_transform() const;
LibWeb/CSS: Remove redundant CSS:: namespaces from ComputedProperties We're already in the CSS namespace, so let's remove the clutter.
2025-02-05 12:57:41 +00:00
Vector<ShadowData> text_shadow(Layout::Node const&) const;
LibWeb: Parse and propagate `text-wrap-mode` CSS property
2025-05-18 00:49:25 +12:00
TextWrapMode text_wrap_mode() const;
LibWeb/CSS: Stop returning Optional for enum properties While keyword_to_foo() does return Optional<Foo>, in practice the invalid keywords get rejected at parse-time, so we don't have to worry about them here. This simplifies the user code quite a bit.
2025-02-05 12:55:02 +00:00
ListStyleType list_style_type() const;
ListStylePosition list_style_position() const;
FlexDirection flex_direction() const;
FlexWrap flex_wrap() const;
FlexBasis flex_basis() const;
LibWeb: Make computed flex-grow and flex-shrink always available These values are not allowed to be absent (auto/none/etc) so we don't need to use Optional<float> for them. This simplifies some things.
2021-10-19 15:22:08 +02:00
float flex_grow() const;
float flex_shrink() const;
LibWeb: Implement the flex order CSS property Adds support for the flex order property and a test page for it on the browser welcome page.
2022-03-31 22:11:38 +02:00
int order() const;
LibWeb: Parse and plumb the `accent-color` CSS property
2023-03-18 20:49:00 +01:00
Optional<Color> accent_color(Layout::NodeWithStyle const&) const;
LibWeb/CSS: Stop returning Optional for enum properties While keyword_to_foo() does return Optional<Foo>, in practice the invalid keywords get rejected at parse-time, so we don't have to worry about them here. This simplifies the user code quite a bit.
2025-02-05 12:55:02 +00:00
AlignContent align_content() const;
AlignItems align_items() const;
AlignSelf align_self() const;
Appearance appearance() const;
LibWeb/CSS: Remove redundant CSS:: namespaces from ComputedProperties We're already in the CSS namespace, so let's remove the clutter.
2025-02-05 12:57:41 +00:00
Filter backdrop_filter() const;
Filter filter() const;
LibWeb: Make computed opacity always available No need to store opacity as Optional<float> as there's always a value (and the default initial value is 1.)
2021-10-19 15:27:40 +02:00
float opacity() const;
LibWeb/CSS: Stop returning Optional for enum properties While keyword_to_foo() does return Optional<Foo>, in practice the invalid keywords get rejected at parse-time, so we don't have to worry about them here. This simplifies the user code quite a bit.
2025-02-05 12:55:02 +00:00
Visibility visibility() const;
ImageRendering image_rendering() const;
JustifyContent justify_content() const;
JustifyItems justify_items() const;
JustifySelf justify_self() const;
Overflow overflow_x() const;
Overflow overflow_y() const;
LibWeb/CSS: Remove redundant CSS:: namespaces from ComputedProperties We're already in the CSS namespace, so let's remove the clutter.
2025-02-05 12:57:41 +00:00
Vector<ShadowData> box_shadow(Layout::Node const&) const;
LibWeb/CSS: Stop returning Optional for enum properties While keyword_to_foo() does return Optional<Foo>, in practice the invalid keywords get rejected at parse-time, so we don't have to worry about them here. This simplifies the user code quite a bit.
2025-02-05 12:55:02 +00:00
BoxSizing box_sizing() const;
PointerEvents pointer_events() const;
LibWeb/CSS: Remove redundant CSS:: namespaces from ComputedProperties We're already in the CSS namespace, so let's remove the clutter.
2025-02-05 12:57:41 +00:00
Variant<VerticalAlign, LengthPercentage> vertical_align() const;
LibWeb: Style font-variant-* css properties
2024-12-05 01:19:03 +01:00
Optional<Gfx::FontVariantAlternates> font_variant_alternates() const;
LibWeb/CSS: Stop returning Optional for enum properties While keyword_to_foo() does return Optional<Foo>, in practice the invalid keywords get rejected at parse-time, so we don't have to worry about them here. This simplifies the user code quite a bit.
2025-02-05 12:55:02 +00:00
FontVariantCaps font_variant_caps() const;
LibWeb: Style font-variant-* css properties
2024-12-05 01:19:03 +01:00
Optional<Gfx::FontVariantEastAsian> font_variant_east_asian() const;
LibWeb/CSS: Stop returning Optional for enum properties While keyword_to_foo() does return Optional<Foo>, in practice the invalid keywords get rejected at parse-time, so we don't have to worry about them here. This simplifies the user code quite a bit.
2025-02-05 12:55:02 +00:00
FontVariantEmoji font_variant_emoji() const;
LibWeb: Style font-variant-* css properties
2024-12-05 01:19:03 +01:00
Optional<Gfx::FontVariantLigatures> font_variant_ligatures() const;
Optional<Gfx::FontVariantNumeric> font_variant_numeric() const;
LibWeb/CSS: Stop returning Optional for enum properties While keyword_to_foo() does return Optional<Foo>, in practice the invalid keywords get rejected at parse-time, so we don't have to worry about them here. This simplifies the user code quite a bit.
2025-02-05 12:55:02 +00:00
FontVariantPosition font_variant_position() const;
LibWeb/CSS: Implement the `font-kerning` property This sets whether the kerning information stored on the current font is used.
2025-06-22 18:59:42 +01:00
FontKerning font_kerning() const;
LibWeb/CSS: Parse and propagate the font-language-override property
2024-09-27 17:11:05 +01:00
Optional<FlyString> font_language_override() const;
LibWeb/CSS: Parse and propagate font-feature-settings property
2024-10-01 09:37:43 +01:00
Optional<HashMap<FlyString, IntegerOrCalculated>> font_feature_settings() const;
LibWeb/CSS: Parse and propagate font-variation-settings property
2024-10-01 09:20:06 +01:00
Optional<HashMap<FlyString, NumberOrCalculated>> font_variation_settings() const;
LibWeb/CSS: Remove redundant CSS:: namespaces from ComputedProperties We're already in the CSS namespace, so let's remove the clutter.
2025-02-05 12:57:41 +00:00
GridTrackSizeList grid_auto_columns() const;
GridTrackSizeList grid_auto_rows() const;
GridTrackSizeList grid_template_columns() const;
GridTrackSizeList grid_template_rows() const;
[[nodiscard]] GridAutoFlow grid_auto_flow() const;
GridTrackPlacement grid_column_end() const;
GridTrackPlacement grid_column_start() const;
GridTrackPlacement grid_row_end() const;
GridTrackPlacement grid_row_start() const;
LibWeb/CSS: Stop returning Optional for enum properties While keyword_to_foo() does return Optional<Foo>, in practice the invalid keywords get rejected at parse-time, so we don't have to worry about them here. This simplifies the user code quite a bit.
2025-02-05 12:55:02 +00:00
BorderCollapse border_collapse() const;
LibWeb/CSS: Implement the `empty-cells` property This property sets whether table borders and backgrounds are painted if a given table cell has no visible content.
2025-06-18 12:28:18 +01:00
CSS::EmptyCells empty_cells() const;
LibWeb: Parse `grid-template-areas` CSS property
2023-01-16 18:17:05 +01:00
Vector<Vector<String>> grid_template_areas() const;
LibWeb/CSS: Stop returning Optional for enum properties While keyword_to_foo() does return Optional<Foo>, in practice the invalid keywords get rejected at parse-time, so we don't have to worry about them here. This simplifies the user code quite a bit.
2025-02-05 12:55:02 +00:00
ObjectFit object_fit() const;
LibWeb/CSS: Remove redundant CSS:: namespaces from ComputedProperties We're already in the CSS namespace, so let's remove the clutter.
2025-02-05 12:57:41 +00:00
ObjectPosition object_position() const;
LibWeb/CSS: Stop returning Optional for enum properties While keyword_to_foo() does return Optional<Foo>, in practice the invalid keywords get rejected at parse-time, so we don't have to worry about them here. This simplifies the user code quite a bit.
2025-02-05 12:55:02 +00:00
TableLayout table_layout() const;
Direction direction() const;
UnicodeBidi unicode_bidi() const;
WritingMode writing_mode() const;
UserSelect user_select() const;
Isolation isolation() const;
LibWeb: Parse and propagate touch-action CSS property Co-authored-by: Sam Atkins <sam@ladybird.org>
2025-03-16 18:44:49 -07:00
TouchActionData touch_action() const;
LibWeb/CSS: Remove redundant CSS:: namespaces from ComputedProperties We're already in the CSS namespace, so let's remove the clutter.
2025-02-05 12:57:41 +00:00
Containment contain() const;
LibWeb/CSS: Parse the container-type property This applies size, inline-size, and style containment in some cases. There are other WPT tests for that, but we seem to not implement enough of containment for this to have an effect so I've not imported those. Gets us 35 WPT subtests.
2025-09-30 14:48:55 +01:00
ContainerType container_type() const;
LibWeb/CSS: Stop returning Optional for enum properties While keyword_to_foo() does return Optional<Foo>, in practice the invalid keywords get rejected at parse-time, so we don't have to worry about them here. This simplifies the user code quite a bit.
2025-02-05 12:55:02 +00:00
MixBlendMode mix_blend_mode() const;
LibWeb: Add CSS view-transition-name
2025-02-21 17:56:24 +01:00
Optional<FlyString> view_transition_name() const;
LibHTML: Get rid of the style tree We now create a layout tree directly from the DOM tree. This way we don't actually lose text nodes ^)
2019-09-21 15:32:17 +03:00
LibWeb: Position absolute block-level boxes below previous siblings Whether an absbox is positioned below or to the right of its previous sibling in an `InlineFormattingContext` is determined by the display-outside value before blockification, so we store the pre-blockification `display` value in `ComputedValues` to access it in `InlineFormattingContext` and position the box accordingly.
2025-09-09 00:35:59 +02:00
Display display_before_box_type_transformation() const;
void set_display_before_box_type_transformation(Display value);
LibWeb: Move and rename CSSStyleValue to StyleValues/StyleValue.{h,cpp} This reverts 0e3487b9ab455a7648185995363bb3b487551d40. Back when I made that change, I thought we could make our StyleValue classes match the typed-om definitions directly. However, they have different requirements. Typed-om types need to be mutable and GCed, whereas StyleValues are immutable and ideally wouldn't require a JS VM. While I was already making such a cataclysmic change, I've moved it into the StyleValues directory, because it *not* being there has bothered me for a long time. 😅
2025-08-08 10:11:51 +01:00
static Vector<Transformation> transformations_for_style_value(StyleValue const& value);
LibWeb/CSS: Remove redundant CSS:: namespaces from ComputedProperties We're already in the CSS namespace, so let's remove the clutter.
2025-02-05 12:57:41 +00:00
Vector<Transformation> transformations() const;
LibWeb/CSS: Stop returning Optional for enum properties While keyword_to_foo() does return Optional<Foo>, in practice the invalid keywords get rejected at parse-time, so we don't have to worry about them here. This simplifies the user code quite a bit.
2025-02-05 12:55:02 +00:00
TransformBox transform_box() const;
LibWeb/CSS: Remove redundant CSS:: namespaces from ComputedProperties We're already in the CSS namespace, so let's remove the clutter.
2025-02-05 12:57:41 +00:00
TransformOrigin transform_origin() const;
Optional<Transformation> rotate() const;
Optional<Transformation> translate() const;
Optional<Transformation> scale() const;
LibWeb: Add transform property to the system This patch adds parsing support as well as all the needed stuctures all over LibWeb to pass Transformations around.
2021-09-18 17:20:00 +02:00
LibWeb/CSS: Stop returning Optional for enum properties While keyword_to_foo() does return Optional<Foo>, in practice the invalid keywords get rejected at parse-time, so we don't have to worry about them here. This simplifies the user code quite a bit.
2025-02-05 12:55:02 +00:00
MaskType mask_type() const;
LibWeb: Implement SVG opacity properties This implements the stop-opacity, fill-opacity, and stroke-opacity properties (in CSS). This replaces the existing more ad-hoc fill-opacity attribute handling.
2023-05-19 20:35:39 +01:00
float stop_opacity() const;
float fill_opacity() const;
LibWeb/CSS: Stop returning Optional for enum properties While keyword_to_foo() does return Optional<Foo>, in practice the invalid keywords get rejected at parse-time, so we don't have to worry about them here. This simplifies the user code quite a bit.
2025-02-05 12:55:02 +00:00
StrokeLinecap stroke_linecap() const;
StrokeLinejoin stroke_linejoin() const;
LibWeb: Parse stroke-{linejoin,miterlimit} attributes Similar to LadybirdBrowser/ladybird#1714. We don't implement the linejoin values `miter-clip` and `arcs`, because according to the SVG 2 spec: > The values miter-clip and arcs of the stroke-linejoin property are at > risk. There are no known browser implementations. See issue Github > issue w3c/svgwg#592. Nothing uses this yet. The next step is to change SVGPathPaintable::paint() to read `graphics_element.stroke_linejoin()` and `graphics_element.stroke_miterlimit()` when painting.
2024-10-28 20:51:16 -04:00
NumberOrCalculated stroke_miterlimit() const;
LibWeb: Implement SVG opacity properties This implements the stop-opacity, fill-opacity, and stroke-opacity properties (in CSS). This replaces the existing more ad-hoc fill-opacity attribute handling.
2023-05-19 20:35:39 +01:00
float stroke_opacity() const;
LibWeb/CSS: Stop returning Optional for enum properties While keyword_to_foo() does return Optional<Foo>, in practice the invalid keywords get rejected at parse-time, so we don't have to worry about them here. This simplifies the user code quite a bit.
2025-02-05 12:55:02 +00:00
FillRule fill_rule() const;
ClipRule clip_rule() const;
LibWeb/SVG: Add FEFloodElement
2025-07-06 21:48:55 +02:00
float flood_opacity() const;
LibWeb: Parse the `shape-rendering` property
2025-08-16 17:48:30 +01:00
CSS::ShapeRendering shape_rendering() const;
LibWeb/CSS: Parse the `paint-order` property
2025-08-24 15:00:53 +01:00
PaintOrderList paint_order() const;
LibWeb: Add stop-color as a CSS property (This is to set the color of a stop for an SVG gradient)
2023-04-19 18:51:00 +01:00
LibWeb: Parse the `will-change` property This property provides a hint to the rendering engine about properties that are likely to change in the near future, allowing for early optimizations to be applied.
2025-08-16 08:39:18 +01:00
WillChange will_change() const;
LibGfx+LibWeb: Produce font cascade list in CSS font matching algorithm According to the CSS font matching algorithm specification, it is supposed to be executed for each glyph instead of each text run, as is currently done. This change partially implements this by having the font matching algorithm produce a list of fonts against which each glyph will be tested to find its suitable font. Now, it becomes possible to have per-glyph fallback fonts: if the needed glyph is not present in a font, we can check the subsequent fonts in the list.
2023-12-09 23:42:02 +01:00
Gfx::FontCascadeList const& computed_font_list() const
LibWeb: Start absolutizing lengths after performing the CSS cascade Once we've performed the cascade on a set of values for an element, we should have enough information to resolve/absolutize some lengths. Basically, any CSS length that isn't "auto" or a percentage can be turned into an absolute length (in pixels) as long as we have the following information: - The viewport rect - The parent element's font - The document element's font - The element's own font To ensure that we can absolutize lengths relative to the element's own font, we now do a separate first pass where font-related properties are defaulted (in the cascade spec sense of the word) and become usable. There's a lot more work to do here, but this should open up a lot of simplification in layout code, since it will no longer need to care about relative lengths. Layout still needs to resolve percentages, since we can't do that for some properties until the containing block dimensions are known.
2021-09-23 13:13:51 +02:00
{
LibWeb: Make CSS::ComputedProperties GC-allocated
2024-12-20 16:35:12 +01:00
VERIFY(m_font_list);
return *m_font_list;
LibWeb: Start absolutizing lengths after performing the CSS cascade Once we've performed the cascade on a set of values for an element, we should have enough information to resolve/absolutize some lengths. Basically, any CSS length that isn't "auto" or a percentage can be turned into an absolute length (in pixels) as long as we have the following information: - The viewport rect - The parent element's font - The document element's font - The element's own font To ensure that we can absolutize lengths relative to the element's own font, we now do a separate first pass where font-related properties are defaulted (in the cascade spec sense of the word) and become usable. There's a lot more work to do here, but this should open up a lot of simplification in layout code, since it will no longer need to care about relative lengths. Layout still needs to resolve percentages, since we can't do that for some properties until the containing block dimensions are known.
2021-09-23 13:13:51 +02:00
}
LibWeb: Use font with space in range for first_available_computed_font
2025-03-16 21:30:19 +01:00
Gfx::Font const& first_available_computed_font() const
{
VERIFY(m_first_available_computed_font);
return *m_first_available_computed_font;
}
LibGfx+LibWeb: Store Typeface and Font-related types in RefPtr to const
2025-04-15 15:48:14 -06:00
void set_computed_font_list(NonnullRefPtr<Gfx::FontCascadeList const> font_list)
LibWeb: Start absolutizing lengths after performing the CSS cascade Once we've performed the cascade on a set of values for an element, we should have enough information to resolve/absolutize some lengths. Basically, any CSS length that isn't "auto" or a percentage can be turned into an absolute length (in pixels) as long as we have the following information: - The viewport rect - The parent element's font - The document element's font - The element's own font To ensure that we can absolutize lengths relative to the element's own font, we now do a separate first pass where font-related properties are defaulted (in the cascade spec sense of the word) and become usable. There's a lot more work to do here, but this should open up a lot of simplification in layout code, since it will no longer need to care about relative lengths. Layout still needs to resolve percentages, since we can't do that for some properties until the containing block dimensions are known.
2021-09-23 13:13:51 +02:00
{
LibWeb: Make CSS::ComputedProperties GC-allocated
2024-12-20 16:35:12 +01:00
m_font_list = move(font_list);
LibWeb: Use font with space in range for first_available_computed_font
2025-03-16 21:30:19 +01:00
// https://drafts.csswg.org/css-fonts/#first-available-font
// First font for which the character U+0020 (space) is not excluded by a unicode-range
m_first_available_computed_font = m_font_list->font_for_code_point(' ');
LibWeb: Start absolutizing lengths after performing the CSS cascade Once we've performed the cascade on a set of values for an element, we should have enough information to resolve/absolutize some lengths. Basically, any CSS length that isn't "auto" or a percentage can be turned into an absolute length (in pixels) as long as we have the following information: - The viewport rect - The parent element's font - The document element's font - The element's own font To ensure that we can absolutize lengths relative to the element's own font, we now do a separate first pass where font-related properties are defaulted (in the cascade spec sense of the word) and become usable. There's a lot more work to do here, but this should open up a lot of simplification in layout code, since it will no longer need to care about relative lengths. Layout still needs to resolve percentages, since we can't do that for some properties until the containing block dimensions are known.
2021-09-23 13:13:51 +02:00
}
LibWeb: Store `line-height` in ComputedProperties in computed form We now fail a few more tests in properties-value-inherit-001.txt as we no longer overwrite the non-animated value of `line-height` with the animated value, this is in line with other major browsers.
2025-09-23 20:53:07 +12:00
[[nodiscard]] CSSPixels line_height() const;
LibWeb: Don't store separate computed value for font_size The StyleValue stored in m_property_values is already in it's computed form and it's trivial to pull the underlying value out so there is no need to store this separately. Also removes unnecessary handling of percentage values in `absolutize_values` - this is already handled within `compute_font`.
2025-08-25 13:20:20 +12:00
[[nodiscard]] CSSPixels font_size() const;
LibWeb: Store font-weight in ComputedProperties in computed form We now also more closely follow the spec when computing values for font-weight and we now: - Support relative lengths in `calc()`s - Properly clamp `calc()`s - Support relative keywords (e.g. lighter, bolder) - Respect that font-weight can be a non-integer number. This does expose a few false positives in the font-weight-computed.html WPT test. This is because we don't recompute non-inherited font-weight within `recompute_inherited_style` which means that relative keyword values can fall out of sync with their parent's value. These previously passed as we treated `bolder` and `lighter` as aliases for `bold` and `normal` respectively.
2025-09-02 01:14:06 +12:00
double font_weight() const;
LibWeb: Store font-width in ComputedProperties in computed form
2025-09-02 20:43:10 +12:00
Percentage font_width() const;
LibWeb: Store font-style in ComputedProperties in computed form
2025-09-03 18:57:32 +12:00
int font_slope() const;
LibHTML: Add StyleProperties::line_height() We currently hard-code the line height to 140% of the font glyph height and this patch doesn't fix the hard-coding, but at least moves it out of LayoutText and into StyleProperties where it can be re-used until the day we go and do a proper implementation of CSS line-height. :^)
2019-10-12 13:42:58 +02:00
LibWeb: Rename CSS::StyleProperties => CSS::ComputedProperties Now that StyleProperties is only used to hold computed properties, let's name it ComputedProperties.
2024-12-20 11:32:17 +01:00
bool operator==(ComputedProperties const&) 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/CSS: Stop returning Optional for enum properties While keyword_to_foo() does return Optional<Foo>, in practice the invalid keywords get rejected at parse-time, so we don't have to worry about them here. This simplifies the user code quite a bit.
2025-02-05 12:55:02 +00:00
Positioning position() const;
LibWeb: Respect CSS z-index property while painting To support z-ordering when painting, the layout tree now has a parallel sparse tree of stacking contexts. The rules for which layout boxes establish a stacking context are a bit complex, but the intent is to encapsulate the decision making into establishes_stacking_context(). When we paint, we start from the ICB (LayoutDocument) who always has a StackingContext and then paint the tree of StackingContexts where each node has its children sorted by z-index. This is pretty crude, but gets the basic job done. Note that this does not yet support hit testing; hit testing is still done using a naive treewalk from the root.
2020-06-15 17:29:35 +02:00
Optional<int> z_index() const;
LibWeb: CSS: Add "position: absolute" with top and left This momentarily handles the CSS property "position: absolute;" in combination with the properties "top" and "left", so that elements can be placed anywhere on the page independently from their parents. Statically positioned elements ignore absolute positioned elements when calculating their position as they don't take up space.
2020-03-23 17:29:15 +01:00
LibWeb: Implement the `math-depth` CSS property This one is a bit fun because it can be `add(<integer>)` or `auto-add`, but children have to inherit the computed value not the specified one. We also have to compute it before computing the font-size, because of `font-size: math` which will be implemented later.
2023-09-07 15:29:54 +01:00
void set_math_depth(int math_depth);
LibWeb: Make CSS::ComputedProperties GC-allocated
2024-12-20 16:35:12 +01:00
int math_depth() const { return m_math_depth; }
LibWeb: Implement the `math-depth` CSS property This one is a bit fun because it can be `add(<integer>)` or `auto-add`, but children have to inherit the computed value not the specified one. We also have to compute it before computing the font-size, because of `font-size: math` which will be implemented later.
2023-09-07 15:29:54 +01:00
LibWeb: Parse and compute CSS `quotes` property
2023-09-12 11:34:26 +01:00
QuotesData quotes() const;
LibWeb: Implement counter-[increment,reset,set] properties These control the state of CSS counters. Parsing code for `reversed(counter-name)` is implemented, but disabled for now until we are able to resolve values for those.
2024-07-24 15:47:11 +01:00
Vector<CounterData> counter_data(PropertyID) const;
LibWeb: Parse and compute CSS `quotes` property
2023-09-12 11:34:26 +01:00
LibWeb/CSS: Implement the `scrollbar-color` property This allows the user to set the scrollbar thumb and track colors.
2025-05-26 22:36:12 +01:00
ScrollbarColorData scrollbar_color(Layout::NodeWithStyle const& layout_node) const;
LibWeb/CSS: Stop returning Optional for enum properties While keyword_to_foo() does return Optional<Foo>, in practice the invalid keywords get rejected at parse-time, so we don't have to worry about them here. This simplifies the user code quite a bit.
2025-02-05 12:55:02 +00:00
ScrollbarWidth scrollbar_width() const;
LibWeb: Parse the CSS scrollbar-width property
2024-02-27 09:37:18 +01:00
LibWeb+LibWebView: Allow to specify default font size in FontPlugin Instead of always assuming 12pt size for default font, explicitly pass it as a parameter.
2025-01-02 03:56:05 +03:00
static NonnullRefPtr<Gfx::Font const> font_fallback(bool monospace, bool bold, float point_size);
LibWeb: Start absolutizing lengths after performing the CSS cascade Once we've performed the cascade on a set of values for an element, we should have enough information to resolve/absolutize some lengths. Basically, any CSS length that isn't "auto" or a percentage can be turned into an absolute length (in pixels) as long as we have the following information: - The viewport rect - The parent element's font - The document element's font - The element's own font To ensure that we can absolutize lengths relative to the element's own font, we now do a separate first pass where font-related properties are defaulted (in the cascade spec sense of the word) and become usable. There's a lot more work to do here, but this should open up a lot of simplification in layout code, since it will no longer need to care about relative lengths. Layout still needs to resolve percentages, since we can't do that for some properties until the containing block dimensions are known.
2021-09-23 13:13:51 +02:00
LibWeb: Make :hover invalidation logic reusable for all pseudo classes We achieve this by keeping track of all checked pseudo class selectors in the SelectorEngine code. We also give StyleComputer per-pseudo-class rule caches.
2025-04-17 13:39:30 +02:00
bool has_attempted_match_against_pseudo_class(PseudoClass pseudo_class) const
{
return m_attempted_pseudo_class_matches.get(pseudo_class);
}
void set_attempted_pseudo_class_matches(PseudoClassBitmap const& results)
{
m_attempted_pseudo_class_matches = results;
}
LibWeb: Optimize :hover style invalidation Instead of recalculating styles for all nodes in the common ancestor of the new and old hovered nodes' subtrees, this change introduces the following approach: - While calculating ComputedProperties, a flag is saved if any rule applied to an element is affected by the hover state during the execution of SelectorEngine::matches(). - When the hovered element changes, styles are marked for recalculation only if the flag saved in ComputedProperties indicates that the element could be affected by the hover state.
2025-01-03 20:39:25 +03:00
LibHTML: Get rid of the style tree We now create a layout tree directly from the DOM tree. This way we don't actually lose text nodes ^)
2019-09-21 15:32:17 +03:00
private:
LibWeb: Make CSS::ComputedProperties GC-allocated
2024-12-20 16:35:12 +01:00
ComputedProperties();
virtual void visit_edges(Visitor&) override;
LibWeb/CSS: Remove redundant CSS:: namespaces from ComputedProperties We're already in the CSS namespace, so let's remove the clutter.
2025-02-05 12:57:41 +00:00
Overflow overflow(PropertyID) const;
Vector<ShadowData> shadow(PropertyID, Layout::Node const&) const;
LibHTML: Move font loading from LayoutText to StyleProperties Since LayoutText inherits all of its style information from its parent Element anyway, it makes more sense to load the font at a higher level. And since the font depends only on the style and nothing else, this patch moves font loading (and caching) into StyleProperties. This could be made a lot smarter to avoid loading the same font many times, etc.
2019-10-06 11:23:58 +02:00
LibWeb/CSS: Remove redundant CSS:: namespaces from ComputedProperties We're already in the CSS namespace, so let's remove the clutter.
2025-02-05 12:57:41 +00:00
GC::Ptr<CSSStyleDeclaration const> m_animation_name_source;
GC::Ptr<CSSStyleDeclaration const> m_transition_property_source;
LibWeb: Make CSS::ComputedProperties GC-allocated
2024-12-20 16:35:12 +01:00
LibWeb: Don't allocate space for shorthands in ComputedProperties Only longhands have computed values so allocating space for shorthands is just wasted memory
2025-08-25 16:04:32 +12:00
Array<RefPtr<StyleValue const>, number_of_longhand_properties> m_property_values;
Array<u8, ceil_div(number_of_longhand_properties, 8uz)> m_property_important {};
Array<u8, ceil_div(number_of_longhand_properties, 8uz)> m_property_inherited {};
Array<u8, ceil_div(number_of_longhand_properties, 8uz)> m_animated_property_inherited {};
LibWeb: Make CSS::ComputedProperties GC-allocated
2024-12-20 16:35:12 +01:00
LibWeb: Move and rename CSSStyleValue to StyleValues/StyleValue.{h,cpp} This reverts 0e3487b9ab455a7648185995363bb3b487551d40. Back when I made that change, I thought we could make our StyleValue classes match the typed-om definitions directly. However, they have different requirements. Typed-om types need to be mutable and GCed, whereas StyleValues are immutable and ideally wouldn't require a JS VM. While I was already making such a cataclysmic change, I've moved it into the StyleValues directory, because it *not* being there has bothered me for a long time. 😅
2025-08-08 10:11:51 +01:00
HashMap<PropertyID, NonnullRefPtr<StyleValue const>> m_animated_property_values;
LibWeb: Make CSS::ComputedProperties GC-allocated
2024-12-20 16:35:12 +01:00
LibWeb: Position absolute block-level boxes below previous siblings Whether an absbox is positioned below or to the right of its previous sibling in an `InlineFormattingContext` is determined by the display-outside value before blockification, so we store the pre-blockification `display` value in `ComputedValues` to access it in `InlineFormattingContext` and position the box accordingly.
2025-09-09 00:35:59 +02:00
Display m_display_before_box_type_transformation { InitialValues::display() };
LibWeb: Make CSS::ComputedProperties GC-allocated
2024-12-20 16:35:12 +01:00
int m_math_depth { InitialValues::math_depth() };
LibGfx+LibWeb: Store Typeface and Font-related types in RefPtr to const
2025-04-15 15:48:14 -06:00
RefPtr<Gfx::FontCascadeList const> m_font_list;
RefPtr<Gfx::Font const> m_first_available_computed_font;
LibWeb: Make CSS::ComputedProperties GC-allocated
2024-12-20 16:35:12 +01:00
Optional<CSSPixels> m_line_height;
LibWeb: Optimize :hover style invalidation Instead of recalculating styles for all nodes in the common ancestor of the new and old hovered nodes' subtrees, this change introduces the following approach: - While calculating ComputedProperties, a flag is saved if any rule applied to an element is affected by the hover state during the execution of SelectorEngine::matches(). - When the hovered element changes, styles are marked for recalculation only if the flag saved in ComputedProperties indicates that the element could be affected by the hover state.
2025-01-03 20:39:25 +03:00
LibWeb: Make :hover invalidation logic reusable for all pseudo classes We achieve this by keeping track of all checked pseudo class selectors in the SelectorEngine code. We also give StyleComputer per-pseudo-class rule caches.
2025-04-17 13:39:30 +02:00
PseudoClassBitmap m_attempted_pseudo_class_matches;
LibHTML: Get rid of the style tree We now create a layout tree directly from the DOM tree. This way we don't actually lose text nodes ^)
2019-09-21 15:32:17 +03:00
};
LibWeb: Move everything into the Web namespace
2020-03-07 10:27:02 +01:00
}
Reference in a new issue Copy permalink