Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / web / css / style_values / easing_style_value.lucb

#==============================================================================================
#
#   easing_style_value - EasingStyleValue: linear(), cubic-bezier() and steps()
#
#   DESCRIPTION:
#       Port of LibWeb/CSS/StyleValues/EasingStyleValue.cpp (lines 1-131) and the inline members
#       of EasingStyleValue.h: each easing function's serialization and computational
#       independence, and the style value's absolutization. The structs' defaulted operator==
#       are the css_easing_*_equal helpers (CubicBezier's own operator== ignores its sample cache).
#
#       Copyright (c) 2018-2020, Andreas Kling <andreas@ladybird.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>
#       Copyright (c) 2023, Ali Mohammad Pur <mpfard@serenityos.org>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: Linear ==================================================================================

## Ported from Libraries/LibWeb/CSS/StyleValues/EasingStyleValue.h:32 Web::CSS::EasingStyleValue::Linear::is_computationally_independent.
pub func css_easing_style_value_linear_is_computationally_independent(this: const CssEasingStyleValueLinear*) -> bool:
    for stop in ak.vector_span_const(&this.stops):
        if not css_style_value_is_computationally_independent(stop.output):
            return false
        if let input = stop.input:
            if not css_style_value_is_computationally_independent(input):
                return false
    return true

## Ported from Libraries/LibWeb/CSS/StyleValues/EasingStyleValue.cpp:21 Web::CSS::EasingStyleValue::Linear::serialize.
# https://drafts.csswg.org/css-easing/#linear-easing-function-serializing
pub func css_easing_style_value_linear_serialize(this: const CssEasingStyleValueLinear*, builder: ak.StringBuilder*, mode: css_syntax.SerializationMode):
    # To serialize a linear() function:
    # 1. Let s be the string "linear(".
    ak.string_builder_append(builder, "linear(")

    # 2. Serialize each control point of the function,
    # concatenate the results using the separator ", ",
    # and append the result to s.
    var first = true
    for stop in ak.vector_span_const(&this.stops):
        if first:
            first = false
        else:
            ak.string_builder_append(builder, ", ")

        # To serialize a linear() control point:
        # 1. Let s be the serialization, as a <number>, of the control point's output progress value.
        css_style_value_serialize(stop.output, builder, mode)

        # 2. If the control point originally lacked an input progress value, return s.
        # 3. Otherwise, append " " (U+0020 SPACE) to s,
        # then serialize the control point's input progress value as a <percentage> and append it to s.
        if let input = stop.input:
            ak.string_builder_append_u8(builder, ' ')
            css_style_value_serialize(input, builder, mode)

        # 4. Return s.

    # 4. Append ")" to s, and return it.
    ak.string_builder_append_u8(builder, ')')

## Ported from Libraries/LibWeb/CSS/StyleValues/EasingStyleValue.h:38 Web::CSS::EasingStyleValue::Linear::to_string.
pub func css_easing_style_value_linear_to_string(this: const CssEasingStyleValueLinear*, mode: css_syntax.SerializationMode) -> ak.String:
    var builder = ak.string_builder_new()
    css_easing_style_value_linear_serialize(this, &builder, mode)
    return ak.string_builder_to_string_without_validation(&builder)

## Linear's defaulted operator== (its stops' ValueComparing output and input).
func css_easing_linears_equal(a: const CssEasingStyleValueLinear*, b: const CssEasingStyleValueLinear*) -> bool:
    if ak.vector_size(&a.stops) != ak.vector_size(&b.stops):
        return false
    for i in 0..<ak.vector_size(&a.stops):
        let left = ak.vector_at_const(&a.stops, i)
        let right = ak.vector_at_const(&b.stops, i)
        if not (css_style_values_equal(left.output, right.output) and css_optional_style_values_equal(left.input, right.input)):
            return false
    return true

# mark: CubicBezier =============================================================================

## Ported from Libraries/LibWeb/CSS/StyleValues/EasingStyleValue.h:60 Web::CSS::EasingStyleValue::CubicBezier::operator==.
pub func css_easing_style_value_cubic_bezier_eq(this: const CssEasingStyleValueCubicBezier*, other: CssEasingStyleValueCubicBezier) -> bool:
    return css_style_values_equal(this.x1, other.x1) and css_style_values_equal(this.y1, other.y1) and css_style_values_equal(this.x2, other.x2) and css_style_values_equal(this.y2, other.y2)

## Ported from Libraries/LibWeb/CSS/StyleValues/EasingStyleValue.h:65 Web::CSS::EasingStyleValue::CubicBezier::is_computationally_independent.
pub func css_easing_style_value_cubic_bezier_is_computationally_independent(this: const CssEasingStyleValueCubicBezier*) -> bool:
    return css_style_value_is_computationally_independent(this.x1) and css_style_value_is_computationally_independent(this.y1) and css_style_value_is_computationally_independent(this.x2) and css_style_value_is_computationally_independent(this.y2)

## Ported from Libraries/LibWeb/CSS/StyleValues/EasingStyleValue.cpp:58 Web::CSS::EasingStyleValue::CubicBezier::serialize.
# https://drafts.csswg.org/css-easing/#bezier-serialization
pub func css_easing_style_value_cubic_bezier_serialize(this: const CssEasingStyleValueCubicBezier*, builder: ak.StringBuilder*, mode: css_syntax.SerializationMode):
    ak.string_builder_append(builder, "cubic-bezier(")
    css_style_value_serialize(this.x1, builder, mode)
    ak.string_builder_append(builder, ", ")
    css_style_value_serialize(this.y1, builder, mode)
    ak.string_builder_append(builder, ", ")
    css_style_value_serialize(this.x2, builder, mode)
    ak.string_builder_append(builder, ", ")
    css_style_value_serialize(this.y2, builder, mode)
    ak.string_builder_append_u8(builder, ')')

## Ported from Libraries/LibWeb/CSS/StyleValues/EasingStyleValue.h:71 Web::CSS::EasingStyleValue::CubicBezier::to_string.
pub func css_easing_style_value_cubic_bezier_to_string(this: const CssEasingStyleValueCubicBezier*, mode: css_syntax.SerializationMode) -> ak.String:
    var builder = ak.string_builder_new()
    css_easing_style_value_cubic_bezier_serialize(this, &builder, mode)
    return ak.string_builder_to_string_without_validation(&builder)

# mark: Steps ===================================================================================

## Ported from Libraries/LibWeb/CSS/StyleValues/EasingStyleValue.h:85 Web::CSS::EasingStyleValue::Steps::is_computationally_independent.
pub func css_easing_style_value_steps_is_computationally_independent(this: const CssEasingStyleValueSteps*) -> bool:
    return css_style_value_is_computationally_independent(this.number_of_intervals)

## Ported from Libraries/LibWeb/CSS/StyleValues/EasingStyleValue.cpp:72 Web::CSS::EasingStyleValue::Steps::serialize.
# https://drafts.csswg.org/css-easing/#steps-serialization
pub func css_easing_style_value_steps_serialize(this: const CssEasingStyleValueSteps*, builder: ak.StringBuilder*, mode: css_syntax.SerializationMode):
    # The `position` lambda.
    var position: ak.StringView? = none
    if not (this.position == css_data.StepPosition.jump_end or this.position == css_data.StepPosition.end):
        position = css_data.to_string_step_position(this.position)

    ak.string_builder_append(builder, "steps(")
    css_style_value_serialize(this.number_of_intervals, builder, mode)
    if let text = position:
        ak.string_builder_append(builder, ", ")
        ak.string_builder_append_string_view(builder, text)
    ak.string_builder_append_u8(builder, ')')

## Ported from Libraries/LibWeb/CSS/StyleValues/EasingStyleValue.h:91 Web::CSS::EasingStyleValue::Steps::to_string.
pub func css_easing_style_value_steps_to_string(this: const CssEasingStyleValueSteps*, mode: css_syntax.SerializationMode) -> ak.String:
    var builder = ak.string_builder_new()
    css_easing_style_value_steps_serialize(this, &builder, mode)
    return ak.string_builder_to_string_without_validation(&builder)

# mark: Function and EasingStyleValue ===========================================================

## Ported from Libraries/LibWeb/CSS/StyleValues/EasingStyleValue.cpp:89 Web::CSS::EasingStyleValue::Function::serialize.
pub func css_easing_style_value_function_serialize(this: const CssEasingStyleValueFunction*, builder: ak.StringBuilder*, mode: css_syntax.SerializationMode):
    match this.variant:
        .css_easing_style_value_linear(curve): css_easing_style_value_linear_serialize(&curve, builder, mode)
        .css_easing_style_value_cubic_bezier(curve): css_easing_style_value_cubic_bezier_serialize(&curve, builder, mode)
        .css_easing_style_value_steps(curve): css_easing_style_value_steps_serialize(&curve, builder, mode)

## Function's operator== (Variant: the same alternative, and that struct's operator==).
func css_easing_functions_equal(a: const CssEasingStyleValueFunction*, b: const CssEasingStyleValueFunction*) -> bool:
    match a.variant:
        .css_easing_style_value_linear(left):
            match b.variant:
                .css_easing_style_value_linear(right): return css_easing_linears_equal(&left, &right)
                _: return false
        .css_easing_style_value_cubic_bezier(left):
            match b.variant:
                .css_easing_style_value_cubic_bezier(right): return css_easing_style_value_cubic_bezier_eq(&left, right)
                _: return false
        .css_easing_style_value_steps(left):
            match b.variant:
                .css_easing_style_value_steps(right): return css_style_values_equal(left.number_of_intervals, right.number_of_intervals) and left.position == right.position
                _: return false

## Ported from Libraries/LibWeb/CSS/StyleValues/EasingStyleValue.h:105 Web::CSS::EasingStyleValue::create.
pub func css_easing_style_value_create(function: CssEasingStyleValueFunction) -> CssEasingStyleValue*:
    let this = &(new CssEasingStyleValue[1] --- else trap("out of memory"))[0]
    css_easing_style_value_construct(this, function)
    return this

## Ported from Libraries/LibWeb/CSS/StyleValues/EasingStyleValue.h:125 Web::CSS::EasingStyleValue::EasingStyleValue.
pub func css_easing_style_value_construct(this: CssEasingStyleValue*, function: CssEasingStyleValueFunction):
    css_style_value_construct(this.css_style_value(), CssStyleValueType.easing)
    css_style_value_set_class(this.css_style_value(), (const CssStyleValueVTable*)&css_easing_style_value_vtable, &css_easing_style_value_class)
    this.m_function = function

## Ported from Libraries/LibWeb/CSS/StyleValues/EasingStyleValue.h:111 Web::CSS::EasingStyleValue::function.
pub func css_easing_style_value_function(this: CssEasingStyleValue*) -> CssEasingStyleValueFunction:
    return this.m_function

## Ported from Libraries/LibWeb/CSS/StyleValues/EasingStyleValue.h:113 Web::CSS::EasingStyleValue::serialize (override).
pub func css_easing_style_value_serialize_impl(base: CssStyleValue*, builder: ak.StringBuilder*, mode: css_syntax.SerializationMode):
    let this = (CssEasingStyleValue*)base
    css_easing_style_value_function_serialize(&this.m_function, builder, mode)

## Ported from Libraries/LibWeb/CSS/StyleValues/EasingStyleValue.cpp:96 Web::CSS::EasingStyleValue::absolutized (override).
pub func css_easing_style_value_absolutized_impl(base: CssStyleValue*, computation_context: CssComputationContext) -> CssStyleValue*:
    let this = (CssEasingStyleValue*)base
    var absolutized_function: CssEasingStyleValueFunction = ---
    match this.m_function.variant:
        .css_easing_style_value_linear(linear):
            var absolutized_stops = ak.Vector[CssEasingStyleValueLinearStop]()
            for stop in ak.vector_span_const(&linear.stops):
                var absolutized_input: CssStyleValue*? = none
                if let input = stop.input:
                    absolutized_input = css_style_value_absolutized(input, computation_context)

                ak.vector_append_t(&absolutized_stops, CssEasingStyleValueLinearStop(output = css_style_value_absolutized(stop.output, computation_context), input = absolutized_input))
            absolutized_function = CssEasingStyleValueFunction(variant = CssEasingStyleValueLinearOrCssEasingStyleValueCubicBezierOrCssEasingStyleValueSteps.css_easing_style_value_linear(CssEasingStyleValueLinear(stops = absolutized_stops)))
        .css_easing_style_value_cubic_bezier(cubic_bezier):
            absolutized_function = CssEasingStyleValueFunction(variant = CssEasingStyleValueLinearOrCssEasingStyleValueCubicBezierOrCssEasingStyleValueSteps.css_easing_style_value_cubic_bezier(CssEasingStyleValueCubicBezier(
                x1 = css_style_value_absolutized(cubic_bezier.x1, computation_context),
                y1 = css_style_value_absolutized(cubic_bezier.y1, computation_context),
                x2 = css_style_value_absolutized(cubic_bezier.x2, computation_context),
                y2 = css_style_value_absolutized(cubic_bezier.y2, computation_context),
            )))
        .css_easing_style_value_steps(steps):
            absolutized_function = CssEasingStyleValueFunction(variant = CssEasingStyleValueLinearOrCssEasingStyleValueCubicBezierOrCssEasingStyleValueSteps.css_easing_style_value_steps(CssEasingStyleValueSteps(
                number_of_intervals = css_style_value_absolutized(steps.number_of_intervals, computation_context),
                position = steps.position,
            )))

    return css_easing_style_value_create(absolutized_function).css_style_value()

## Ported from Libraries/LibWeb/CSS/StyleValues/EasingStyleValue.h:117 Web::CSS::EasingStyleValue::properties_equal.
pub func css_easing_style_value_properties_equal(this: CssEasingStyleValue*, other: CssEasingStyleValue*) -> bool:
    return css_easing_functions_equal(&this.m_function, &other.m_function)

## Ported from Libraries/LibWeb/CSS/StyleValues/EasingStyleValue.h:119 Web::CSS::EasingStyleValue::is_computationally_independent (override).
pub func css_easing_style_value_is_computationally_independent_impl(base: CssStyleValue*) -> bool:
    let this = (CssEasingStyleValue*)base
    match this.m_function.variant:
        .css_easing_style_value_linear(function): return css_easing_style_value_linear_is_computationally_independent(&function)
        .css_easing_style_value_cubic_bezier(function): return css_easing_style_value_cubic_bezier_is_computationally_independent(&function)
        .css_easing_style_value_steps(function): return css_easing_style_value_steps_is_computationally_independent(&function)

## Ported from Libraries/LibWeb/CSS/StyleValues/StyleValue.h:202 Web::CSS::StyleValueWithDefaultOperators::equals for Web::CSS::EasingStyleValue (CRTP helper) (override).
pub func css_easing_style_value_equals_impl(base: CssStyleValue*, other: CssStyleValue*) -> bool:
    if css_style_value_type(base) != css_style_value_type(other):
        return false
    return css_easing_style_value_properties_equal((CssEasingStyleValue*)base, (CssEasingStyleValue*)other)