Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-10-31 05:10:57 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Libraries/LibWeb/CSS/StyleValues/StyleValue.cpp

155 lines
7.1 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: Parse CSS fit-content(<length-percentage>) values Before this change, we only parsed fit-content as a standalone keyword, but CSS-SIZING-3 added it as a function as well. I don't know of anything else in CSS that is overloaded like this, so it ends up looking a little awkward in the implementation. Note that a lot of code had already been prepped for fit-content values to have an argument, we just weren't parsing it.
2025-02-26 18:16:36 +01:00
* Copyright (c) 2018-2025, Andreas Kling <andreas@ladybird.org>
LibWeb/CSS: Implement CursorStyleValue A cursor is an image, with an optional x,y hotspot. We know that a CursorStyleValue's bitmap never needs to change size, so we create the ShareableBitmap once and then cache it, so that we don't have to repeatedly create an FD for it or do the work of painting. To avoid repainting that bitmap, we cache the values that were used to create it - what currentColor is and its length resolution context - and only repaint when those change.
2025-02-21 13:04:20 +00:00
* Copyright (c) 2021-2025, Sam Atkins <sam@ladybird.org>
LibWeb: Move calc()-resolution code from Length to CalculatedStyleValue The code is unchanged, just moved.
2022-01-24 17:38:29 +00:00
* Copyright (c) 2021, Tobias Christiansen <tobyase@serenityos.org>
LibWeb: Remove some unnecessary .release_value()s in StyleValue And instead propagate these errors. Also while here add my copyright (I've touched these files a lot)
2023-01-13 23:44:44 +00:00
* Copyright (c) 2022-2023, MacDue <macdue@dueutil.tech>
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
*/
LibWeb: Reduce number of recompiled files for display list headers This reduces the number of `.cpp` files that need to be recompiled when one of the below header files changes as follows: Painting/Command.h: 1030 -> 61 Painting/DisplayList.h: 1030 -> 60 Painting/DisplayListRecorder.h: 557 -> 59
2025-02-02 15:55:26 +01:00
#include <LibGfx/Font/Font.h>
LibWeb: Move resolution of font weights and slopes to StyleValue This isn't exactly ideal factoring (though I'm not sure what is) but this will make it possible to reuse this code in the parser.
2023-05-24 15:28:09 +02:00
#include <LibGfx/Font/FontStyleMapping.h>
LibGfx+Userland: Move FontWeight enum into its own file FontDatabase.h with its includes add up to quite a lot of code. In the next commit, compiled GML files are going to need to access the FontWeight enum, so let's allow them to do that without pulling in lots of other things. Also, change users to include FontWeight.h instead of FontDatabase.h where appropriate.
2024-01-16 14:53:44 +00:00
#include <LibGfx/Font/FontWeight.h>
LibWeb/CSS: Add ability to reify a StyleValue When no better reification form is available, we produce an opaque CSSStyleValue with a serialized value. For starters, this will be the only way to reify, and then we'll add others later.
2025-08-13 14:46:21 +01:00
#include <LibWeb/CSS/CSSStyleValue.h>
LibWeb/CSS: Add tokenize() method to style values, to get a list of CVs A couple of arbitrary substitution functions require us to get or produce some style value, and then substitute its ComponentValues into the original ComponentValue list. So this commit gives CSSStyleValue a tokenize() method that does so. Apart from a couple of unusual cases like the guaranteed-invalid value, style values can all be converted into ComponentValues by serializing them as a string, and then parsing that as a list of component values. That feels unnecessarily inefficient in most cases though, so I've implemented faster overrides for a lot of the basic style value classes, but left that serialize-and-reparse method as the fallback.
2025-07-10 12:17:27 +01:00
#include <LibWeb/CSS/Parser/Parser.h>
LibWeb: Split AbstractImageStyleValue out of StyleValue.{h,cpp}
2023-03-24 16:42:50 +00:00
#include <LibWeb/CSS/StyleValues/AbstractImageStyleValue.h>
LibWeb: Implement `anchor-size(..)` function parsing This parses `anchor-size(..)` functions in CSS, but does not yet result in a useful `Size`: we need style & layout interleaving similar to container queries for this, since the resulting value depends on layout results. Not supported yet: `anchor-size()` appearing inside a `calc()` node. Adds 4280 WPT subtest passes in `css/css-anchor-position`.
2025-07-30 14:14:53 +02:00
#include <LibWeb/CSS/StyleValues/AnchorSizeStyleValue.h>
LibWeb: Parse `anchor()` function for inset properties
2025-08-03 13:58:13 +01:00
#include <LibWeb/CSS/StyleValues/AnchorStyleValue.h>
LibWeb: Split AngleStyleValue out of StyleValue.{h,cpp}
2023-03-23 17:26:13 +00:00
#include <LibWeb/CSS/StyleValues/AngleStyleValue.h>
LibWeb: Split BackgroundSizeStyleValue out of StyleValue.{h,cpp}
2023-03-23 17:54:05 +00:00
#include <LibWeb/CSS/StyleValues/BackgroundSizeStyleValue.h>
LibWeb: Add `BasicShapeStyleValue` to represent CSS basic shapes See: https://www.w3.org/TR/css-shapes-1/#basic-shape-functions This patch only implements the `polygon()` basic shape (with the rest left as FIXMEs).
2024-05-25 23:06:47 +01:00
#include <LibWeb/CSS/StyleValues/BasicShapeStyleValue.h>
LibWeb: Parse the `border-image-slice` property
2025-06-10 16:58:54 +01:00
#include <LibWeb/CSS/StyleValues/BorderImageSliceStyleValue.h>
LibWeb: Split BorderRadiusStyleValue out of StyleValue.{h,cpp}
2023-03-25 00:33:20 +00:00
#include <LibWeb/CSS/StyleValues/BorderRadiusStyleValue.h>
Revert "LibWeb/CSS: Rename CalculatedStyleValue -> CSSMathValue" This reverts commit 76daba3069de4c184c6b2317d0c89b50f81a8c00. We're going to need separate types for the JS-exposed style values, so it doesn't make sense for us to match their names with our internal types.
2024-12-11 15:05:56 +00:00
#include <LibWeb/CSS/StyleValues/CalculatedStyleValue.h>
LibWeb/CSS: Implement the color-scheme CSS property
2025-01-02 12:59:09 +11:00
#include <LibWeb/CSS/StyleValues/ColorSchemeStyleValue.h>
LibWeb/CSS: Rename CSSColorValue -> ColorStyleValue The typed-om class will be a separate thing.
2025-08-08 11:24:15 +01:00
#include <LibWeb/CSS/StyleValues/ColorStyleValue.h>
LibWeb: Split ConicGradientStyleValue out of StyleValue.{h,cpp}
2023-03-24 16:09:41 +00:00
#include <LibWeb/CSS/StyleValues/ConicGradientStyleValue.h>
LibWeb: Split ContentStyleValue out of StyleValue.{h,cpp}
2023-03-23 21:17:43 +00:00
#include <LibWeb/CSS/StyleValues/ContentStyleValue.h>
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
#include <LibWeb/CSS/StyleValues/CounterDefinitionsStyleValue.h>
LibWeb: Implement CounterStyleValue This is `counter(name, style?)` or `counters(name, link, style?)`. The difference being, `counter()` matches only the nearest level (eg, "1"), and `counters()` combines all the levels in the tree (eg, "3.4.1").
2024-07-24 14:56:16 +01:00
#include <LibWeb/CSS/StyleValues/CounterStyleValue.h>
LibWeb/CSS: Implement CursorStyleValue A cursor is an image, with an optional x,y hotspot. We know that a CursorStyleValue's bitmap never needs to change size, so we create the ShareableBitmap once and then cache it, so that we don't have to repeatedly create an FD for it or do the work of painting. To avoid repainting that bitmap, we cache the values that were used to create it - what currentColor is and its length resolution context - and only repaint when those change.
2025-02-21 13:04:20 +00:00
#include <LibWeb/CSS/StyleValues/CursorStyleValue.h>
LibWeb: Add CustomIdentStyleValue, along with parsing for it This corresponds to the `<custom-ident>` type in CSS grammar.
2023-05-25 12:43:52 +01:00
#include <LibWeb/CSS/StyleValues/CustomIdentStyleValue.h>
LibWeb: Support multi-keyword syntax for CSS display property The Display class already supported all specific values, and now they will be parsed too. The display property now has a special type DisplayStyleValue.
2023-04-26 21:05:38 +02:00
#include <LibWeb/CSS/StyleValues/DisplayStyleValue.h>
Meta/CodeGenerators+LibWeb: Implement parsing CSS easing functions This only implements the parser bits, no functionality is implemented, and no properties are parsed because of this.
2023-07-06 02:29:36 +03:30
#include <LibWeb/CSS/StyleValues/EasingStyleValue.h>
LibWeb: Add EdgeStyleValue This represents a single edge and offset, this will be needed for the values of background-position-x/y.
2023-04-02 22:56:45 +01:00
#include <LibWeb/CSS/StyleValues/EdgeStyleValue.h>
LibWeb: Split FilterValueListStyleValue out of StyleValue.{h,cpp}
2023-03-23 21:26:03 +00:00
#include <LibWeb/CSS/StyleValues/FilterValueListStyleValue.h>
LibWeb: Parse CSS fit-content(<length-percentage>) values Before this change, we only parsed fit-content as a standalone keyword, but CSS-SIZING-3 added it as a function as well. I don't know of anything else in CSS that is overloaded like this, so it ends up looking a little awkward in the implementation. Note that a lot of code had already been prepped for fit-content values to have an argument, we just weren't parsing it.
2025-02-26 18:16:36 +01:00
#include <LibWeb/CSS/StyleValues/FitContentStyleValue.h>
LibWeb: Implement Flex and FlexStyleValue types
2023-09-28 15:18:14 +01:00
#include <LibWeb/CSS/StyleValues/FlexStyleValue.h>
LibWeb/CSS: Add FontSourceStyleValue This will be used by the `@font { src: ... }` descriptor once we parse descriptors as style values.
2025-04-02 17:01:16 +01:00
#include <LibWeb/CSS/StyleValues/FontSourceStyleValue.h>
LibWeb: Parse oblique `font-style` with an angle value
2025-05-02 13:55:58 +01:00
#include <LibWeb/CSS/StyleValues/FontStyleStyleValue.h>
LibWeb: Split FrequencyStyleValue out of StyleValue.{h,cpp}
2023-03-23 21:50:24 +00:00
#include <LibWeb/CSS/StyleValues/FrequencyStyleValue.h>
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
#include <LibWeb/CSS/StyleValues/GridAutoFlowStyleValue.h>
LibWeb: Split GridTemplateAreaStyleValue out of StyleValue.{h,cpp}
2023-03-24 14:25:00 +00:00
#include <LibWeb/CSS/StyleValues/GridTemplateAreaStyleValue.h>
LibWeb: Split GridTrackPlacementStyleValue out of StyleValue.{h,cpp}
2023-03-24 14:53:08 +00:00
#include <LibWeb/CSS/StyleValues/GridTrackPlacementStyleValue.h>
LibWeb: Change name of GridTrackSizeListStyleValue Change the name of GridTrackSizeStyleValue to GridTrackSizeListStyleValue which is more accurate.
2023-04-29 17:59:07 +02:00
#include <LibWeb/CSS/StyleValues/GridTrackSizeListStyleValue.h>
LibWeb/CSS: Implement guaranteed-invalid value This is a special value produced when var/attr substitution fails, and is also the initial value for custom properties.
2025-03-12 15:29:12 +00:00
#include <LibWeb/CSS/StyleValues/GuaranteedInvalidStyleValue.h>
LibWeb: Split ImageStyleValue out of StyleValue.{h,cpp}
2023-03-24 15:17:11 +00:00
#include <LibWeb/CSS/StyleValues/ImageStyleValue.h>
LibWeb: Implement IntegerStyleValue, for holding `<integer>` Having one StyleValue for `<number>` and `<integer>` is making user code more complicated than it needs to be. We know based on the property being parsed, whether it wants a `<number>` or an `<integer>`, so we can use separate StyleValue types for these.
2023-06-01 17:01:09 +01:00
#include <LibWeb/CSS/StyleValues/IntegerStyleValue.h>
LibWeb/CSS: Rename CSSKeywordValue -> KeywordStyleValue The typed-om CSSKeywordValue will need to be a separate class.
2025-08-08 10:28:41 +01:00
#include <LibWeb/CSS/StyleValues/KeywordStyleValue.h>
LibWeb: Split LengthStyleValue out of StyleValue.{h,cpp}
2023-03-24 17:04:04 +00:00
#include <LibWeb/CSS/StyleValues/LengthStyleValue.h>
LibWeb: Split LinearGradientStyleValue out of StyleValue.{h,cpp}
2023-03-24 16:17:50 +00:00
#include <LibWeb/CSS/StyleValues/LinearGradientStyleValue.h>
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
#include <LibWeb/CSS/StyleValues/MathDepthStyleValue.h>
LibWeb: Rename NumericStyleValue -> NumberStyleValue This is in preparation of splitting off a separate IntegerStyleValue.
2023-06-01 16:16:15 +01:00
#include <LibWeb/CSS/StyleValues/NumberStyleValue.h>
LibWeb/CSS: Introduce OpenTypeTaggedStyleValue Two font properties, font-feature-settings and font-variation-settings, contain a list of values that are an `<opentype-tag>` followed by a single value. This class is intended to fill both roles.
2024-09-30 17:05:52 +01:00
#include <LibWeb/CSS/StyleValues/OpenTypeTaggedStyleValue.h>
LibWeb/CSS: Implement pending-substitution value This is a special value temporarily assigned to longhands when their shorthand is unresolved, and then later replaced once that is resolved.
2025-03-12 19:24:59 +00:00
#include <LibWeb/CSS/StyleValues/PendingSubstitutionStyleValue.h>
LibWeb: Split PercentageStyleValue out of StyleValue.{h,cpp}
2023-03-24 17:28:43 +00:00
#include <LibWeb/CSS/StyleValues/PercentageStyleValue.h>
LibWeb: Split PositionStyleValue out of StyleValue.{h,cpp}
2023-03-24 17:35:31 +00:00
#include <LibWeb/CSS/StyleValues/PositionStyleValue.h>
LibWeb: Split RadialGradientStyleValue out of StyleValue.{h,cpp}
2023-03-24 16:35:18 +00:00
#include <LibWeb/CSS/StyleValues/RadialGradientStyleValue.h>
LibWeb: Add RatioStyleValue and parsing
2023-06-06 15:42:43 +01:00
#include <LibWeb/CSS/StyleValues/RatioStyleValue.h>
LibWeb: Split RectStyleValue out of StyleValue.{h,cpp}
2023-03-25 00:02:50 +00:00
#include <LibWeb/CSS/StyleValues/RectStyleValue.h>
LibWeb/CSS: Rename background-repeat related symbols to align with spec These will be used for the mask-repeat property as well in an upcoming commit, hence the more generic names. Also, this more closely matches the names used in the spec.
2025-07-18 20:36:09 +02:00
#include <LibWeb/CSS/StyleValues/RepeatStyleStyleValue.h>
LibWeb: Split ResolutionStyleValue out of StyleValue.{h,cpp}
2023-03-24 17:40:28 +00:00
#include <LibWeb/CSS/StyleValues/ResolutionStyleValue.h>
LibWeb/CSS: Implement the `scrollbar-color` property This allows the user to set the scrollbar thumb and track colors.
2025-05-26 22:36:12 +01:00
#include <LibWeb/CSS/StyleValues/ScrollbarColorStyleValue.h>
LibWeb: Implement support for scrollbar-gutter This property is now correctly parsed. Ladybird always uses overlay scrollbars so this property does nothing.
2024-06-26 23:19:38 +01:00
#include <LibWeb/CSS/StyleValues/ScrollbarGutterStyleValue.h>
LibWeb: Split ShadowStyleValue out of StyleValue.{h,cpp}
2023-03-24 17:45:25 +00:00
#include <LibWeb/CSS/StyleValues/ShadowStyleValue.h>
LibWeb: Rename CompositeStyleValue -> ShorthandStyleValue It's a shorthand, so let's call it that. :^)
2023-09-19 12:21:15 +01:00
#include <LibWeb/CSS/StyleValues/ShorthandStyleValue.h>
LibWeb: Split StringStyleValue out of StyleValue.{h,cpp}
2023-03-24 17:48:42 +00:00
#include <LibWeb/CSS/StyleValues/StringStyleValue.h>
LibWeb: Move and rename CSSStyleValue to StyleValues/StyleValue.{h,cpp} This reverts 0e3487b9ab455a7648185995363bb3b487551d40. Back when I made that change, I thought we could make our StyleValue classes match the typed-om definitions directly. However, they have different requirements. Typed-om types need to be mutable and GCed, whereas StyleValues are immutable and ideally wouldn't require a JS VM. While I was already making such a cataclysmic change, I've moved it into the StyleValues directory, because it *not* being there has bothered me for a long time. 😅
2025-08-08 10:11:51 +01:00
#include <LibWeb/CSS/StyleValues/StyleValue.h>
LibWeb: Split StyleValueList out of StyleValue.{h,cpp}
2023-03-25 00:12:21 +00:00
#include <LibWeb/CSS/StyleValues/StyleValueList.h>
LibWeb: Parse `text-underline-position` property This introduces the `TextUnderlinePositionStyleValue` class, it is possible to represent `text-underline-position` as a `StyleValueList` but would have required ugly workarounds for either serialization or in `ComputedProperties::text_underline_position`
2025-09-13 19:27:52 +12:00
#include <LibWeb/CSS/StyleValues/TextUnderlinePositionStyleValue.h>
LibWeb: Split TimeStyleValue out of StyleValue.{h,cpp}
2023-03-24 23:47:56 +00:00
#include <LibWeb/CSS/StyleValues/TimeStyleValue.h>
LibWeb: Split TransformationStyleValue out of StyleValue.{h,cpp}
2023-03-24 17:59:33 +00:00
#include <LibWeb/CSS/StyleValues/TransformationStyleValue.h>
LibWeb: Parse transition style values
2024-02-19 19:01:34 -07:00
#include <LibWeb/CSS/StyleValues/TransitionStyleValue.h>
LibWeb: Add URLStyleValue to represent general url() values This is primarily being added to support `fill: url(#gradient)` for SVGs.
2023-04-20 18:31:00 +01:00
#include <LibWeb/CSS/StyleValues/URLStyleValue.h>
LibWeb/CSS: Implement UnicodeRangeStyleValue This is preparation for storing at-rule descriptors as style values.
2025-03-27 17:35:06 +00:00
#include <LibWeb/CSS/StyleValues/UnicodeRangeStyleValue.h>
LibWeb: Split UnresolvedStyleValue out of StyleValue.{h,cpp}
2023-03-24 23:53:41 +00:00
#include <LibWeb/CSS/StyleValues/UnresolvedStyleValue.h>
LibWeb: Update `to_color` to take `ColorResolutionContext` Using a generic context argument will allow us to resolve colors in places where we have all the required information but not in the form of a layout node as was expected previously.
2025-07-19 11:31:07 +12:00
#include <LibWeb/Layout/Node.h>
LibHTML: Implement enough of the CSS parser to parse the default stylesheet.
2019-06-22 21:48:21 +02: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: Support creating ColorResolutionContext from AbstractElement No functionality changes.
2025-07-19 15:38:16 +12:00
ColorResolutionContext ColorResolutionContext::for_element(DOM::AbstractElement const& element)
{
auto color_scheme = element.computed_properties()->color_scheme(element.document().page().preferred_color_scheme(), element.document().supported_color_schemes());
CalculationResolutionContext calculation_resolution_context { .length_resolution_context = Length::ResolutionContext::for_element(element) };
return {
.color_scheme = color_scheme,
.current_color = element.computed_properties()->color_or_fallback(PropertyID::Color, { color_scheme, CSS::InitialValues::color(), element.document(), calculation_resolution_context }, CSS::InitialValues::color()),
.document = element.document(),
.calculation_resolution_context = calculation_resolution_context
};
}
LibWeb: Update `to_color` to take `ColorResolutionContext` Using a generic context argument will allow us to resolve colors in places where we have all the required information but not in the form of a layout node as was expected previously.
2025-07-19 11:31:07 +12:00
ColorResolutionContext ColorResolutionContext::for_layout_node_with_style(Layout::NodeWithStyle const& layout_node)
{
return {
.color_scheme = layout_node.computed_values().color_scheme(),
.current_color = layout_node.computed_values().color(),
.document = layout_node.document(),
.calculation_resolution_context = { .length_resolution_context = Length::ResolutionContext::for_layout_node(layout_node) },
};
}
LibWeb: Move and rename CSSStyleValue to StyleValues/StyleValue.{h,cpp} This reverts 0e3487b9ab455a7648185995363bb3b487551d40. Back when I made that change, I thought we could make our StyleValue classes match the typed-om definitions directly. However, they have different requirements. Typed-om types need to be mutable and GCed, whereas StyleValues are immutable and ideally wouldn't require a JS VM. While I was already making such a cataclysmic change, I've moved it into the StyleValues directory, because it *not* being there has bothered me for a long time. 😅
2025-08-08 10:11:51 +01:00
StyleValue::StyleValue(Type type)
LibHTML: Implement enough of the CSS parser to parse the default stylesheet.
2019-06-22 21:48:21 +02:00
: m_type(type)
{
}
LibWeb: Move and rename CSSStyleValue to StyleValues/StyleValue.{h,cpp} This reverts 0e3487b9ab455a7648185995363bb3b487551d40. Back when I made that change, I thought we could make our StyleValue classes match the typed-om definitions directly. However, they have different requirements. Typed-om types need to be mutable and GCed, whereas StyleValues are immutable and ideally wouldn't require a JS VM. While I was already making such a cataclysmic change, I've moved it into the StyleValues directory, because it *not* being there has bothered me for a long time. 😅
2025-08-08 10:11:51 +01:00
AbstractImageStyleValue const& StyleValue::as_abstract_image() const
LibWeb: Convert images to common AbstractImageStyleValue base This commit moves both the ImageStyleValue and LinearGradientStyleValue to a common base class of AbstractImageStyleValue. This abstracts getting the natural_width/height, loading/resolving, and painting the image. Now for 'free' you get: - Linear gradients working with the various background sizing/repeat properties. - Linear gradients working as list-markers :^) -- best feature ever! P.s. This commit is a little large as it's tricky to make this change incrementally without breaking things.
2022-07-31 01:11:59 +01:00
{
VERIFY(is_abstract_image());
return static_cast<AbstractImageStyleValue const&>(*this);
LibWeb: Implement `anchor-size(..)` function parsing This parses `anchor-size(..)` functions in CSS, but does not yet result in a useful `Size`: we need style & layout interleaving similar to container queries for this, since the resulting value depends on layout results. Not supported yet: `anchor-size()` appearing inside a `calc()` node. Adds 4280 WPT subtest passes in `css/css-anchor-position`.
2025-07-30 14:14:53 +02:00
}
LibWeb/CSS: Replace CSSUnitValue with DimensionStyleValue CSSUnitValue is a typed-om type which we will implement separately in the future. However, it still seems useful to give our dimension values a base class. (Maybe they could be templated in the future?) So instead of deleting it entirely, rename it to DimensionStyleValue and make its API match our style better.
2025-08-08 11:08:54 +01:00
DimensionStyleValue const& StyleValue::as_dimension() const
{
VERIFY(is_dimension());
return static_cast<DimensionStyleValue const&>(*this);
}
LibWeb: Use a macro for repetitive code in CSSStyleValue.{h,cpp} This reduces the number of places we need to touch when creating a new type
2025-08-08 19:09:51 +12:00
#define __ENUMERATE_CSS_STYLE_VALUE_TYPE(title_case, snake_case, style_value_class_name) \
LibWeb: Move and rename CSSStyleValue to StyleValues/StyleValue.{h,cpp} This reverts 0e3487b9ab455a7648185995363bb3b487551d40. Back when I made that change, I thought we could make our StyleValue classes match the typed-om definitions directly. However, they have different requirements. Typed-om types need to be mutable and GCed, whereas StyleValues are immutable and ideally wouldn't require a JS VM. While I was already making such a cataclysmic change, I've moved it into the StyleValues directory, because it *not* being there has bothered me for a long time. 😅
2025-08-08 10:11:51 +01:00
style_value_class_name const& StyleValue::as_##snake_case() const \
LibWeb: Use a macro for repetitive code in CSSStyleValue.{h,cpp} This reduces the number of places we need to touch when creating a new type
2025-08-08 19:09:51 +12:00
{ \
VERIFY(is_##snake_case()); \
return static_cast<style_value_class_name const&>(*this); \
}
ENUMERATE_CSS_STYLE_VALUE_TYPES
#undef __ENUMERATE_CSS_STYLE_VALUE_TYPE
LibWeb: Clarify StyleValue API with new naming scheme This does a few things, that are hard to separate. For a while now, it's been confuzing what `StyleValue::is_foo()` actually means. It sometimes was used to check the type, and sometimes to see if it could return a certain value type. The new naming scheme is: - `is_length()` - is it a LengthStyleValue? - `as_length()` - casts it to LengthStyleValue - `has_length()` - can it return a Length? - `to_length()` - gets the internal value out (eg, Length) This also means, no more `static_cast<LengthStyleValue const&>(*this)` stuff when dealing with StyleValues. :^) Hopefully this will be a bit clearer going forward. There are lots of places using the original methods, so I'll be going through them to hopefully catch any issues.
2021-09-23 19:54:19 +01:00
LibWeb: Move and rename CSSStyleValue to StyleValues/StyleValue.{h,cpp} This reverts 0e3487b9ab455a7648185995363bb3b487551d40. Back when I made that change, I thought we could make our StyleValue classes match the typed-om definitions directly. However, they have different requirements. Typed-om types need to be mutable and GCed, whereas StyleValues are immutable and ideally wouldn't require a JS VM. While I was already making such a cataclysmic change, I've moved it into the StyleValues directory, because it *not* being there has bothered me for a long time. 😅
2025-08-08 10:11:51 +01:00
ValueComparingNonnullRefPtr<StyleValue const> StyleValue::absolutized(CSSPixelRect const&, Length::FontMetrics const&, Length::FontMetrics const&) const
LibWeb: Move StyleValue::absolutized() back where it belongs I accidentally moved this when moving the CalculatedStyleValue methods, and didn't notice because it was hidden in the middle. Oops!
2023-03-31 14:25:38 +01:00
{
return *this;
}
LibWeb: Move and rename CSSStyleValue to StyleValues/StyleValue.{h,cpp} This reverts 0e3487b9ab455a7648185995363bb3b487551d40. Back when I made that change, I thought we could make our StyleValue classes match the typed-om definitions directly. However, they have different requirements. Typed-om types need to be mutable and GCed, whereas StyleValues are immutable and ideally wouldn't require a JS VM. While I was already making such a cataclysmic change, I've moved it into the StyleValues directory, because it *not* being there has bothered me for a long time. 😅
2025-08-08 10:11:51 +01:00
bool StyleValue::has_auto() const
LibWeb: Simplify StyleValue API now that `auto` isn't a length Now that LengthStyleValue never contains `auto`, IdentifierStyleValue is the only type that can hold an identifier. This lets us remove a couple of virtual methods from StyleValue. I've kept `has_auto()` and `to_identifier()` for convenience, but they are now simple non-virtual methods.
2023-04-19 12:00:38 +01:00
{
LibWeb: Rename "identifier" and "ValueID" to "Keyword" where correct For a long time, we've used two terms, inconsistently: - "Identifier" is a spec term, but refers to a sequence of alphanumeric characters, which may or may not be a keyword. (Keywords are a subset of all identifiers.) - "ValueID" is entirely non-spec, and is directly called a "keyword" in the CSS specs. So to avoid confusion as much as possible, let's align with the spec terminology. I've attempted to change variable names as well, but obviously we use Keywords in a lot of places in LibWeb and so I may have missed some. One exception is that I've not renamed "valid-identifiers" in Properties.json... I'd like to combine that and the "valid-types" array together eventually, so there's no benefit to doing an extra rename now.
2024-08-14 14:06:03 +01:00
return is_keyword() && as_keyword().keyword() == Keyword::Auto;
LibWeb: Simplify StyleValue API now that `auto` isn't a length Now that LengthStyleValue never contains `auto`, IdentifierStyleValue is the only type that can hold an identifier. This lets us remove a couple of virtual methods from StyleValue. I've kept `has_auto()` and `to_identifier()` for convenience, but they are now simple non-virtual methods.
2023-04-19 12:00:38 +01:00
}
LibWeb: Move and rename CSSStyleValue to StyleValues/StyleValue.{h,cpp} This reverts 0e3487b9ab455a7648185995363bb3b487551d40. Back when I made that change, I thought we could make our StyleValue classes match the typed-om definitions directly. However, they have different requirements. Typed-om types need to be mutable and GCed, whereas StyleValues are immutable and ideally wouldn't require a JS VM. While I was already making such a cataclysmic change, I've moved it into the StyleValues directory, because it *not* being there has bothered me for a long time. 😅
2025-08-08 10:11:51 +01:00
Vector<Parser::ComponentValue> StyleValue::tokenize() const
LibWeb/CSS: Add tokenize() method to style values, to get a list of CVs A couple of arbitrary substitution functions require us to get or produce some style value, and then substitute its ComponentValues into the original ComponentValue list. So this commit gives CSSStyleValue a tokenize() method that does so. Apart from a couple of unusual cases like the guaranteed-invalid value, style values can all be converted into ComponentValues by serializing them as a string, and then parsing that as a list of component values. That feels unnecessarily inefficient in most cases though, so I've implemented faster overrides for a lot of the basic style value classes, but left that serialize-and-reparse method as the fallback.
2025-07-10 12:17:27 +01:00
{
// This is an inefficient way of producing ComponentValues, but it's guaranteed to work for types that round-trip.
// FIXME: Implement better versions in the subclasses.
return Parser::Parser::create(Parser::ParsingParams {}, to_string(SerializationMode::Normal)).parse_as_list_of_component_values();
}
LibWeb/CSS: Add ability to reify a StyleValue When no better reification form is available, we produce an opaque CSSStyleValue with a serialized value. For starters, this will be the only way to reify, and then we'll add others later.
2025-08-13 14:46:21 +01:00
// https://drafts.css-houdini.org/css-typed-om-1/#reify-as-a-cssstylevalue
GC::Ref<CSSStyleValue> StyleValue::reify(JS::Realm& realm, String const& associated_property) const
{
// 1. Return a new CSSStyleValue object representing value whose [[associatedProperty]] internal slot is set to property.
return CSSStyleValue::create(realm, associated_property, to_string(SerializationMode::Normal));
}
LibWeb: Move everything into the Web namespace
2020-03-07 10:27:02 +01:00
}
Reference in a new issue Copy permalink