Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

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

#==============================================================================================
#
#   radial_gradient_style_value - RadialGradientStyleValue: radial-gradient() and repeating-radial-gradient()
#
#   DESCRIPTION:
#       Port of LibWeb/CSS/StyleValues/RadialGradientStyleValue.cpp (lines 1-126) and the inline
#       members of RadialGradientStyleValue.h.
#
#       Copyright (c) 2018-2020, Andreas Kling <andreas@ladybird.org>
#       Copyright (c) 2021, Tobias Christiansen <tobyase@serenityos.org>
#       Copyright (c) 2021-2025, Sam Atkins <sam@ladybird.org>
#       Copyright (c) 2022-2023, MacDue <macdue@dueutil.tech>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: Creation ================================================================================

## Ported from Libraries/LibWeb/CSS/StyleValues/RadialGradientStyleValue.h:26 Web::CSS::RadialGradientStyleValue::create.
pub func css_radial_gradient_style_value_create(ending_shape: CssRadialGradientStyleValueEndingShape, size: CssStyleValue*, position: CssPositionStyleValue*, color_stop_list: ak.Vector[CssColorStopListElement], repeating: CssGradientRepeating, color_interpolation_method: CssStyleValue*?) -> CssRadialGradientStyleValue*:
    assert(not ak.vector_is_empty(&color_stop_list))
    let any_non_legacy = css_color_stop_list_has_non_legacy_color(&color_stop_list)
    let this = &(new CssRadialGradientStyleValue[1] --- else trap("out of memory"))[0]
    css_radial_gradient_style_value_construct(this, ending_shape, size, position, color_stop_list, repeating, color_interpolation_method, CssColorSyntax.modern if any_non_legacy else CssColorSyntax.legacy)
    return this

## Ported from Libraries/LibWeb/CSS/StyleValues/RadialGradientStyleValue.h:66 Web::CSS::RadialGradientStyleValue::RadialGradientStyleValue.
pub func css_radial_gradient_style_value_construct(this: CssRadialGradientStyleValue*, ending_shape: CssRadialGradientStyleValueEndingShape, size: CssStyleValue*, position: CssPositionStyleValue*, color_stop_list: ak.Vector[CssColorStopListElement], repeating: CssGradientRepeating, color_interpolation_method: CssStyleValue*?, color_syntax: CssColorSyntax):
    css_style_value_construct(this.css_style_value(), CssStyleValueType.radial_gradient)
    css_style_value_set_class(this.css_style_value(), (const CssStyleValueVTable*)&css_radial_gradient_style_value_vtable, &css_radial_gradient_style_value_class)
    this.m_properties = CssRadialGradientStyleValueProperties(ending_shape = ending_shape, size = size, position = position, color_stop_list = color_stop_list, repeating = repeating, color_interpolation_method = color_interpolation_method, color_syntax = color_syntax)
    this.m_resolved_data_cache_key = none
    this.m_resolved = none

# mark: Serialization and equality ==============================================================

## Ported from Libraries/LibWeb/CSS/StyleValues/RadialGradientStyleValue.cpp:18 Web::CSS::RadialGradientStyleValue::serialize (override).
pub func css_radial_gradient_style_value_serialize_impl(base: CssStyleValue*, builder: ak.StringBuilder*, mode: css_syntax.SerializationMode):
    let this = (CssRadialGradientStyleValue*)base
    if css_radial_gradient_style_value_is_repeating(this):
        ak.string_builder_append(builder, "repeating-")
    ak.string_builder_append(builder, "radial-gradient(")

    # AD-HOC: We need to check the serialized size to determine if it should be included.
    let serialized_size = css_style_value_to_string(this.m_properties.size, mode)

    let has_size = not ak.string_eq_string_view(&serialized_size, ak.sv("farthest-corner"))
    let has_position = not css_position_style_value_is_center(this.m_properties.position, mode)
    var has_color_space = false
    if let method = this.m_properties.color_interpolation_method:
        has_color_space = css_color_interpolation_method_style_value_color_interpolation_method(css_style_value_as_color_interpolation_method(method)) != css_color_interpolation_method_style_value_default_color_interpolation_method(this.m_properties.color_syntax)

    if has_size:
        css_style_value_serialize(this.m_properties.size, builder, mode)

    if has_position:
        if has_size:
            ak.string_builder_append_u8(builder, ' ')

        ak.string_builder_append(builder, "at ")
        css_style_value_serialize(this.m_properties.position.css_style_value(), builder, mode)

    if has_color_space:
        if has_size or has_position:
            ak.string_builder_append_u8(builder, ' ')

        css_style_value_serialize(this.m_properties.color_interpolation_method else trap("VERIFY_NOT_REACHED"), builder, mode)

    if has_size or has_position or has_color_space:
        ak.string_builder_append(builder, ", ")

    css_serialize_color_stop_list(builder, this.m_properties.color_stop_list, mode)
    ak.string_builder_append_u8(builder, ')')

## Ported from Libraries/LibWeb/CSS/StyleValues/RadialGradientStyleValue.cpp:86 Web::CSS::RadialGradientStyleValue::absolutized (override).
pub func css_radial_gradient_style_value_absolutized_impl(base: CssStyleValue*, context: CssComputationContext) -> CssStyleValue*:
    let this = (CssRadialGradientStyleValue*)base
    let absolutized_color_stops = css_color_stop_list_absolutized(&this.m_properties.color_stop_list, context)

    let absolutized_size = css_style_value_absolutized(this.m_properties.size, context)
    let absolutized_position = css_style_value_as_position(css_style_value_absolutized(this.m_properties.position.css_style_value(), context))

    var absolutized_color_interpolation_method: CssStyleValue*? = none
    if let method = this.m_properties.color_interpolation_method:
        absolutized_color_interpolation_method = css_style_value_absolutized(method, context)

    return css_radial_gradient_style_value_create(this.m_properties.ending_shape, absolutized_size, absolutized_position, absolutized_color_stops, this.m_properties.repeating, absolutized_color_interpolation_method).css_style_value()

## Ported from Libraries/LibWeb/CSS/StyleValues/RadialGradientStyleValue.cpp:102 Web::CSS::RadialGradientStyleValue::equals (override).
pub func css_radial_gradient_style_value_equals_impl(base: CssStyleValue*, other: CssStyleValue*) -> bool:
    let this = (CssRadialGradientStyleValue*)base
    if css_style_value_type(base) != css_style_value_type(other):
        return false
    let other_gradient = css_style_value_as_radial_gradient(other)
    # NB: Properties::operator== is defaulted.
    let a = &this.m_properties
    let b = &other_gradient.m_properties
    return a.ending_shape == b.ending_shape and css_style_values_equal(a.size, b.size) and css_style_values_equal(a.position.css_style_value(), b.position.css_style_value()) and css_color_stop_lists_equal(&a.color_stop_list, &b.color_stop_list) and a.repeating == b.repeating and css_optional_style_values_equal(a.color_interpolation_method, b.color_interpolation_method) and a.color_syntax == b.color_syntax

## Ported from Libraries/LibWeb/CSS/StyleValues/RadialGradientStyleValue.cpp:110 Web::CSS::RadialGradientStyleValue::is_computationally_independent (override).
pub func css_radial_gradient_style_value_is_computationally_independent_impl(base: CssStyleValue*) -> bool:
    let this = (CssRadialGradientStyleValue*)base
    if not css_style_value_is_computationally_independent(this.m_properties.size):
        return false
    if not css_style_value_is_computationally_independent(this.m_properties.position.css_style_value()):
        return false
    for stop in ak.vector_span_const(&this.m_properties.color_stop_list):
        if not css_style_value_is_computationally_independent(stop.color_stop.color else trap("VERIFY: a color stop's color")):
            return false
    return css_is_null_or_computationally_independent(this.m_properties.color_interpolation_method)

# mark: Accessors ===============================================================================

## Ported from Libraries/LibWeb/CSS/StyleValues/RadialGradientStyleValue.h:42 Web::CSS::RadialGradientStyleValue::color_stop_list.
pub func css_radial_gradient_style_value_color_stop_list(this: CssRadialGradientStyleValue*) -> ak.Vector[CssColorStopListElement]:
    return this.m_properties.color_stop_list

## Ported from Libraries/LibWeb/CSS/StyleValues/RadialGradientStyleValue.h:47 Web::CSS::RadialGradientStyleValue::interpolation_method.
pub func css_radial_gradient_style_value_interpolation_method(this: CssRadialGradientStyleValue*) -> display_list.ColorInterpolationMethod:
    if let method = this.m_properties.color_interpolation_method:
        return css_color_interpolation_method_style_value_color_interpolation_method(css_style_value_as_color_interpolation_method(method))
    return css_color_interpolation_method_style_value_default_color_interpolation_method(this.m_properties.color_syntax)

## Ported from Libraries/LibWeb/CSS/StyleValues/RadialGradientStyleValue.h:61 Web::CSS::RadialGradientStyleValue::is_repeating.
pub func css_radial_gradient_style_value_is_repeating(this: CssRadialGradientStyleValue*) -> bool:
    return this.m_properties.repeating == CssGradientRepeating.yes

# mark: Sizing and painting =====================================================================

## Ported from Libraries/LibWeb/CSS/StyleValues/RadialGradientStyleValue.cpp:56 Web::CSS::RadialGradientStyleValue::resolve_size.
pub func css_radial_gradient_style_value_resolve_size(this: CssRadialGradientStyleValue*, center: gfx.CssPixelPoint, reference_box: gfx.CssPixelRect, node: LayoutNodeWithStyle*) -> gfx.CssPixelSize:
    if this.m_properties.ending_shape == CssRadialGradientStyleValueEndingShape.circle:
        let radius = css_radial_size_style_value_resolve_circle_size(css_style_value_as_radial_size(this.m_properties.size), center, reference_box, (LayoutNode*)node)
        return gfx.CssPixelSize(m_width = radius, m_height = radius)

    return css_radial_size_style_value_resolve_ellipse_size(css_style_value_as_radial_size(this.m_properties.size), center, reference_box, (LayoutNode*)node)

## Ported from Libraries/LibWeb/CSS/StyleValues/RadialGradientStyleValue.cpp:66 Web::CSS::RadialGradientStyleValue::resolve_for_size (override).
pub func css_radial_gradient_style_value_resolve_for_size_impl(base: CssAbstractImageStyleValue*, node: LayoutNodeWithStyle*, paint_size: gfx.CssPixelSize):
    let this = (CssRadialGradientStyleValue*)base
    var gradient_box: gfx.CssPixelRect = ---
    gfx.css_pixel_rect_construct_css_pixel_point(&gradient_box, gfx.CssPixelPoint(), paint_size)
    let center = css_position_style_value_resolved(this.m_properties.position, (LayoutNode*)node, gradient_box)
    let gradient_size = css_radial_gradient_style_value_resolve_size(this, center, gradient_box, node)

    let cache_key = CssRadialGradientStyleValueResolvedDataCacheKey(length_resolution_context = css_length_resolution_context_for_layout_node((LayoutNode*)node), size = paint_size)
    if this.m_resolved_data_cache_key != cache_key:
        this.m_resolved_data_cache_key = cache_key
        this.m_resolved = CssRadialGradientStyleValueResolvedData(data = paint_resolve_radial_gradient_data(node, gradient_size, this), gradient_size = gradient_size, center = center)

## Ported from Libraries/LibWeb/CSS/StyleValues/RadialGradientStyleValue.h:55 Web::CSS::RadialGradientStyleValue::is_paintable (override).
pub func css_radial_gradient_style_value_is_paintable_impl(base: CssAbstractImageStyleValue*) -> bool:
    _ = base
    return true

## Ported from Libraries/LibWeb/CSS/StyleValues/RadialGradientStyleValue.cpp:118 Web::CSS::RadialGradientStyleValue::paint (override).
pub func css_radial_gradient_style_value_paint_impl(base: CssAbstractImageStyleValue*, context: DisplayListRecordingContext*, dest_rect: gfx.DevicePixelRect, arg2: css_data.ImageRendering):
    _ = arg2
    let this = (CssRadialGradientStyleValue*)base
    let resolved = this.m_resolved else trap("VERIFY: resolved gradient data")
    let center = display_list_recording_context_rounded_device_point(context, resolved.center)
    let size = display_list_recording_context_rounded_device_size(context, resolved.gradient_size)
    display_list.display_list_recorder_fill_rect_with_radial_gradient(display_list_recording_context_display_list_recorder(context), dest_rect, resolved.data, center, size)