dymokomi/luce-browser-engine
Source of release 0.6.1
0.6.1 / 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)