Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-11-03 23:00:58 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Userland/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.h

762 lines
33 KiB
C
Raw Normal View History

LibWeb: Split CalculatedStyleValue out of StyleValue.{h,cpp}
2023-03-30 17:34:14 +01:00
/*
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
* Copyright (c) 2021, Tobias Christiansen <tobyase@serenityos.org>
* Copyright (c) 2021-2023, Sam Atkins <atkinssj@serenityos.org>
* Copyright (c) 2022-2023, MacDue <macdue@dueutil.tech>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
LibWeb+LibJS: Move some code around to make CSS/Parser parse faster This makes it possible to include fewer full definitions of things, which makes the file about 30% faster to compile.
2023-07-09 11:40:17 +03:30
#include <AK/Function.h>
LibWeb: Split CalculatedStyleValue out of StyleValue.{h,cpp}
2023-03-30 17:34:14 +01:00
#include <LibWeb/CSS/Angle.h>
LibWeb: Implement "Determine the type of a calculation" algorithm This is sitting alongside our old implementation for the moment.
2023-07-05 19:58:13 +01:00
#include <LibWeb/CSS/CSSNumericType.h>
LibWeb: Implement Flex and FlexStyleValue types
2023-09-28 15:18:14 +01:00
#include <LibWeb/CSS/Flex.h>
LibWeb: Split CalculatedStyleValue out of StyleValue.{h,cpp}
2023-03-30 17:34:14 +01:00
#include <LibWeb/CSS/Frequency.h>
#include <LibWeb/CSS/Length.h>
#include <LibWeb/CSS/Percentage.h>
#include <LibWeb/CSS/StyleValue.h>
#include <LibWeb/CSS/Time.h>
namespace Web::CSS {
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
class CalculationNode;
LibWeb: Split CalculatedStyleValue out of StyleValue.{h,cpp}
2023-03-30 17:34:14 +01:00
class CalculatedStyleValue : public StyleValue {
public:
enum class ResolvedType {
Angle,
LibWeb: Implement Flex and FlexStyleValue types
2023-09-28 15:18:14 +01:00
Flex,
LibWeb: Split CalculatedStyleValue out of StyleValue.{h,cpp}
2023-03-30 17:34:14 +01:00
Frequency,
Integer,
Length,
Number,
Percentage,
Time,
};
enum class SumOperation {
Add,
Subtract,
};
enum class ProductOperation {
Multiply,
Divide,
};
LibWeb: Implement Flex and FlexStyleValue types
2023-09-28 15:18:14 +01:00
using PercentageBasis = Variant<Empty, Angle, Flex, Frequency, Length, Time>;
LibWeb: Split CalculatedStyleValue out of StyleValue.{h,cpp}
2023-03-30 17:34:14 +01:00
class CalculationResult {
public:
LibWeb: Implement Flex and FlexStyleValue types
2023-09-28 15:18:14 +01:00
using Value = Variant<Number, Angle, Flex, Frequency, Length, Percentage, Time>;
LibWeb: Split CalculatedStyleValue out of StyleValue.{h,cpp}
2023-03-30 17:34:14 +01:00
CalculationResult(Value value)
: m_value(move(value))
{
}
LibWeb: Add a way to resolve calc() values without a layout node Instead of a layout node, you can pass a new Length::ResolutionContext struct which contains everything needed to resolve calc() lengths.
2023-06-02 12:39:39 +02:00
void add(CalculationResult const& other, Optional<Length::ResolutionContext const&>, PercentageBasis const& percentage_basis);
void subtract(CalculationResult const& other, Optional<Length::ResolutionContext const&>, PercentageBasis const& percentage_basis);
void multiply_by(CalculationResult const& other, Optional<Length::ResolutionContext const&>);
void divide_by(CalculationResult const& other, Optional<Length::ResolutionContext const&>);
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
void negate();
void invert();
LibWeb: Split CalculatedStyleValue out of StyleValue.{h,cpp}
2023-03-30 17:34:14 +01:00
Value const& value() const { return m_value; }
private:
LibWeb: Add a way to resolve calc() values without a layout node Instead of a layout node, you can pass a new Length::ResolutionContext struct which contains everything needed to resolve calc() lengths.
2023-06-02 12:39:39 +02:00
void add_or_subtract_internal(SumOperation op, CalculationResult const& other, Optional<Length::ResolutionContext const&>, PercentageBasis const& percentage_basis);
LibWeb: Split CalculatedStyleValue out of StyleValue.{h,cpp}
2023-03-30 17:34:14 +01:00
Value m_value;
};
LibWeb: Make StyleValue constructors infallible
2023-08-19 14:00:10 +01:00
static ValueComparingNonnullRefPtr<CalculatedStyleValue> create(NonnullOwnPtr<CalculationNode> calculation, CSSNumericType resolved_type)
LibWeb: Split CalculatedStyleValue out of StyleValue.{h,cpp}
2023-03-30 17:34:14 +01:00
{
LibWeb: Make StyleValue constructors infallible
2023-08-19 14:00:10 +01:00
return adopt_ref(*new (nothrow) CalculatedStyleValue(move(calculation), resolved_type));
LibWeb: Split CalculatedStyleValue out of StyleValue.{h,cpp}
2023-03-30 17:34:14 +01:00
}
LibWeb: Make StyleValue::to_string() infallible
2023-08-22 14:08:15 +01:00
String to_string() const override;
LibWeb: Split CalculatedStyleValue out of StyleValue.{h,cpp}
2023-03-30 17:34:14 +01:00
virtual bool equals(StyleValue const& other) const override;
LibWeb: Use CSSNumericType for CalculatedStyleValue resolved type
2023-06-30 16:29:06 +01:00
bool resolves_to_angle() const { return m_resolved_type.matches_angle(); }
bool resolves_to_angle_percentage() const { return m_resolved_type.matches_angle_percentage(); }
LibWeb: Split CalculatedStyleValue out of StyleValue.{h,cpp}
2023-03-30 17:34:14 +01:00
Optional<Angle> resolve_angle() const;
Optional<Angle> resolve_angle_percentage(Angle const& percentage_basis) const;
LibWeb: Implement Flex and FlexStyleValue types
2023-09-28 15:18:14 +01:00
bool resolves_to_flex() const { return m_resolved_type.matches_flex(); }
Optional<Flex> resolve_flex() const;
LibWeb: Use CSSNumericType for CalculatedStyleValue resolved type
2023-06-30 16:29:06 +01:00
bool resolves_to_frequency() const { return m_resolved_type.matches_frequency(); }
bool resolves_to_frequency_percentage() const { return m_resolved_type.matches_frequency_percentage(); }
LibWeb: Split CalculatedStyleValue out of StyleValue.{h,cpp}
2023-03-30 17:34:14 +01:00
Optional<Frequency> resolve_frequency() const;
Optional<Frequency> resolve_frequency_percentage(Frequency const& percentage_basis) const;
LibWeb: Use CSSNumericType for CalculatedStyleValue resolved type
2023-06-30 16:29:06 +01:00
bool resolves_to_length() const { return m_resolved_type.matches_length(); }
bool resolves_to_length_percentage() const { return m_resolved_type.matches_length_percentage(); }
LibWeb: Add a way to resolve calc() values without a layout node Instead of a layout node, you can pass a new Length::ResolutionContext struct which contains everything needed to resolve calc() lengths.
2023-06-02 12:39:39 +02:00
[[nodiscard]] Optional<Length> resolve_length(Length::ResolutionContext const&) const;
LibWeb: Split CalculatedStyleValue out of StyleValue.{h,cpp}
2023-03-30 17:34:14 +01:00
Optional<Length> resolve_length(Layout::Node const& layout_node) const;
Optional<Length> resolve_length_percentage(Layout::Node const&, Length const& percentage_basis) const;
LibWeb: Add `Length::resolved()` overload for CSSPixels Since we always pass the px value as an argument to resolved(), we can pass it directly as CSSPixels instead of wrapping it in Length. This approach allows us to avoid converting to a double, resulting in fewer precision issues.
2023-08-29 18:57:09 +02:00
Optional<Length> resolve_length_percentage(Layout::Node const&, CSSPixels percentage_basis) const;
LibWeb: Split CalculatedStyleValue out of StyleValue.{h,cpp}
2023-03-30 17:34:14 +01:00
LibWeb: Use CSSNumericType for CalculatedStyleValue resolved type
2023-06-30 16:29:06 +01:00
bool resolves_to_percentage() const { return m_resolved_type.matches_percentage(); }
LibWeb: Split CalculatedStyleValue out of StyleValue.{h,cpp}
2023-03-30 17:34:14 +01:00
Optional<Percentage> resolve_percentage() const;
LibWeb: Use CSSNumericType for CalculatedStyleValue resolved type
2023-06-30 16:29:06 +01:00
bool resolves_to_time() const { return m_resolved_type.matches_time(); }
bool resolves_to_time_percentage() const { return m_resolved_type.matches_time_percentage(); }
LibWeb: Split CalculatedStyleValue out of StyleValue.{h,cpp}
2023-03-30 17:34:14 +01:00
Optional<Time> resolve_time() const;
Optional<Time> resolve_time_percentage(Time const& percentage_basis) const;
LibWeb: Use CSSNumericType for CalculatedStyleValue resolved type
2023-06-30 16:29:06 +01:00
bool resolves_to_number() const { return m_resolved_type.matches_number(); }
bool resolves_to_number_percentage() const { return m_resolved_type.matches_number_percentage(); }
LibWeb: Change calc node representation from float to double
2023-05-27 21:10:21 +02:00
Optional<double> resolve_number() const;
LibWeb: Mark CalculatedStyleValue::resolve_integer() as const
2023-09-07 15:11:09 +01:00
Optional<i64> resolve_integer() const;
LibWeb: Split CalculatedStyleValue out of StyleValue.{h,cpp}
2023-03-30 17:34:14 +01:00
bool contains_percentage() const;
private:
LibWeb: Use CSSNumericType for CalculatedStyleValue resolved type
2023-06-30 16:29:06 +01:00
explicit CalculatedStyleValue(NonnullOwnPtr<CalculationNode> calculation, CSSNumericType resolved_type)
LibWeb: Split CalculatedStyleValue out of StyleValue.{h,cpp}
2023-03-30 17:34:14 +01:00
: StyleValue(Type::Calculated)
, m_resolved_type(resolved_type)
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
, m_calculation(move(calculation))
LibWeb: Split CalculatedStyleValue out of StyleValue.{h,cpp}
2023-03-30 17:34:14 +01:00
{
}
LibWeb: Use CSSNumericType for CalculatedStyleValue resolved type
2023-06-30 16:29:06 +01:00
CSSNumericType m_resolved_type;
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
NonnullOwnPtr<CalculationNode> m_calculation;
};
// https://www.w3.org/TR/css-values-4/#calculation-tree
class CalculationNode {
public:
LibWeb: Parse css math constants
2023-05-26 21:24:31 +02:00
// https://drafts.csswg.org/css-values-4/#calc-constants
// https://drafts.csswg.org/css-values-4/#calc-error-constants
enum class ConstantType {
E,
LibWeb: Extract CalculationNode::constant_type_from_string() function This is needed by some upcoming generated code. Renamed "PI" member to "Pi" while I was at it.
2023-07-08 16:55:06 +01:00
Pi,
LibWeb: Parse css math constants
2023-05-26 21:24:31 +02:00
NaN,
Infinity,
MinusInfinity,
};
LibWeb: Extract CalculationNode::constant_type_from_string() function This is needed by some upcoming generated code. Renamed "PI" member to "Pi" while I was at it.
2023-07-08 16:55:06 +01:00
static Optional<ConstantType> constant_type_from_string(StringView);
LibWeb: Parse css math constants
2023-05-26 21:24:31 +02:00
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
enum class Type {
Numeric,
// NOTE: Currently, any value with a `var()` or `attr()` function in it is always an
// UnresolvedStyleValue so we do not have to implement a NonMathFunction type here.
LibWeb: Parse `min()` css math function
2023-05-26 11:21:49 +02:00
// Comparison function nodes, a sub-type of operator node
// https://drafts.csswg.org/css-values-4/#comp-func
Min,
Max,
Clamp,
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
// Calc-operator nodes, a sub-type of operator node
// https://www.w3.org/TR/css-values-4/#calculation-tree-calc-operator-nodes
Sum,
Product,
Negate,
Invert,
LibWeb: Implement CSS `abs()`
2023-05-27 22:56:41 +02:00
// Sign-Related Functions, a sub-type of operator node
// https://drafts.csswg.org/css-values-4/#sign-funcs
Abs,
Sign,
LibWeb: Parse css math constants
2023-05-26 21:24:31 +02:00
// Constant Nodes
// https://drafts.csswg.org/css-values-4/#calc-constants
Constant,
LibWeb: Implement CSS `sin()`
2023-05-27 23:50:33 +02:00
// Trigonometric functions, a sub-type of operator node
// https://drafts.csswg.org/css-values-4/#trig-funcs
Sin,
Cos,
Tan,
Asin,
Acos,
Atan,
Atan2,
LibWeb: Implement CSS `pow()`
2023-05-28 11:26:42 +02:00
// Exponential functions, a sub-type of operator node
// https://drafts.csswg.org/css-values-4/#exponent-funcs
Pow,
Sqrt,
Hypot,
Log,
Exp,
LibWeb: Implement CSS `round()`
2023-05-27 16:07:50 +02:00
// Stepped value functions, a sub-type of operator node
// https://drafts.csswg.org/css-values-4/#round-func
Round,
Mod,
Rem,
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
// This only exists during parsing.
Unparsed,
};
using NumericValue = CalculatedStyleValue::CalculationResult::Value;
virtual ~CalculationNode();
Type type() const { return m_type; }
LibWeb: Return true for `is_operator_node()` for math-function nodes
2023-07-04 16:08:19 +01:00
// https://www.w3.org/TR/css-values-4/#calculation-tree-operator-nodes
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
bool is_operator_node() const
{
LibWeb: Return true for `is_operator_node()` for math-function nodes
2023-07-04 16:08:19 +01:00
return is_calc_operator_node() || is_math_function_node();
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
}
LibWeb: Return true for `is_operator_node()` for math-function nodes
2023-07-04 16:08:19 +01:00
bool is_math_function_node() const
{
switch (m_type) {
case Type::Min:
case Type::Max:
case Type::Clamp:
case Type::Abs:
case Type::Sign:
case Type::Sin:
case Type::Cos:
case Type::Tan:
case Type::Asin:
case Type::Acos:
case Type::Atan:
case Type::Atan2:
case Type::Pow:
case Type::Sqrt:
case Type::Hypot:
case Type::Log:
case Type::Exp:
case Type::Round:
case Type::Mod:
case Type::Rem:
return true;
default:
return false;
}
}
// https://www.w3.org/TR/css-values-4/#calculation-tree-calc-operator-nodes
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
bool is_calc_operator_node() const
{
return first_is_one_of(m_type, Type::Sum, Type::Product, Type::Negate, Type::Invert);
}
LibWeb: Make StyleValue::to_string() infallible
2023-08-22 14:08:15 +01:00
virtual String to_string() const = 0;
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const = 0;
LibWeb: Implement "Determine the type of a calculation" algorithm This is sitting alongside our old implementation for the moment.
2023-07-05 19:58:13 +01:00
virtual Optional<CSSNumericType> determine_type(PropertyID) const = 0;
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
virtual bool contains_percentage() const = 0;
LibWeb: Add a way to resolve calc() values without a layout node Instead of a layout node, you can pass a new Length::ResolutionContext struct which contains everything needed to resolve calc() lengths.
2023-06-02 12:39:39 +02:00
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const = 0;
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) = 0;
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
LibWeb: Make CalculatedStyleValue::dump() infallible
2023-08-22 14:13:22 +01:00
virtual void dump(StringBuilder&, int indent) const = 0;
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
protected:
explicit CalculationNode(Type);
private:
Type m_type;
};
class NumericCalculationNode final : public CalculationNode {
public:
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
static NonnullOwnPtr<NumericCalculationNode> create(NumericValue);
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
~NumericCalculationNode();
LibWeb: Make StyleValue::to_string() infallible
2023-08-22 14:08:15 +01:00
virtual String to_string() const override;
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
LibWeb: Implement "Determine the type of a calculation" algorithm This is sitting alongside our old implementation for the moment.
2023-07-05 19:58:13 +01:00
virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
virtual bool contains_percentage() const override;
LibWeb: Add a way to resolve calc() values without a layout node Instead of a layout node, you can pass a new Length::ResolutionContext struct which contains everything needed to resolve calc() lengths.
2023-06-02 12:39:39 +02:00
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override { }
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
LibWeb: Make CalculatedStyleValue::dump() infallible
2023-08-22 14:13:22 +01:00
virtual void dump(StringBuilder&, int indent) const override;
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
private:
explicit NumericCalculationNode(NumericValue);
NumericValue m_value;
};
class SumCalculationNode final : public CalculationNode {
public:
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
static NonnullOwnPtr<SumCalculationNode> create(Vector<NonnullOwnPtr<CalculationNode>>);
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
~SumCalculationNode();
LibWeb: Make StyleValue::to_string() infallible
2023-08-22 14:08:15 +01:00
virtual String to_string() const override;
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
LibWeb: Implement "Determine the type of a calculation" algorithm This is sitting alongside our old implementation for the moment.
2023-07-05 19:58:13 +01:00
virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
virtual bool contains_percentage() const override;
LibWeb: Add a way to resolve calc() values without a layout node Instead of a layout node, you can pass a new Length::ResolutionContext struct which contains everything needed to resolve calc() lengths.
2023-06-02 12:39:39 +02:00
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
LibWeb: Make CalculatedStyleValue::dump() infallible
2023-08-22 14:13:22 +01:00
virtual void dump(StringBuilder&, int indent) const override;
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
private:
explicit SumCalculationNode(Vector<NonnullOwnPtr<CalculationNode>>);
Vector<NonnullOwnPtr<CalculationNode>> m_values;
};
class ProductCalculationNode final : public CalculationNode {
public:
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
static NonnullOwnPtr<ProductCalculationNode> create(Vector<NonnullOwnPtr<CalculationNode>>);
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
~ProductCalculationNode();
LibWeb: Make StyleValue::to_string() infallible
2023-08-22 14:08:15 +01:00
virtual String to_string() const override;
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
LibWeb: Implement "Determine the type of a calculation" algorithm This is sitting alongside our old implementation for the moment.
2023-07-05 19:58:13 +01:00
virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
virtual bool contains_percentage() const override;
LibWeb: Add a way to resolve calc() values without a layout node Instead of a layout node, you can pass a new Length::ResolutionContext struct which contains everything needed to resolve calc() lengths.
2023-06-02 12:39:39 +02:00
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
LibWeb: Make CalculatedStyleValue::dump() infallible
2023-08-22 14:13:22 +01:00
virtual void dump(StringBuilder&, int indent) const override;
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
private:
explicit ProductCalculationNode(Vector<NonnullOwnPtr<CalculationNode>>);
Vector<NonnullOwnPtr<CalculationNode>> m_values;
};
class NegateCalculationNode final : public CalculationNode {
public:
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
static NonnullOwnPtr<NegateCalculationNode> create(NonnullOwnPtr<CalculationNode>);
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
~NegateCalculationNode();
LibWeb: Make StyleValue::to_string() infallible
2023-08-22 14:08:15 +01:00
virtual String to_string() const override;
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
LibWeb: Implement "Determine the type of a calculation" algorithm This is sitting alongside our old implementation for the moment.
2023-07-05 19:58:13 +01:00
virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
virtual bool contains_percentage() const override;
LibWeb: Add a way to resolve calc() values without a layout node Instead of a layout node, you can pass a new Length::ResolutionContext struct which contains everything needed to resolve calc() lengths.
2023-06-02 12:39:39 +02:00
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
LibWeb: Make CalculatedStyleValue::dump() infallible
2023-08-22 14:13:22 +01:00
virtual void dump(StringBuilder&, int indent) const override;
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
private:
explicit NegateCalculationNode(NonnullOwnPtr<CalculationNode>);
NonnullOwnPtr<CalculationNode> m_value;
};
class InvertCalculationNode final : public CalculationNode {
public:
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
static NonnullOwnPtr<InvertCalculationNode> create(NonnullOwnPtr<CalculationNode>);
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
~InvertCalculationNode();
LibWeb: Make StyleValue::to_string() infallible
2023-08-22 14:08:15 +01:00
virtual String to_string() const override;
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
LibWeb: Implement "Determine the type of a calculation" algorithm This is sitting alongside our old implementation for the moment.
2023-07-05 19:58:13 +01:00
virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
virtual bool contains_percentage() const override;
LibWeb: Add a way to resolve calc() values without a layout node Instead of a layout node, you can pass a new Length::ResolutionContext struct which contains everything needed to resolve calc() lengths.
2023-06-02 12:39:39 +02:00
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
LibWeb: Make CalculatedStyleValue::dump() infallible
2023-08-22 14:13:22 +01:00
virtual void dump(StringBuilder&, int indent) const override;
LibWeb: Reimplement CalculatedStyleValue as a calculation node tree VALUES-4 defines the internal representation of `calc()` as a tree of calculation nodes. ( https://www.w3.org/TR/css-values-4/#calc-internal ) VALUES-3 lacked any definition here, so we had our own ad-hoc implementation based around the spec grammar. This commit replaces that with CalculationNodes representing each possible node in the tree. There are no intended functional changes, though we do now support nested calc() which previously did not work. For example: `width: calc( 42 * calc(3 + 7) );` I have added an example of this to our test page. A couple of the layout tests that used `calc()` now return values that are 0.5px different from before. There's no visual difference, so I have updated the tests to use the new results.
2023-04-11 15:48:06 +01:00
private:
explicit InvertCalculationNode(NonnullOwnPtr<CalculationNode>);
NonnullOwnPtr<CalculationNode> m_value;
LibWeb: Split CalculatedStyleValue out of StyleValue.{h,cpp}
2023-03-30 17:34:14 +01:00
};
LibWeb: Parse `min()` css math function
2023-05-26 11:21:49 +02:00
class MinCalculationNode final : public CalculationNode {
public:
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
static NonnullOwnPtr<MinCalculationNode> create(Vector<NonnullOwnPtr<CalculationNode>>);
LibWeb: Parse `min()` css math function
2023-05-26 11:21:49 +02:00
~MinCalculationNode();
LibWeb: Make StyleValue::to_string() infallible
2023-08-22 14:08:15 +01:00
virtual String to_string() const override;
LibWeb: Parse `min()` css math function
2023-05-26 11:21:49 +02:00
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
LibWeb: Implement "Determine the type of a calculation" algorithm This is sitting alongside our old implementation for the moment.
2023-07-05 19:58:13 +01:00
virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
LibWeb: Parse `min()` css math function
2023-05-26 11:21:49 +02:00
virtual bool contains_percentage() const override;
LibWeb: Add a way to resolve calc() values without a layout node Instead of a layout node, you can pass a new Length::ResolutionContext struct which contains everything needed to resolve calc() lengths.
2023-06-02 12:39:39 +02:00
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
LibWeb: Parse `min()` css math function
2023-05-26 11:21:49 +02:00
LibWeb: Make CalculatedStyleValue::dump() infallible
2023-08-22 14:13:22 +01:00
virtual void dump(StringBuilder&, int indent) const override;
LibWeb: Parse `min()` css math function
2023-05-26 11:21:49 +02:00
private:
explicit MinCalculationNode(Vector<NonnullOwnPtr<CalculationNode>>);
Vector<NonnullOwnPtr<CalculationNode>> m_values;
};
LibWeb: Parse `max()` css math function
2023-05-26 15:00:22 +02:00
class MaxCalculationNode final : public CalculationNode {
public:
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
static NonnullOwnPtr<MaxCalculationNode> create(Vector<NonnullOwnPtr<CalculationNode>>);
LibWeb: Parse `max()` css math function
2023-05-26 15:00:22 +02:00
~MaxCalculationNode();
LibWeb: Make StyleValue::to_string() infallible
2023-08-22 14:08:15 +01:00
virtual String to_string() const override;
LibWeb: Parse `max()` css math function
2023-05-26 15:00:22 +02:00
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
LibWeb: Implement "Determine the type of a calculation" algorithm This is sitting alongside our old implementation for the moment.
2023-07-05 19:58:13 +01:00
virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
LibWeb: Parse `max()` css math function
2023-05-26 15:00:22 +02:00
virtual bool contains_percentage() const override;
LibWeb: Add a way to resolve calc() values without a layout node Instead of a layout node, you can pass a new Length::ResolutionContext struct which contains everything needed to resolve calc() lengths.
2023-06-02 12:39:39 +02:00
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
LibWeb: Parse `max()` css math function
2023-05-26 15:00:22 +02:00
LibWeb: Make CalculatedStyleValue::dump() infallible
2023-08-22 14:13:22 +01:00
virtual void dump(StringBuilder&, int indent) const override;
LibWeb: Parse `max()` css math function
2023-05-26 15:00:22 +02:00
private:
explicit MaxCalculationNode(Vector<NonnullOwnPtr<CalculationNode>>);
Vector<NonnullOwnPtr<CalculationNode>> m_values;
};
LibWeb: Parse `clamp()` css math function
2023-05-26 15:40:39 +02:00
class ClampCalculationNode final : public CalculationNode {
public:
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
static NonnullOwnPtr<ClampCalculationNode> create(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
LibWeb: Parse `clamp()` css math function
2023-05-26 15:40:39 +02:00
~ClampCalculationNode();
LibWeb: Make StyleValue::to_string() infallible
2023-08-22 14:08:15 +01:00
virtual String to_string() const override;
LibWeb: Parse `clamp()` css math function
2023-05-26 15:40:39 +02:00
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
LibWeb: Implement "Determine the type of a calculation" algorithm This is sitting alongside our old implementation for the moment.
2023-07-05 19:58:13 +01:00
virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
LibWeb: Parse `clamp()` css math function
2023-05-26 15:40:39 +02:00
virtual bool contains_percentage() const override;
LibWeb: Add a way to resolve calc() values without a layout node Instead of a layout node, you can pass a new Length::ResolutionContext struct which contains everything needed to resolve calc() lengths.
2023-06-02 12:39:39 +02:00
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
LibWeb: Parse `clamp()` css math function
2023-05-26 15:40:39 +02:00
LibWeb: Make CalculatedStyleValue::dump() infallible
2023-08-22 14:13:22 +01:00
virtual void dump(StringBuilder&, int indent) const override;
LibWeb: Parse `clamp()` css math function
2023-05-26 15:40:39 +02:00
private:
explicit ClampCalculationNode(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
NonnullOwnPtr<CalculationNode> m_min_value;
NonnullOwnPtr<CalculationNode> m_center_value;
NonnullOwnPtr<CalculationNode> m_max_value;
};
LibWeb: Implement CSS `abs()`
2023-05-27 22:56:41 +02:00
class AbsCalculationNode final : public CalculationNode {
public:
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
static NonnullOwnPtr<AbsCalculationNode> create(NonnullOwnPtr<CalculationNode>);
LibWeb: Implement CSS `abs()`
2023-05-27 22:56:41 +02:00
~AbsCalculationNode();
LibWeb: Make StyleValue::to_string() infallible
2023-08-22 14:08:15 +01:00
virtual String to_string() const override;
LibWeb: Implement CSS `abs()`
2023-05-27 22:56:41 +02:00
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
LibWeb: Implement "Determine the type of a calculation" algorithm This is sitting alongside our old implementation for the moment.
2023-07-05 19:58:13 +01:00
virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
LibWeb: Implement CSS `abs()`
2023-05-27 22:56:41 +02:00
virtual bool contains_percentage() const override;
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
LibWeb: Implement CSS `abs()`
2023-05-27 22:56:41 +02:00
LibWeb: Make CalculatedStyleValue::dump() infallible
2023-08-22 14:13:22 +01:00
virtual void dump(StringBuilder&, int indent) const override;
LibWeb: Implement CSS `abs()`
2023-05-27 22:56:41 +02:00
private:
AbsCalculationNode(NonnullOwnPtr<CalculationNode>);
NonnullOwnPtr<CalculationNode> m_value;
};
LibWeb: Implement CSS `sign()`
2023-05-27 23:02:39 +02:00
class SignCalculationNode final : public CalculationNode {
public:
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
static NonnullOwnPtr<SignCalculationNode> create(NonnullOwnPtr<CalculationNode>);
LibWeb: Implement CSS `sign()`
2023-05-27 23:02:39 +02:00
~SignCalculationNode();
LibWeb: Make StyleValue::to_string() infallible
2023-08-22 14:08:15 +01:00
virtual String to_string() const override;
LibWeb: Implement CSS `sign()`
2023-05-27 23:02:39 +02:00
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
LibWeb: Implement "Determine the type of a calculation" algorithm This is sitting alongside our old implementation for the moment.
2023-07-05 19:58:13 +01:00
virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
LibWeb: Implement CSS `sign()`
2023-05-27 23:02:39 +02:00
virtual bool contains_percentage() const override;
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
LibWeb: Implement CSS `sign()`
2023-05-27 23:02:39 +02:00
LibWeb: Make CalculatedStyleValue::dump() infallible
2023-08-22 14:13:22 +01:00
virtual void dump(StringBuilder&, int indent) const override;
LibWeb: Implement CSS `sign()`
2023-05-27 23:02:39 +02:00
private:
SignCalculationNode(NonnullOwnPtr<CalculationNode>);
NonnullOwnPtr<CalculationNode> m_value;
};
LibWeb: Parse css math constants
2023-05-26 21:24:31 +02:00
class ConstantCalculationNode final : public CalculationNode {
public:
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
static NonnullOwnPtr<ConstantCalculationNode> create(CalculationNode::ConstantType);
LibWeb: Parse css math constants
2023-05-26 21:24:31 +02:00
~ConstantCalculationNode();
LibWeb: Make StyleValue::to_string() infallible
2023-08-22 14:08:15 +01:00
virtual String to_string() const override;
LibWeb: Parse css math constants
2023-05-26 21:24:31 +02:00
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
LibWeb: Implement "Determine the type of a calculation" algorithm This is sitting alongside our old implementation for the moment.
2023-07-05 19:58:13 +01:00
virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
Everywhere: Remove needless trailing semi-colons after functions This is a new option in clang-format-16.
2023-07-07 22:48:11 -04:00
virtual bool contains_percentage() const override { return false; }
LibWeb: Parse css math constants
2023-05-26 21:24:31 +02:00
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&> context, CalculatedStyleValue::PercentageBasis const&) const override;
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override { }
LibWeb: Parse css math constants
2023-05-26 21:24:31 +02:00
LibWeb: Make CalculatedStyleValue::dump() infallible
2023-08-22 14:13:22 +01:00
virtual void dump(StringBuilder&, int indent) const override;
LibWeb: Parse css math constants
2023-05-26 21:24:31 +02:00
private:
ConstantCalculationNode(ConstantType);
CalculationNode::ConstantType m_constant;
};
LibWeb: Implement CSS `sin()`
2023-05-27 23:50:33 +02:00
class SinCalculationNode final : public CalculationNode {
public:
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
static NonnullOwnPtr<SinCalculationNode> create(NonnullOwnPtr<CalculationNode>);
LibWeb: Implement CSS `sin()`
2023-05-27 23:50:33 +02:00
~SinCalculationNode();
LibWeb: Make StyleValue::to_string() infallible
2023-08-22 14:08:15 +01:00
virtual String to_string() const override;
LibWeb: Implement CSS `sin()`
2023-05-27 23:50:33 +02:00
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
LibWeb: Implement "Determine the type of a calculation" algorithm This is sitting alongside our old implementation for the moment.
2023-07-05 19:58:13 +01:00
virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
LibWeb: Implement CSS `sin()`
2023-05-27 23:50:33 +02:00
virtual bool contains_percentage() const override;
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
LibWeb: Implement CSS `sin()`
2023-05-27 23:50:33 +02:00
LibWeb: Make CalculatedStyleValue::dump() infallible
2023-08-22 14:13:22 +01:00
virtual void dump(StringBuilder&, int indent) const override;
LibWeb: Implement CSS `sin()`
2023-05-27 23:50:33 +02:00
private:
SinCalculationNode(NonnullOwnPtr<CalculationNode>);
NonnullOwnPtr<CalculationNode> m_value;
};
LibWeb: Implement CSS `cos()`
2023-05-27 23:57:01 +02:00
class CosCalculationNode final : public CalculationNode {
public:
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
static NonnullOwnPtr<CosCalculationNode> create(NonnullOwnPtr<CalculationNode>);
LibWeb: Implement CSS `cos()`
2023-05-27 23:57:01 +02:00
~CosCalculationNode();
LibWeb: Make StyleValue::to_string() infallible
2023-08-22 14:08:15 +01:00
virtual String to_string() const override;
LibWeb: Implement CSS `cos()`
2023-05-27 23:57:01 +02:00
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
LibWeb: Implement "Determine the type of a calculation" algorithm This is sitting alongside our old implementation for the moment.
2023-07-05 19:58:13 +01:00
virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
LibWeb: Implement CSS `cos()`
2023-05-27 23:57:01 +02:00
virtual bool contains_percentage() const override;
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
LibWeb: Implement CSS `cos()`
2023-05-27 23:57:01 +02:00
LibWeb: Make CalculatedStyleValue::dump() infallible
2023-08-22 14:13:22 +01:00
virtual void dump(StringBuilder&, int indent) const override;
LibWeb: Implement CSS `cos()`
2023-05-27 23:57:01 +02:00
private:
CosCalculationNode(NonnullOwnPtr<CalculationNode>);
NonnullOwnPtr<CalculationNode> m_value;
};
LibWeb: Implement CSS `tan()`
2023-05-28 00:02:43 +02:00
class TanCalculationNode final : public CalculationNode {
public:
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
static NonnullOwnPtr<TanCalculationNode> create(NonnullOwnPtr<CalculationNode>);
LibWeb: Implement CSS `tan()`
2023-05-28 00:02:43 +02:00
~TanCalculationNode();
LibWeb: Make StyleValue::to_string() infallible
2023-08-22 14:08:15 +01:00
virtual String to_string() const override;
LibWeb: Implement CSS `tan()`
2023-05-28 00:02:43 +02:00
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
LibWeb: Implement "Determine the type of a calculation" algorithm This is sitting alongside our old implementation for the moment.
2023-07-05 19:58:13 +01:00
virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
LibWeb: Implement CSS `tan()`
2023-05-28 00:02:43 +02:00
virtual bool contains_percentage() const override;
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
LibWeb: Implement CSS `tan()`
2023-05-28 00:02:43 +02:00
LibWeb: Make CalculatedStyleValue::dump() infallible
2023-08-22 14:13:22 +01:00
virtual void dump(StringBuilder&, int indent) const override;
LibWeb: Implement CSS `tan()`
2023-05-28 00:02:43 +02:00
private:
TanCalculationNode(NonnullOwnPtr<CalculationNode>);
NonnullOwnPtr<CalculationNode> m_value;
};
LibWeb: Implement CSS `asin()`
2023-05-28 10:55:52 +02:00
class AsinCalculationNode final : public CalculationNode {
public:
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
static NonnullOwnPtr<AsinCalculationNode> create(NonnullOwnPtr<CalculationNode>);
LibWeb: Implement CSS `asin()`
2023-05-28 10:55:52 +02:00
~AsinCalculationNode();
LibWeb: Make StyleValue::to_string() infallible
2023-08-22 14:08:15 +01:00
virtual String to_string() const override;
LibWeb: Implement CSS `asin()`
2023-05-28 10:55:52 +02:00
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
LibWeb: Implement "Determine the type of a calculation" algorithm This is sitting alongside our old implementation for the moment.
2023-07-05 19:58:13 +01:00
virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
LibWeb: Implement CSS `asin()`
2023-05-28 10:55:52 +02:00
virtual bool contains_percentage() const override;
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
LibWeb: Implement CSS `asin()`
2023-05-28 10:55:52 +02:00
LibWeb: Make CalculatedStyleValue::dump() infallible
2023-08-22 14:13:22 +01:00
virtual void dump(StringBuilder&, int indent) const override;
LibWeb: Implement CSS `asin()`
2023-05-28 10:55:52 +02:00
private:
AsinCalculationNode(NonnullOwnPtr<CalculationNode>);
NonnullOwnPtr<CalculationNode> m_value;
};
LibWeb: Implement CSS `acos()`
2023-05-28 11:00:35 +02:00
class AcosCalculationNode final : public CalculationNode {
public:
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
static NonnullOwnPtr<AcosCalculationNode> create(NonnullOwnPtr<CalculationNode>);
LibWeb: Implement CSS `acos()`
2023-05-28 11:00:35 +02:00
~AcosCalculationNode();
LibWeb: Make StyleValue::to_string() infallible
2023-08-22 14:08:15 +01:00
virtual String to_string() const override;
LibWeb: Implement CSS `acos()`
2023-05-28 11:00:35 +02:00
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
LibWeb: Implement "Determine the type of a calculation" algorithm This is sitting alongside our old implementation for the moment.
2023-07-05 19:58:13 +01:00
virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
LibWeb: Implement CSS `acos()`
2023-05-28 11:00:35 +02:00
virtual bool contains_percentage() const override;
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
LibWeb: Implement CSS `acos()`
2023-05-28 11:00:35 +02:00
LibWeb: Make CalculatedStyleValue::dump() infallible
2023-08-22 14:13:22 +01:00
virtual void dump(StringBuilder&, int indent) const override;
LibWeb: Implement CSS `acos()`
2023-05-28 11:00:35 +02:00
private:
AcosCalculationNode(NonnullOwnPtr<CalculationNode>);
NonnullOwnPtr<CalculationNode> m_value;
};
LibWeb: Implement CSS `atan()`
2023-05-28 11:04:57 +02:00
class AtanCalculationNode final : public CalculationNode {
public:
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
static NonnullOwnPtr<AtanCalculationNode> create(NonnullOwnPtr<CalculationNode>);
LibWeb: Implement CSS `atan()`
2023-05-28 11:04:57 +02:00
~AtanCalculationNode();
LibWeb: Make StyleValue::to_string() infallible
2023-08-22 14:08:15 +01:00
virtual String to_string() const override;
LibWeb: Implement CSS `atan()`
2023-05-28 11:04:57 +02:00
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
LibWeb: Implement "Determine the type of a calculation" algorithm This is sitting alongside our old implementation for the moment.
2023-07-05 19:58:13 +01:00
virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
LibWeb: Implement CSS `atan()`
2023-05-28 11:04:57 +02:00
virtual bool contains_percentage() const override;
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
LibWeb: Implement CSS `atan()`
2023-05-28 11:04:57 +02:00
LibWeb: Make CalculatedStyleValue::dump() infallible
2023-08-22 14:13:22 +01:00
virtual void dump(StringBuilder&, int indent) const override;
LibWeb: Implement CSS `atan()`
2023-05-28 11:04:57 +02:00
private:
AtanCalculationNode(NonnullOwnPtr<CalculationNode>);
NonnullOwnPtr<CalculationNode> m_value;
};
LibWeb: Implement CSS `atan2()`
2023-05-28 11:19:10 +02:00
class Atan2CalculationNode final : public CalculationNode {
public:
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
static NonnullOwnPtr<Atan2CalculationNode> create(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
LibWeb: Implement CSS `atan2()`
2023-05-28 11:19:10 +02:00
~Atan2CalculationNode();
LibWeb: Make StyleValue::to_string() infallible
2023-08-22 14:08:15 +01:00
virtual String to_string() const override;
LibWeb: Implement CSS `atan2()`
2023-05-28 11:19:10 +02:00
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
LibWeb: Implement "Determine the type of a calculation" algorithm This is sitting alongside our old implementation for the moment.
2023-07-05 19:58:13 +01:00
virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
LibWeb: Implement CSS `atan2()`
2023-05-28 11:19:10 +02:00
virtual bool contains_percentage() const override;
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
LibWeb: Implement CSS `atan2()`
2023-05-28 11:19:10 +02:00
LibWeb: Make CalculatedStyleValue::dump() infallible
2023-08-22 14:13:22 +01:00
virtual void dump(StringBuilder&, int indent) const override;
LibWeb: Implement CSS `atan2()`
2023-05-28 11:19:10 +02:00
private:
Atan2CalculationNode(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
NonnullOwnPtr<CalculationNode> m_y;
NonnullOwnPtr<CalculationNode> m_x;
};
LibWeb: Implement CSS `pow()`
2023-05-28 11:26:42 +02:00
class PowCalculationNode final : public CalculationNode {
public:
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
static NonnullOwnPtr<PowCalculationNode> create(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
LibWeb: Implement CSS `pow()`
2023-05-28 11:26:42 +02:00
~PowCalculationNode();
LibWeb: Make StyleValue::to_string() infallible
2023-08-22 14:08:15 +01:00
virtual String to_string() const override;
LibWeb: Implement CSS `pow()`
2023-05-28 11:26:42 +02:00
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
LibWeb: Implement "Determine the type of a calculation" algorithm This is sitting alongside our old implementation for the moment.
2023-07-05 19:58:13 +01:00
virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
Everywhere: Remove needless trailing semi-colons after functions This is a new option in clang-format-16.
2023-07-07 22:48:11 -04:00
virtual bool contains_percentage() const override { return false; }
LibWeb: Implement CSS `pow()`
2023-05-28 11:26:42 +02:00
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
LibWeb: Implement CSS `pow()`
2023-05-28 11:26:42 +02:00
LibWeb: Make CalculatedStyleValue::dump() infallible
2023-08-22 14:13:22 +01:00
virtual void dump(StringBuilder&, int indent) const override;
LibWeb: Implement CSS `pow()`
2023-05-28 11:26:42 +02:00
private:
explicit PowCalculationNode(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
NonnullOwnPtr<CalculationNode> m_x;
NonnullOwnPtr<CalculationNode> m_y;
};
LibWeb: Implement CSS `sqrt()`
2023-05-28 11:31:50 +02:00
class SqrtCalculationNode final : public CalculationNode {
public:
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
static NonnullOwnPtr<SqrtCalculationNode> create(NonnullOwnPtr<CalculationNode>);
LibWeb: Implement CSS `sqrt()`
2023-05-28 11:31:50 +02:00
~SqrtCalculationNode();
LibWeb: Make StyleValue::to_string() infallible
2023-08-22 14:08:15 +01:00
virtual String to_string() const override;
LibWeb: Implement CSS `sqrt()`
2023-05-28 11:31:50 +02:00
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
LibWeb: Implement "Determine the type of a calculation" algorithm This is sitting alongside our old implementation for the moment.
2023-07-05 19:58:13 +01:00
virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
Everywhere: Remove needless trailing semi-colons after functions This is a new option in clang-format-16.
2023-07-07 22:48:11 -04:00
virtual bool contains_percentage() const override { return false; }
LibWeb: Implement CSS `sqrt()`
2023-05-28 11:31:50 +02:00
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
LibWeb: Implement CSS `sqrt()`
2023-05-28 11:31:50 +02:00
LibWeb: Make CalculatedStyleValue::dump() infallible
2023-08-22 14:13:22 +01:00
virtual void dump(StringBuilder&, int indent) const override;
LibWeb: Implement CSS `sqrt()`
2023-05-28 11:31:50 +02:00
private:
SqrtCalculationNode(NonnullOwnPtr<CalculationNode>);
NonnullOwnPtr<CalculationNode> m_value;
};
LibWeb: Implement CSS `hypot()`
2023-05-28 11:43:04 +02:00
class HypotCalculationNode final : public CalculationNode {
public:
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
static NonnullOwnPtr<HypotCalculationNode> create(Vector<NonnullOwnPtr<CalculationNode>>);
LibWeb: Implement CSS `hypot()`
2023-05-28 11:43:04 +02:00
~HypotCalculationNode();
LibWeb: Make StyleValue::to_string() infallible
2023-08-22 14:08:15 +01:00
virtual String to_string() const override;
LibWeb: Implement CSS `hypot()`
2023-05-28 11:43:04 +02:00
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
LibWeb: Implement "Determine the type of a calculation" algorithm This is sitting alongside our old implementation for the moment.
2023-07-05 19:58:13 +01:00
virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
LibWeb: Implement CSS `hypot()`
2023-05-28 11:43:04 +02:00
virtual bool contains_percentage() const override;
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
LibWeb: Implement CSS `hypot()`
2023-05-28 11:43:04 +02:00
LibWeb: Make CalculatedStyleValue::dump() infallible
2023-08-22 14:13:22 +01:00
virtual void dump(StringBuilder&, int indent) const override;
LibWeb: Implement CSS `hypot()`
2023-05-28 11:43:04 +02:00
private:
explicit HypotCalculationNode(Vector<NonnullOwnPtr<CalculationNode>>);
Vector<NonnullOwnPtr<CalculationNode>> m_values;
};
LibWeb: Implement CSS `log()`
2023-05-28 11:53:57 +02:00
class LogCalculationNode final : public CalculationNode {
public:
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
static NonnullOwnPtr<LogCalculationNode> create(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
LibWeb: Implement CSS `log()`
2023-05-28 11:53:57 +02:00
~LogCalculationNode();
LibWeb: Make StyleValue::to_string() infallible
2023-08-22 14:08:15 +01:00
virtual String to_string() const override;
LibWeb: Implement CSS `log()`
2023-05-28 11:53:57 +02:00
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
LibWeb: Implement "Determine the type of a calculation" algorithm This is sitting alongside our old implementation for the moment.
2023-07-05 19:58:13 +01:00
virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
Everywhere: Remove needless trailing semi-colons after functions This is a new option in clang-format-16.
2023-07-07 22:48:11 -04:00
virtual bool contains_percentage() const override { return false; }
LibWeb: Implement CSS `log()`
2023-05-28 11:53:57 +02:00
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
LibWeb: Implement CSS `log()`
2023-05-28 11:53:57 +02:00
LibWeb: Make CalculatedStyleValue::dump() infallible
2023-08-22 14:13:22 +01:00
virtual void dump(StringBuilder&, int indent) const override;
LibWeb: Implement CSS `log()`
2023-05-28 11:53:57 +02:00
private:
LogCalculationNode(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
NonnullOwnPtr<CalculationNode> m_x;
NonnullOwnPtr<CalculationNode> m_y;
};
LibWeb: Implement CSS `exp()`
2023-05-28 11:58:30 +02:00
class ExpCalculationNode final : public CalculationNode {
public:
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
static NonnullOwnPtr<ExpCalculationNode> create(NonnullOwnPtr<CalculationNode>);
LibWeb: Implement CSS `exp()`
2023-05-28 11:58:30 +02:00
~ExpCalculationNode();
LibWeb: Make StyleValue::to_string() infallible
2023-08-22 14:08:15 +01:00
virtual String to_string() const override;
LibWeb: Implement CSS `exp()`
2023-05-28 11:58:30 +02:00
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
LibWeb: Implement "Determine the type of a calculation" algorithm This is sitting alongside our old implementation for the moment.
2023-07-05 19:58:13 +01:00
virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
Everywhere: Remove needless trailing semi-colons after functions This is a new option in clang-format-16.
2023-07-07 22:48:11 -04:00
virtual bool contains_percentage() const override { return false; }
LibWeb: Implement CSS `exp()`
2023-05-28 11:58:30 +02:00
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
LibWeb: Implement CSS `exp()`
2023-05-28 11:58:30 +02:00
LibWeb: Make CalculatedStyleValue::dump() infallible
2023-08-22 14:13:22 +01:00
virtual void dump(StringBuilder&, int indent) const override;
LibWeb: Implement CSS `exp()`
2023-05-28 11:58:30 +02:00
private:
ExpCalculationNode(NonnullOwnPtr<CalculationNode>);
NonnullOwnPtr<CalculationNode> m_value;
};
LibWeb: Implement CSS `round()`
2023-05-27 16:07:50 +02:00
class RoundCalculationNode final : public CalculationNode {
public:
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
static NonnullOwnPtr<RoundCalculationNode> create(RoundingStrategy, NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
LibWeb: Implement CSS `round()`
2023-05-27 16:07:50 +02:00
~RoundCalculationNode();
LibWeb: Make StyleValue::to_string() infallible
2023-08-22 14:08:15 +01:00
virtual String to_string() const override;
LibWeb: Implement CSS `round()`
2023-05-27 16:07:50 +02:00
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
LibWeb: Implement "Determine the type of a calculation" algorithm This is sitting alongside our old implementation for the moment.
2023-07-05 19:58:13 +01:00
virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
LibWeb: Implement CSS `round()`
2023-05-27 16:07:50 +02:00
virtual bool contains_percentage() const override;
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
LibWeb: Implement CSS `round()`
2023-05-27 16:07:50 +02:00
LibWeb: Make CalculatedStyleValue::dump() infallible
2023-08-22 14:13:22 +01:00
virtual void dump(StringBuilder&, int indent) const override;
LibWeb: Implement CSS `round()`
2023-05-27 16:07:50 +02:00
private:
LibWeb: Move RoundingMode to Enums.json In the spec this is a `<rounding-strategy>`, so let's use that name. This also fixes a bug where we were serializing `to-zero` as `toward-zero`.
2023-07-13 14:51:11 +01:00
RoundCalculationNode(RoundingStrategy, NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
RoundingStrategy m_strategy;
LibWeb: Implement CSS `round()`
2023-05-27 16:07:50 +02:00
NonnullOwnPtr<CalculationNode> m_x;
NonnullOwnPtr<CalculationNode> m_y;
};
LibWeb: Implement CSS `mod()`
2023-05-27 19:03:07 +02:00
class ModCalculationNode final : public CalculationNode {
public:
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
static NonnullOwnPtr<ModCalculationNode> create(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
LibWeb: Implement CSS `mod()`
2023-05-27 19:03:07 +02:00
~ModCalculationNode();
LibWeb: Make StyleValue::to_string() infallible
2023-08-22 14:08:15 +01:00
virtual String to_string() const override;
LibWeb: Implement CSS `mod()`
2023-05-27 19:03:07 +02:00
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
LibWeb: Implement "Determine the type of a calculation" algorithm This is sitting alongside our old implementation for the moment.
2023-07-05 19:58:13 +01:00
virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
LibWeb: Implement CSS `mod()`
2023-05-27 19:03:07 +02:00
virtual bool contains_percentage() const override;
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
LibWeb: Implement CSS `mod()`
2023-05-27 19:03:07 +02:00
LibWeb: Make CalculatedStyleValue::dump() infallible
2023-08-22 14:13:22 +01:00
virtual void dump(StringBuilder&, int indent) const override;
LibWeb: Implement CSS `mod()`
2023-05-27 19:03:07 +02:00
private:
ModCalculationNode(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
NonnullOwnPtr<CalculationNode> m_x;
NonnullOwnPtr<CalculationNode> m_y;
};
LibWeb: Implement CSS `rem()`
2023-05-27 19:08:07 +02:00
class RemCalculationNode final : public CalculationNode {
public:
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
static NonnullOwnPtr<RemCalculationNode> create(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
LibWeb: Implement CSS `rem()`
2023-05-27 19:08:07 +02:00
~RemCalculationNode();
LibWeb: Make StyleValue::to_string() infallible
2023-08-22 14:08:15 +01:00
virtual String to_string() const override;
LibWeb: Implement CSS `rem()`
2023-05-27 19:08:07 +02:00
virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
LibWeb: Implement "Determine the type of a calculation" algorithm This is sitting alongside our old implementation for the moment.
2023-07-05 19:58:13 +01:00
virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
LibWeb: Implement CSS `rem()`
2023-05-27 19:08:07 +02:00
virtual bool contains_percentage() const override;
virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
LibWeb: Make CSS math function parsing infallible
2023-08-19 15:20:23 +01:00
virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
LibWeb: Implement CSS `rem()`
2023-05-27 19:08:07 +02:00
LibWeb: Make CalculatedStyleValue::dump() infallible
2023-08-22 14:13:22 +01:00
virtual void dump(StringBuilder&, int indent) const override;
LibWeb: Implement CSS `rem()`
2023-05-27 19:08:07 +02:00
private:
RemCalculationNode(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
NonnullOwnPtr<CalculationNode> m_x;
NonnullOwnPtr<CalculationNode> m_y;
};
LibWeb: Split CalculatedStyleValue out of StyleValue.{h,cpp}
2023-03-30 17:34:14 +01:00
}
Reference in a new issue Copy permalink