mirror of
https://github.com/LadybirdBrowser/ladybird.git
synced 2025-10-24 08:59:50 +00:00
831e471444
Adds support for `sibling-index()` and `sibling-count()` when parsing
`<number>` and `<integer>`. This is achieved by a new
`TreeCountingFunctionStyleValue` class which is converted within
`absolutized` to `NumberStyleValue` and `IntegerStyleValue` respectively
There are still a few kinks to work out in order to support these
everywhere, namely:
- There are some `StyleValue`s which aren't absolutized (i.e. those
which are stored within another `StyleValue` without an
`absolutize()` method.
- We don't have a way to represent this new `StyleValue` within
`{Number,Integer}OrCalculated`. This would be fixed if we were to
instead just use the `StyleValue` classes until style computation at
which time they would be absolutized into their respective
primitives (double, i64, etc) bypassing the need for *OrCalculated
entirely.
64 lines
2 KiB
C++
64 lines
2 KiB
C++
/*
|
|
* Copyright (c) 2025, Callum Law <callumlaw1709@outlook.com>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#include "TreeCountingFunctionStyleValue.h"
|
|
#include <LibWeb/CSS/StyleValues/IntegerStyleValue.h>
|
|
#include <LibWeb/CSS/StyleValues/NumberStyleValue.h>
|
|
|
|
namespace Web::CSS {
|
|
|
|
String TreeCountingFunctionStyleValue::to_string(SerializationMode) const
|
|
{
|
|
switch (m_function) {
|
|
case TreeCountingFunction::SiblingCount:
|
|
return "sibling-count()"_string;
|
|
case TreeCountingFunction::SiblingIndex:
|
|
return "sibling-index()"_string;
|
|
}
|
|
|
|
VERIFY_NOT_REACHED();
|
|
}
|
|
|
|
size_t TreeCountingFunctionStyleValue::resolve(TreeCountingFunctionResolutionContext const& tree_counting_function_resolution_context) const
|
|
{
|
|
switch (m_function) {
|
|
case TreeCountingFunction::SiblingCount:
|
|
return tree_counting_function_resolution_context.sibling_count;
|
|
case TreeCountingFunction::SiblingIndex:
|
|
return tree_counting_function_resolution_context.sibling_index;
|
|
}
|
|
|
|
VERIFY_NOT_REACHED();
|
|
}
|
|
|
|
ValueComparingNonnullRefPtr<StyleValue const> TreeCountingFunctionStyleValue::absolutized(ComputationContext const& computation_context) const
|
|
{
|
|
// FIXME: We should clamp this value in case it falls outside the valid range for the context it is in
|
|
VERIFY(computation_context.tree_counting_function_resolution_context.has_value());
|
|
|
|
size_t value = resolve(computation_context.tree_counting_function_resolution_context.value());
|
|
|
|
switch (m_computed_type) {
|
|
case ComputedType::Integer:
|
|
return IntegerStyleValue::create(value);
|
|
case ComputedType::Number:
|
|
return NumberStyleValue::create(static_cast<double>(value));
|
|
}
|
|
|
|
VERIFY_NOT_REACHED();
|
|
}
|
|
|
|
bool TreeCountingFunctionStyleValue::equals(StyleValue const& other) const
|
|
{
|
|
if (type() != other.type())
|
|
return false;
|
|
|
|
auto const& other_tree_counting_function = other.as_tree_counting_function();
|
|
|
|
return m_function == other_tree_counting_function.m_function && m_computed_type == other_tree_counting_function.m_computed_type;
|
|
}
|
|
|
|
}
|