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

235 lines
10 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: Only remember source CSSStyleDeclaration for animation-name We were saving to source declarations for *every* property, even though we only ever looked it up for animation-name. This patch gets rid of the per-property source pointer and we now keep a single pointer to the animation-name source only. This shrinks StyleProperties from 6512 bytes to 4368 bytes per instance.
2024-08-02 11:58:56 +02:00
* Copyright (c) 2018-2024, Andreas Kling <andreas@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>
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: Fix some GCVerifier warnings
2024-04-05 13:47:48 -07:00
#include <LibJS/Heap/GCPtr.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: 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>
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: Remove reference counting for `CSS::StyleProperties` `AK::CopyOnWrite` already does reference counting, so there is no need to do it again.
2024-10-26 17:42:27 +02:00
class StyleProperties {
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:
static constexpr size_t number_of_properties = to_underlying(CSS::last_property_id) + 1;
private:
struct Data : public RefCounted<Data> {
friend class StyleComputer;
NonnullRefPtr<Data> clone() const;
LibWeb: Parse transition values and cache them on Animatable elements Co-authored-by: Matthew Olsson <matthewcolsson@gmail.com>
2024-09-19 14:14:13 +01:00
// FIXME: These need protection from GC!
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
JS::GCPtr<CSS::CSSStyleDeclaration const> m_animation_name_source;
LibWeb: Parse transition values and cache them on Animatable elements Co-authored-by: Matthew Olsson <matthewcolsson@gmail.com>
2024-09-19 14:14:13 +01:00
JS::GCPtr<CSS::CSSStyleDeclaration const> m_transition_property_source;
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
Array<RefPtr<CSSStyleValue const>, number_of_properties> m_property_values;
Array<u8, ceil_div(number_of_properties, 8uz)> m_property_important {};
Array<u8, ceil_div(number_of_properties, 8uz)> m_property_inherited {};
HashMap<CSS::PropertyID, NonnullRefPtr<CSSStyleValue const>> m_animated_property_values;
int m_math_depth { InitialValues::math_depth() };
mutable RefPtr<Gfx::FontCascadeList> m_font_list;
Optional<CSSPixels> m_line_height;
};
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
public:
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
StyleProperties() = default;
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::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
for (size_t i = 0; i < m_data->m_property_values.size(); ++i) {
if (m_data->m_property_values[i])
callback((CSS::PropertyID)i, *m_data->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: 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
HashMap<CSS::PropertyID, NonnullRefPtr<CSSStyleValue const>> const& animated_property_values() const { return m_data->m_animated_property_values; }
LibWeb: Add fast path for animated style properties update Patch up existing style properties instead of using the regular style invalidation path, which requires rule matching for each element in the invalidated subtree. - !important properties: this change introduces a flag used to skip the update of animated properties overridden by !important. - inherited animated properties: for now, these are invalidated by traversing animated element's subtree to propagate the update. - StyleProperties has a separate array for animated properties that allows the removal animated properties after animation has ended, without requiring full style invalidation.
2024-03-16 07:44:48 +01:00
void reset_animated_properties();
bool is_property_important(CSS::PropertyID property_id) const;
bool is_property_inherited(CSS::PropertyID property_id) const;
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
void set_property_important(CSS::PropertyID, Important);
void set_property_inherited(CSS::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: 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
void set_property(CSS::PropertyID, NonnullRefPtr<CSSStyleValue const> value, Inherited = Inherited::No, Important = Important::No);
void set_animated_property(CSS::PropertyID, NonnullRefPtr<CSSStyleValue const> value);
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,
};
NonnullRefPtr<CSSStyleValue const> property(CSS::PropertyID, WithAnimationsApplied = WithAnimationsApplied::Yes) const;
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> maybe_null_property(CSS::PropertyID) const;
LibWeb: Don't crash on CSS `all: revert` Not every value in a StyleProperties will be non-null by the time we perform `revert`, so let's make a specialized function for reverting a property instead of using the path that requires the value to be non-null.
2024-08-04 10:08:28 +02:00
void revert_property(CSS::PropertyID, StyleProperties const& style_for_revert);
LibWeb: Only remember source CSSStyleDeclaration for animation-name We were saving to source declarations for *every* property, even though we only ever looked it up for animation-name. This patch gets rid of the per-property source pointer and we now keep a single pointer to the animation-name source only. This shrinks StyleProperties from 6512 bytes to 4368 bytes per instance.
2024-08-02 11:58:56 +02:00
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
JS::GCPtr<CSS::CSSStyleDeclaration const> animation_name_source() const { return m_data->m_animation_name_source; }
void set_animation_name_source(JS::GCPtr<CSS::CSSStyleDeclaration const> declaration) { m_data->m_animation_name_source = declaration; }
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: Parse transition values and cache them on Animatable elements Co-authored-by: Matthew Olsson <matthewcolsson@gmail.com>
2024-09-19 14:14:13 +01:00
JS::GCPtr<CSS::CSSStyleDeclaration const> transition_property_source() const { return m_data->m_transition_property_source; }
void set_transition_property_source(JS::GCPtr<CSS::CSSStyleDeclaration const> declaration) { m_data->m_transition_property_source = declaration; }
LibWeb: Teach CSS::StyleProperties to create CSS::Size values You can now use StyleProperties::size_value(CSS::PropertyID) to extract a CSS::Size for a given property.
2022-09-25 15:47:40 +02:00
CSS::Size size_value(CSS::PropertyID) const;
LibWeb: Convert width/height and min-/max- versions to LengthPercentage A lot of this is quite ugly, but it should only be so until I remove Length::Type::Percentage entirely. (Which should happen later in this PR, otherwise, yell at me!) For now, a lot of things have to be resolved twice, first from a LengthPercentage to a Length, and then from a Length to a pixel one.
2022-01-19 16:19:43 +00:00
LengthPercentage length_percentage_or_fallback(CSS::PropertyID, LengthPercentage const& fallback) const;
LibWeb: Use Optional instead of undefined-lengths for widths/heights
2022-02-18 15:10:11 +00:00
Optional<LengthPercentage> length_percentage(CSS::PropertyID) const;
LibWeb: Oops, not all length boxes should default to 'auto' values Only the offset box (left/top/right/bottom) box defaults to 'auto'. Both the padding and margin boxes default to '0' for all values.
2020-12-15 20:01:00 +01:00
LengthBox length_box(CSS::PropertyID left_id, CSS::PropertyID top_id, CSS::PropertyID right_id, CSS::PropertyID bottom_id, const CSS::Length& default_value) const;
LibWeb: Make StyleValue::to_color() take a Node instead of the Document This is in preparation for the `currentcolor` value, which needs to know what Node it's on so it can check the `color`.
2021-09-16 19:20:20 +01:00
Color color_or_fallback(CSS::PropertyID, Layout::NodeWithStyle const&, Color fallback) const;
LibWeb: Add an initial implementation of SVG `text-anchor` This only handles very simple <text> elements, but this is enough (with the font-size changes) to improve the badges on the GitHub README a fair bit.
2023-07-19 19:12:00 +01:00
Optional<CSS::TextAnchor> text_anchor() const;
LibWeb: Use CSS::ValueID for 'text-align' values Let's start moving away from using raw strings for CSS identifiers. The idea here is to use IdentifierStyleValue with a CSS::ValueID inside for all CSS identifier values.
2020-12-14 18:38:02 +01:00
Optional<CSS::TextAlign> text_align() const;
LibWeb: Add support for the text-justify property This commit adds the text-justify property as defined in: https://drafts.csswg.org/css-text/#propdef-text-justify
2022-03-12 19:31:32 +00:00
Optional<CSS::TextJustify> text_justify() const;
LibWeb: Add plumbing for new "text-overflow" CSS property This patch adds the new "text-overflow" CSS property to all the relevant places.
2024-07-24 20:58:17 +02:00
Optional<CSS::TextOverflow> text_overflow() const;
LibWeb: Don't crash when encountering `border-spacing: calc(...)` This allows us to progress further on this WPT test: https://wpt.live/quirks/unitless-length/quirks.html ...although it still crashes before finishing.
2024-10-09 13:36:09 +02:00
CSS::Length border_spacing_horizontal(Layout::Node const&) const;
CSS::Length border_spacing_vertical(Layout::Node const&) const;
LibWeb: Add support for table caption Adds layout support and the CSS caption-side property.
2023-06-07 02:10:55 +00:00
Optional<CSS::CaptionSide> caption_side() const;
LibWeb: Use rect value in CSS clip property When a rect value is passed to the clip property via CSS, keep it in ComputedValues so that at a later stage can make use of it.
2022-07-31 18:47:09 +02:00
CSS::Clip clip() const;
LibWeb: Add CSS::Display enum and StyleProperties::display() The display property is not interesting after we've built the layout tree, so we don't have to move it into LayoutStyle.
2020-06-24 16:22:16 +02:00
CSS::Display display() const;
LibWeb: Add the 'float' CSS property to LayoutStyle Note that we don't use the property for anything yet, as I'm still wrapping my head around how to implement floats.
2020-06-26 15:08:42 +02:00
Optional<CSS::Float> float_() const;
LibWeb: Naively implement the CSS clear property This is definitely not fully-featured, but basically we now handle the clear property by forcing the cleared box below the bottom-most floated box on the relevant side.
2020-12-06 01:45:51 +01:00
Optional<CSS::Clear> clear() const;
LibWeb: Support parsing column-span
2024-08-20 20:23:55 -04:00
Optional<CSS::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 {
CSS::ContentData content_data;
u32 final_quote_nesting_level { 0 };
};
Last: LibWeb: Add counter() and counters() functions to content property These let you format counters' current values as strings for use in generated content.
2024-07-18 20:29:02 +01:00
ContentDataAndQuoteNestingLevel content(DOM::Element&, u32 initial_quote_nesting_level) const;
LibWeb: Support content-visibility css
2024-06-23 14:52:56 +02:00
Optional<CSS::ContentVisibility> content_visibility() const;
LibWeb: Parese the CSS "cursor" property
2021-02-21 17:41:00 +00:00
Optional<CSS::Cursor> cursor() const;
LibWeb/CSS: Parse the tab-size property
2024-10-01 13:07:06 +01:00
Variant<LengthOrCalculated, NumberOrCalculated> tab_size() const;
LibWeb: Move white-space into LayoutStyle
2020-06-24 16:37:44 +02:00
Optional<CSS::WhiteSpace> white_space() const;
LibWeb: Parse the word-break css property
2024-10-25 16:47:05 +01:00
Optional<CSS::WordBreak> word_break() const;
LibWeb: Apply the word-spacing css property to Node This will let us start to begin applying this during text shaping.
2024-10-18 21:00:28 +01:00
Optional<CSS::LengthOrCalculated> word_spacing() const;
LibWeb: Add letter-spacing css property to Node
2024-10-22 14:21:20 +01:00
Optional<LengthOrCalculated> letter_spacing() const;
LibWeb: Compute the final border-style property before painting Instead of doing a CSS property lookup for the line style of each border edge during paint, we now cache the final CSS::LineStyle to use in the Layout::BorderData.
2020-12-04 16:11:55 +01:00
Optional<CSS::LineStyle> line_style(CSS::PropertyID) const;
LibWeb: Implement the CSS `outline` property :^) ...along with `outline-color`, `outline-style`, and `outline-width`. This re-uses the existing border-painting code, which seems to work well enough! This replaces the previous code for drawing focus-outlines, with generic outline painting for any elements that want it. Focus outlines are now instead supported by this code in Default.css: ```css :focus-visible { outline: auto; } ```
2023-08-02 17:24:14 +01:00
Optional<CSS::OutlineStyle> outline_style() const;
LibWeb: Allow multiple text-decoration-lines The spec grammar for `text-decoration-line` is: `none | [ underline || overline || line-through || blink ]` Which means that it's either `none`, or any combination of the other values. This patch makes that parse for `text-decoration-line` and `text-decoration`, stores the results as a Vector, and adjusts `paint_text_decoration()` to run as a loop over all the values that are provided. As noted, storing a Vector of values is a bit wasteful, as they could be stored as flags in a single `u8`. But I was getting too confused trying to do that in a nice way.
2022-04-14 16:22:35 +01:00
Vector<CSS::TextDecorationLine> text_decoration_line() const;
LibWeb: Add new property 'text-decoration-style' This patch makes the property 'text-decoration-style' known throughout all the places in LibWeb that care.
2022-01-20 20:27:55 +01:00
Optional<CSS::TextDecorationStyle> text_decoration_style() const;
LibWeb: Use IdentifierStyleValue for CSS 'text-transform'
2020-12-15 14:15:49 +01:00
Optional<CSS::TextTransform> text_transform() const;
LibWeb: Support calc(...) in box-shadow's values of type Length The CSS box-shadow property takes 2-4 properties that are `<length>`s, those being: - offset-x - offset-y - blur-radius - spread-radius Previously these were resolved directly to concrete Lengths at parse time, but now they will be parsed as LengthStyleValues and/or CalculatedStyleValues and be stored that way until styles are later resolved.
2023-05-31 16:07:06 -04:00
Vector<CSS::ShadowData> text_shadow(Layout::Node const&) const;
LibWeb: Use IdentifierStyleValue for CSS 'list-style-type'
2020-12-15 16:50:39 +01:00
Optional<CSS::ListStyleType> list_style_type() const;
LibWeb: Support list-style-position This moves the ::marker inside of <summary> actually inside. :^)
2023-06-02 23:05:15 +02:00
Optional<CSS::ListStylePosition> list_style_position() const;
LibWeb: Parse the CSS "flex-direction" property
2021-01-18 17:41:57 +01:00
Optional<CSS::FlexDirection> flex_direction() const;
LibWeb: Add parsing for flex-wrap property
2021-05-30 12:11:32 +02:00
Optional<CSS::FlexWrap> flex_wrap() const;
LibWeb: Modernize handling of the CSS flex-basis property Instead of a custom struct, use an AK::Variant for flex-basis. A flex-basis is either `content` or a CSS size value, so we don't need anything custom for that. By using a CSS size, we also avoid having to convert in and out of size in various places, simplifying the code. This finally gets rid of the "Unsupported main size for flex-basis" debug spam. :^)
2023-06-21 19:39:07 +02:00
Optional<CSS::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: Parse the CSS align-content property
2022-10-14 13:50:06 +02:00
Optional<CSS::AlignContent> align_content() const;
LibWeb: Add proper parsing of the AlignItems property This teaches all the relevant places about 'align-items'.
2021-09-15 18:27:20 +02:00
Optional<CSS::AlignItems> align_items() const;
LibWeb: Honor `align-self` over `align-items` when non-auto on flex item
2022-07-11 23:52:36 +02:00
Optional<CSS::AlignSelf> align_self() const;
LibWeb: Implement `appearance` CSS property This includes the "compat" values even though they are not strictly necessary.
2022-07-22 16:05:11 +01:00
Optional<CSS::Appearance> appearance() const;
LibWeb: Parse and store `filter` property This shares its implementation with `backdrop-filter`.
2024-10-25 11:00:22 +02:00
CSS::Filter backdrop_filter() const;
CSS::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: Pick up the CSS "visibility" property an honor it when painting
2022-03-21 15:42:57 +01:00
Optional<CSS::Visibility> visibility() const;
LibWeb: Add support for CSS image-rendering property Currently only "auto" and "pixelated" values are supported.
2022-02-18 12:21:27 +01:00
Optional<CSS::ImageRendering> image_rendering() const;
LibWeb: Add parsing for the justify-content property
2021-07-16 18:38:26 +02:00
Optional<CSS::JustifyContent> justify_content() const;
LibWeb: Add support for justify-items property in CSS parser
2023-07-14 20:49:22 +02:00
Optional<CSS::JustifyItems> justify_items() const;
LibWeb: Add support for justify-self property in CSS parser
2023-07-14 14:41:22 +02:00
Optional<CSS::JustifySelf> justify_self() const;
LibWeb: Add parsing and application of CSS "overflow" property We don't actually do anything with the values yet, but now they are available for layout nodes once we are ready to implement them.
2021-02-22 15:20:31 +01:00
Optional<CSS::Overflow> overflow_x() const;
Optional<CSS::Overflow> overflow_y() const;
LibWeb: Support calc(...) in box-shadow's values of type Length The CSS box-shadow property takes 2-4 properties that are `<length>`s, those being: - offset-x - offset-y - blur-radius - spread-radius Previously these were resolved directly to concrete Lengths at parse time, but now they will be parsed as LengthStyleValues and/or CalculatedStyleValues and be stored that way until styles are later resolved.
2023-05-31 16:07:06 -04:00
Vector<CSS::ShadowData> box_shadow(Layout::Node const&) const;
LibWeb: Return Optional from StyleProperties::box_sizing() This function was written as if it returned `Optional<CSS::BoxSizing>` but actually returned a plain `CSS::BoxSizing`, meaning if the property was not set or was invalid, it would return whichever enum value was first. This wasn't visible because we don't yet pay any attention to the `box-sizing` property.
2022-04-13 19:33:56 +01:00
Optional<CSS::BoxSizing> box_sizing() const;
LibWeb: Add initial version of pointer-events CSS property
2021-10-05 19:47:13 +01:00
Optional<CSS::PointerEvents> pointer_events() const;
LibWeb: Add vertical-align to ComputedValues
2022-02-26 01:34:07 +01:00
Variant<CSS::VerticalAlign, CSS::LengthPercentage> vertical_align() const;
LibWeb: Parse CSS "font-variant" as part of "font" This allows us to parse CSS "font" values that contain e.g "small-caps" or "normal", as used on Acid3.
2022-03-23 14:54:21 +01:00
Optional<CSS::FontVariant> font_variant() 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: Implement parsing of grid-auto-columns and grid-auto-rows
2023-05-21 18:08:41 +03:00
CSS::GridTrackSizeList grid_auto_columns() const;
CSS::GridTrackSizeList grid_auto_rows() const;
LibWeb: Refactor GridTrackSize classes Refactor various classes in the GridTrackSize file for the incoming named_tracks feature. Previously the ExplicitTrackSizing had mixed responsiblities with the newly-named GridRepeat class. This made it so it was not possible to have multiple repeats within a single 'GridTrackSizeList' definition. The MetaGridTrackSize class had both the responsibilities of being a container for minmax values as well as for simple GridSizes. By uniting the different possible values (repeat, minmax, default) into the ExplicitGridTrack class are able to be more expressive as to the different grid size modalities. The GridTrackSizeList will be useful as compared to a Vector<ExplicitGridTrack> since this way can keep track of the declared line names. These same line names are able to be declared within the values of a repeat function, hence the presence of a GridTrackSizeList inside the GridRepeat class.
2022-10-30 13:27:57 +01:00
CSS::GridTrackSizeList grid_template_columns() const;
CSS::GridTrackSizeList grid_template_rows() const;
LibWeb: Add support for parsing `grid-auto-flow` CSS property Co-Authored-By: Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
2023-08-17 20:25:18 +02:00
[[nodiscard]] CSS::GridAutoFlow grid_auto_flow() const;
LibWeb: Parse grid-column-start and related CSS properties Parse grid-column-start, end, and the equivalent for rows.
2022-08-23 19:58:00 +02:00
CSS::GridTrackPlacement grid_column_end() const;
CSS::GridTrackPlacement grid_column_start() const;
CSS::GridTrackPlacement grid_row_end() const;
CSS::GridTrackPlacement grid_row_start() const;
LibWeb: Parse `border-collapse` property for HTML table
2023-01-02 23:01:29 +01:00
Optional<CSS::BorderCollapse> border_collapse() const;
LibWeb: Parse `grid-template-areas` CSS property
2023-01-16 18:17:05 +01:00
Vector<Vector<String>> grid_template_areas() const;
LibWeb: Add 'object-fit' property This patch adds support for the 'object-fit' CSS property. :^)
2023-08-01 20:06:50 +02:00
Optional<CSS::ObjectFit> object_fit() const;
LibWeb: Add "object-position" CSS property into ComputedValues
2024-02-26 11:33:54 +01:00
CSS::ObjectPosition object_position() const;
LibWeb: Add table-layout CSS property
2023-08-07 01:32:52 +00:00
Optional<CSS::TableLayout> table_layout() const;
LibWeb: Use reverse direction on flex containers with `rtl` direction If a flex container has `direction: rtl` set, reverse the row direction.
2024-08-10 23:13:26 +01:00
Optional<CSS::Direction> direction() const;
LibWeb/CSS: Add support for `unicode-bidi` property
2024-10-03 21:09:29 +02:00
Optional<CSS::UnicodeBidi> unicode_bidi() const;
LibWeb: Add `writing-mode` CSS property, and its values Introduce the `writing-mode` property, as specified in https://drafts.csswg.org/css-writing-modes/#block-flow
2024-10-27 22:12:54 +00:00
Optional<CSS::WritingMode> writing_mode() 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: 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
static Vector<CSS::Transformation> transformations_for_style_value(CSSStyleValue const& value);
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
Vector<CSS::Transformation> transformations() const;
LibWeb: Parse the CSS transform-box property
2024-01-25 17:02:37 +00:00
Optional<CSS::TransformBox> transform_box() const;
LibWeb: Apply the CSS transform-origin property We don't have transform-box yet, so this applies to the border-box for now. This also makes us pass a couple Web Platform Tests as well :^) For example: https://wpt.live/css/css-transforms/css3-transform-scale-002.html
2022-03-21 19:38:00 +01:00
CSS::TransformOrigin transform_origin() const;
LibWeb: Parse the rotate css property
2024-10-16 08:50:35 +02:00
Optional<CSS::Transformation> rotate(Layout::Node const&) 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: Implement `mask-type` CSS property This property allows specifying if a mask is an alpha or luminance mask. See: https://drafts.fxtf.org/css-masking/#the-mask-type
2023-10-08 11:06:34 +01:00
Optional<CSS::MaskType> mask_type() 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
Color stop_color() 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: Add stroke-linecap attribute and plumb it to SVGGraphicsElement SVGGraphicsElement then goes ahead and does nothing with it for now.
2024-10-10 10:15:49 -04:00
Optional<CSS::StrokeLinecap> stroke_linecap() 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
Optional<CSS::StrokeLinejoin> stroke_linejoin() const;
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: Implement SVG `fill-rule` attribute Previously, we did an evenodd fill for everything which while for most SVGs works, it is not correct default (it should be nonzero), and broke some SVGs. This fixes a few of the icons on https://shopify.com/.
2023-06-11 16:43:46 +01:00
Optional<CSS::FillRule> fill_rule() const;
LibWeb: Implement the SVG `clip-rule` attribute This controls the fill rule used when rasterizing `<clipPath>` elements.
2024-05-12 20:19:43 +01:00
Optional<CSS::ClipRule> clip_rule() 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: 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
Gfx::Font const& first_available_computed_font() const { return m_data->m_font_list->first(); }
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::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
VERIFY(m_data->m_font_list);
return *m_data->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
}
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
void set_computed_font_list(NonnullRefPtr<Gfx::FontCascadeList> 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::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
m_data->m_font_list = move(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: Bring CSS `line-height` closer to other engines This patch makes a few changes to the way we calculate line-height: - `line-height: normal` is now resolved using metrics from the used font (specifically, round(A + D + lineGap)). - `line-height: calc(...)` is now resolved at style compute time. - `line-height` values are now absolutized at style compute time. As a consequence of the above, we no longer need to walk the DOM ancestor chain looking for line-heights during style computation. Instead, values are inherited, resolved and absolutized locally. This is not only much faster, but also makes our line-height metrics match those of other engines like Gecko and Blink.
2024-01-12 12:39:40 +01:00
[[nodiscard]] CSSPixels compute_line_height(CSSPixelRect const& viewport_rect, Length::FontMetrics const& font_metrics, Length::FontMetrics const& root_font_metrics) const;
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
[[nodiscard]] CSSPixels line_height() const { return *m_data->m_line_height; }
void set_line_height(Badge<StyleComputer> const&, CSSPixels line_height) { m_data->m_line_height = line_height; }
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
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
bool operator==(StyleProperties 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: Rename "position" enum to "positioning" The postitioning enum values are used by the position CSS property. Unfortunately, the prior naming clashes with the CSS Values-4 type named position, which will be implemented in a later commit.
2023-10-27 15:17:36 +02:00
Optional<CSS::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::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
int math_depth() const { return m_data->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: Parse the CSS scrollbar-width property
2024-02-27 09:37:18 +01:00
Optional<CSS::ScrollbarWidth> scrollbar_width() const;
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
static NonnullRefPtr<Gfx::Font const> font_fallback(bool monospace, bool bold);
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: 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
static float resolve_opacity_value(CSSStyleValue const& value);
LibWeb: Add fast path to calculate invalidations for animated css props - Compare only the animated properties - Clone only the hash map containing animated properties, instead of the entire StyleProperties. Reduces `KeyframeEffect::update_style_properties()` from 10% to 3% in GitHub profiles.
2024-03-19 12:02:06 +01:00
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: Rename CSS::StyleResolver => StyleComputer Resolved style is a spec concept that refers to the weird mix of computed style and used style reflected by getComputedStyle(). The purpose of this class is to produce the *computed* style for a given element, so let's call it StyleComputer.
2021-09-24 13:49:57 +02:00
friend class StyleComputer;
LibWeb: Start implementing the CSS cascade The 'C' in "CSS" is for Cascade, so let's actually implement the cascade in LibWeb. :^) StyleResolver::resolve_style() now begins by collecting all the matching CSS rules for the given DOM::Element. Rules are then processed in the spec's cascade order (instead of in the order we encounter them.) With this, "!important" is now honored on CSS properties. After performing the cascade, we do another pass of what the spec calls "defaulting" where we resolve "inherit" and "initial" values. I've left a FIXME about supporting correct "initial" values for every property, since we're currently lacking some coverage there. Note that this mechanism now resolves every known CSS property. This is *not* space-efficient and we'll eventually need to come up with some strategies to reduce memory usage around this. However, this will do fine until we have more of the engine working correctly. :^)
2021-09-21 11:38:18 +02:00
LibWeb: Add parsing and application of CSS "overflow" property We don't actually do anything with the values yet, but now they are available for layout nodes once we are ready to implement them.
2021-02-22 15:20:31 +01:00
Optional<CSS::Overflow> overflow(CSS::PropertyID) const;
LibWeb: Support calc(...) in box-shadow's values of type Length The CSS box-shadow property takes 2-4 properties that are `<length>`s, those being: - offset-x - offset-y - blur-radius - spread-radius Previously these were resolved directly to concrete Lengths at parse time, but now they will be parsed as LengthStyleValues and/or CalculatedStyleValues and be stored that way until styles are later resolved.
2023-05-31 16:07:06 -04:00
Vector<CSS::ShadowData> shadow(CSS::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: 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
AK::CopyOnWrite<StyleProperties::Data> m_data;
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