ladybird/Libraries/LibWeb/CSS/CounterStyle.h
Callum Law 595848b0fa LibWeb: Implement CounterStyle::equals
This makes `ValueComparingRefPtr<CounterStyle>` work
2026-04-15 11:07:38 +01:00

89 lines
3.7 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*
* Copyright (c) 2026, Callum Law <callumlaw1709@outlook.com>.
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/FlyString.h>
#include <LibWeb/CSS/CounterStyleDefinition.h>
#include <LibWeb/CSS/Enums.h>
namespace Web::CSS {
// https://drafts.csswg.org/css-counter-styles-3/#counter-styles
class CounterStyle : public RefCounted<CounterStyle> {
public:
static NonnullRefPtr<CounterStyle const> decimal();
static NonnullRefPtr<CounterStyle const> disc();
static NonnullRefPtr<CounterStyle const> from_counter_style_definition(CounterStyleDefinition const&, StyleScope const&);
static NonnullRefPtr<CounterStyle const> create(FlyString name, CounterStyleAlgorithm algorithm, CounterStyleNegativeSign negative_sign, FlyString prefix, FlyString suffix, Vector<CounterStyleRangeEntry> range, Optional<FlyString> fallback, CounterStylePad pad)
{
// NB: All counter styles apart from 'decimal' must have a fallback.
VERIFY(fallback.has_value() || name == "decimal"_fly_string);
return adopt_ref(*new (nothrow) CounterStyle(move(name), move(algorithm), move(negative_sign), move(prefix), move(suffix), move(range), move(fallback), move(pad)));
}
FlyString const& name() const { return m_name; }
CounterStyleAlgorithm const& algorithm() const { return m_algorithm; }
CounterStyleNegativeSign const& negative_sign() const { return m_negative_sign; }
FlyString const& prefix() const { return m_prefix; }
FlyString const& suffix() const { return m_suffix; }
Vector<CounterStyleRangeEntry> const& range() const { return m_range; }
Optional<FlyString> const& fallback() const { return m_fallback; }
CounterStylePad const& pad() const { return m_pad; }
Optional<String> generate_an_initial_representation_for_the_counter_value(i64 value) const;
bool uses_a_negative_sign() const;
bool equals(CounterStyle const&) const;
virtual ~CounterStyle() = default;
private:
CounterStyle(FlyString name, CounterStyleAlgorithm algorithm, CounterStyleNegativeSign negative_sign, FlyString prefix, FlyString suffix, Vector<CounterStyleRangeEntry> range, Optional<FlyString> fallback, CounterStylePad pad)
: m_name(move(name))
, m_algorithm(move(algorithm))
, m_negative_sign(move(negative_sign))
, m_prefix(move(prefix))
, m_suffix(move(suffix))
, m_range(move(range))
, m_fallback(move(fallback))
, m_pad(move(pad))
{
}
// Counter styles are composed of:
// a name, to identify the style
FlyString m_name;
// an algorithm, which transforms integer counter values into a basic string representation
CounterStyleAlgorithm m_algorithm;
// a negative sign, which is prepended or appended to the representation of a negative counter value.
CounterStyleNegativeSign m_negative_sign;
// a prefix, to prepend to the representation
FlyString m_prefix;
// a suffix to append to the representation
FlyString m_suffix;
// a range, which limits the values that a counter style handles
Vector<CounterStyleRangeEntry> m_range;
// FIXME: a spoken form, which describes how to read out the counter style in a speech synthesizer
// and a fallback style, to render the representation with when the counter value is outside the counter styles
// range or the counter style otherwise cant render the counter value
Optional<FlyString> m_fallback;
// AD-HOC: We store the `pad` descriptor here as well to have everything in one place
CounterStylePad m_pad;
};
String generate_a_counter_representation(RefPtr<CounterStyle const> const& counter_style, StyleScope const& style_scope, i32 value);
}