dymokomi/luce-browser-engine
Source of release 0.6.0
0.6.0 / src / web / css / interpolation_2.lucb
#==============================================================================================
#
# interpolation_2 - CSS interpolation: grid track lists and interpolate_property
#
# DESCRIPTION:
# Port of Libraries/LibWeb/CSS/Interpolation.cpp (lines 533-833), by region p4a:
# expanding a grid track list into tracks and line names and interpolating two of them,
# interpolate_property (keywords resolved, then by the property's animation type: by
# computed value, repeatable list, or the custom rules of transform, shadows, font-style,
# font-variation-settings, visibility, content-visibility, display, scale, translate,
# rotate, filters, grid templates and stroke-dasharray, else discrete), and whether two
# values of a property are transitionable.
#
# Copyright (c) 2018-2023, Andreas Kling <andreas@ladybird.org>
# Copyright (c) 2021-2025, Sam Atkins <sam@ladybird.org>
# Copyright (c) 2024, Matthew Olsson <mattco@serenityos.org>
# Copyright (c) 2025-2026, Tim Ledbetter <tim.ledbetter@ladybird.org>
# SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================
# mark: Grid track lists ========================================================================
## Web::CSS::ExpandedGridTracksAndLines (Libraries/LibWeb/CSS/Interpolation.cpp:535).
struct CssExpandedGridTracksAndLines:
var tracks: ak.Vector[CssExplicitGridTrack]
var line_names: ak.Vector[CssGridLineNames?]
## Ported from Libraries/LibWeb/CSS/Interpolation.cpp:540 Web::CSS::expand_grid_tracks_and_lines.
func css_expand_grid_tracks_and_lines(list: const CssGridTrackSizeList*) -> CssExpandedGridTracksAndLines:
var result = CssExpandedGridTracksAndLines()
var current_track: CssExplicitGridTrack? = none
var current_line_names: CssGridLineNames? = none
let components = css_grid_track_size_list_list(list)
for component in ak.vector_span_const(&components):
match component:
.css_grid_line_names(grid_line_names):
assert(current_line_names == none)
current_line_names = grid_line_names
.css_explicit_grid_track(grid_track):
if let track = current_track:
# append_result()
ak.vector_append_t(&result.tracks, track)
ak.vector_append_t(&result.line_names, current_line_names)
current_track = none
current_line_names = none
current_track = grid_track
if current_track != none and current_line_names != none:
# append_result()
ak.vector_append_t(&result.tracks, current_track else trap("unreachable: checked above"))
ak.vector_append_t(&result.line_names, current_line_names)
current_track = none
current_line_names = none
if let track = current_track:
# append_result()
ak.vector_append_t(&result.tracks, track)
ak.vector_append_t(&result.line_names, current_line_names)
return result
## Ported from Libraries/LibWeb/CSS/Interpolation.cpp:571 Web::CSS::append_grid_track_with_line_names.
func css_append_grid_track_with_line_names(list: CssGridTrackSizeList*, track: CssExplicitGridTrack, line_names: CssGridLineNames?):
css_grid_track_size_list_append_css_explicit_grid_track(list, track)
if let names = line_names:
css_grid_track_size_list_append_css_grid_line_names(list, names)
## interpolate_grid_track_size_list's `interpolate_grid_size` lambda.
func css_interpolate_grid_size(element: DomElement*, calculation_context: const CssCalculationContext*, from_grid_size: CssGridSize, to_grid_size: CssGridSize, delta: f32) -> CssGridSize:
let interpolated = css_interpolate_value(element, calculation_context, css_grid_size_style_value(&from_grid_size), css_grid_size_style_value(&to_grid_size), delta, CssAllowDiscrete.yes) else trap("a null interpolated grid size")
return css_grid_size_new(interpolated)
## Ported from Libraries/LibWeb/CSS/Interpolation.cpp:578 Web::CSS::interpolate_grid_track_size_list.
func css_interpolate_grid_track_size_list(element: DomElement*, calculation_context: const CssCalculationContext*, from_: const CssGridTrackSizeList*, to: const CssGridTrackSizeList*, delta: f32) -> CssGridTrackSizeList?:
let expanded_from = css_expand_grid_tracks_and_lines(from_)
let expanded_to = css_expand_grid_tracks_and_lines(to)
if ak.vector_size(&expanded_from.tracks) != ak.vector_size(&expanded_to.tracks):
return none
var result = CssGridTrackSizeList()
for i in 0..<ak.vector_size(&expanded_from.tracks):
let from_track = *ak.vector_at_const(&expanded_from.tracks, i)
let to_track = *ak.vector_at_const(&expanded_to.tracks, i)
let interpolated_line_names = *ak.vector_at_const(&expanded_from.line_names, i) if delta < 0.5 else *ak.vector_at_const(&expanded_to.line_names, i)
if css_explicit_grid_track_is_repeat(&from_track) or css_explicit_grid_track_is_repeat(&to_track):
# https://drafts.csswg.org/css-grid/#repeat-interpolation
if not css_explicit_grid_track_is_repeat(&from_track) or not css_explicit_grid_track_is_repeat(&to_track):
return none
let from_repeat = css_explicit_grid_track_repeat(&from_track)
let to_repeat = css_explicit_grid_track_repeat(&to_track)
if not css_grid_repeat_is_fixed(&from_repeat) or not css_grid_repeat_is_fixed(&to_repeat):
return none
let from_repeat_list = css_grid_repeat_grid_track_size_list(&from_repeat)
let to_repeat_list = css_grid_repeat_grid_track_size_list(&to_repeat)
let from_repeat_tracks = css_grid_track_size_list_track_list(&from_repeat_list)
let to_repeat_tracks = css_grid_track_size_list_track_list(&to_repeat_list)
if css_grid_repeat_repeat_count(&from_repeat) != css_grid_repeat_repeat_count(&to_repeat) or ak.vector_size(&from_repeat_tracks) != ak.vector_size(&to_repeat_tracks):
return none
let interpolated_repeat_grid_tracks = css_interpolate_grid_track_size_list(element, calculation_context, &from_repeat_list, &to_repeat_list, delta) else return none
var repeat: CssGridRepeat = ---
css_grid_repeat_construct_css_grid_repeat_type(&repeat, css_grid_repeat_type(&from_repeat), interpolated_repeat_grid_tracks, css_integer_style_value_create((i32)css_grid_repeat_repeat_count(&from_repeat)).css_style_value())
let interpolated_grid_track = css_explicit_grid_track_new(.css_grid_repeat(repeat))
css_append_grid_track_with_line_names(&result, interpolated_grid_track, interpolated_line_names)
elif css_explicit_grid_track_is_minmax(&from_track) and css_explicit_grid_track_is_minmax(&to_track):
let from_minmax = css_explicit_grid_track_minmax(&from_track)
let to_minmax = css_explicit_grid_track_minmax(&to_track)
let interpolated_min = css_interpolate_grid_size(element, calculation_context, css_grid_min_max_min_grid_size(&from_minmax), css_grid_min_max_min_grid_size(&to_minmax), delta)
let interpolated_max = css_interpolate_grid_size(element, calculation_context, css_grid_min_max_max_grid_size(&from_minmax), css_grid_min_max_max_grid_size(&to_minmax), delta)
var minmax: CssGridMinMax = ---
css_grid_min_max_construct(&minmax, interpolated_min, interpolated_max)
let interpolated_grid_track = css_explicit_grid_track_new(.css_grid_min_max(minmax))
css_append_grid_track_with_line_names(&result, interpolated_grid_track, interpolated_line_names)
elif css_explicit_grid_track_is_default(&from_track) and css_explicit_grid_track_is_default(&to_track):
let from_grid_size = css_explicit_grid_track_grid_size(&from_track)
let to_grid_size = css_explicit_grid_track_grid_size(&to_track)
let interpolated_grid_size = css_interpolate_grid_size(element, calculation_context, from_grid_size, to_grid_size, delta)
let interpolated_grid_track = css_explicit_grid_track_new(.css_grid_size(interpolated_grid_size))
css_append_grid_track_with_line_names(&result, interpolated_grid_track, interpolated_line_names)
else:
let interpolated_grid_track = from_track if delta < 0.5 else to_track
css_append_grid_track_with_line_names(&result, interpolated_grid_track, interpolated_line_names)
return result
# mark: interpolate_property ====================================================================
## interpolate_property's `static oblique_0deg_value`.
var css_interpolate_property_oblique_0deg_value: CssStyleValue*?
## `FontStyleStyleValue::create(FontStyleKeyword::Oblique, AngleStyleValue::create(Angle::make_degrees(0)))`.
func css_interpolate_property_make_oblique_0deg_value() -> CssStyleValue*:
return css_font_style_style_value_create(css_data.FontStyleKeyword.oblique, css_angle_style_value_create(css_angle_make_degrees(0.0)).css_style_value()).css_style_value()
## Ported from Libraries/LibWeb/CSS/Interpolation.cpp:635 Web::CSS::interpolate_property.
pub func css_interpolate_property(element: DomElement*, property_id: css_data.PropertyId, a_from: CssStyleValue*, a_to: CssStyleValue*, delta: f32, allow_discrete: CssAllowDiscrete) -> CssStyleValue*?:
let from_ = css_with_keyword_values_resolved(element, property_id, a_from)
let to = css_with_keyword_values_resolved(element, property_id, a_to)
let calculation_context = css_calculation_context_for_property(css_property_name_and_id_from_id(property_id))
let animation_type = css_data.animation_type_from_longhand_property(property_id)
match animation_type:
.by_computed_value:
return css_interpolate_value(element, &calculation_context, from_, to, delta, allow_discrete)
.none_:
return to
.repeatable_list:
return css_interpolate_repeatable_list(element, &calculation_context, from_, to, delta, allow_discrete)
.custom:
return css_interpolate_custom_property(element, &calculation_context, property_id, from_, to, delta, allow_discrete)
_:
# case AnimationType::Discrete: default:
return css_interpolate_discrete(from_, to, delta, allow_discrete)
## The `case AnimationType::Custom` of interpolate_property, with its fallthrough to discrete.
func css_interpolate_custom_property(element: DomElement*, calculation_context: const CssCalculationContext*, property_id: css_data.PropertyId, from_: CssStyleValue*, to: CssStyleValue*, delta: f32, allow_discrete: CssAllowDiscrete) -> CssStyleValue*?:
if property_id == css_data.PropertyId.transform:
if let interpolated_transform = css_interpolate_transform(element, calculation_context, from_, to, delta, allow_discrete):
return interpolated_transform
# https://drafts.csswg.org/css-transforms-1/#interpolation-of-transforms
# In some cases, an animation might cause a transformation matrix to be singular or non-invertible.
# For example, an animation in which scale moves from 1 to -1. At the time when the matrix is in
# such a state, the transformed element is not rendered.
return none
if property_id == css_data.PropertyId.box_shadow or property_id == css_data.PropertyId.text_shadow:
if let interpolated_box_shadow = css_interpolate_box_shadow(element, calculation_context, from_, to, delta, allow_discrete):
return interpolated_box_shadow
return css_interpolate_discrete(from_, to, delta, allow_discrete)
if property_id == css_data.PropertyId.font_style:
let oblique_0deg_value = css_interpolation_static_value(&css_interpolate_property_oblique_0deg_value, css_interpolate_property_make_oblique_0deg_value)
let from_value = oblique_0deg_value if css_font_style_style_value_font_style(css_style_value_as_font_style(from_)) == css_data.FontStyleKeyword.normal else from_
let to_value = oblique_0deg_value if css_font_style_style_value_font_style(css_style_value_as_font_style(to)) == css_data.FontStyleKeyword.normal else to
return css_interpolate_value(element, calculation_context, from_value, to_value, delta, allow_discrete)
if property_id == css_data.PropertyId.font_variation_settings:
# https://drafts.csswg.org/css-fonts/#font-variation-settings-def
# Two declarations of font-feature-settings can be animated between if they are "like". "Like" declarations
# are ones where the same set of properties appear (in any order). Because successive duplicate properties
# are applied instead of prior duplicate properties, two declarations can be "like" even if they have
# differing number of properties. If two declarations are "like" then animation occurs pairwise between
# corresponding values in the declarations. Otherwise, animation is not possible.
if not css_style_value_is_value_list(from_) or not css_style_value_is_value_list(to):
return css_interpolate_discrete(from_, to, delta, allow_discrete)
# The values in these lists have already been deduplicated and sorted at this point, so we can use
# interpolate_value() to interpolate them pairwise.
return css_interpolate_value(element, calculation_context, from_, to, delta, allow_discrete)
# https://drafts.csswg.org/web-animations-1/#animating-visibility
if property_id == css_data.PropertyId.visibility:
# For the visibility property, visible is interpolated as a discrete step where values of p between 0 and 1 map to visible and other values of p map to the closer endpoint.
# If neither value is visible, then discrete animation is used.
if css_style_value_equals(from_, to):
return from_
let from_is_visible = css_style_value_to_keyword(from_) == css_data.Keyword.visible
let to_is_visible = css_style_value_to_keyword(to) == css_data.Keyword.visible
if from_is_visible or to_is_visible:
if delta <= 0.0:
return from_
if delta >= 1.0:
return to
return css_keyword_style_value_create(css_data.Keyword.visible).css_style_value()
return css_interpolate_discrete(from_, to, delta, allow_discrete)
# https://drafts.csswg.org/css-contain/#content-visibility-animation
if property_id == css_data.PropertyId.content_visibility:
# In general, the content-visibility property’s animation type is discrete.
# However, similar to interpolation of visibility, during interpolation between hidden and any other content-visibility value,
# p values between 0 and 1 map to the non-hidden value.
if css_style_value_equals(from_, to):
return from_
let from_is_hidden = css_style_value_to_keyword(from_) == css_data.Keyword.hidden
let to_is_hidden = css_style_value_to_keyword(to) == css_data.Keyword.hidden
if from_is_hidden or to_is_hidden:
let non_hidden_value = to if from_is_hidden else from_
if delta <= 0.0:
return from_
if delta >= 1.0:
return to
return non_hidden_value
return css_interpolate_discrete(from_, to, delta, allow_discrete)
# https://drafts.csswg.org/css-display-4/#display-animation
if property_id == css_data.PropertyId.display:
# In general, the display property’s animation type is discrete. However, similar to interpolation of
# visibility (see Web Animations § Animation of visibility), during interpolation between none and any
# other display value, p values between 0 and 1 map to the non-none value. Additionally, the element is
# inert as long as its display value would compute to none when ignoring the Transitions and Animations
# cascade origins.
# FIXME: Implement the inertness portion of this.
if css_style_value_equals(from_, to):
return from_
let from_display = css_display_style_value_display(css_style_value_as_display(from_))
let to_display = css_display_style_value_display(css_style_value_as_display(to))
let from_is_none = css_display_is_none(&from_display)
let to_is_none = css_display_is_none(&to_display)
if from_is_none or to_is_none:
let non_none_value = to if from_is_none else from_
if delta <= 0.0:
return from_
if delta >= 1.0:
return to
return non_none_value
return css_interpolate_discrete(from_, to, delta, allow_discrete)
if property_id == css_data.PropertyId.scale:
if let result = css_interpolate_scale(element, calculation_context, from_, to, delta, allow_discrete):
return result
return css_interpolate_discrete(from_, to, delta, allow_discrete)
if property_id == css_data.PropertyId.translate:
if let result = css_interpolate_translate(element, calculation_context, from_, to, delta, allow_discrete):
return result
return css_interpolate_discrete(from_, to, delta, allow_discrete)
if property_id == css_data.PropertyId.rotate:
if let result = css_interpolate_rotate(element, calculation_context, from_, to, delta, allow_discrete):
return result
return css_interpolate_discrete(from_, to, delta, allow_discrete)
if property_id == css_data.PropertyId.filter or property_id == css_data.PropertyId.backdrop_filter:
if let result = css_interpolate_filter_value_list(element, calculation_context, from_, to, delta, allow_discrete):
return result
return css_interpolate_discrete(from_, to, delta, allow_discrete)
if property_id == css_data.PropertyId.grid_template_rows or property_id == css_data.PropertyId.grid_template_columns:
# https://drafts.csswg.org/css-grid/#track-sizing
# If the list lengths match, by computed value type per item in the computed track list.
let from_list = css_grid_track_size_list_style_value_grid_track_size_list(css_style_value_as_grid_track_size_list(from_))
let to_list = css_grid_track_size_list_style_value_grid_track_size_list(css_style_value_as_grid_track_size_list(to))
let interpolated_grid_tack_size_list = css_interpolate_grid_track_size_list(element, calculation_context, &from_list, &to_list, delta) else return css_interpolate_discrete(from_, to, delta, allow_discrete)
return css_grid_track_size_list_style_value_create(interpolated_grid_tack_size_list).css_style_value()
if property_id == css_data.PropertyId.stroke_dasharray:
# https://svgwg.org/svg2-draft/painting.html#StrokeDashing
# If either start or end compute to none or are invalid, start or end are combined using the discrete animation type.
if not css_style_value_is_value_list(from_) or not css_style_value_is_value_list(to):
return css_interpolate_discrete(from_, to, delta, allow_discrete)
# Otherwise, repeat both dash patterns of start and end value list until the length of elements in
# both value lists match. Each item is then combined by computed value.
if let result = css_interpolate_repeatable_list(element, calculation_context, from_, to, delta, allow_discrete):
return result
return css_interpolate_discrete(from_, to, delta, allow_discrete)
# FIXME: Handle all custom animatable properties
# [[fallthrough]] to AnimationType::Discrete
return css_interpolate_discrete(from_, to, delta, allow_discrete)
## Ported from Libraries/LibWeb/CSS/Interpolation.cpp:819 Web::CSS::property_values_are_transitionable.
# https://drafts.csswg.org/css-transitions/#transitionable
pub func css_property_values_are_transitionable(property_id: css_data.PropertyId, old_value: CssStyleValue*, new_value: CssStyleValue*, element: DomElement*, transition_behavior: css_data.TransitionBehavior) -> bool:
# When comparing the before-change style and after-change style for a given property,
# the property values are transitionable if they have an animation type that is neither not animatable nor discrete.
let animation_type = css_data.animation_type_from_longhand_property(property_id)
if animation_type == css_data.AnimationType.none_ or (transition_behavior != css_data.TransitionBehavior.allow_discrete and animation_type == css_data.AnimationType.discrete):
return false
# Even when a property is transitionable, the two values may not be. The spec uses the example of inset/non-inset shadows.
if transition_behavior != css_data.TransitionBehavior.allow_discrete and css_interpolate_property(element, property_id, old_value, new_value, 0.5, CssAllowDiscrete.no) == none:
return false
return true