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

LibWeb: Support top-level tree counting functions

Browse source 
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.
This commit is contained in:
Callum Law 2025-10-01 20:02:33 +13:00 • committed by Tim Ledbetter
commit 831e471444
Notes: github-actions[bot] 2025-10-20 15:13:44 +00:00
17 changed files with 184 additions and 32 deletions
Download patch file Download diff file Expand all files Collapse all files

64
Libraries/LibWeb/CSS/StyleValues/TreeCountingFunctionStyleValue.cpp Normal file
View file

@ -0,0 +1,64 @@
/*
* 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;
}
}