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

177 lines
7.3 KiB
C
Raw Normal View History

Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 09:38:21 +01:00
/*
LibWeb+LibIDL: Fix (or paper over) various const-correctness issues There's definitely stuff to iterate on here, but this takes care of making the libraries compile with stricter RP and NNRP.
2023-02-20 18:56:08 +01:00
* Copyright (c) 2018-2023, Andreas Kling <kling@serenityos.org>
Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 09:38:21 +01:00
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 01:24:48 -07:00
* SPDX-License-Identifier: BSD-2-Clause
Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 09:38:21 +01:00
*/
LibHTML: 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: 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>
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
LibHTML: LayoutText should always use parent's style properties This patch makes StyleProperties heap-allocated and ref-counted so that a LayoutNode can be without one. The ref-counting also allows anonymous blocks to share style with their parent block. LayoutText never needs a StyleProperties, since text always inherits style from its parent element. This is handled by style_properties().
2019-10-04 12:12:39 +02:00
class StyleProperties : public RefCounted<StyleProperties> {
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
AK: Rename adopt() to adopt_ref() This makes it more symmetrical with adopt_own() (which is used to create a NonnullOwnPtr from the result of a naked new.)
2021-04-23 16:46:57 +02:00
static NonnullRefPtr<StyleProperties> create() { return adopt_ref(*new StyleProperties); }
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: 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
for (size_t i = 0; i < m_property_values.size(); ++i) {
LibWeb: Keep track of CSS property source declarations This allows us to figure out where a specific CSS property comes from, which is going to be used in a future commit to uniquely identify running animations.
2023-05-26 23:25:25 +03:30
if (m_property_values[i].has_value())
callback((CSS::PropertyID)i, *m_property_values[i]->style);
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: Implement the CSS `revert` keyword This is a universal value like `initial` and `inherit` and works by reverting the current value to whatever we had at the start of the current cascade origin. The implementation is somewhat inefficient as we make a copy of all current values at the start of each origin. I'm sure we can come up with a way to make this faster eventually.
2023-07-29 17:14:18 +02:00
struct StyleAndSourceDeclaration {
NonnullRefPtr<StyleValue const> style;
CSS::CSSStyleDeclaration const* declaration = nullptr;
};
using PropertyValues = Array<Optional<StyleAndSourceDeclaration>, to_underlying(CSS::last_property_id) + 1>;
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
auto& properties() { return m_property_values; }
auto const& properties() const { return m_property_values; }
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: Keep track of CSS property source declarations This allows us to figure out where a specific CSS property comes from, which is going to be used in a future commit to uniquely identify running animations.
2023-05-26 23:25:25 +03:30
void set_property(CSS::PropertyID, NonnullRefPtr<StyleValue const> value, CSS::CSSStyleDeclaration const* source_declaration = nullptr);
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
NonnullRefPtr<StyleValue const> property(CSS::PropertyID) const;
RefPtr<StyleValue const> maybe_null_property(CSS::PropertyID) const;
LibWeb: Keep track of CSS property source declarations This allows us to figure out where a specific CSS property comes from, which is going to be used in a future commit to uniquely identify running animations.
2023-05-26 23:25:25 +03:30
CSS::CSSStyleDeclaration const* property_source_declaration(CSS::PropertyID) 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: 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 CSS support for border-spacing property
2023-06-16 02:35:03 +00:00
CSS::Length border_spacing_horizontal() const;
CSS::Length border_spacing_vertical() 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: 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 };
};
ContentDataAndQuoteNestingLevel content(u32 initial_quote_nesting_level) const;
LibWeb: Parese the CSS "cursor" property
2021-02-21 17:41:00 +00:00
Optional<CSS::Cursor> cursor() const;
LibWeb: Move white-space into LayoutStyle
2020-06-24 16:37:44 +02:00
Optional<CSS::WhiteSpace> white_space() 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: Plumb style/computed values for `backdrop-filter`
2022-09-15 08:31:19 +01:00
CSS::BackdropFilter backdrop_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: 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: Parse `grid-area` CSS property
2023-01-16 19:02:39 +01:00
String grid_area() 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;
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 DOMMatrix string constructor and set matrix value
2024-01-06 18:05:21 +01:00
static Vector<CSS::Transformation> transformations_for_style_value(StyleValue 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: 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;
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: 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
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::Font const& first_available_computed_font() const { return m_font_list->first(); }
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
{
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
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
}
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
{
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
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;
[[nodiscard]] CSSPixels compute_line_height(Layout::Node const&) const;
[[nodiscard]] CSSPixels line_height() const { return *m_line_height; }
void set_line_height(Badge<StyleComputer> const&, CSSPixels line_height) { 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);
int math_depth() const { return m_math_depth; }
LibWeb: Parse and compute CSS `quotes` property
2023-09-12 11:34:26 +01:00
QuotesData quotes() 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
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: Implement the CSS `revert` keyword This is a universal value like `initial` and `inherit` and works by reverting the current value to whatever we had at the start of the current cascade origin. The implementation is somewhat inefficient as we make a copy of all current values at the start of each origin. I'm sure we can come up with a way to make this faster eventually.
2023-07-29 17:14:18 +02:00
PropertyValues m_property_values;
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: 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
int m_math_depth { InitialValues::math_depth() };
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
mutable RefPtr<Gfx::FontCascadeList> m_font_list;
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
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
};
LibWeb: Move everything into the Web namespace
2020-03-07 10:27:02 +01:00
}
Reference in a new issue Copy permalink