mirrors/ladybird
0
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-10-03 14:50:02 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 10

LibWeb/CSS: Rename CalculatedStyleValue -> CSSMathValue

Browse source 
This matches the name in the CSS Typed OM spec. There's quite a lot
still to do to make it match the spec behavior, but this is the first
step.
This commit is contained in:
Sam Atkins 2024-09-18 17:27:47 +01:00 • committed by Sam Atkins
commit 76daba3069
Notes: github-actions[bot] 2024-09-18 19:39:35 +00:00
32 changed files with 340 additions and 340 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Meta/Lagom/Tools/CodeGenerators/LibWeb/GenerateCSSMathFunctions.cpp
View file

@ -90,7 +90,7 @@ ErrorOr<void> generate_implementation_file(JsonObject& functions_data, Core::Fil
#include <LibWeb/CSS/MathFunctions.h> #include <LibWeb/CSS/MathFunctions.h>
#include <LibWeb/CSS/Parser/Parser.h> #include <LibWeb/CSS/Parser/Parser.h>
#include <LibWeb/CSS/Enums.h> #include <LibWeb/CSS/Enums.h>
#include <LibWeb/CSS/StyleValues/CalculatedStyleValue.h> #include <LibWeb/CSS/StyleValues/CSSMathValue.h>
namespace Web::CSS::Parser { namespace Web::CSS::Parser {

2
Meta/gn/secondary/Userland/Libraries/LibWeb/CSS/StyleValues/BUILD.gn
View file

@ -11,10 +11,10 @@ source_set("StyleValues") {
"CSSHSL.cpp", "CSSHSL.cpp",
"CSSHWB.cpp", "CSSHWB.cpp",
"CSSKeywordValue.cpp", "CSSKeywordValue.cpp",
"CSSMathValue.cpp",
"CSSOKLCH.cpp", "CSSOKLCH.cpp",
"CSSOKLab.cpp", "CSSOKLab.cpp",
"CSSRGB.cpp", "CSSRGB.cpp",
"CalculatedStyleValue.cpp",
"ConicGradientStyleValue.cpp", "ConicGradientStyleValue.cpp",
"ContentStyleValue.cpp", "ContentStyleValue.cpp",
"DisplayStyleValue.cpp", "DisplayStyleValue.cpp",

2
Userland/Libraries/LibWeb/CMakeLists.txt
View file

@ -112,7 +112,6 @@ set(SOURCES
CSS/StyleValues/BackgroundSizeStyleValue.cpp CSS/StyleValues/BackgroundSizeStyleValue.cpp
CSS/StyleValues/BasicShapeStyleValue.cpp CSS/StyleValues/BasicShapeStyleValue.cpp
CSS/StyleValues/BorderRadiusStyleValue.cpp CSS/StyleValues/BorderRadiusStyleValue.cpp
CSS/StyleValues/CalculatedStyleValue.cpp
CSS/StyleValues/ConicGradientStyleValue.cpp CSS/StyleValues/ConicGradientStyleValue.cpp
CSS/StyleValues/ContentStyleValue.cpp CSS/StyleValues/ContentStyleValue.cpp
CSS/StyleValues/CounterDefinitionsStyleValue.cpp CSS/StyleValues/CounterDefinitionsStyleValue.cpp
@ -121,6 +120,7 @@ set(SOURCES
CSS/StyleValues/CSSHSL.cpp CSS/StyleValues/CSSHSL.cpp
CSS/StyleValues/CSSHWB.cpp CSS/StyleValues/CSSHWB.cpp
CSS/StyleValues/CSSKeywordValue.cpp CSS/StyleValues/CSSKeywordValue.cpp
CSS/StyleValues/CSSMathValue.cpp
CSS/StyleValues/CSSOKLab.cpp CSS/StyleValues/CSSOKLab.cpp
CSS/StyleValues/CSSOKLCH.cpp CSS/StyleValues/CSSOKLCH.cpp
CSS/StyleValues/CSSRGB.cpp CSS/StyleValues/CSSRGB.cpp

4
Userland/Libraries/LibWeb/CSS/Angle.cpp
View file

@ -7,7 +7,7 @@
#include "Angle.h" #include "Angle.h"
#include <AK/Math.h> #include <AK/Math.h>
#include <LibWeb/CSS/Percentage.h> #include <LibWeb/CSS/Percentage.h>
#include <LibWeb/CSS/StyleValues/CalculatedStyleValue.h> #include <LibWeb/CSS/StyleValues/CSSMathValue.h>
namespace Web::CSS { namespace Web::CSS {
@ -84,7 +84,7 @@ Optional<Angle::Type> Angle::unit_from_name(StringView name)
return {}; return {};
} }
Angle Angle::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, Layout::Node const&, Angle const& reference_value) Angle Angle::resolve_calculated(NonnullRefPtr<CSSMathValue> const& calculated, Layout::Node const&, Angle const& reference_value)
{ {
return calculated->resolve_angle_percentage(reference_value).value(); return calculated->resolve_angle_percentage(reference_value).value();
} }

2
Userland/Libraries/LibWeb/CSS/Angle.h
View file

@ -52,7 +52,7 @@ public:
return 0; return 0;
} }
static Angle resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const&, Layout::Node const&, Angle const& reference_value); static Angle resolve_calculated(NonnullRefPtr<CSSMathValue> const&, Layout::Node const&, Angle const& reference_value);
private: private:
Type m_type; Type m_type;

12
Userland/Libraries/LibWeb/CSS/CSSStyleValue.cpp
View file

@ -18,7 +18,7 @@
#include <LibWeb/CSS/StyleValues/BorderRadiusStyleValue.h> #include <LibWeb/CSS/StyleValues/BorderRadiusStyleValue.h>
#include <LibWeb/CSS/StyleValues/CSSColorValue.h> #include <LibWeb/CSS/StyleValues/CSSColorValue.h>
#include <LibWeb/CSS/StyleValues/CSSKeywordValue.h> #include <LibWeb/CSS/StyleValues/CSSKeywordValue.h>
#include <LibWeb/CSS/StyleValues/CalculatedStyleValue.h> #include <LibWeb/CSS/StyleValues/CSSMathValue.h>
#include <LibWeb/CSS/StyleValues/ConicGradientStyleValue.h> #include <LibWeb/CSS/StyleValues/ConicGradientStyleValue.h>
#include <LibWeb/CSS/StyleValues/ContentStyleValue.h> #include <LibWeb/CSS/StyleValues/ContentStyleValue.h>
#include <LibWeb/CSS/StyleValues/CounterDefinitionsStyleValue.h> #include <LibWeb/CSS/StyleValues/CounterDefinitionsStyleValue.h>
@ -100,10 +100,10 @@ BorderRadiusStyleValue const& CSSStyleValue::as_border_radius() const
return static_cast<BorderRadiusStyleValue const&>(*this); return static_cast<BorderRadiusStyleValue const&>(*this);
} }
CalculatedStyleValue const& CSSStyleValue::as_calculated() const CSSMathValue const& CSSStyleValue::as_math() const
{ {
VERIFY(is_calculated()); VERIFY(is_math());
return static_cast<CalculatedStyleValue const&>(*this); return static_cast<CSSMathValue const&>(*this);
} }
CSSColorValue const& CSSStyleValue::as_color() const CSSColorValue const& CSSStyleValue::as_color() const
@ -378,8 +378,8 @@ int CSSStyleValue::to_font_weight() const
if (is_number()) { if (is_number()) {
return round_to<int>(as_number().number()); return round_to<int>(as_number().number());
} }
if (is_calculated()) { if (is_math()) {
auto maybe_weight = const_cast<CalculatedStyleValue&>(as_calculated()).resolve_integer(); auto maybe_weight = const_cast<CSSMathValue&>(as_math()).resolve_integer();
if (maybe_weight.has_value()) if (maybe_weight.has_value())
return maybe_weight.value(); return maybe_weight.value();
} }

10
Userland/Libraries/LibWeb/CSS/CSSStyleValue.h
View file

@ -93,7 +93,6 @@ public:
BackgroundSize, BackgroundSize,
BasicShape, BasicShape,
BorderRadius, BorderRadius,
Calculated,
Color, Color,
ConicGradient, ConicGradient,
Content, Content,
@ -115,6 +114,7 @@ public:
Keyword, Keyword,
Length, Length,
LinearGradient, LinearGradient,
Math,
MathDepth, MathDepth,
Number, Number,
Percentage, Percentage,
@ -164,10 +164,6 @@ public:
BorderRadiusStyleValue const& as_border_radius() const; BorderRadiusStyleValue const& as_border_radius() const;
BorderRadiusStyleValue& as_border_radius() { return const_cast<BorderRadiusStyleValue&>(const_cast<CSSStyleValue const&>(*this).as_border_radius()); } BorderRadiusStyleValue& as_border_radius() { return const_cast<BorderRadiusStyleValue&>(const_cast<CSSStyleValue const&>(*this).as_border_radius()); }
bool is_calculated() const { return type() == Type::Calculated; }
CalculatedStyleValue const& as_calculated() const;
CalculatedStyleValue& as_calculated() { return const_cast<CalculatedStyleValue&>(const_cast<CSSStyleValue const&>(*this).as_calculated()); }
bool is_color() const { return type() == Type::Color; } bool is_color() const { return type() == Type::Color; }
CSSColorValue const& as_color() const; CSSColorValue const& as_color() const;
CSSColorValue& as_color() { return const_cast<CSSColorValue&>(const_cast<CSSStyleValue const&>(*this).as_color()); } CSSColorValue& as_color() { return const_cast<CSSColorValue&>(const_cast<CSSStyleValue const&>(*this).as_color()); }
@ -252,6 +248,10 @@ public:
LinearGradientStyleValue const& as_linear_gradient() const; LinearGradientStyleValue const& as_linear_gradient() const;
LinearGradientStyleValue& as_linear_gradient() { return const_cast<LinearGradientStyleValue&>(const_cast<CSSStyleValue const&>(*this).as_linear_gradient()); } LinearGradientStyleValue& as_linear_gradient() { return const_cast<LinearGradientStyleValue&>(const_cast<CSSStyleValue const&>(*this).as_linear_gradient()); }
bool is_math() const { return type() == Type::Math; }
CSSMathValue const& as_math() const;
CSSMathValue& as_math() { return const_cast<CSSMathValue&>(const_cast<CSSStyleValue const&>(*this).as_math()); }
bool is_math_depth() const { return type() == Type::MathDepth; } bool is_math_depth() const { return type() == Type::MathDepth; }
MathDepthStyleValue const& as_math_depth() const; MathDepthStyleValue const& as_math_depth() const;
MathDepthStyleValue& as_math_depth() { return const_cast<MathDepthStyleValue&>(const_cast<CSSStyleValue const&>(*this).as_math_depth()); } MathDepthStyleValue& as_math_depth() { return const_cast<MathDepthStyleValue&>(const_cast<CSSStyleValue const&>(*this).as_math_depth()); }

18
Userland/Libraries/LibWeb/CSS/CalculatedOr.cpp
View file

@ -17,7 +17,7 @@
namespace Web::CSS { namespace Web::CSS {
Angle AngleOrCalculated::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, Layout::Node const&) const Angle AngleOrCalculated::resolve_calculated(NonnullRefPtr<CSSMathValue> const& calculated, Layout::Node const&) const
{ {
return calculated->resolve_angle().value(); return calculated->resolve_angle().value();
} }
@ -27,7 +27,7 @@ NonnullRefPtr<CSSStyleValue> AngleOrCalculated::create_style_value() const
return AngleStyleValue::create(value()); return AngleStyleValue::create(value());
} }
Flex FlexOrCalculated::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, Layout::Node const&) const Flex FlexOrCalculated::resolve_calculated(NonnullRefPtr<CSSMathValue> const& calculated, Layout::Node const&) const
{ {
return calculated->resolve_flex().value(); return calculated->resolve_flex().value();
} }
@ -37,7 +37,7 @@ NonnullRefPtr<CSSStyleValue> FlexOrCalculated::create_style_value() const
return FlexStyleValue::create(value()); return FlexStyleValue::create(value());
} }
Frequency FrequencyOrCalculated::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, Layout::Node const&) const Frequency FrequencyOrCalculated::resolve_calculated(NonnullRefPtr<CSSMathValue> const& calculated, Layout::Node const&) const
{ {
return calculated->resolve_frequency().value(); return calculated->resolve_frequency().value();
} }
@ -47,7 +47,7 @@ NonnullRefPtr<CSSStyleValue> FrequencyOrCalculated::create_style_value() const
return FrequencyStyleValue::create(value()); return FrequencyStyleValue::create(value());
} }
i64 IntegerOrCalculated::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, Layout::Node const&) const i64 IntegerOrCalculated::resolve_calculated(NonnullRefPtr<CSSMathValue> const& calculated, Layout::Node const&) const
{ {
return calculated->resolve_integer().value(); return calculated->resolve_integer().value();
} }
@ -57,7 +57,7 @@ NonnullRefPtr<CSSStyleValue> IntegerOrCalculated::create_style_value() const
return IntegerStyleValue::create(value()); return IntegerStyleValue::create(value());
} }
Length LengthOrCalculated::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, Layout::Node const& layout_node) const Length LengthOrCalculated::resolve_calculated(NonnullRefPtr<CSSMathValue> const& calculated, Layout::Node const& layout_node) const
{ {
return calculated->resolve_length(layout_node).value(); return calculated->resolve_length(layout_node).value();
} }
@ -74,7 +74,7 @@ NonnullRefPtr<CSSStyleValue> LengthOrCalculated::create_style_value() const
return LengthStyleValue::create(value()); return LengthStyleValue::create(value());
} }
double NumberOrCalculated::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, Layout::Node const&) const double NumberOrCalculated::resolve_calculated(NonnullRefPtr<CSSMathValue> const& calculated, Layout::Node const&) const
{ {
return calculated->resolve_number().value(); return calculated->resolve_number().value();
} }
@ -84,7 +84,7 @@ NonnullRefPtr<CSSStyleValue> NumberOrCalculated::create_style_value() const
return NumberStyleValue::create(value()); return NumberStyleValue::create(value());
} }
Percentage PercentageOrCalculated::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, Layout::Node const&) const Percentage PercentageOrCalculated::resolve_calculated(NonnullRefPtr<CSSMathValue> const& calculated, Layout::Node const&) const
{ {
return calculated->resolve_percentage().value(); return calculated->resolve_percentage().value();
} }
@ -94,7 +94,7 @@ NonnullRefPtr<CSSStyleValue> PercentageOrCalculated::create_style_value() const
return PercentageStyleValue::create(value()); return PercentageStyleValue::create(value());
} }
Resolution ResolutionOrCalculated::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, Layout::Node const&) const Resolution ResolutionOrCalculated::resolve_calculated(NonnullRefPtr<CSSMathValue> const& calculated, Layout::Node const&) const
{ {
return calculated->resolve_resolution().value(); return calculated->resolve_resolution().value();
} }
@ -104,7 +104,7 @@ NonnullRefPtr<CSSStyleValue> ResolutionOrCalculated::create_style_value() const
return ResolutionStyleValue::create(value()); return ResolutionStyleValue::create(value());
} }
Time TimeOrCalculated::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, Layout::Node const&) const Time TimeOrCalculated::resolve_calculated(NonnullRefPtr<CSSMathValue> const& calculated, Layout::Node const&) const
{ {
return calculated->resolve_time().value(); return calculated->resolve_time().value();
} }

36
Userland/Libraries/LibWeb/CSS/CalculatedOr.h
View file

@ -13,7 +13,7 @@
#include <LibWeb/CSS/Length.h> #include <LibWeb/CSS/Length.h>
#include <LibWeb/CSS/Percentage.h> #include <LibWeb/CSS/Percentage.h>
#include <LibWeb/CSS/Resolution.h> #include <LibWeb/CSS/Resolution.h>
#include <LibWeb/CSS/StyleValues/CalculatedStyleValue.h> #include <LibWeb/CSS/StyleValues/CSSMathValue.h>
#include <LibWeb/CSS/Time.h> #include <LibWeb/CSS/Time.h>
namespace Web::CSS { namespace Web::CSS {
@ -26,14 +26,14 @@ public:
{ {
} }
CalculatedOr(NonnullRefPtr<CalculatedStyleValue> calculated) CalculatedOr(NonnullRefPtr<CSSMathValue> calculated)
: m_value(move(calculated)) : m_value(move(calculated))
{ {
} }
virtual ~CalculatedOr() = default; virtual ~CalculatedOr() = default;
bool is_calculated() const { return m_value.template has<NonnullRefPtr<CalculatedStyleValue>>(); } bool is_calculated() const { return m_value.template has<NonnullRefPtr<CSSMathValue>>(); }
T const& value() const T const& value() const
{ {
@ -48,10 +48,10 @@ public:
return create_style_value(); return create_style_value();
} }
NonnullRefPtr<CalculatedStyleValue> const& calculated() const NonnullRefPtr<CSSMathValue> const& calculated() const
{ {
VERIFY(is_calculated()); VERIFY(is_calculated());
return m_value.template get<NonnullRefPtr<CalculatedStyleValue>>(); return m_value.template get<NonnullRefPtr<CSSMathValue>>();
} }
T resolved(Layout::Node const& layout_node) const T resolved(Layout::Node const& layout_node) const
@ -60,7 +60,7 @@ public:
[&](T const& t) { [&](T const& t) {
return t; return t;
}, },
[&](NonnullRefPtr<CalculatedStyleValue> const& calculated) { [&](NonnullRefPtr<CSSMathValue> const& calculated) {
return resolve_calculated(calculated, layout_node); return resolve_calculated(calculated, layout_node);
}); });
} }
@ -68,7 +68,7 @@ public:
String to_string() const String to_string() const
{ {
if (is_calculated()) if (is_calculated())
return m_value.template get<NonnullRefPtr<CalculatedStyleValue>>()->to_string(); return m_value.template get<NonnullRefPtr<CSSMathValue>>()->to_string();
return m_value.template get<T>().to_string(); return m_value.template get<T>().to_string();
} }
@ -81,11 +81,11 @@ public:
} }
protected: protected:
virtual T resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const&, Layout::Node const&) const = 0; virtual T resolve_calculated(NonnullRefPtr<CSSMathValue> const&, Layout::Node const&) const = 0;
virtual NonnullRefPtr<CSSStyleValue> create_style_value() const = 0; virtual NonnullRefPtr<CSSStyleValue> create_style_value() const = 0;
private: private:
Variant<T, NonnullRefPtr<CalculatedStyleValue>> m_value; Variant<T, NonnullRefPtr<CSSMathValue>> m_value;
}; };
class AngleOrCalculated : public CalculatedOr<Angle> { class AngleOrCalculated : public CalculatedOr<Angle> {
@ -93,7 +93,7 @@ public:
using CalculatedOr<Angle>::CalculatedOr; using CalculatedOr<Angle>::CalculatedOr;
private: private:
virtual Angle resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const&, Layout::Node const&) const override; virtual Angle resolve_calculated(NonnullRefPtr<CSSMathValue> const&, Layout::Node const&) const override;
virtual NonnullRefPtr<CSSStyleValue> create_style_value() const override; virtual NonnullRefPtr<CSSStyleValue> create_style_value() const override;
}; };
@ -102,7 +102,7 @@ public:
using CalculatedOr<Flex>::CalculatedOr; using CalculatedOr<Flex>::CalculatedOr;
private: private:
virtual Flex resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const&, Layout::Node const&) const override; virtual Flex resolve_calculated(NonnullRefPtr<CSSMathValue> const&, Layout::Node const&) const override;
virtual NonnullRefPtr<CSSStyleValue> create_style_value() const override; virtual NonnullRefPtr<CSSStyleValue> create_style_value() const override;
}; };
@ -111,7 +111,7 @@ public:
using CalculatedOr<Frequency>::CalculatedOr; using CalculatedOr<Frequency>::CalculatedOr;
private: private:
virtual Frequency resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const&, Layout::Node const&) const override; virtual Frequency resolve_calculated(NonnullRefPtr<CSSMathValue> const&, Layout::Node const&) const override;
virtual NonnullRefPtr<CSSStyleValue> create_style_value() const override; virtual NonnullRefPtr<CSSStyleValue> create_style_value() const override;
}; };
@ -120,7 +120,7 @@ public:
using CalculatedOr<i64>::CalculatedOr; using CalculatedOr<i64>::CalculatedOr;
private: private:
virtual i64 resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const&, Layout::Node const&) const override; virtual i64 resolve_calculated(NonnullRefPtr<CSSMathValue> const&, Layout::Node const&) const override;
virtual NonnullRefPtr<CSSStyleValue> create_style_value() const override; virtual NonnullRefPtr<CSSStyleValue> create_style_value() const override;
}; };
@ -131,7 +131,7 @@ public:
[[nodiscard]] Length resolved(Length::ResolutionContext const&) const; [[nodiscard]] Length resolved(Length::ResolutionContext const&) const;
private: private:
virtual Length resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const&, Layout::Node const&) const override; virtual Length resolve_calculated(NonnullRefPtr<CSSMathValue> const&, Layout::Node const&) const override;
virtual NonnullRefPtr<CSSStyleValue> create_style_value() const override; virtual NonnullRefPtr<CSSStyleValue> create_style_value() const override;
}; };
@ -140,7 +140,7 @@ public:
using CalculatedOr<double>::CalculatedOr; using CalculatedOr<double>::CalculatedOr;
private: private:
virtual double resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const&, Layout::Node const&) const override; virtual double resolve_calculated(NonnullRefPtr<CSSMathValue> const&, Layout::Node const&) const override;
virtual NonnullRefPtr<CSSStyleValue> create_style_value() const override; virtual NonnullRefPtr<CSSStyleValue> create_style_value() const override;
}; };
@ -149,7 +149,7 @@ public:
using CalculatedOr<Percentage>::CalculatedOr; using CalculatedOr<Percentage>::CalculatedOr;
private: private:
virtual Percentage resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const&, Layout::Node const&) const override; virtual Percentage resolve_calculated(NonnullRefPtr<CSSMathValue> const&, Layout::Node const&) const override;
virtual NonnullRefPtr<CSSStyleValue> create_style_value() const override; virtual NonnullRefPtr<CSSStyleValue> create_style_value() const override;
}; };
@ -158,7 +158,7 @@ public:
using CalculatedOr<Resolution>::CalculatedOr; using CalculatedOr<Resolution>::CalculatedOr;
private: private:
virtual Resolution resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const&, Layout::Node const&) const override; virtual Resolution resolve_calculated(NonnullRefPtr<CSSMathValue> const&, Layout::Node const&) const override;
virtual NonnullRefPtr<CSSStyleValue> create_style_value() const override; virtual NonnullRefPtr<CSSStyleValue> create_style_value() const override;
}; };
@ -167,7 +167,7 @@ public:
using CalculatedOr<Time>::CalculatedOr; using CalculatedOr<Time>::CalculatedOr;
private: private:
virtual Time resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const&, Layout::Node const&) const override; virtual Time resolve_calculated(NonnullRefPtr<CSSMathValue> const&, Layout::Node const&) const override;
virtual NonnullRefPtr<CSSStyleValue> create_style_value() const override; virtual NonnullRefPtr<CSSStyleValue> create_style_value() const override;
}; };

4
Userland/Libraries/LibWeb/CSS/Frequency.cpp
View file

@ -6,7 +6,7 @@
#include "Frequency.h" #include "Frequency.h"
#include <LibWeb/CSS/Percentage.h> #include <LibWeb/CSS/Percentage.h>
#include <LibWeb/CSS/StyleValues/CalculatedStyleValue.h> #include <LibWeb/CSS/StyleValues/CSSMathValue.h>
namespace Web::CSS { namespace Web::CSS {
@ -63,7 +63,7 @@ Optional<Frequency::Type> Frequency::unit_from_name(StringView name)
return {}; return {};
} }
Frequency Frequency::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, Layout::Node const&, Frequency const& reference_value) Frequency Frequency::resolve_calculated(NonnullRefPtr<CSSMathValue> const& calculated, Layout::Node const&, Frequency const& reference_value)
{ {
return calculated->resolve_frequency_percentage(reference_value).value(); return calculated->resolve_frequency_percentage(reference_value).value();
} }

2
Userland/Libraries/LibWeb/CSS/Frequency.h
View file

@ -47,7 +47,7 @@ public:
return 0; return 0;
} }
static Frequency resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const&, Layout::Node const&, Frequency const& reference_value); static Frequency resolve_calculated(NonnullRefPtr<CSSMathValue> const&, Layout::Node const&, Frequency const& reference_value);
private: private:
Type m_type; Type m_type;

4
Userland/Libraries/LibWeb/CSS/Length.cpp
View file

@ -391,12 +391,12 @@ Length Length::absolutized(CSSPixelRect const& viewport_rect, FontMetrics const&
return absolutize(viewport_rect, font_metrics, root_font_metrics).value_or(*this); return absolutize(viewport_rect, font_metrics, root_font_metrics).value_or(*this);
} }
Length Length::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, Layout::Node const& layout_node, Length const& reference_value) Length Length::resolve_calculated(NonnullRefPtr<CSSMathValue> const& calculated, Layout::Node const& layout_node, Length const& reference_value)
{ {
return calculated->resolve_length_percentage(layout_node, reference_value).value(); return calculated->resolve_length_percentage(layout_node, reference_value).value();
} }
Length Length::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, Layout::Node const& layout_node, CSSPixels reference_value) Length Length::resolve_calculated(NonnullRefPtr<CSSMathValue> const& calculated, Layout::Node const& layout_node, CSSPixels reference_value)
{ {
return calculated->resolve_length_percentage(layout_node, reference_value).value(); return calculated->resolve_length_percentage(layout_node, reference_value).value();
} }

4
Userland/Libraries/LibWeb/CSS/Length.h
View file

@ -223,8 +223,8 @@ public:
Optional<Length> absolutize(CSSPixelRect const& viewport_rect, FontMetrics const& font_metrics, FontMetrics const& root_font_metrics) const; Optional<Length> absolutize(CSSPixelRect const& viewport_rect, FontMetrics const& font_metrics, FontMetrics const& root_font_metrics) const;
Length absolutized(CSSPixelRect const& viewport_rect, FontMetrics const& font_metrics, FontMetrics const& root_font_metrics) const; Length absolutized(CSSPixelRect const& viewport_rect, FontMetrics const& font_metrics, FontMetrics const& root_font_metrics) const;
static Length resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const&, Layout::Node const&, Length const& reference_value); static Length resolve_calculated(NonnullRefPtr<CSSMathValue> const&, Layout::Node const&, Length const& reference_value);
static Length resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const&, Layout::Node const&, CSSPixels reference_value); static Length resolve_calculated(NonnullRefPtr<CSSMathValue> const&, Layout::Node const&, CSSPixels reference_value);
private: private:
[[nodiscard]] CSSPixels to_px_slow_case(Layout::Node const&) const; [[nodiscard]] CSSPixels to_px_slow_case(Layout::Node const&) const;

2
Userland/Libraries/LibWeb/CSS/LengthBox.h
View file

@ -16,7 +16,7 @@ public:
LengthBox(LengthPercentage top, LengthPercentage right, LengthPercentage bottom, LengthPercentage left); LengthBox(LengthPercentage top, LengthPercentage right, LengthPercentage bottom, LengthPercentage left);
~LengthBox(); ~LengthBox();
// Length (and thus LengthPercentage) includes a RefPtr<CalculatedStyleValue> member, but we can't include the header CSSStyleValue.h as it includes // Length (and thus LengthPercentage) includes a RefPtr<CSSMathValue> member, but we can't include the header CSSStyleValue.h as it includes
// this file already. To break the cyclic dependency, we must initialize these members in the constructor. // this file already. To break the cyclic dependency, we must initialize these members in the constructor.
LengthPercentage& top() { return m_top; } LengthPercentage& top() { return m_top; }
LengthPercentage& right() { return m_right; } LengthPercentage& right() { return m_right; }

44
Userland/Libraries/LibWeb/CSS/Parser/Parser.cpp
View file

@ -1797,7 +1797,7 @@ RefPtr<CustomIdentStyleValue> Parser::parse_custom_ident_value(TokenStream<Compo
return CustomIdentStyleValue::create(custom_ident); return CustomIdentStyleValue::create(custom_ident);
} }
RefPtr<CalculatedStyleValue> Parser::parse_calculated_value(ComponentValue const& component_value) RefPtr<CSSMathValue> Parser::parse_calculated_value(ComponentValue const& component_value)
{ {
if (!component_value.is_function()) if (!component_value.is_function())
return nullptr; return nullptr;
@ -1812,7 +1812,7 @@ RefPtr<CalculatedStyleValue> Parser::parse_calculated_value(ComponentValue const
if (!function_type.has_value()) if (!function_type.has_value())
return nullptr; return nullptr;
return CalculatedStyleValue::create(function_node.release_nonnull(), function_type.release_value()); return CSSMathValue::create(function_node.release_nonnull(), function_type.release_value());
} }
OwnPtr<CalculationNode> Parser::parse_a_calc_function_node(Function const& function) OwnPtr<CalculationNode> Parser::parse_a_calc_function_node(Function const& function)
@ -2529,7 +2529,7 @@ RefPtr<CSSStyleValue> Parser::parse_angle_value(TokenStream<ComponentValue>& tok
auto transaction = tokens.begin_transaction(); auto transaction = tokens.begin_transaction();
if (auto dimension_value = parse_dimension_value(tokens)) { if (auto dimension_value = parse_dimension_value(tokens)) {
if (dimension_value->is_angle() if (dimension_value->is_angle()
|| (dimension_value->is_calculated() && dimension_value->as_calculated().resolves_to_angle())) { || (dimension_value->is_math() && dimension_value->as_math().resolves_to_angle())) {
transaction.commit(); transaction.commit();
return dimension_value; return dimension_value;
} }
@ -2542,7 +2542,7 @@ RefPtr<CSSStyleValue> Parser::parse_angle_percentage_value(TokenStream<Component
auto transaction = tokens.begin_transaction(); auto transaction = tokens.begin_transaction();
if (auto dimension_value = parse_dimension_value(tokens)) { if (auto dimension_value = parse_dimension_value(tokens)) {
if (dimension_value->is_angle() || dimension_value->is_percentage() if (dimension_value->is_angle() || dimension_value->is_percentage()
|| (dimension_value->is_calculated() && dimension_value->as_calculated().resolves_to_angle_percentage())) { || (dimension_value->is_math() && dimension_value->as_math().resolves_to_angle_percentage())) {
transaction.commit(); transaction.commit();
return dimension_value; return dimension_value;
} }
@ -2555,7 +2555,7 @@ RefPtr<CSSStyleValue> Parser::parse_flex_value(TokenStream<ComponentValue>& toke
auto transaction = tokens.begin_transaction(); auto transaction = tokens.begin_transaction();
if (auto dimension_value = parse_dimension_value(tokens)) { if (auto dimension_value = parse_dimension_value(tokens)) {
if (dimension_value->is_flex() if (dimension_value->is_flex()
|| (dimension_value->is_calculated() && dimension_value->as_calculated().resolves_to_flex())) { || (dimension_value->is_math() && dimension_value->as_math().resolves_to_flex())) {
transaction.commit(); transaction.commit();
return dimension_value; return dimension_value;
} }
@ -2568,7 +2568,7 @@ RefPtr<CSSStyleValue> Parser::parse_frequency_value(TokenStream<ComponentValue>&
auto transaction = tokens.begin_transaction(); auto transaction = tokens.begin_transaction();
if (auto dimension_value = parse_dimension_value(tokens)) { if (auto dimension_value = parse_dimension_value(tokens)) {
if (dimension_value->is_frequency() if (dimension_value->is_frequency()
|| (dimension_value->is_calculated() && dimension_value->as_calculated().resolves_to_frequency())) { || (dimension_value->is_math() && dimension_value->as_math().resolves_to_frequency())) {
transaction.commit(); transaction.commit();
return dimension_value; return dimension_value;
} }
@ -2581,7 +2581,7 @@ RefPtr<CSSStyleValue> Parser::parse_frequency_percentage_value(TokenStream<Compo
auto transaction = tokens.begin_transaction(); auto transaction = tokens.begin_transaction();
if (auto dimension_value = parse_dimension_value(tokens)) { if (auto dimension_value = parse_dimension_value(tokens)) {
if (dimension_value->is_frequency() || dimension_value->is_percentage() if (dimension_value->is_frequency() || dimension_value->is_percentage()
|| (dimension_value->is_calculated() && dimension_value->as_calculated().resolves_to_frequency_percentage())) { || (dimension_value->is_math() && dimension_value->as_math().resolves_to_frequency_percentage())) {
transaction.commit(); transaction.commit();
return dimension_value; return dimension_value;
} }
@ -2594,7 +2594,7 @@ RefPtr<CSSStyleValue> Parser::parse_length_value(TokenStream<ComponentValue>& to
auto transaction = tokens.begin_transaction(); auto transaction = tokens.begin_transaction();
if (auto dimension_value = parse_dimension_value(tokens)) { if (auto dimension_value = parse_dimension_value(tokens)) {
if (dimension_value->is_length() if (dimension_value->is_length()
|| (dimension_value->is_calculated() && dimension_value->as_calculated().resolves_to_length())) { || (dimension_value->is_math() && dimension_value->as_math().resolves_to_length())) {
transaction.commit(); transaction.commit();
return dimension_value; return dimension_value;
} }
@ -2607,7 +2607,7 @@ RefPtr<CSSStyleValue> Parser::parse_length_percentage_value(TokenStream<Componen
auto transaction = tokens.begin_transaction(); auto transaction = tokens.begin_transaction();
if (auto dimension_value = parse_dimension_value(tokens)) { if (auto dimension_value = parse_dimension_value(tokens)) {
if (dimension_value->is_length() || dimension_value->is_percentage() if (dimension_value->is_length() || dimension_value->is_percentage()
|| (dimension_value->is_calculated() && dimension_value->as_calculated().resolves_to_length_percentage())) { || (dimension_value->is_math() && dimension_value->as_math().resolves_to_length_percentage())) {
transaction.commit(); transaction.commit();
return dimension_value; return dimension_value;
} }
@ -2620,7 +2620,7 @@ RefPtr<CSSStyleValue> Parser::parse_resolution_value(TokenStream<ComponentValue>
auto transaction = tokens.begin_transaction(); auto transaction = tokens.begin_transaction();
if (auto dimension_value = parse_dimension_value(tokens)) { if (auto dimension_value = parse_dimension_value(tokens)) {
if (dimension_value->is_resolution() if (dimension_value->is_resolution()
|| (dimension_value->is_calculated() && dimension_value->as_calculated().resolves_to_resolution())) { || (dimension_value->is_math() && dimension_value->as_math().resolves_to_resolution())) {
transaction.commit(); transaction.commit();
return dimension_value; return dimension_value;
} }
@ -2633,7 +2633,7 @@ RefPtr<CSSStyleValue> Parser::parse_time_value(TokenStream<ComponentValue>& toke
auto transaction = tokens.begin_transaction(); auto transaction = tokens.begin_transaction();
if (auto dimension_value = parse_dimension_value(tokens)) { if (auto dimension_value = parse_dimension_value(tokens)) {
if (dimension_value->is_time() if (dimension_value->is_time()
|| (dimension_value->is_calculated() && dimension_value->as_calculated().resolves_to_time())) { || (dimension_value->is_math() && dimension_value->as_math().resolves_to_time())) {
transaction.commit(); transaction.commit();
return dimension_value; return dimension_value;
} }
@ -2646,7 +2646,7 @@ RefPtr<CSSStyleValue> Parser::parse_time_percentage_value(TokenStream<ComponentV
auto transaction = tokens.begin_transaction(); auto transaction = tokens.begin_transaction();
if (auto dimension_value = parse_dimension_value(tokens)) { if (auto dimension_value = parse_dimension_value(tokens)) {
if (dimension_value->is_time() || dimension_value->is_percentage() if (dimension_value->is_time() || dimension_value->is_percentage()
|| (dimension_value->is_calculated() && dimension_value->as_calculated().resolves_to_time_percentage())) { || (dimension_value->is_math() && dimension_value->as_math().resolves_to_time_percentage())) {
transaction.commit(); transaction.commit();
return dimension_value; return dimension_value;
} }
@ -2855,7 +2855,7 @@ RefPtr<CSSStyleValue> Parser::parse_rgb_color_value(TokenStream<ComponentValue>&
// Verify we're all percentages or all numbers // Verify we're all percentages or all numbers
auto is_percentage = [](CSSStyleValue const& style_value) { auto is_percentage = [](CSSStyleValue const& style_value) {
return style_value.is_percentage() return style_value.is_percentage()
|| (style_value.is_calculated() && style_value.as_calculated().resolves_to_percentage()); || (style_value.is_math() && style_value.as_math().resolves_to_percentage());
}; };
bool red_is_percentage = is_percentage(*red); bool red_is_percentage = is_percentage(*red);
bool green_is_percentage = is_percentage(*green); bool green_is_percentage = is_percentage(*green);
@ -4170,8 +4170,8 @@ static Optional<LengthPercentage> style_value_to_length_percentage(auto value)
return LengthPercentage { value->as_percentage().percentage() }; return LengthPercentage { value->as_percentage().percentage() };
if (value->is_length()) if (value->is_length())
return LengthPercentage { value->as_length().length() }; return LengthPercentage { value->as_length().length() };
if (value->is_calculated()) if (value->is_math())
return LengthPercentage { value->as_calculated() }; return LengthPercentage { value->as_math() };
return {}; return {};
} }
@ -4298,8 +4298,8 @@ RefPtr<CSSStyleValue> Parser::parse_single_background_size_value(TokenStream<Com
return LengthPercentage { style_value.as_percentage().percentage() }; return LengthPercentage { style_value.as_percentage().percentage() };
if (style_value.is_length()) if (style_value.is_length())
return LengthPercentage { style_value.as_length().length() }; return LengthPercentage { style_value.as_length().length() };
if (style_value.is_calculated()) if (style_value.is_math())
return LengthPercentage { style_value.as_calculated() }; return LengthPercentage { style_value.as_math() };
return {}; return {};
}; };
@ -6207,7 +6207,7 @@ RefPtr<CSSStyleValue> Parser::parse_transform_value(TokenStream<ComponentValue>&
argument_tokens.skip_whitespace(); argument_tokens.skip_whitespace();
auto const& value = argument_tokens.next_token(); auto const& value = argument_tokens.next_token();
RefPtr<CalculatedStyleValue> maybe_calc_value = parse_calculated_value(value); RefPtr<CSSMathValue> maybe_calc_value = parse_calculated_value(value);
switch (function_metadata.parameters[argument_index].type) { switch (function_metadata.parameters[argument_index].type) {
case TransformFunctionParameterType::Angle: { case TransformFunctionParameterType::Angle: {
@ -7909,10 +7909,10 @@ public:
ComponentValue& component_value() { return m_component_value; } ComponentValue& component_value() { return m_component_value; }
virtual String to_string() const override { VERIFY_NOT_REACHED(); } virtual String to_string() const override { VERIFY_NOT_REACHED(); }
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override { VERIFY_NOT_REACHED(); } virtual Optional<CSSMathValue::ResolvedType> resolved_type() const override { VERIFY_NOT_REACHED(); }
virtual Optional<CSSNumericType> determine_type(Web::CSS::PropertyID) const override { VERIFY_NOT_REACHED(); } virtual Optional<CSSNumericType> determine_type(Web::CSS::PropertyID) const override { VERIFY_NOT_REACHED(); }
virtual bool contains_percentage() const override { VERIFY_NOT_REACHED(); } virtual bool contains_percentage() const override { VERIFY_NOT_REACHED(); }
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override { VERIFY_NOT_REACHED(); } virtual CSSMathValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CSSMathValue::PercentageBasis const&) const override { VERIFY_NOT_REACHED(); }
virtual void for_each_child_node(AK::Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override { } virtual void for_each_child_node(AK::Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override { }
virtual void dump(StringBuilder& builder, int indent) const override virtual void dump(StringBuilder& builder, int indent) const override
@ -8445,8 +8445,8 @@ bool Parser::expand_unresolved_values(DOM::Element& element, FlyString const& pr
continue; continue;
} }
if (auto maybe_calc_value = parse_calculated_value(value); maybe_calc_value && maybe_calc_value->is_calculated()) { if (auto maybe_calc_value = parse_calculated_value(value); maybe_calc_value && maybe_calc_value->is_math()) {
auto& calc_value = maybe_calc_value->as_calculated(); auto& calc_value = maybe_calc_value->as_math();
if (calc_value.resolves_to_angle()) { if (calc_value.resolves_to_angle()) {
auto resolved_value = calc_value.resolve_angle(); auto resolved_value = calc_value.resolve_angle();
dest.empend(Token::create_dimension(resolved_value->to_degrees(), "deg"_fly_string)); dest.empend(Token::create_dimension(resolved_value->to_degrees(), "deg"_fly_string));

4
Userland/Libraries/LibWeb/CSS/Parser/Parser.h
View file

@ -30,7 +30,7 @@
#include <LibWeb/CSS/Ratio.h> #include <LibWeb/CSS/Ratio.h>
#include <LibWeb/CSS/Selector.h> #include <LibWeb/CSS/Selector.h>
#include <LibWeb/CSS/StyleValues/AbstractImageStyleValue.h> #include <LibWeb/CSS/StyleValues/AbstractImageStyleValue.h>
#include <LibWeb/CSS/StyleValues/CalculatedStyleValue.h> #include <LibWeb/CSS/StyleValues/CSSMathValue.h>
#include <LibWeb/CSS/Supports.h> #include <LibWeb/CSS/Supports.h>
#include <LibWeb/Forward.h> #include <LibWeb/Forward.h>
@ -234,7 +234,7 @@ private:
}; };
Optional<PropertyAndValue> parse_css_value_for_properties(ReadonlySpan<PropertyID>, TokenStream<ComponentValue>&); Optional<PropertyAndValue> parse_css_value_for_properties(ReadonlySpan<PropertyID>, TokenStream<ComponentValue>&);
RefPtr<CSSStyleValue> parse_builtin_value(TokenStream<ComponentValue>&); RefPtr<CSSStyleValue> parse_builtin_value(TokenStream<ComponentValue>&);
RefPtr<CalculatedStyleValue> parse_calculated_value(ComponentValue const&); RefPtr<CSSMathValue> parse_calculated_value(ComponentValue const&);
RefPtr<CustomIdentStyleValue> parse_custom_ident_value(TokenStream<ComponentValue>&, std::initializer_list<StringView> blacklist); RefPtr<CustomIdentStyleValue> parse_custom_ident_value(TokenStream<ComponentValue>&, std::initializer_list<StringView> blacklist);
// NOTE: Implemented in generated code. (GenerateCSSMathFunctions.cpp) // NOTE: Implemented in generated code. (GenerateCSSMathFunctions.cpp)
OwnPtr<CalculationNode> parse_math_function(PropertyID, Function const&); OwnPtr<CalculationNode> parse_math_function(PropertyID, Function const&);

22
Userland/Libraries/LibWeb/CSS/PercentageOr.h
View file

@ -13,7 +13,7 @@
#include <LibWeb/CSS/Length.h> #include <LibWeb/CSS/Length.h>
#include <LibWeb/CSS/Number.h> #include <LibWeb/CSS/Number.h>
#include <LibWeb/CSS/Percentage.h> #include <LibWeb/CSS/Percentage.h>
#include <LibWeb/CSS/StyleValues/CalculatedStyleValue.h> #include <LibWeb/CSS/StyleValues/CSSMathValue.h>
#include <LibWeb/CSS/Time.h> #include <LibWeb/CSS/Time.h>
namespace Web::CSS { namespace Web::CSS {
@ -31,7 +31,7 @@ public:
{ {
} }
PercentageOr(NonnullRefPtr<CalculatedStyleValue> calculated) PercentageOr(NonnullRefPtr<CSSMathValue> calculated)
: m_value(move(calculated)) : m_value(move(calculated))
{ {
} }
@ -51,7 +51,7 @@ public:
} }
bool is_percentage() const { return m_value.template has<Percentage>(); } bool is_percentage() const { return m_value.template has<Percentage>(); }
bool is_calculated() const { return m_value.template has<NonnullRefPtr<CalculatedStyleValue>>(); } bool is_calculated() const { return m_value.template has<NonnullRefPtr<CSSMathValue>>(); }
bool contains_percentage() const bool contains_percentage() const
{ {
@ -62,7 +62,7 @@ public:
[&](Percentage const&) { [&](Percentage const&) {
return true; return true;
}, },
[&](NonnullRefPtr<CalculatedStyleValue> const& calculated) { [&](NonnullRefPtr<CSSMathValue> const& calculated) {
return calculated->contains_percentage(); return calculated->contains_percentage();
}); });
} }
@ -73,10 +73,10 @@ public:
return m_value.template get<Percentage>(); return m_value.template get<Percentage>();
} }
NonnullRefPtr<CalculatedStyleValue> const& calculated() const NonnullRefPtr<CSSMathValue> const& calculated() const
{ {
VERIFY(is_calculated()); VERIFY(is_calculated());
return m_value.template get<NonnullRefPtr<CalculatedStyleValue>>(); return m_value.template get<NonnullRefPtr<CSSMathValue>>();
} }
CSSPixels to_px(Layout::Node const& layout_node, CSSPixels reference_value) const CSSPixels to_px(Layout::Node const& layout_node, CSSPixels reference_value) const
@ -100,7 +100,7 @@ public:
[&](Percentage const& percentage) { [&](Percentage const& percentage) {
return reference_value.percentage_of(percentage); return reference_value.percentage_of(percentage);
}, },
[&](NonnullRefPtr<CalculatedStyleValue> const& calculated) { [&](NonnullRefPtr<CSSMathValue> const& calculated) {
return T::resolve_calculated(calculated, layout_node, reference_value); return T::resolve_calculated(calculated, layout_node, reference_value);
}); });
} }
@ -114,7 +114,7 @@ public:
[&](Percentage const& percentage) { [&](Percentage const& percentage) {
return Length::make_px(CSSPixels(percentage.value() * reference_value) / 100); return Length::make_px(CSSPixels(percentage.value() * reference_value) / 100);
}, },
[&](NonnullRefPtr<CalculatedStyleValue> const& calculated) { [&](NonnullRefPtr<CSSMathValue> const& calculated) {
return T::resolve_calculated(calculated, layout_node, reference_value); return T::resolve_calculated(calculated, layout_node, reference_value);
}); });
} }
@ -122,7 +122,7 @@ public:
String to_string() const String to_string() const
{ {
if (is_calculated()) if (is_calculated())
return m_value.template get<NonnullRefPtr<CalculatedStyleValue>>()->to_string(); return m_value.template get<NonnullRefPtr<CSSMathValue>>()->to_string();
if (is_percentage()) if (is_percentage())
return m_value.template get<Percentage>().to_string(); return m_value.template get<Percentage>().to_string();
return m_value.template get<T>().to_string(); return m_value.template get<T>().to_string();
@ -135,7 +135,7 @@ public:
if (is_percentage() != other.is_percentage()) if (is_percentage() != other.is_percentage())
return false; return false;
if (is_calculated()) if (is_calculated())
return (*m_value.template get<NonnullRefPtr<CalculatedStyleValue>>() == *other.m_value.template get<NonnullRefPtr<CalculatedStyleValue>>()); return (*m_value.template get<NonnullRefPtr<CSSMathValue>>() == *other.m_value.template get<NonnullRefPtr<CSSMathValue>>());
if (is_percentage()) if (is_percentage())
return (m_value.template get<Percentage>() == other.m_value.template get<Percentage>()); return (m_value.template get<Percentage>() == other.m_value.template get<Percentage>());
return (m_value.template get<T>() == other.m_value.template get<T>()); return (m_value.template get<T>() == other.m_value.template get<T>());
@ -146,7 +146,7 @@ protected:
T const& get_t() const { return m_value.template get<T>(); } T const& get_t() const { return m_value.template get<T>(); }
private: private:
Variant<T, Percentage, NonnullRefPtr<CalculatedStyleValue>> m_value; Variant<T, Percentage, NonnullRefPtr<CSSMathValue>> m_value;
}; };
template<typename T> template<typename T>

2
Userland/Libraries/LibWeb/CSS/ResolvedCSSStyleDeclaration.cpp
View file

@ -17,7 +17,7 @@
#include <LibWeb/CSS/StyleValues/BorderRadiusStyleValue.h> #include <LibWeb/CSS/StyleValues/BorderRadiusStyleValue.h>
#include <LibWeb/CSS/StyleValues/CSSColorValue.h> #include <LibWeb/CSS/StyleValues/CSSColorValue.h>
#include <LibWeb/CSS/StyleValues/CSSKeywordValue.h> #include <LibWeb/CSS/StyleValues/CSSKeywordValue.h>
#include <LibWeb/CSS/StyleValues/CalculatedStyleValue.h> #include <LibWeb/CSS/StyleValues/CSSMathValue.h>
#include <LibWeb/CSS/StyleValues/EdgeStyleValue.h> #include <LibWeb/CSS/StyleValues/EdgeStyleValue.h>
#include <LibWeb/CSS/StyleValues/GridTrackPlacementStyleValue.h> #include <LibWeb/CSS/StyleValues/GridTrackPlacementStyleValue.h>
#include <LibWeb/CSS/StyleValues/GridTrackSizeListStyleValue.h> #include <LibWeb/CSS/StyleValues/GridTrackSizeListStyleValue.h>

2
Userland/Libraries/LibWeb/CSS/Size.cpp
View file

@ -44,7 +44,7 @@ Size Size::make_percentage(Percentage percentage)
return Size { Type::Percentage, move(percentage) }; return Size { Type::Percentage, move(percentage) };
} }
Size Size::make_calculated(NonnullRefPtr<Web::CSS::CalculatedStyleValue> calculated) Size Size::make_calculated(NonnullRefPtr<Web::CSS::CSSMathValue> calculated)
{ {
return Size { Type::Calculated, move(calculated) }; return Size { Type::Calculated, move(calculated) };
} }

4
Userland/Libraries/LibWeb/CSS/Size.h
View file

@ -29,7 +29,7 @@ public:
static Size make_px(CSSPixels); static Size make_px(CSSPixels);
static Size make_length(Length); static Size make_length(Length);
static Size make_percentage(Percentage); static Size make_percentage(Percentage);
static Size make_calculated(NonnullRefPtr<CalculatedStyleValue>); static Size make_calculated(NonnullRefPtr<CSSMathValue>);
static Size make_min_content(); static Size make_min_content();
static Size make_max_content(); static Size make_max_content();
static Size make_fit_content(Length available_space); static Size make_fit_content(Length available_space);
@ -52,7 +52,7 @@ public:
bool contains_percentage() const; bool contains_percentage() const;
CalculatedStyleValue const& calculated() const CSSMathValue const& calculated() const
{ {
VERIFY(is_calculated()); VERIFY(is_calculated());
return m_length_percentage.calculated(); return m_length_percentage.calculated();

18
Userland/Libraries/LibWeb/CSS/StyleComputer.cpp
View file

@ -1038,8 +1038,8 @@ static RefPtr<CSSStyleValue const> interpolate_transform(DOM::Element& element,
case CSSStyleValue::Type::Angle: case CSSStyleValue::Type::Angle:
values.append(AngleOrCalculated { value->as_angle().angle() }); values.append(AngleOrCalculated { value->as_angle().angle() });
break; break;
case CSSStyleValue::Type::Calculated: case CSSStyleValue::Type::Math:
values.append(LengthPercentage { value->as_calculated() }); values.append(LengthPercentage { value->as_math() });
break; break;
case CSSStyleValue::Type::Length: case CSSStyleValue::Type::Length:
values.append(LengthPercentage { value->as_length().length() }); values.append(LengthPercentage { value->as_length().length() });
@ -1472,7 +1472,7 @@ static NonnullRefPtr<CSSStyleValue const> interpolate_value(DOM::Element& elemen
values.unchecked_append(to_calculation_node(interpolated_from)); values.unchecked_append(to_calculation_node(interpolated_from));
values.unchecked_append(to_calculation_node(interpolated_to)); values.unchecked_append(to_calculation_node(interpolated_to));
auto calc_node = SumCalculationNode::create(move(values)); auto calc_node = SumCalculationNode::create(move(values));
return CalculatedStyleValue::create(move(calc_node), CSSNumericType { to_base_type_and_default->base_type, 1 }); return CSSMathValue::create(move(calc_node), CSSNumericType { to_base_type_and_default->base_type, 1 });
} }
return delta >= 0.5f ? to : from; return delta >= 0.5f ? to : from;
@ -2240,11 +2240,11 @@ RefPtr<Gfx::FontCascadeList const> StyleComputer::compute_font_for_style_values(
} else if (font_size.is_length()) { } else if (font_size.is_length()) {
maybe_length = font_size.as_length().length(); maybe_length = font_size.as_length().length();
} else if (font_size.is_calculated()) { } else if (font_size.is_math()) {
if (font_size.as_calculated().contains_percentage()) { if (font_size.as_math().contains_percentage()) {
maybe_length = font_size.as_calculated().resolve_length_percentage(length_resolution_context, Length::make_px(parent_font_size())); maybe_length = font_size.as_math().resolve_length_percentage(length_resolution_context, Length::make_px(parent_font_size()));
} else { } else {
maybe_length = font_size.as_calculated().resolve_length(length_resolution_context); maybe_length = font_size.as_math().resolve_length(length_resolution_context);
} }
} }
if (maybe_length.has_value()) { if (maybe_length.has_value()) {
@ -3097,8 +3097,8 @@ void StyleComputer::compute_math_depth(StyleProperties& style, DOM::Element cons
auto resolve_integer = [&](CSSStyleValue const& integer_value) { auto resolve_integer = [&](CSSStyleValue const& integer_value) {
if (integer_value.is_integer()) if (integer_value.is_integer())
return integer_value.as_integer().integer(); return integer_value.as_integer().integer();
if (integer_value.is_calculated()) if (integer_value.is_math())
return integer_value.as_calculated().resolve_integer().value(); return integer_value.as_math().resolve_integer().value();
VERIFY_NOT_REACHED(); VERIFY_NOT_REACHED();
}; };

44
Userland/Libraries/LibWeb/CSS/StyleProperties.cpp
View file

@ -148,8 +148,8 @@ CSS::Size StyleProperties::size_value(CSS::PropertyID id) const
} }
} }
if (value->is_calculated()) if (value->is_math())
return CSS::Size::make_calculated(const_cast<CalculatedStyleValue&>(value->as_calculated())); return CSS::Size::make_calculated(const_cast<CSSMathValue&>(value->as_math()));
if (value->is_percentage()) if (value->is_percentage())
return CSS::Size::make_percentage(value->as_percentage().percentage()); return CSS::Size::make_percentage(value->as_percentage().percentage());
@ -175,8 +175,8 @@ Optional<LengthPercentage> StyleProperties::length_percentage(CSS::PropertyID id
{ {
auto value = property(id); auto value = property(id);
if (value->is_calculated()) if (value->is_math())
return LengthPercentage { const_cast<CalculatedStyleValue&>(value->as_calculated()) }; return LengthPercentage { const_cast<CSSMathValue&>(value->as_math()) };
if (value->is_percentage()) if (value->is_percentage())
return value->as_percentage().percentage(); return value->as_percentage().percentage();
@ -244,19 +244,19 @@ CSSPixels StyleProperties::compute_line_height(CSSPixelRect const& viewport_rect
return Length(percentage.as_fraction(), Length::Type::Em).to_px(viewport_rect, font_metrics, root_font_metrics); return Length(percentage.as_fraction(), Length::Type::Em).to_px(viewport_rect, font_metrics, root_font_metrics);
} }
if (line_height->is_calculated()) { if (line_height->is_math()) {
if (line_height->as_calculated().resolves_to_number()) { if (line_height->as_math().resolves_to_number()) {
auto resolved = line_height->as_calculated().resolve_number(); auto resolved = line_height->as_math().resolve_number();
if (!resolved.has_value()) { if (!resolved.has_value()) {
dbgln("FIXME: Failed to resolve calc() line-height (number): {}", line_height->as_calculated().to_string()); dbgln("FIXME: Failed to resolve calc() line-height (number): {}", line_height->as_math().to_string());
return CSSPixels::nearest_value_for(m_data->m_font_list->first().pixel_metrics().line_spacing()); return CSSPixels::nearest_value_for(m_data->m_font_list->first().pixel_metrics().line_spacing());
} }
return Length(resolved.value(), Length::Type::Em).to_px(viewport_rect, font_metrics, root_font_metrics); return Length(resolved.value(), Length::Type::Em).to_px(viewport_rect, font_metrics, root_font_metrics);
} }
auto resolved = line_height->as_calculated().resolve_length(Length::ResolutionContext { viewport_rect, font_metrics, root_font_metrics }); auto resolved = line_height->as_math().resolve_length(Length::ResolutionContext { viewport_rect, font_metrics, root_font_metrics });
if (!resolved.has_value()) { if (!resolved.has_value()) {
dbgln("FIXME: Failed to resolve calc() line-height: {}", line_height->as_calculated().to_string()); dbgln("FIXME: Failed to resolve calc() line-height: {}", line_height->as_math().to_string());
return CSSPixels::nearest_value_for(m_data->m_font_list->first().pixel_metrics().line_spacing()); return CSSPixels::nearest_value_for(m_data->m_font_list->first().pixel_metrics().line_spacing());
} }
return resolved->to_px(viewport_rect, font_metrics, root_font_metrics); return resolved->to_px(viewport_rect, font_metrics, root_font_metrics);
@ -288,16 +288,16 @@ float StyleProperties::resolve_opacity_value(CSSStyleValue const& value)
if (value.is_number()) { if (value.is_number()) {
unclamped_opacity = value.as_number().number(); unclamped_opacity = value.as_number().number();
} else if (value.is_calculated()) { } else if (value.is_math()) {
auto& calculated = value.as_calculated(); auto& calculated = value.as_math();
if (calculated.resolves_to_percentage()) { if (calculated.resolves_to_percentage()) {
auto maybe_percentage = value.as_calculated().resolve_percentage(); auto maybe_percentage = value.as_math().resolve_percentage();
if (maybe_percentage.has_value()) if (maybe_percentage.has_value())
unclamped_opacity = maybe_percentage->as_fraction(); unclamped_opacity = maybe_percentage->as_fraction();
else else
dbgln("Unable to resolve calc() as opacity (percentage): {}", value.to_string()); dbgln("Unable to resolve calc() as opacity (percentage): {}", value.to_string());
} else if (calculated.resolves_to_number()) { } else if (calculated.resolves_to_number()) {
auto maybe_number = const_cast<CalculatedStyleValue&>(value.as_calculated()).resolve_number(); auto maybe_number = const_cast<CSSMathValue&>(value.as_math()).resolve_number();
if (maybe_number.has_value()) if (maybe_number.has_value())
unclamped_opacity = maybe_number.value(); unclamped_opacity = maybe_number.value();
else else
@ -469,8 +469,8 @@ Vector<CSS::Transformation> StyleProperties::transformations_for_style_value(CSS
Vector<TransformValue> values; Vector<TransformValue> values;
size_t argument_index = 0; size_t argument_index = 0;
for (auto& transformation_value : transformation_style_value.values()) { for (auto& transformation_value : transformation_style_value.values()) {
if (transformation_value->is_calculated()) { if (transformation_value->is_math()) {
auto& calculated = transformation_value->as_calculated(); auto& calculated = transformation_value->as_math();
if (calculated.resolves_to_length_percentage()) { if (calculated.resolves_to_length_percentage()) {
values.append(CSS::LengthPercentage { calculated }); values.append(CSS::LengthPercentage { calculated });
} else if (calculated.resolves_to_percentage()) { } else if (calculated.resolves_to_percentage()) {
@ -903,8 +903,8 @@ Vector<ShadowData> StyleProperties::shadow(PropertyID property_id, Layout::Node
auto resolve_to_length = [&layout_node](NonnullRefPtr<CSSStyleValue const> const& value) -> Optional<Length> { auto resolve_to_length = [&layout_node](NonnullRefPtr<CSSStyleValue const> const& value) -> Optional<Length> {
if (value->is_length()) if (value->is_length())
return value->as_length().length(); return value->as_length().length();
if (value->is_calculated()) if (value->is_math())
return value->as_calculated().resolve_length(layout_node); return value->as_math().resolve_length(layout_node);
return {}; return {};
}; };
@ -985,8 +985,8 @@ Variant<CSS::VerticalAlign, CSS::LengthPercentage> StyleProperties::vertical_ali
if (value->is_percentage()) if (value->is_percentage())
return CSS::LengthPercentage(value->as_percentage().percentage()); return CSS::LengthPercentage(value->as_percentage().percentage());
if (value->is_calculated()) if (value->is_math())
return LengthPercentage { const_cast<CalculatedStyleValue&>(value->as_calculated()) }; return LengthPercentage { const_cast<CSSMathValue&>(value->as_math()) };
VERIFY_NOT_REACHED(); VERIFY_NOT_REACHED();
} }
@ -1178,8 +1178,8 @@ Vector<CounterData> StyleProperties::counter_data(PropertyID property_id) const
if (counter.value) { if (counter.value) {
if (counter.value->is_integer()) { if (counter.value->is_integer()) {
data.value = AK::clamp_to<i32>(counter.value->as_integer().integer()); data.value = AK::clamp_to<i32>(counter.value->as_integer().integer());
} else if (counter.value->is_calculated()) { } else if (counter.value->is_math()) {
auto maybe_int = counter.value->as_calculated().resolve_integer(); auto maybe_int = counter.value->as_math().resolve_integer();
if (maybe_int.has_value()) if (maybe_int.has_value())
data.value = AK::clamp_to<i32>(*maybe_int); data.value = AK::clamp_to<i32>(*maybe_int);
} else { } else {

14
Userland/Libraries/LibWeb/CSS/StyleValues/CSSColorValue.cpp
View file

@ -10,8 +10,8 @@
#include "CSSColorValue.h" #include "CSSColorValue.h"
#include <LibWeb/CSS/Serialize.h> #include <LibWeb/CSS/Serialize.h>
#include <LibWeb/CSS/StyleValues/AngleStyleValue.h> #include <LibWeb/CSS/StyleValues/AngleStyleValue.h>
#include <LibWeb/CSS/StyleValues/CSSMathValue.h>
#include <LibWeb/CSS/StyleValues/CSSRGB.h> #include <LibWeb/CSS/StyleValues/CSSRGB.h>
#include <LibWeb/CSS/StyleValues/CalculatedStyleValue.h>
#include <LibWeb/CSS/StyleValues/NumberStyleValue.h> #include <LibWeb/CSS/StyleValues/NumberStyleValue.h>
#include <LibWeb/CSS/StyleValues/PercentageStyleValue.h> #include <LibWeb/CSS/StyleValues/PercentageStyleValue.h>
@ -58,8 +58,8 @@ Optional<float> CSSColorValue::resolve_hue(CSSStyleValue const& style_value)
if (style_value.is_angle()) if (style_value.is_angle())
return normalized(style_value.as_angle().angle().to_degrees()); return normalized(style_value.as_angle().angle().to_degrees());
if (style_value.is_calculated() && style_value.as_calculated().resolves_to_angle()) if (style_value.is_math() && style_value.as_math().resolves_to_angle())
return normalized(style_value.as_calculated().resolve_angle().value().to_degrees()); return normalized(style_value.as_math().resolve_angle().value().to_degrees());
if (style_value.is_keyword() && style_value.to_keyword() == Keyword::None) if (style_value.is_keyword() && style_value.to_keyword() == Keyword::None)
return 0; return 0;
@ -80,8 +80,8 @@ Optional<float> CSSColorValue::resolve_with_reference_value(CSSStyleValue const&
if (style_value.is_number()) if (style_value.is_number())
return style_value.as_number().number(); return style_value.as_number().number();
if (style_value.is_calculated()) { if (style_value.is_math()) {
auto const& calculated = style_value.as_calculated(); auto const& calculated = style_value.as_math();
if (calculated.resolves_to_number()) if (calculated.resolves_to_number())
return calculated.resolve_number().value(); return calculated.resolve_number().value();
if (calculated.resolves_to_percentage()) if (calculated.resolves_to_percentage())
@ -107,8 +107,8 @@ Optional<float> CSSColorValue::resolve_alpha(CSSStyleValue const& style_value)
if (style_value.is_percentage()) if (style_value.is_percentage())
return normalized(style_value.as_percentage().percentage().as_fraction()); return normalized(style_value.as_percentage().percentage().as_fraction());
if (style_value.is_calculated()) { if (style_value.is_math()) {
auto const& calculated = style_value.as_calculated(); auto const& calculated = style_value.as_math();
if (calculated.resolves_to_number()) if (calculated.resolves_to_number())
return normalized(calculated.resolve_number().value()); return normalized(calculated.resolve_number().value());
if (calculated.resolves_to_percentage()) if (calculated.resolves_to_percentage())

274
Userland/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.cpp → Userland/Libraries/LibWeb/CSS/StyleValues/CSSMathValue.cpp
View file

@ -1,31 +1,31 @@
/* /*
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org> * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
* Copyright (c) 2021, Tobias Christiansen <tobyase@serenityos.org> * Copyright (c) 2021, Tobias Christiansen <tobyase@serenityos.org>
* Copyright (c) 2021-2023, Sam Atkins <atkinssj@serenityos.org> * Copyright (c) 2021-2024, Sam Atkins <sam@ladybird.org>
* Copyright (c) 2022-2023, MacDue <macdue@dueutil.tech> * Copyright (c) 2022-2023, MacDue <macdue@dueutil.tech>
* *
* SPDX-License-Identifier: BSD-2-Clause * SPDX-License-Identifier: BSD-2-Clause
*/ */
#include "CalculatedStyleValue.h" #include "CSSMathValue.h"
#include <LibWeb/CSS/Percentage.h> #include <LibWeb/CSS/Percentage.h>
#include <LibWeb/CSS/PropertyID.h> #include <LibWeb/CSS/PropertyID.h>
namespace Web::CSS { namespace Web::CSS {
static bool is_number(CalculatedStyleValue::ResolvedType type) static bool is_number(CSSMathValue::ResolvedType type)
{ {
return type == CalculatedStyleValue::ResolvedType::Number || type == CalculatedStyleValue::ResolvedType::Integer; return type == CSSMathValue::ResolvedType::Number || type == CSSMathValue::ResolvedType::Integer;
} }
static bool is_dimension(CalculatedStyleValue::ResolvedType type) static bool is_dimension(CSSMathValue::ResolvedType type)
{ {
return type != CalculatedStyleValue::ResolvedType::Number return type != CSSMathValue::ResolvedType::Number
&& type != CalculatedStyleValue::ResolvedType::Integer && type != CSSMathValue::ResolvedType::Integer
&& type != CalculatedStyleValue::ResolvedType::Percentage; && type != CSSMathValue::ResolvedType::Percentage;
} }
static double resolve_value_radians(CalculatedStyleValue::CalculationResult::Value value) static double resolve_value_radians(CSSMathValue::CalculationResult::Value value)
{ {
return value.visit( return value.visit(
[](Number const& number) { return number.value(); }, [](Number const& number) { return number.value(); },
@ -33,7 +33,7 @@ static double resolve_value_radians(CalculatedStyleValue::CalculationResult::Val
[](auto const&) { VERIFY_NOT_REACHED(); return 0.0; }); [](auto const&) { VERIFY_NOT_REACHED(); return 0.0; });
} }
static double resolve_value(CalculatedStyleValue::CalculationResult::Value value, Optional<Length::ResolutionContext const&> context) static double resolve_value(CSSMathValue::CalculationResult::Value value, Optional<Length::ResolutionContext const&> context)
{ {
return value.visit( return value.visit(
[](Number const& number) { return number.value(); }, [](Number const& number) { return number.value(); },
@ -67,26 +67,26 @@ static Optional<CSSNumericType> add_the_types(Vector<NonnullOwnPtr<CalculationNo
return left_type; return left_type;
} }
static CalculatedStyleValue::CalculationResult to_resolved_type(CalculatedStyleValue::ResolvedType type, double value) static CSSMathValue::CalculationResult to_resolved_type(CSSMathValue::ResolvedType type, double value)
{ {
switch (type) { switch (type) {
case CalculatedStyleValue::ResolvedType::Integer: case CSSMathValue::ResolvedType::Integer:
return { Number(Number::Type::Integer, value) }; return { Number(Number::Type::Integer, value) };
case CalculatedStyleValue::ResolvedType::Number: case CSSMathValue::ResolvedType::Number:
return { Number(Number::Type::Number, value) }; return { Number(Number::Type::Number, value) };
case CalculatedStyleValue::ResolvedType::Angle: case CSSMathValue::ResolvedType::Angle:
return { Angle::make_degrees(value) }; return { Angle::make_degrees(value) };
case CalculatedStyleValue::ResolvedType::Flex: case CSSMathValue::ResolvedType::Flex:
return { Flex::make_fr(value) }; return { Flex::make_fr(value) };
case CalculatedStyleValue::ResolvedType::Frequency: case CSSMathValue::ResolvedType::Frequency:
return { Frequency::make_hertz(value) }; return { Frequency::make_hertz(value) };
case CalculatedStyleValue::ResolvedType::Length: case CSSMathValue::ResolvedType::Length:
return { Length::make_px(CSSPixels::nearest_value_for(value)) }; return { Length::make_px(CSSPixels::nearest_value_for(value)) };
case CalculatedStyleValue::ResolvedType::Percentage: case CSSMathValue::ResolvedType::Percentage:
return { Percentage(value) }; return { Percentage(value) };
case CalculatedStyleValue::ResolvedType::Resolution: case CSSMathValue::ResolvedType::Resolution:
return { Resolution::make_dots_per_pixel(value) }; return { Resolution::make_dots_per_pixel(value) };
case CalculatedStyleValue::ResolvedType::Time: case CSSMathValue::ResolvedType::Time:
return { Time::make_seconds(value) }; return { Time::make_seconds(value) };
} }
@ -138,17 +138,17 @@ String NumericCalculationNode::to_string() const
return m_value.visit([](auto& value) { return value.to_string(); }); return m_value.visit([](auto& value) { return value.to_string(); });
} }
Optional<CalculatedStyleValue::ResolvedType> NumericCalculationNode::resolved_type() const Optional<CSSMathValue::ResolvedType> NumericCalculationNode::resolved_type() const
{ {
return m_value.visit( return m_value.visit(
[](Number const&) { return CalculatedStyleValue::ResolvedType::Number; }, [](Number const&) { return CSSMathValue::ResolvedType::Number; },
[](Angle const&) { return CalculatedStyleValue::ResolvedType::Angle; }, [](Angle const&) { return CSSMathValue::ResolvedType::Angle; },
[](Flex const&) { return CalculatedStyleValue::ResolvedType::Flex; }, [](Flex const&) { return CSSMathValue::ResolvedType::Flex; },
[](Frequency const&) { return CalculatedStyleValue::ResolvedType::Frequency; }, [](Frequency const&) { return CSSMathValue::ResolvedType::Frequency; },
[](Length const&) { return CalculatedStyleValue::ResolvedType::Length; }, [](Length const&) { return CSSMathValue::ResolvedType::Length; },
[](Percentage const&) { return CalculatedStyleValue::ResolvedType::Percentage; }, [](Percentage const&) { return CSSMathValue::ResolvedType::Percentage; },
[](Resolution const&) { return CalculatedStyleValue::ResolvedType::Resolution; }, [](Resolution const&) { return CSSMathValue::ResolvedType::Resolution; },
[](Time const&) { return CalculatedStyleValue::ResolvedType::Time; }); [](Time const&) { return CSSMathValue::ResolvedType::Time; });
} }
// https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
@ -217,17 +217,17 @@ bool NumericCalculationNode::contains_percentage() const
return m_value.has<Percentage>(); return m_value.has<Percentage>();
} }
CalculatedStyleValue::CalculationResult NumericCalculationNode::resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const& percentage_basis) const CSSMathValue::CalculationResult NumericCalculationNode::resolve(Optional<Length::ResolutionContext const&>, CSSMathValue::PercentageBasis const& percentage_basis) const
{ {
if (m_value.has<Percentage>()) { if (m_value.has<Percentage>()) {
// NOTE: Depending on whether percentage_basis is set, the caller of resolve() is expecting a raw percentage or // NOTE: Depending on whether percentage_basis is set, the caller of resolve() is expecting a raw percentage or
// resolved length. // resolved length.
return percentage_basis.visit( return percentage_basis.visit(
[&](Empty const&) -> CalculatedStyleValue::CalculationResult { [&](Empty const&) -> CSSMathValue::CalculationResult {
return m_value; return m_value;
}, },
[&](auto const& value) { [&](auto const& value) {
return CalculatedStyleValue::CalculationResult(value.percentage_of(m_value.get<Percentage>())); return CSSMathValue::CalculationResult(value.percentage_of(m_value.get<Percentage>()));
}); });
} }
@ -275,12 +275,12 @@ String SumCalculationNode::to_string() const
return MUST(builder.to_string()); return MUST(builder.to_string());
} }
Optional<CalculatedStyleValue::ResolvedType> SumCalculationNode::resolved_type() const Optional<CSSMathValue::ResolvedType> SumCalculationNode::resolved_type() const
{ {
// FIXME: Implement https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // FIXME: Implement https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
// For now, this is just ad-hoc, based on the old implementation. // For now, this is just ad-hoc, based on the old implementation.
Optional<CalculatedStyleValue::ResolvedType> type; Optional<CSSMathValue::ResolvedType> type;
for (auto const& value : m_values) { for (auto const& value : m_values) {
auto maybe_value_type = value->resolved_type(); auto maybe_value_type = value->resolved_type();
if (!maybe_value_type.has_value()) if (!maybe_value_type.has_value())
@ -299,17 +299,17 @@ Optional<CalculatedStyleValue::ResolvedType> SumCalculationNode::resolved_type()
// If one side is a <number> and the other is an <integer>, resolve to <number>. // If one side is a <number> and the other is an <integer>, resolve to <number>.
if (is_number(*type) && is_number(value_type)) { if (is_number(*type) && is_number(value_type)) {
type = CalculatedStyleValue::ResolvedType::Number; type = CSSMathValue::ResolvedType::Number;
continue; continue;
} }
// FIXME: calc() handles <percentage> by allowing them to pretend to be whatever <dimension> type is allowed at this location. // FIXME: calc() handles <percentage> by allowing them to pretend to be whatever <dimension> type is allowed at this location.
// Since we can't easily check what that type is, we just allow <percentage> to combine with any other <dimension> type. // Since we can't easily check what that type is, we just allow <percentage> to combine with any other <dimension> type.
if (type == CalculatedStyleValue::ResolvedType::Percentage && is_dimension(value_type)) { if (type == CSSMathValue::ResolvedType::Percentage && is_dimension(value_type)) {
type = value_type; type = value_type;
continue; continue;
} }
if (is_dimension(*type) && value_type == CalculatedStyleValue::ResolvedType::Percentage) if (is_dimension(*type) && value_type == CSSMathValue::ResolvedType::Percentage)
continue; continue;
return {}; return {};
@ -335,9 +335,9 @@ bool SumCalculationNode::contains_percentage() const
return false; return false;
} }
CalculatedStyleValue::CalculationResult SumCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CalculatedStyleValue::PercentageBasis const& percentage_basis) const CSSMathValue::CalculationResult SumCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CSSMathValue::PercentageBasis const& percentage_basis) const
{ {
Optional<CalculatedStyleValue::CalculationResult> total; Optional<CSSMathValue::CalculationResult> total;
for (auto& additional_product : m_values) { for (auto& additional_product : m_values) {
auto additional_value = additional_product->resolve(context, percentage_basis); auto additional_value = additional_product->resolve(context, percentage_basis);
@ -408,12 +408,12 @@ String ProductCalculationNode::to_string() const
return MUST(builder.to_string()); return MUST(builder.to_string());
} }
Optional<CalculatedStyleValue::ResolvedType> ProductCalculationNode::resolved_type() const Optional<CSSMathValue::ResolvedType> ProductCalculationNode::resolved_type() const
{ {
// FIXME: Implement https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // FIXME: Implement https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
// For now, this is just ad-hoc, based on the old implementation. // For now, this is just ad-hoc, based on the old implementation.
Optional<CalculatedStyleValue::ResolvedType> type; Optional<CSSMathValue::ResolvedType> type;
for (auto const& value : m_values) { for (auto const& value : m_values) {
auto maybe_value_type = value->resolved_type(); auto maybe_value_type = value->resolved_type();
if (!maybe_value_type.has_value()) if (!maybe_value_type.has_value())
@ -429,8 +429,8 @@ Optional<CalculatedStyleValue::ResolvedType> ProductCalculationNode::resolved_ty
if (!(is_number(*type) || is_number(value_type))) if (!(is_number(*type) || is_number(value_type)))
return {}; return {};
// If both sides are <integer>, resolve to <integer>. // If both sides are <integer>, resolve to <integer>.
if (type == CalculatedStyleValue::ResolvedType::Integer && value_type == CalculatedStyleValue::ResolvedType::Integer) { if (type == CSSMathValue::ResolvedType::Integer && value_type == CSSMathValue::ResolvedType::Integer) {
type = CalculatedStyleValue::ResolvedType::Integer; type = CSSMathValue::ResolvedType::Integer;
} else { } else {
// Otherwise, resolve to the type of the other side. // Otherwise, resolve to the type of the other side.
if (is_number(*type)) if (is_number(*type))
@ -473,9 +473,9 @@ bool ProductCalculationNode::contains_percentage() const
return false; return false;
} }
CalculatedStyleValue::CalculationResult ProductCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CalculatedStyleValue::PercentageBasis const& percentage_basis) const CSSMathValue::CalculationResult ProductCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CSSMathValue::PercentageBasis const& percentage_basis) const
{ {
Optional<CalculatedStyleValue::CalculationResult> total; Optional<CSSMathValue::CalculationResult> total;
for (auto& additional_product : m_values) { for (auto& additional_product : m_values) {
auto additional_value = additional_product->resolve(context, percentage_basis); auto additional_value = additional_product->resolve(context, percentage_basis);
@ -537,7 +537,7 @@ String NegateCalculationNode::to_string() const
return MUST(String::formatted("(0 - {})", m_value->to_string())); return MUST(String::formatted("(0 - {})", m_value->to_string()));
} }
Optional<CalculatedStyleValue::ResolvedType> NegateCalculationNode::resolved_type() const Optional<CSSMathValue::ResolvedType> NegateCalculationNode::resolved_type() const
{ {
return m_value->resolved_type(); return m_value->resolved_type();
} }
@ -554,7 +554,7 @@ bool NegateCalculationNode::contains_percentage() const
return m_value->contains_percentage(); return m_value->contains_percentage();
} }
CalculatedStyleValue::CalculationResult NegateCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CalculatedStyleValue::PercentageBasis const& percentage_basis) const CSSMathValue::CalculationResult NegateCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CSSMathValue::PercentageBasis const& percentage_basis) const
{ {
auto child_value = m_value->resolve(context, percentage_basis); auto child_value = m_value->resolve(context, percentage_basis);
child_value.negate(); child_value.negate();
@ -600,11 +600,11 @@ String InvertCalculationNode::to_string() const
return MUST(String::formatted("(1 / {})", m_value->to_string())); return MUST(String::formatted("(1 / {})", m_value->to_string()));
} }
Optional<CalculatedStyleValue::ResolvedType> InvertCalculationNode::resolved_type() const Optional<CSSMathValue::ResolvedType> InvertCalculationNode::resolved_type() const
{ {
auto type = m_value->resolved_type(); auto type = m_value->resolved_type();
if (type == CalculatedStyleValue::ResolvedType::Integer) if (type == CSSMathValue::ResolvedType::Integer)
return CalculatedStyleValue::ResolvedType::Number; return CSSMathValue::ResolvedType::Number;
return type; return type;
} }
@ -624,7 +624,7 @@ bool InvertCalculationNode::contains_percentage() const
return m_value->contains_percentage(); return m_value->contains_percentage();
} }
CalculatedStyleValue::CalculationResult InvertCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CalculatedStyleValue::PercentageBasis const& percentage_basis) const CSSMathValue::CalculationResult InvertCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CSSMathValue::PercentageBasis const& percentage_basis) const
{ {
auto child_value = m_value->resolve(context, percentage_basis); auto child_value = m_value->resolve(context, percentage_basis);
child_value.invert(); child_value.invert();
@ -678,7 +678,7 @@ String MinCalculationNode::to_string() const
return MUST(builder.to_string()); return MUST(builder.to_string());
} }
Optional<CalculatedStyleValue::ResolvedType> MinCalculationNode::resolved_type() const Optional<CSSMathValue::ResolvedType> MinCalculationNode::resolved_type() const
{ {
// NOTE: We check during parsing that all values have the same type. // NOTE: We check during parsing that all values have the same type.
return m_values[0]->resolved_type(); return m_values[0]->resolved_type();
@ -701,9 +701,9 @@ bool MinCalculationNode::contains_percentage() const
return false; return false;
} }
CalculatedStyleValue::CalculationResult MinCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CalculatedStyleValue::PercentageBasis const& percentage_basis) const CSSMathValue::CalculationResult MinCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CSSMathValue::PercentageBasis const& percentage_basis) const
{ {
CalculatedStyleValue::CalculationResult smallest_node = m_values.first()->resolve(context, percentage_basis); CSSMathValue::CalculationResult smallest_node = m_values.first()->resolve(context, percentage_basis);
auto smallest_value = resolve_value(smallest_node.value(), context); auto smallest_value = resolve_value(smallest_node.value(), context);
for (size_t i = 1; i < m_values.size(); i++) { for (size_t i = 1; i < m_values.size(); i++) {
@ -775,7 +775,7 @@ String MaxCalculationNode::to_string() const
return MUST(builder.to_string()); return MUST(builder.to_string());
} }
Optional<CalculatedStyleValue::ResolvedType> MaxCalculationNode::resolved_type() const Optional<CSSMathValue::ResolvedType> MaxCalculationNode::resolved_type() const
{ {
// NOTE: We check during parsing that all values have the same type. // NOTE: We check during parsing that all values have the same type.
return m_values[0]->resolved_type(); return m_values[0]->resolved_type();
@ -798,9 +798,9 @@ bool MaxCalculationNode::contains_percentage() const
return false; return false;
} }
CalculatedStyleValue::CalculationResult MaxCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CalculatedStyleValue::PercentageBasis const& percentage_basis) const CSSMathValue::CalculationResult MaxCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CSSMathValue::PercentageBasis const& percentage_basis) const
{ {
CalculatedStyleValue::CalculationResult largest_node = m_values.first()->resolve(context, percentage_basis); CSSMathValue::CalculationResult largest_node = m_values.first()->resolve(context, percentage_basis);
auto largest_value = resolve_value(largest_node.value(), context); auto largest_value = resolve_value(largest_node.value(), context);
for (size_t i = 1; i < m_values.size(); i++) { for (size_t i = 1; i < m_values.size(); i++) {
@ -874,7 +874,7 @@ String ClampCalculationNode::to_string() const
return MUST(builder.to_string()); return MUST(builder.to_string());
} }
Optional<CalculatedStyleValue::ResolvedType> ClampCalculationNode::resolved_type() const Optional<CSSMathValue::ResolvedType> ClampCalculationNode::resolved_type() const
{ {
// NOTE: We check during parsing that all values have the same type. // NOTE: We check during parsing that all values have the same type.
return m_min_value->resolved_type(); return m_min_value->resolved_type();
@ -902,7 +902,7 @@ bool ClampCalculationNode::contains_percentage() const
return m_min_value->contains_percentage() || m_center_value->contains_percentage() || m_max_value->contains_percentage(); return m_min_value->contains_percentage() || m_center_value->contains_percentage() || m_max_value->contains_percentage();
} }
CalculatedStyleValue::CalculationResult ClampCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CalculatedStyleValue::PercentageBasis const& percentage_basis) const CSSMathValue::CalculationResult ClampCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CSSMathValue::PercentageBasis const& percentage_basis) const
{ {
auto min_node = m_min_value->resolve(context, percentage_basis); auto min_node = m_min_value->resolve(context, percentage_basis);
auto center_node = m_center_value->resolve(context, percentage_basis); auto center_node = m_center_value->resolve(context, percentage_basis);
@ -975,7 +975,7 @@ String AbsCalculationNode::to_string() const
return MUST(builder.to_string()); return MUST(builder.to_string());
} }
Optional<CalculatedStyleValue::ResolvedType> AbsCalculationNode::resolved_type() const Optional<CSSMathValue::ResolvedType> AbsCalculationNode::resolved_type() const
{ {
return m_value->resolved_type(); return m_value->resolved_type();
} }
@ -992,7 +992,7 @@ bool AbsCalculationNode::contains_percentage() const
return m_value->contains_percentage(); return m_value->contains_percentage();
} }
CalculatedStyleValue::CalculationResult AbsCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CalculatedStyleValue::PercentageBasis const& percentage_basis) const CSSMathValue::CalculationResult AbsCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CSSMathValue::PercentageBasis const& percentage_basis) const
{ {
auto resolved_type = m_value->resolved_type().value(); auto resolved_type = m_value->resolved_type().value();
auto node_a = m_value->resolve(context, percentage_basis); auto node_a = m_value->resolve(context, percentage_basis);
@ -1046,9 +1046,9 @@ String SignCalculationNode::to_string() const
return MUST(builder.to_string()); return MUST(builder.to_string());
} }
Optional<CalculatedStyleValue::ResolvedType> SignCalculationNode::resolved_type() const Optional<CSSMathValue::ResolvedType> SignCalculationNode::resolved_type() const
{ {
return CalculatedStyleValue::ResolvedType::Integer; return CSSMathValue::ResolvedType::Integer;
} }
// https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
@ -1063,7 +1063,7 @@ bool SignCalculationNode::contains_percentage() const
return m_value->contains_percentage(); return m_value->contains_percentage();
} }
CalculatedStyleValue::CalculationResult SignCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CalculatedStyleValue::PercentageBasis const& percentage_basis) const CSSMathValue::CalculationResult SignCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CSSMathValue::PercentageBasis const& percentage_basis) const
{ {
auto node_a = m_value->resolve(context, percentage_basis); auto node_a = m_value->resolve(context, percentage_basis);
auto node_a_value = resolve_value(node_a.value(), context); auto node_a_value = resolve_value(node_a.value(), context);
@ -1127,9 +1127,9 @@ String ConstantCalculationNode::to_string() const
VERIFY_NOT_REACHED(); VERIFY_NOT_REACHED();
} }
Optional<CalculatedStyleValue::ResolvedType> ConstantCalculationNode::resolved_type() const Optional<CSSMathValue::ResolvedType> ConstantCalculationNode::resolved_type() const
{ {
return CalculatedStyleValue::ResolvedType::Number; return CSSMathValue::ResolvedType::Number;
} }
// https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
@ -1141,7 +1141,7 @@ Optional<CSSNumericType> ConstantCalculationNode::determine_type(PropertyID) con
return CSSNumericType {}; return CSSNumericType {};
} }
CalculatedStyleValue::CalculationResult ConstantCalculationNode::resolve([[maybe_unused]] Optional<Length::ResolutionContext const&> context, [[maybe_unused]] CalculatedStyleValue::PercentageBasis const& percentage_basis) const CSSMathValue::CalculationResult ConstantCalculationNode::resolve([[maybe_unused]] Optional<Length::ResolutionContext const&> context, [[maybe_unused]] CSSMathValue::PercentageBasis const& percentage_basis) const
{ {
switch (m_constant) { switch (m_constant) {
case CalculationNode::ConstantType::E: case CalculationNode::ConstantType::E:
@ -1196,9 +1196,9 @@ String SinCalculationNode::to_string() const
return MUST(builder.to_string()); return MUST(builder.to_string());
} }
Optional<CalculatedStyleValue::ResolvedType> SinCalculationNode::resolved_type() const Optional<CSSMathValue::ResolvedType> SinCalculationNode::resolved_type() const
{ {
return CalculatedStyleValue::ResolvedType::Number; return CSSMathValue::ResolvedType::Number;
} }
// https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
@ -1213,7 +1213,7 @@ bool SinCalculationNode::contains_percentage() const
return m_value->contains_percentage(); return m_value->contains_percentage();
} }
CalculatedStyleValue::CalculationResult SinCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CalculatedStyleValue::PercentageBasis const& percentage_basis) const CSSMathValue::CalculationResult SinCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CSSMathValue::PercentageBasis const& percentage_basis) const
{ {
auto node_a = m_value->resolve(context, percentage_basis); auto node_a = m_value->resolve(context, percentage_basis);
auto node_a_value = resolve_value_radians(node_a.value()); auto node_a_value = resolve_value_radians(node_a.value());
@ -1264,9 +1264,9 @@ String CosCalculationNode::to_string() const
return MUST(builder.to_string()); return MUST(builder.to_string());
} }
Optional<CalculatedStyleValue::ResolvedType> CosCalculationNode::resolved_type() const Optional<CSSMathValue::ResolvedType> CosCalculationNode::resolved_type() const
{ {
return CalculatedStyleValue::ResolvedType::Number; return CSSMathValue::ResolvedType::Number;
} }
// https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
@ -1281,7 +1281,7 @@ bool CosCalculationNode::contains_percentage() const
return m_value->contains_percentage(); return m_value->contains_percentage();
} }
CalculatedStyleValue::CalculationResult CosCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CalculatedStyleValue::PercentageBasis const& percentage_basis) const CSSMathValue::CalculationResult CosCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CSSMathValue::PercentageBasis const& percentage_basis) const
{ {
auto node_a = m_value->resolve(context, percentage_basis); auto node_a = m_value->resolve(context, percentage_basis);
auto node_a_value = resolve_value_radians(node_a.value()); auto node_a_value = resolve_value_radians(node_a.value());
@ -1332,9 +1332,9 @@ String TanCalculationNode::to_string() const
return MUST(builder.to_string()); return MUST(builder.to_string());
} }
Optional<CalculatedStyleValue::ResolvedType> TanCalculationNode::resolved_type() const Optional<CSSMathValue::ResolvedType> TanCalculationNode::resolved_type() const
{ {
return CalculatedStyleValue::ResolvedType::Number; return CSSMathValue::ResolvedType::Number;
} }
// https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
@ -1349,7 +1349,7 @@ bool TanCalculationNode::contains_percentage() const
return m_value->contains_percentage(); return m_value->contains_percentage();
} }
CalculatedStyleValue::CalculationResult TanCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CalculatedStyleValue::PercentageBasis const& percentage_basis) const CSSMathValue::CalculationResult TanCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CSSMathValue::PercentageBasis const& percentage_basis) const
{ {
auto node_a = m_value->resolve(context, percentage_basis); auto node_a = m_value->resolve(context, percentage_basis);
auto node_a_value = resolve_value_radians(node_a.value()); auto node_a_value = resolve_value_radians(node_a.value());
@ -1400,9 +1400,9 @@ String AsinCalculationNode::to_string() const
return MUST(builder.to_string()); return MUST(builder.to_string());
} }
Optional<CalculatedStyleValue::ResolvedType> AsinCalculationNode::resolved_type() const Optional<CSSMathValue::ResolvedType> AsinCalculationNode::resolved_type() const
{ {
return CalculatedStyleValue::ResolvedType::Angle; return CSSMathValue::ResolvedType::Angle;
} }
// https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
@ -1417,7 +1417,7 @@ bool AsinCalculationNode::contains_percentage() const
return m_value->contains_percentage(); return m_value->contains_percentage();
} }
CalculatedStyleValue::CalculationResult AsinCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CalculatedStyleValue::PercentageBasis const& percentage_basis) const CSSMathValue::CalculationResult AsinCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CSSMathValue::PercentageBasis const& percentage_basis) const
{ {
auto node_a = m_value->resolve(context, percentage_basis); auto node_a = m_value->resolve(context, percentage_basis);
auto node_a_value = resolve_value(node_a.value(), context); auto node_a_value = resolve_value(node_a.value(), context);
@ -1468,9 +1468,9 @@ String AcosCalculationNode::to_string() const
return MUST(builder.to_string()); return MUST(builder.to_string());
} }
Optional<CalculatedStyleValue::ResolvedType> AcosCalculationNode::resolved_type() const Optional<CSSMathValue::ResolvedType> AcosCalculationNode::resolved_type() const
{ {
return CalculatedStyleValue::ResolvedType::Angle; return CSSMathValue::ResolvedType::Angle;
} }
// https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
@ -1485,7 +1485,7 @@ bool AcosCalculationNode::contains_percentage() const
return m_value->contains_percentage(); return m_value->contains_percentage();
} }
CalculatedStyleValue::CalculationResult AcosCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CalculatedStyleValue::PercentageBasis const& percentage_basis) const CSSMathValue::CalculationResult AcosCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CSSMathValue::PercentageBasis const& percentage_basis) const
{ {
auto node_a = m_value->resolve(context, percentage_basis); auto node_a = m_value->resolve(context, percentage_basis);
auto node_a_value = resolve_value(node_a.value(), context); auto node_a_value = resolve_value(node_a.value(), context);
@ -1536,9 +1536,9 @@ String AtanCalculationNode::to_string() const
return MUST(builder.to_string()); return MUST(builder.to_string());
} }
Optional<CalculatedStyleValue::ResolvedType> AtanCalculationNode::resolved_type() const Optional<CSSMathValue::ResolvedType> AtanCalculationNode::resolved_type() const
{ {
return CalculatedStyleValue::ResolvedType::Angle; return CSSMathValue::ResolvedType::Angle;
} }
// https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
@ -1553,7 +1553,7 @@ bool AtanCalculationNode::contains_percentage() const
return m_value->contains_percentage(); return m_value->contains_percentage();
} }
CalculatedStyleValue::CalculationResult AtanCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CalculatedStyleValue::PercentageBasis const& percentage_basis) const CSSMathValue::CalculationResult AtanCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CSSMathValue::PercentageBasis const& percentage_basis) const
{ {
auto node_a = m_value->resolve(context, percentage_basis); auto node_a = m_value->resolve(context, percentage_basis);
auto node_a_value = resolve_value(node_a.value(), context); auto node_a_value = resolve_value(node_a.value(), context);
@ -1607,9 +1607,9 @@ String Atan2CalculationNode::to_string() const
return MUST(builder.to_string()); return MUST(builder.to_string());
} }
Optional<CalculatedStyleValue::ResolvedType> Atan2CalculationNode::resolved_type() const Optional<CSSMathValue::ResolvedType> Atan2CalculationNode::resolved_type() const
{ {
return CalculatedStyleValue::ResolvedType::Angle; return CSSMathValue::ResolvedType::Angle;
} }
// https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
@ -1624,7 +1624,7 @@ bool Atan2CalculationNode::contains_percentage() const
return m_y->contains_percentage() || m_x->contains_percentage(); return m_y->contains_percentage() || m_x->contains_percentage();
} }
CalculatedStyleValue::CalculationResult Atan2CalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CalculatedStyleValue::PercentageBasis const& percentage_basis) const CSSMathValue::CalculationResult Atan2CalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CSSMathValue::PercentageBasis const& percentage_basis) const
{ {
auto node_a = m_y->resolve(context, percentage_basis); auto node_a = m_y->resolve(context, percentage_basis);
auto node_a_value = resolve_value(node_a.value(), context); auto node_a_value = resolve_value(node_a.value(), context);
@ -1685,9 +1685,9 @@ String PowCalculationNode::to_string() const
return MUST(builder.to_string()); return MUST(builder.to_string());
} }
Optional<CalculatedStyleValue::ResolvedType> PowCalculationNode::resolved_type() const Optional<CSSMathValue::ResolvedType> PowCalculationNode::resolved_type() const
{ {
return CalculatedStyleValue::ResolvedType::Number; return CSSMathValue::ResolvedType::Number;
} }
// https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
@ -1697,7 +1697,7 @@ Optional<CSSNumericType> PowCalculationNode::determine_type(PropertyID) const
return CSSNumericType {}; return CSSNumericType {};
} }
CalculatedStyleValue::CalculationResult PowCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CalculatedStyleValue::PercentageBasis const& percentage_basis) const CSSMathValue::CalculationResult PowCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CSSMathValue::PercentageBasis const& percentage_basis) const
{ {
auto node_a = m_x->resolve(context, percentage_basis); auto node_a = m_x->resolve(context, percentage_basis);
auto node_a_value = resolve_value(node_a.value(), context); auto node_a_value = resolve_value(node_a.value(), context);
@ -1755,9 +1755,9 @@ String SqrtCalculationNode::to_string() const
return MUST(builder.to_string()); return MUST(builder.to_string());
} }
Optional<CalculatedStyleValue::ResolvedType> SqrtCalculationNode::resolved_type() const Optional<CSSMathValue::ResolvedType> SqrtCalculationNode::resolved_type() const
{ {
return CalculatedStyleValue::ResolvedType::Number; return CSSMathValue::ResolvedType::Number;
} }
// https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
@ -1767,7 +1767,7 @@ Optional<CSSNumericType> SqrtCalculationNode::determine_type(PropertyID) const
return CSSNumericType {}; return CSSNumericType {};
} }
CalculatedStyleValue::CalculationResult SqrtCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CalculatedStyleValue::PercentageBasis const& percentage_basis) const CSSMathValue::CalculationResult SqrtCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CSSMathValue::PercentageBasis const& percentage_basis) const
{ {
auto node_a = m_value->resolve(context, percentage_basis); auto node_a = m_value->resolve(context, percentage_basis);
auto node_a_value = resolve_value(node_a.value(), context); auto node_a_value = resolve_value(node_a.value(), context);
@ -1822,7 +1822,7 @@ String HypotCalculationNode::to_string() const
return MUST(builder.to_string()); return MUST(builder.to_string());
} }
Optional<CalculatedStyleValue::ResolvedType> HypotCalculationNode::resolved_type() const Optional<CSSMathValue::ResolvedType> HypotCalculationNode::resolved_type() const
{ {
// NOTE: We check during parsing that all values have the same type. // NOTE: We check during parsing that all values have the same type.
return m_values[0]->resolved_type(); return m_values[0]->resolved_type();
@ -1845,7 +1845,7 @@ bool HypotCalculationNode::contains_percentage() const
return false; return false;
} }
CalculatedStyleValue::CalculationResult HypotCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CalculatedStyleValue::PercentageBasis const& percentage_basis) const CSSMathValue::CalculationResult HypotCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CSSMathValue::PercentageBasis const& percentage_basis) const
{ {
double square_sum = 0.0; double square_sum = 0.0;
@ -1914,9 +1914,9 @@ String LogCalculationNode::to_string() const
return MUST(builder.to_string()); return MUST(builder.to_string());
} }
Optional<CalculatedStyleValue::ResolvedType> LogCalculationNode::resolved_type() const Optional<CSSMathValue::ResolvedType> LogCalculationNode::resolved_type() const
{ {
return CalculatedStyleValue::ResolvedType::Number; return CSSMathValue::ResolvedType::Number;
} }
// https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
@ -1926,7 +1926,7 @@ Optional<CSSNumericType> LogCalculationNode::determine_type(PropertyID) const
return CSSNumericType {}; return CSSNumericType {};
} }
CalculatedStyleValue::CalculationResult LogCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CalculatedStyleValue::PercentageBasis const& percentage_basis) const CSSMathValue::CalculationResult LogCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CSSMathValue::PercentageBasis const& percentage_basis) const
{ {
auto node_a = m_x->resolve(context, percentage_basis); auto node_a = m_x->resolve(context, percentage_basis);
auto node_a_value = resolve_value(node_a.value(), context); auto node_a_value = resolve_value(node_a.value(), context);
@ -1984,9 +1984,9 @@ String ExpCalculationNode::to_string() const
return MUST(builder.to_string()); return MUST(builder.to_string());
} }
Optional<CalculatedStyleValue::ResolvedType> ExpCalculationNode::resolved_type() const Optional<CSSMathValue::ResolvedType> ExpCalculationNode::resolved_type() const
{ {
return CalculatedStyleValue::ResolvedType::Number; return CSSMathValue::ResolvedType::Number;
} }
// https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
@ -1996,7 +1996,7 @@ Optional<CSSNumericType> ExpCalculationNode::determine_type(PropertyID) const
return CSSNumericType {}; return CSSNumericType {};
} }
CalculatedStyleValue::CalculationResult ExpCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CalculatedStyleValue::PercentageBasis const& percentage_basis) const CSSMathValue::CalculationResult ExpCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CSSMathValue::PercentageBasis const& percentage_basis) const
{ {
auto node_a = m_value->resolve(context, percentage_basis); auto node_a = m_value->resolve(context, percentage_basis);
auto node_a_value = resolve_value(node_a.value(), context); auto node_a_value = resolve_value(node_a.value(), context);
@ -2053,7 +2053,7 @@ String RoundCalculationNode::to_string() const
return MUST(builder.to_string()); return MUST(builder.to_string());
} }
Optional<CalculatedStyleValue::ResolvedType> RoundCalculationNode::resolved_type() const Optional<CSSMathValue::ResolvedType> RoundCalculationNode::resolved_type() const
{ {
// Note: We check during parsing that all values have the same type // Note: We check during parsing that all values have the same type
return m_x->resolved_type(); return m_x->resolved_type();
@ -2077,7 +2077,7 @@ bool RoundCalculationNode::contains_percentage() const
return m_x->contains_percentage() || m_y->contains_percentage(); return m_x->contains_percentage() || m_y->contains_percentage();
} }
CalculatedStyleValue::CalculationResult RoundCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CalculatedStyleValue::PercentageBasis const& percentage_basis) const CSSMathValue::CalculationResult RoundCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CSSMathValue::PercentageBasis const& percentage_basis) const
{ {
auto node_a = m_x->resolve(context, percentage_basis); auto node_a = m_x->resolve(context, percentage_basis);
auto node_b = m_y->resolve(context, percentage_basis); auto node_b = m_y->resolve(context, percentage_basis);
@ -2164,7 +2164,7 @@ String ModCalculationNode::to_string() const
return MUST(builder.to_string()); return MUST(builder.to_string());
} }
Optional<CalculatedStyleValue::ResolvedType> ModCalculationNode::resolved_type() const Optional<CSSMathValue::ResolvedType> ModCalculationNode::resolved_type() const
{ {
// Note: We check during parsing that all values have the same type // Note: We check during parsing that all values have the same type
return m_x->resolved_type(); return m_x->resolved_type();
@ -2188,7 +2188,7 @@ bool ModCalculationNode::contains_percentage() const
return m_x->contains_percentage() || m_y->contains_percentage(); return m_x->contains_percentage() || m_y->contains_percentage();
} }
CalculatedStyleValue::CalculationResult ModCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CalculatedStyleValue::PercentageBasis const& percentage_basis) const CSSMathValue::CalculationResult ModCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CSSMathValue::PercentageBasis const& percentage_basis) const
{ {
auto resolved_type = m_x->resolved_type().value(); auto resolved_type = m_x->resolved_type().value();
auto node_a = m_x->resolve(context, percentage_basis); auto node_a = m_x->resolve(context, percentage_basis);
@ -2250,7 +2250,7 @@ String RemCalculationNode::to_string() const
return MUST(builder.to_string()); return MUST(builder.to_string());
} }
Optional<CalculatedStyleValue::ResolvedType> RemCalculationNode::resolved_type() const Optional<CSSMathValue::ResolvedType> RemCalculationNode::resolved_type() const
{ {
// Note: We check during parsing that all values have the same type // Note: We check during parsing that all values have the same type
return m_x->resolved_type(); return m_x->resolved_type();
@ -2274,7 +2274,7 @@ bool RemCalculationNode::contains_percentage() const
return m_x->contains_percentage() || m_y->contains_percentage(); return m_x->contains_percentage() || m_y->contains_percentage();
} }
CalculatedStyleValue::CalculationResult RemCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CalculatedStyleValue::PercentageBasis const& percentage_basis) const CSSMathValue::CalculationResult RemCalculationNode::resolve(Optional<Length::ResolutionContext const&> context, CSSMathValue::PercentageBasis const& percentage_basis) const
{ {
auto resolved_type = m_x->resolved_type().value(); auto resolved_type = m_x->resolved_type().value();
auto node_a = m_x->resolve(context, percentage_basis); auto node_a = m_x->resolve(context, percentage_basis);
@ -2310,17 +2310,17 @@ bool RemCalculationNode::equals(CalculationNode const& other) const
&& m_y->equals(*static_cast<RemCalculationNode const&>(other).m_y); && m_y->equals(*static_cast<RemCalculationNode const&>(other).m_y);
} }
void CalculatedStyleValue::CalculationResult::add(CalculationResult const& other, Optional<Length::ResolutionContext const&> context, PercentageBasis const& percentage_basis) void CSSMathValue::CalculationResult::add(CalculationResult const& other, Optional<Length::ResolutionContext const&> context, PercentageBasis const& percentage_basis)
{ {
add_or_subtract_internal(SumOperation::Add, other, context, percentage_basis); add_or_subtract_internal(SumOperation::Add, other, context, percentage_basis);
} }
void CalculatedStyleValue::CalculationResult::subtract(CalculationResult const& other, Optional<Length::ResolutionContext const&> context, PercentageBasis const& percentage_basis) void CSSMathValue::CalculationResult::subtract(CalculationResult const& other, Optional<Length::ResolutionContext const&> context, PercentageBasis const& percentage_basis)
{ {
add_or_subtract_internal(SumOperation::Subtract, other, context, percentage_basis); add_or_subtract_internal(SumOperation::Subtract, other, context, percentage_basis);
} }
void CalculatedStyleValue::CalculationResult::add_or_subtract_internal(SumOperation op, CalculationResult const& other, Optional<Length::ResolutionContext const&> context, PercentageBasis const& percentage_basis) void CSSMathValue::CalculationResult::add_or_subtract_internal(SumOperation op, CalculationResult const& other, Optional<Length::ResolutionContext const&> context, PercentageBasis const& percentage_basis)
{ {
// We know from validation when resolving the type, that "both sides have the same type, or that one side is a <number> and the other is an <integer>". // We know from validation when resolving the type, that "both sides have the same type, or that one side is a <number> and the other is an <integer>".
// Though, having the same type may mean that one side is a <dimension> and the other a <percentage>. // Though, having the same type may mean that one side is a <dimension> and the other a <percentage>.
@ -2457,7 +2457,7 @@ void CalculatedStyleValue::CalculationResult::add_or_subtract_internal(SumOperat
}); });
} }
void CalculatedStyleValue::CalculationResult::multiply_by(CalculationResult const& other, Optional<Length::ResolutionContext const&> context) void CSSMathValue::CalculationResult::multiply_by(CalculationResult const& other, Optional<Length::ResolutionContext const&> context)
{ {
// We know from validation when resolving the type, that at least one side must be a <number> or <integer>. // We know from validation when resolving the type, that at least one side must be a <number> or <integer>.
// Both of these are represented as a double. // Both of these are represented as a double.
@ -2498,7 +2498,7 @@ void CalculatedStyleValue::CalculationResult::multiply_by(CalculationResult cons
}); });
} }
void CalculatedStyleValue::CalculationResult::divide_by(CalculationResult const& other, Optional<Length::ResolutionContext const&> context) void CSSMathValue::CalculationResult::divide_by(CalculationResult const& other, Optional<Length::ResolutionContext const&> context)
{ {
// We know from validation when resolving the type, that `other` must be a <number> or <integer>. // We know from validation when resolving the type, that `other` must be a <number> or <integer>.
// Both of these are represented as a Number. // Both of these are represented as a Number.
@ -2536,7 +2536,7 @@ void CalculatedStyleValue::CalculationResult::divide_by(CalculationResult const&
}); });
} }
void CalculatedStyleValue::CalculationResult::negate() void CSSMathValue::CalculationResult::negate()
{ {
m_value.visit( m_value.visit(
[&](Number const& number) { [&](Number const& number) {
@ -2565,7 +2565,7 @@ void CalculatedStyleValue::CalculationResult::negate()
}); });
} }
void CalculatedStyleValue::CalculationResult::invert() void CSSMathValue::CalculationResult::invert()
{ {
// FIXME: Correctly handle division by zero. // FIXME: Correctly handle division by zero.
m_value.visit( m_value.visit(
@ -2595,7 +2595,7 @@ void CalculatedStyleValue::CalculationResult::invert()
}); });
} }
CalculatedStyleValue::ResolvedType CalculatedStyleValue::CalculationResult::resolved_type() const CSSMathValue::ResolvedType CSSMathValue::CalculationResult::resolved_type() const
{ {
return m_value.visit( return m_value.visit(
[](Number const&) { return ResolvedType::Number; }, [](Number const&) { return ResolvedType::Number; },
@ -2608,21 +2608,21 @@ CalculatedStyleValue::ResolvedType CalculatedStyleValue::CalculationResult::reso
[](Time const&) { return ResolvedType::Time; }); [](Time const&) { return ResolvedType::Time; });
} }
String CalculatedStyleValue::to_string() const String CSSMathValue::to_string() const
{ {
// FIXME: Implement this according to https://www.w3.org/TR/css-values-4/#calc-serialize once that stabilizes. // FIXME: Implement this according to https://www.w3.org/TR/css-values-4/#calc-serialize once that stabilizes.
return MUST(String::formatted("calc({})", m_calculation->to_string())); return MUST(String::formatted("calc({})", m_calculation->to_string()));
} }
bool CalculatedStyleValue::equals(CSSStyleValue const& other) const bool CSSMathValue::equals(CSSStyleValue const& other) const
{ {
if (type() != other.type()) if (type() != other.type())
return false; return false;
return m_calculation->equals(*static_cast<CalculatedStyleValue const&>(other).m_calculation); return m_calculation->equals(*static_cast<CSSMathValue const&>(other).m_calculation);
} }
Optional<Angle> CalculatedStyleValue::resolve_angle() const Optional<Angle> CSSMathValue::resolve_angle() const
{ {
auto result = m_calculation->resolve({}, {}); auto result = m_calculation->resolve({}, {});
@ -2631,7 +2631,7 @@ Optional<Angle> CalculatedStyleValue::resolve_angle() const
return {}; return {};
} }
Optional<Angle> CalculatedStyleValue::resolve_angle_percentage(Angle const& percentage_basis) const Optional<Angle> CSSMathValue::resolve_angle_percentage(Angle const& percentage_basis) const
{ {
auto result = m_calculation->resolve({}, percentage_basis); auto result = m_calculation->resolve({}, percentage_basis);
@ -2647,7 +2647,7 @@ Optional<Angle> CalculatedStyleValue::resolve_angle_percentage(Angle const& perc
}); });
} }
Optional<Flex> CalculatedStyleValue::resolve_flex() const Optional<Flex> CSSMathValue::resolve_flex() const
{ {
auto result = m_calculation->resolve({}, {}); auto result = m_calculation->resolve({}, {});
@ -2656,7 +2656,7 @@ Optional<Flex> CalculatedStyleValue::resolve_flex() const
return {}; return {};
} }
Optional<Frequency> CalculatedStyleValue::resolve_frequency() const Optional<Frequency> CSSMathValue::resolve_frequency() const
{ {
auto result = m_calculation->resolve({}, {}); auto result = m_calculation->resolve({}, {});
@ -2665,7 +2665,7 @@ Optional<Frequency> CalculatedStyleValue::resolve_frequency() const
return {}; return {};
} }
Optional<Frequency> CalculatedStyleValue::resolve_frequency_percentage(Frequency const& percentage_basis) const Optional<Frequency> CSSMathValue::resolve_frequency_percentage(Frequency const& percentage_basis) const
{ {
auto result = m_calculation->resolve({}, percentage_basis); auto result = m_calculation->resolve({}, percentage_basis);
@ -2681,7 +2681,7 @@ Optional<Frequency> CalculatedStyleValue::resolve_frequency_percentage(Frequency
}); });
} }
Optional<Length> CalculatedStyleValue::resolve_length(Length::ResolutionContext const& context) const Optional<Length> CSSMathValue::resolve_length(Length::ResolutionContext const& context) const
{ {
auto result = m_calculation->resolve(context, {}); auto result = m_calculation->resolve(context, {});
@ -2690,22 +2690,22 @@ Optional<Length> CalculatedStyleValue::resolve_length(Length::ResolutionContext
return {}; return {};
} }
Optional<Length> CalculatedStyleValue::resolve_length(Layout::Node const& layout_node) const Optional<Length> CSSMathValue::resolve_length(Layout::Node const& layout_node) const
{ {
return resolve_length(Length::ResolutionContext::for_layout_node(layout_node)); return resolve_length(Length::ResolutionContext::for_layout_node(layout_node));
} }
Optional<Length> CalculatedStyleValue::resolve_length_percentage(Layout::Node const& layout_node, Length const& percentage_basis) const Optional<Length> CSSMathValue::resolve_length_percentage(Layout::Node const& layout_node, Length const& percentage_basis) const
{ {
return resolve_length_percentage(Length::ResolutionContext::for_layout_node(layout_node), percentage_basis); return resolve_length_percentage(Length::ResolutionContext::for_layout_node(layout_node), percentage_basis);
} }
Optional<Length> CalculatedStyleValue::resolve_length_percentage(Layout::Node const& layout_node, CSSPixels percentage_basis) const Optional<Length> CSSMathValue::resolve_length_percentage(Layout::Node const& layout_node, CSSPixels percentage_basis) const
{ {
return resolve_length_percentage(Length::ResolutionContext::for_layout_node(layout_node), Length::make_px(percentage_basis)); return resolve_length_percentage(Length::ResolutionContext::for_layout_node(layout_node), Length::make_px(percentage_basis));
} }
Optional<Length> CalculatedStyleValue::resolve_length_percentage(Length::ResolutionContext const& resolution_context, Length const& percentage_basis) const Optional<Length> CSSMathValue::resolve_length_percentage(Length::ResolutionContext const& resolution_context, Length const& percentage_basis) const
{ {
auto result = m_calculation->resolve(resolution_context, percentage_basis); auto result = m_calculation->resolve(resolution_context, percentage_basis);
@ -2721,7 +2721,7 @@ Optional<Length> CalculatedStyleValue::resolve_length_percentage(Length::Resolut
}); });
} }
Optional<Percentage> CalculatedStyleValue::resolve_percentage() const Optional<Percentage> CSSMathValue::resolve_percentage() const
{ {
auto result = m_calculation->resolve({}, {}); auto result = m_calculation->resolve({}, {});
if (result.value().has<Percentage>()) if (result.value().has<Percentage>())
@ -2729,7 +2729,7 @@ Optional<Percentage> CalculatedStyleValue::resolve_percentage() const
return {}; return {};
} }
Optional<Resolution> CalculatedStyleValue::resolve_resolution() const Optional<Resolution> CSSMathValue::resolve_resolution() const
{ {
auto result = m_calculation->resolve({}, {}); auto result = m_calculation->resolve({}, {});
if (result.value().has<Resolution>()) if (result.value().has<Resolution>())
@ -2737,7 +2737,7 @@ Optional<Resolution> CalculatedStyleValue::resolve_resolution() const
return {}; return {};
} }
Optional<Time> CalculatedStyleValue::resolve_time() const Optional<Time> CSSMathValue::resolve_time() const
{ {
auto result = m_calculation->resolve({}, {}); auto result = m_calculation->resolve({}, {});
@ -2746,7 +2746,7 @@ Optional<Time> CalculatedStyleValue::resolve_time() const
return {}; return {};
} }
Optional<Time> CalculatedStyleValue::resolve_time_percentage(Time const& percentage_basis) const Optional<Time> CSSMathValue::resolve_time_percentage(Time const& percentage_basis) const
{ {
auto result = m_calculation->resolve({}, percentage_basis); auto result = m_calculation->resolve({}, percentage_basis);
@ -2759,7 +2759,7 @@ Optional<Time> CalculatedStyleValue::resolve_time_percentage(Time const& percent
}); });
} }
Optional<double> CalculatedStyleValue::resolve_number() const Optional<double> CSSMathValue::resolve_number() const
{ {
auto result = m_calculation->resolve({}, {}); auto result = m_calculation->resolve({}, {});
if (result.value().has<Number>()) if (result.value().has<Number>())
@ -2767,7 +2767,7 @@ Optional<double> CalculatedStyleValue::resolve_number() const
return {}; return {};
} }
Optional<i64> CalculatedStyleValue::resolve_integer() const Optional<i64> CSSMathValue::resolve_integer() const
{ {
auto result = m_calculation->resolve({}, {}); auto result = m_calculation->resolve({}, {});
if (result.value().has<Number>()) if (result.value().has<Number>())
@ -2775,12 +2775,12 @@ Optional<i64> CalculatedStyleValue::resolve_integer() const
return {}; return {};
} }
bool CalculatedStyleValue::contains_percentage() const bool CSSMathValue::contains_percentage() const
{ {
return m_calculation->contains_percentage(); return m_calculation->contains_percentage();
} }
String CalculatedStyleValue::dump() const String CSSMathValue::dump() const
{ {
StringBuilder builder; StringBuilder builder;
m_calculation->dump(builder, 0); m_calculation->dump(builder, 0);

122
Userland/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.h → Userland/Libraries/LibWeb/CSS/StyleValues/CSSMathValue.h
View file

@ -1,7 +1,7 @@
/* /*
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org> * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
* Copyright (c) 2021, Tobias Christiansen <tobyase@serenityos.org> * Copyright (c) 2021, Tobias Christiansen <tobyase@serenityos.org>
* Copyright (c) 2021-2023, Sam Atkins <atkinssj@serenityos.org> * Copyright (c) 2021-2024, Sam Atkins <sam@ladybird.org>
* Copyright (c) 2022-2023, MacDue <macdue@dueutil.tech> * Copyright (c) 2022-2023, MacDue <macdue@dueutil.tech>
* *
* SPDX-License-Identifier: BSD-2-Clause * SPDX-License-Identifier: BSD-2-Clause
@ -24,7 +24,7 @@ namespace Web::CSS {
class CalculationNode; class CalculationNode;
class CalculatedStyleValue : public CSSStyleValue { class CSSMathValue : public CSSStyleValue {
public: public:
enum class ResolvedType { enum class ResolvedType {
Angle, Angle,
@ -74,9 +74,9 @@ public:
Value m_value; Value m_value;
}; };
static ValueComparingNonnullRefPtr<CalculatedStyleValue> create(NonnullOwnPtr<CalculationNode> calculation, CSSNumericType resolved_type) static ValueComparingNonnullRefPtr<CSSMathValue> create(NonnullOwnPtr<CalculationNode> calculation, CSSNumericType resolved_type)
{ {
return adopt_ref(*new (nothrow) CalculatedStyleValue(move(calculation), resolved_type)); return adopt_ref(*new (nothrow) CSSMathValue(move(calculation), resolved_type));
} }
String to_string() const override; String to_string() const override;
@ -126,8 +126,8 @@ public:
String dump() const; String dump() const;
private: private:
explicit CalculatedStyleValue(NonnullOwnPtr<CalculationNode> calculation, CSSNumericType resolved_type) explicit CSSMathValue(NonnullOwnPtr<CalculationNode> calculation, CSSNumericType resolved_type)
: CSSStyleValue(Type::Calculated) : CSSStyleValue(Type::Math)
, m_resolved_type(resolved_type) , m_resolved_type(resolved_type)
, m_calculation(move(calculation)) , m_calculation(move(calculation))
{ {
@ -205,7 +205,7 @@ public:
// This only exists during parsing. // This only exists during parsing.
Unparsed, Unparsed,
}; };
using NumericValue = CalculatedStyleValue::CalculationResult::Value; using NumericValue = CSSMathValue::CalculationResult::Value;
virtual ~CalculationNode(); virtual ~CalculationNode();
@ -254,10 +254,10 @@ public:
} }
virtual String to_string() const = 0; virtual String to_string() const = 0;
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const = 0; virtual Optional<CSSMathValue::ResolvedType> resolved_type() const = 0;
virtual Optional<CSSNumericType> determine_type(PropertyID) const = 0; virtual Optional<CSSNumericType> determine_type(PropertyID) const = 0;
virtual bool contains_percentage() const = 0; virtual bool contains_percentage() const = 0;
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const = 0; virtual CSSMathValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CSSMathValue::PercentageBasis const&) const = 0;
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) = 0; virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) = 0;
virtual void dump(StringBuilder&, int indent) const = 0; virtual void dump(StringBuilder&, int indent) const = 0;
@ -276,10 +276,10 @@ public:
~NumericCalculationNode(); ~NumericCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override; virtual Optional<CSSMathValue::ResolvedType> resolved_type() const override;
virtual Optional<CSSNumericType> determine_type(PropertyID) const override; virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override; virtual CSSMathValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CSSMathValue::PercentageBasis const&) const override;
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override { } virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override { }
virtual void dump(StringBuilder&, int indent) const override; virtual void dump(StringBuilder&, int indent) const override;
@ -296,10 +296,10 @@ public:
~SumCalculationNode(); ~SumCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override; virtual Optional<CSSMathValue::ResolvedType> resolved_type() const override;
virtual Optional<CSSNumericType> determine_type(PropertyID) const override; virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override; virtual CSSMathValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CSSMathValue::PercentageBasis const&) const override;
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override; virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
virtual void dump(StringBuilder&, int indent) const override; virtual void dump(StringBuilder&, int indent) const override;
@ -316,10 +316,10 @@ public:
~ProductCalculationNode(); ~ProductCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override; virtual Optional<CSSMathValue::ResolvedType> resolved_type() const override;
virtual Optional<CSSNumericType> determine_type(PropertyID) const override; virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override; virtual CSSMathValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CSSMathValue::PercentageBasis const&) const override;
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override; virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
virtual void dump(StringBuilder&, int indent) const override; virtual void dump(StringBuilder&, int indent) const override;
@ -336,10 +336,10 @@ public:
~NegateCalculationNode(); ~NegateCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override; virtual Optional<CSSMathValue::ResolvedType> resolved_type() const override;
virtual Optional<CSSNumericType> determine_type(PropertyID) const override; virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override; virtual CSSMathValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CSSMathValue::PercentageBasis const&) const override;
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override; virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
virtual void dump(StringBuilder&, int indent) const override; virtual void dump(StringBuilder&, int indent) const override;
@ -356,10 +356,10 @@ public:
~InvertCalculationNode(); ~InvertCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override; virtual Optional<CSSMathValue::ResolvedType> resolved_type() const override;
virtual Optional<CSSNumericType> determine_type(PropertyID) const override; virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override; virtual CSSMathValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CSSMathValue::PercentageBasis const&) const override;
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override; virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
virtual void dump(StringBuilder&, int indent) const override; virtual void dump(StringBuilder&, int indent) const override;
@ -376,10 +376,10 @@ public:
~MinCalculationNode(); ~MinCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override; virtual Optional<CSSMathValue::ResolvedType> resolved_type() const override;
virtual Optional<CSSNumericType> determine_type(PropertyID) const override; virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override; virtual CSSMathValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CSSMathValue::PercentageBasis const&) const override;
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override; virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
virtual void dump(StringBuilder&, int indent) const override; virtual void dump(StringBuilder&, int indent) const override;
@ -396,10 +396,10 @@ public:
~MaxCalculationNode(); ~MaxCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override; virtual Optional<CSSMathValue::ResolvedType> resolved_type() const override;
virtual Optional<CSSNumericType> determine_type(PropertyID) const override; virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override; virtual CSSMathValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CSSMathValue::PercentageBasis const&) const override;
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override; virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
virtual void dump(StringBuilder&, int indent) const override; virtual void dump(StringBuilder&, int indent) const override;
@ -416,10 +416,10 @@ public:
~ClampCalculationNode(); ~ClampCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override; virtual Optional<CSSMathValue::ResolvedType> resolved_type() const override;
virtual Optional<CSSNumericType> determine_type(PropertyID) const override; virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override; virtual CSSMathValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CSSMathValue::PercentageBasis const&) const override;
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override; virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
virtual void dump(StringBuilder&, int indent) const override; virtual void dump(StringBuilder&, int indent) const override;
@ -438,10 +438,10 @@ public:
~AbsCalculationNode(); ~AbsCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override; virtual Optional<CSSMathValue::ResolvedType> resolved_type() const override;
virtual Optional<CSSNumericType> determine_type(PropertyID) const override; virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override; virtual CSSMathValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CSSMathValue::PercentageBasis const&) const override;
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override; virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
virtual void dump(StringBuilder&, int indent) const override; virtual void dump(StringBuilder&, int indent) const override;
@ -458,10 +458,10 @@ public:
~SignCalculationNode(); ~SignCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override; virtual Optional<CSSMathValue::ResolvedType> resolved_type() const override;
virtual Optional<CSSNumericType> determine_type(PropertyID) const override; virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override; virtual CSSMathValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CSSMathValue::PercentageBasis const&) const override;
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override; virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
virtual void dump(StringBuilder&, int indent) const override; virtual void dump(StringBuilder&, int indent) const override;
@ -478,10 +478,10 @@ public:
~ConstantCalculationNode(); ~ConstantCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override; virtual Optional<CSSMathValue::ResolvedType> resolved_type() const override;
virtual Optional<CSSNumericType> determine_type(PropertyID) const override; virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
virtual bool contains_percentage() const override { return false; } virtual bool contains_percentage() const override { return false; }
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&> context, CalculatedStyleValue::PercentageBasis const&) const override; virtual CSSMathValue::CalculationResult resolve(Optional<Length::ResolutionContext const&> context, CSSMathValue::PercentageBasis const&) const override;
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override { } virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override { }
virtual void dump(StringBuilder&, int indent) const override; virtual void dump(StringBuilder&, int indent) const override;
@ -498,10 +498,10 @@ public:
~SinCalculationNode(); ~SinCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override; virtual Optional<CSSMathValue::ResolvedType> resolved_type() const override;
virtual Optional<CSSNumericType> determine_type(PropertyID) const override; virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override; virtual CSSMathValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CSSMathValue::PercentageBasis const&) const override;
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override; virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
virtual void dump(StringBuilder&, int indent) const override; virtual void dump(StringBuilder&, int indent) const override;
@ -518,10 +518,10 @@ public:
~CosCalculationNode(); ~CosCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override; virtual Optional<CSSMathValue::ResolvedType> resolved_type() const override;
virtual Optional<CSSNumericType> determine_type(PropertyID) const override; virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override; virtual CSSMathValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CSSMathValue::PercentageBasis const&) const override;
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override; virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
virtual void dump(StringBuilder&, int indent) const override; virtual void dump(StringBuilder&, int indent) const override;
@ -538,10 +538,10 @@ public:
~TanCalculationNode(); ~TanCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override; virtual Optional<CSSMathValue::ResolvedType> resolved_type() const override;
virtual Optional<CSSNumericType> determine_type(PropertyID) const override; virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override; virtual CSSMathValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CSSMathValue::PercentageBasis const&) const override;
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override; virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
virtual void dump(StringBuilder&, int indent) const override; virtual void dump(StringBuilder&, int indent) const override;
@ -558,10 +558,10 @@ public:
~AsinCalculationNode(); ~AsinCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override; virtual Optional<CSSMathValue::ResolvedType> resolved_type() const override;
virtual Optional<CSSNumericType> determine_type(PropertyID) const override; virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override; virtual CSSMathValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CSSMathValue::PercentageBasis const&) const override;
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override; virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
virtual void dump(StringBuilder&, int indent) const override; virtual void dump(StringBuilder&, int indent) const override;
@ -578,10 +578,10 @@ public:
~AcosCalculationNode(); ~AcosCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override; virtual Optional<CSSMathValue::ResolvedType> resolved_type() const override;
virtual Optional<CSSNumericType> determine_type(PropertyID) const override; virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override; virtual CSSMathValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CSSMathValue::PercentageBasis const&) const override;
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override; virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
virtual void dump(StringBuilder&, int indent) const override; virtual void dump(StringBuilder&, int indent) const override;
@ -598,10 +598,10 @@ public:
~AtanCalculationNode(); ~AtanCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override; virtual Optional<CSSMathValue::ResolvedType> resolved_type() const override;
virtual Optional<CSSNumericType> determine_type(PropertyID) const override; virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override; virtual CSSMathValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CSSMathValue::PercentageBasis const&) const override;
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override; virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
virtual void dump(StringBuilder&, int indent) const override; virtual void dump(StringBuilder&, int indent) const override;
@ -618,10 +618,10 @@ public:
~Atan2CalculationNode(); ~Atan2CalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override; virtual Optional<CSSMathValue::ResolvedType> resolved_type() const override;
virtual Optional<CSSNumericType> determine_type(PropertyID) const override; virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override; virtual CSSMathValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CSSMathValue::PercentageBasis const&) const override;
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override; virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
virtual void dump(StringBuilder&, int indent) const override; virtual void dump(StringBuilder&, int indent) const override;
@ -639,10 +639,10 @@ public:
~PowCalculationNode(); ~PowCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override; virtual Optional<CSSMathValue::ResolvedType> resolved_type() const override;
virtual Optional<CSSNumericType> determine_type(PropertyID) const override; virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
virtual bool contains_percentage() const override { return false; } virtual bool contains_percentage() const override { return false; }
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override; virtual CSSMathValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CSSMathValue::PercentageBasis const&) const override;
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override; virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
virtual void dump(StringBuilder&, int indent) const override; virtual void dump(StringBuilder&, int indent) const override;
@ -660,10 +660,10 @@ public:
~SqrtCalculationNode(); ~SqrtCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override; virtual Optional<CSSMathValue::ResolvedType> resolved_type() const override;
virtual Optional<CSSNumericType> determine_type(PropertyID) const override; virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
virtual bool contains_percentage() const override { return false; } virtual bool contains_percentage() const override { return false; }
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override; virtual CSSMathValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CSSMathValue::PercentageBasis const&) const override;
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override; virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
virtual void dump(StringBuilder&, int indent) const override; virtual void dump(StringBuilder&, int indent) const override;
@ -680,10 +680,10 @@ public:
~HypotCalculationNode(); ~HypotCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override; virtual Optional<CSSMathValue::ResolvedType> resolved_type() const override;
virtual Optional<CSSNumericType> determine_type(PropertyID) const override; virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override; virtual CSSMathValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CSSMathValue::PercentageBasis const&) const override;
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override; virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
virtual void dump(StringBuilder&, int indent) const override; virtual void dump(StringBuilder&, int indent) const override;
@ -700,10 +700,10 @@ public:
~LogCalculationNode(); ~LogCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override; virtual Optional<CSSMathValue::ResolvedType> resolved_type() const override;
virtual Optional<CSSNumericType> determine_type(PropertyID) const override; virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
virtual bool contains_percentage() const override { return false; } virtual bool contains_percentage() const override { return false; }
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override; virtual CSSMathValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CSSMathValue::PercentageBasis const&) const override;
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override; virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
virtual void dump(StringBuilder&, int indent) const override; virtual void dump(StringBuilder&, int indent) const override;
@ -721,10 +721,10 @@ public:
~ExpCalculationNode(); ~ExpCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override; virtual Optional<CSSMathValue::ResolvedType> resolved_type() const override;
virtual Optional<CSSNumericType> determine_type(PropertyID) const override; virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
virtual bool contains_percentage() const override { return false; } virtual bool contains_percentage() const override { return false; }
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override; virtual CSSMathValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CSSMathValue::PercentageBasis const&) const override;
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override; virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
virtual void dump(StringBuilder&, int indent) const override; virtual void dump(StringBuilder&, int indent) const override;
@ -741,10 +741,10 @@ public:
~RoundCalculationNode(); ~RoundCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override; virtual Optional<CSSMathValue::ResolvedType> resolved_type() const override;
virtual Optional<CSSNumericType> determine_type(PropertyID) const override; virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override; virtual CSSMathValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CSSMathValue::PercentageBasis const&) const override;
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override; virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
virtual void dump(StringBuilder&, int indent) const override; virtual void dump(StringBuilder&, int indent) const override;
@ -763,10 +763,10 @@ public:
~ModCalculationNode(); ~ModCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override; virtual Optional<CSSMathValue::ResolvedType> resolved_type() const override;
virtual Optional<CSSNumericType> determine_type(PropertyID) const override; virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override; virtual CSSMathValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CSSMathValue::PercentageBasis const&) const override;
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override; virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
virtual void dump(StringBuilder&, int indent) const override; virtual void dump(StringBuilder&, int indent) const override;
@ -784,10 +784,10 @@ public:
~RemCalculationNode(); ~RemCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override; virtual Optional<CSSMathValue::ResolvedType> resolved_type() const override;
virtual Optional<CSSNumericType> determine_type(PropertyID) const override; virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override; virtual CSSMathValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CSSMathValue::PercentageBasis const&) const override;
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override; virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
virtual void dump(StringBuilder&, int indent) const override; virtual void dump(StringBuilder&, int indent) const override;

2
Userland/Libraries/LibWeb/CSS/StyleValues/CSSOKLCH.cpp
View file

@ -8,7 +8,7 @@
#include <AK/Math.h> #include <AK/Math.h>
#include <AK/TypeCasts.h> #include <AK/TypeCasts.h>
#include <LibWeb/CSS/Serialize.h> #include <LibWeb/CSS/Serialize.h>
#include <LibWeb/CSS/StyleValues/CalculatedStyleValue.h> #include <LibWeb/CSS/StyleValues/CSSMathValue.h>
#include <LibWeb/CSS/StyleValues/NumberStyleValue.h> #include <LibWeb/CSS/StyleValues/NumberStyleValue.h>
#include <LibWeb/CSS/StyleValues/PercentageStyleValue.h> #include <LibWeb/CSS/StyleValues/PercentageStyleValue.h>

2
Userland/Libraries/LibWeb/CSS/StyleValues/CSSOKLab.cpp
View file

@ -7,7 +7,7 @@
#include "CSSOKLab.h" #include "CSSOKLab.h"
#include <AK/TypeCasts.h> #include <AK/TypeCasts.h>
#include <LibWeb/CSS/Serialize.h> #include <LibWeb/CSS/Serialize.h>
#include <LibWeb/CSS/StyleValues/CalculatedStyleValue.h> #include <LibWeb/CSS/StyleValues/CSSMathValue.h>
#include <LibWeb/CSS/StyleValues/NumberStyleValue.h> #include <LibWeb/CSS/StyleValues/NumberStyleValue.h>
#include <LibWeb/CSS/StyleValues/PercentageStyleValue.h> #include <LibWeb/CSS/StyleValues/PercentageStyleValue.h>

6
Userland/Libraries/LibWeb/CSS/StyleValues/CSSRGB.cpp
View file

@ -7,7 +7,7 @@
#include "CSSRGB.h" #include "CSSRGB.h"
#include <AK/TypeCasts.h> #include <AK/TypeCasts.h>
#include <LibWeb/CSS/Serialize.h> #include <LibWeb/CSS/Serialize.h>
#include <LibWeb/CSS/StyleValues/CalculatedStyleValue.h> #include <LibWeb/CSS/StyleValues/CSSMathValue.h>
#include <LibWeb/CSS/StyleValues/NumberStyleValue.h> #include <LibWeb/CSS/StyleValues/NumberStyleValue.h>
#include <LibWeb/CSS/StyleValues/PercentageStyleValue.h> #include <LibWeb/CSS/StyleValues/PercentageStyleValue.h>
@ -27,8 +27,8 @@ Color CSSRGB::to_color(Optional<Layout::NodeWithStyle const&>) const
if (style_value.is_percentage()) if (style_value.is_percentage())
return normalized(style_value.as_percentage().value() * 2.55); return normalized(style_value.as_percentage().value() * 2.55);
if (style_value.is_calculated()) { if (style_value.is_math()) {
auto const& calculated = style_value.as_calculated(); auto const& calculated = style_value.as_math();
if (calculated.resolves_to_number()) if (calculated.resolves_to_number())
return normalized(calculated.resolve_number().value()); return normalized(calculated.resolve_number().value());
if (calculated.resolves_to_percentage()) if (calculated.resolves_to_percentage())

4
Userland/Libraries/LibWeb/CSS/Time.cpp
View file

@ -6,7 +6,7 @@
#include "Time.h" #include "Time.h"
#include <LibWeb/CSS/Percentage.h> #include <LibWeb/CSS/Percentage.h>
#include <LibWeb/CSS/StyleValues/CalculatedStyleValue.h> #include <LibWeb/CSS/StyleValues/CSSMathValue.h>
namespace Web::CSS { namespace Web::CSS {
@ -74,7 +74,7 @@ Optional<Time::Type> Time::unit_from_name(StringView name)
return {}; return {};
} }
Time Time::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, Layout::Node const&, Time const& reference_value) Time Time::resolve_calculated(NonnullRefPtr<CSSMathValue> const& calculated, Layout::Node const&, Time const& reference_value)
{ {
return calculated->resolve_time_percentage(reference_value).value(); return calculated->resolve_time_percentage(reference_value).value();
} }

2
Userland/Libraries/LibWeb/CSS/Time.h
View file

@ -49,7 +49,7 @@ public:
return 0; return 0;
} }
static Time resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const&, Layout::Node const&, Time const& reference_value); static Time resolve_calculated(NonnullRefPtr<CSSMathValue> const&, Layout::Node const&, Time const& reference_value);
private: private:
Type m_type; Type m_type;

2
Userland/Libraries/LibWeb/Forward.h
View file

@ -115,6 +115,7 @@ class CSSKeyframesRule;
class CSSKeywordValue; class CSSKeywordValue;
class CSSLayerBlockRule; class CSSLayerBlockRule;
class CSSLayerStatementRule; class CSSLayerStatementRule;
class CSSMathValue;
class CSSMediaRule; class CSSMediaRule;
class CSSOKLab; class CSSOKLab;
class CSSOKLCH; class CSSOKLCH;
@ -127,7 +128,6 @@ class CSSStyleSheet;
struct CSSStyleSheetInit; struct CSSStyleSheetInit;
class CSSStyleValue; class CSSStyleValue;
class CSSSupportsRule; class CSSSupportsRule;
class CalculatedStyleValue;
class Clip; class Clip;
class ConicGradientStyleValue; class ConicGradientStyleValue;
class ContentStyleValue; class ContentStyleValue;

8
Userland/Libraries/LibWeb/Layout/Node.cpp
View file

@ -702,8 +702,8 @@ void NodeWithStyle::apply_style(const CSS::StyleProperties& computed_style)
if (transition_delay_property->is_time()) { if (transition_delay_property->is_time()) {
auto& transition_delay = transition_delay_property->as_time(); auto& transition_delay = transition_delay_property->as_time();
computed_values.set_transition_delay(transition_delay.time()); computed_values.set_transition_delay(transition_delay.time());
} else if (transition_delay_property->is_calculated()) { } else if (transition_delay_property->is_math()) {
auto& transition_delay = transition_delay_property->as_calculated(); auto& transition_delay = transition_delay_property->as_math();
computed_values.set_transition_delay(transition_delay.resolve_time().value()); computed_values.set_transition_delay(transition_delay.resolve_time().value());
} }
@ -724,8 +724,8 @@ void NodeWithStyle::apply_style(const CSS::StyleProperties& computed_style)
} else { } else {
auto resolve_border_width = [&]() -> CSSPixels { auto resolve_border_width = [&]() -> CSSPixels {
auto value = computed_style.property(width_property); auto value = computed_style.property(width_property);
if (value->is_calculated()) if (value->is_math())
return max(CSSPixels { 0 }, value->as_calculated().resolve_length(*this)->to_px(*this)); return max(CSSPixels { 0 }, value->as_math().resolve_length(*this)->to_px(*this));
if (value->is_length()) if (value->is_length())
return value->as_length().length().to_px(*this); return value->as_length().length().to_px(*this);
if (value->is_keyword()) { if (value->is_keyword()) {