Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

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

#==============================================================================================
#
#   image_set_style_value - ImageSetStyleValue: image-set() and choosing its image
#
#   DESCRIPTION:
#       Port of LibWeb/CSS/StyleValues/ImageSetStyleValue.cpp (lines 1-259) and the inline
#       members of ImageSetStyleValue.h.
#
#       Copyright (c) 2026-present, the Ladybird developers.
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

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

## Ported from Libraries/LibWeb/CSS/StyleValues/ImageSetStyleValue.cpp:22 Web::CSS::ImageSetStyleValue::create.
pub func css_image_set_style_value_create(options: ak.Vector[CssImageSetStyleValueOption]) -> CssImageSetStyleValue*:
    let this = &(new CssImageSetStyleValue[1] --- else trap("out of memory"))[0]
    css_image_set_style_value_construct(this, options)
    return this

## Ported from Libraries/LibWeb/CSS/StyleValues/ImageSetStyleValue.cpp:27 Web::CSS::ImageSetStyleValue::ImageSetStyleValue.
pub func css_image_set_style_value_construct(this: CssImageSetStyleValue*, options: ak.Vector[CssImageSetStyleValueOption]):
    css_style_value_construct(this.css_style_value(), CssStyleValueType.image_set)
    css_style_value_set_class(this.css_style_value(), (const CssStyleValueVTable*)&css_image_set_style_value_vtable, &css_image_set_style_value_class)
    this.m_options = options
    this.m_style_sheet = none
    this.m_selected_image = none

# mark: Selecting an image ======================================================================

## Ported from Libraries/LibWeb/CSS/StyleValues/ImageSetStyleValue.cpp:33 Web::CSS::option_resolution_in_dppx.
func css_option_resolution_in_dppx(option: CssImageSetStyleValueOption, calculation_resolution_context: CssCalculationResolutionContext?) -> f64?:
    if css_style_value_is_resolution(option.resolution):
        let resolution = css_resolution_style_value_resolution(css_style_value_as_resolution(option.resolution))
        return css_resolution_to_dots_per_pixel(&resolution)
    if css_style_value_is_calculated(option.resolution):
        if let resolution = css_calculated_style_value_resolve_resolution(css_style_value_as_calculated(option.resolution), calculation_resolution_context else CssCalculationResolutionContext()):
            return css_resolution_to_dots_per_pixel(&resolution)
    return none

## Whether an option's type() filter excludes it: `option.type.has_value() && !HTML::is_supported_image_type(*option.type)`.
func css_image_set_option_is_excluded_by_type(option: const CssImageSetStyleValueOption*) -> bool:
    if let type_ = option.type_:
        return not html_is_supported_image_type(ak.string_bytes_as_string_view(&type_))
    return false

## Ported from Libraries/LibWeb/CSS/StyleValues/ImageSetStyleValue.cpp:45 Web::CSS::ImageSetStyleValue::select_image.
pub func css_image_set_style_value_select_image(this: CssImageSetStyleValue*, device_pixels_per_css_pixel: f64, calculation_resolution_context: CssCalculationResolutionContext?) -> CssAbstractImageStyleValue*?:
    var best_below_or_equal: CssAbstractImageStyleValue*? = none
    var best_below_or_equal_resolution: f64? = none
    var best_above: CssAbstractImageStyleValue*? = none
    var best_above_resolution: f64? = none

    for option in ak.vector_span_const(&this.m_options):
        if css_image_set_option_is_excluded_by_type(&option):
            continue

        let resolution = css_option_resolution_in_dppx(option, calculation_resolution_context) else continue

        if resolution >= device_pixels_per_css_pixel:
            if best_above_resolution == none or resolution < (best_above_resolution else trap("VERIFY_NOT_REACHED")):
                best_above = option.image
                best_above_resolution = resolution
            continue

        if best_below_or_equal_resolution == none or resolution > (best_below_or_equal_resolution else trap("VERIFY_NOT_REACHED")):
            best_below_or_equal = option.image
            best_below_or_equal_resolution = resolution

    if let image = best_above:
        return image
    if let image = best_below_or_equal:
        return image
    return none

# mark: Value behavior ==========================================================================

## Ported from Libraries/LibWeb/CSS/StyleValues/ImageSetStyleValue.cpp:81 Web::CSS::ImageSetStyleValue::visit_edges (override).
pub func css_image_set_style_value_visit_edges_impl(base: CssStyleValue*, visitor: gc.CellVisitor*):
    let this = (CssImageSetStyleValue*)base
    css_style_value_visit_edges_impl(base, visitor)
    gc.cell_visitor_visit_t(visitor, this.m_style_sheet)
    for option in ak.vector_span_const(&this.m_options):
        css_style_value_visit_edges(option.image.css_style_value(), visitor)

## Ported from Libraries/LibWeb/CSS/StyleValues/ImageSetStyleValue.cpp:89 Web::CSS::ImageSetStyleValue::serialize (override).
pub func css_image_set_style_value_serialize_impl(base: CssStyleValue*, builder: ak.StringBuilder*, mode: css_syntax.SerializationMode):
    let this = (CssImageSetStyleValue*)base
    ak.string_builder_append(builder, "image-set(")
    for i in 0..<ak.vector_size(&this.m_options):
        if i > 0:
            ak.string_builder_append(builder, ", ")
        let option = ak.vector_at_const(&this.m_options, i)
        css_style_value_serialize(option.image.css_style_value(), builder, mode)
        ak.string_builder_append_u8(builder, ' ')
        css_style_value_serialize(option.resolution, builder, mode)
        if let type_ = option.type_:
            ak.string_builder_append(builder, " type(\"")
            ak.string_builder_append_escaped_for_json(builder, ak.string_bytes_as_string_view(&type_))
            ak.string_builder_append(builder, "\")")
    ak.string_builder_append_u8(builder, ')')

## Ported from Libraries/LibWeb/CSS/StyleValues/ImageSetStyleValue.cpp:108 Web::CSS::ImageSetStyleValue::equals (override).
pub func css_image_set_style_value_equals_impl(base: CssStyleValue*, other: CssStyleValue*) -> bool:
    let this = (CssImageSetStyleValue*)base
    if css_style_value_type(base) != css_style_value_type(other):
        return false
    let other_image_set = css_style_value_as_image_set(other)
    if ak.vector_size(&this.m_options) != ak.vector_size(&other_image_set.m_options):
        return false

    for i in 0..<ak.vector_size(&this.m_options):
        let option = ak.vector_at_const(&this.m_options, i)
        let other_option = ak.vector_at_const(&other_image_set.m_options, i)
        if not css_style_value_equals(option.image.css_style_value(), other_option.image.css_style_value()):
            return false
        if not css_style_value_equals(option.resolution, other_option.resolution):
            return false
        if not css_optional_strings_equal(option.type_, other_option.type_):
            return false
    return true

## Ported from Libraries/LibWeb/CSS/StyleValues/ImageSetStyleValue.cpp:129 Web::CSS::ImageSetStyleValue::is_computationally_independent (override).
pub func css_image_set_style_value_is_computationally_independent_impl(base: CssStyleValue*) -> bool:
    let this = (CssImageSetStyleValue*)base
    for option in ak.vector_span_const(&this.m_options):
        if not css_style_value_is_computationally_independent(option.image.css_style_value()):
            return false
        if not css_style_value_is_computationally_independent(option.resolution):
            return false
    return true

# mark: Loading and painting ====================================================================

## Ported from Libraries/LibWeb/CSS/StyleValues/ImageSetStyleValue.cpp:140 Web::CSS::ImageSetStyleValue::load_any_resources (override).
pub func css_image_set_style_value_load_any_resources_dom_document_impl(base: CssAbstractImageStyleValue*, document: DomDocument*):
    let this = (CssImageSetStyleValue*)base
    let dpr = page_client_device_pixels_per_css_pixel(page_client(dom_document_page(document)))
    if let image = css_image_set_style_value_select_image(this, dpr, none):
        if this.m_selected_image != image:
            css_style_value_set_style_sheet(image.css_style_value(), this.m_style_sheet)
            this.m_selected_image = image
    if let selected_image = this.m_selected_image:
        css_abstract_image_style_value_load_any_resources_dom_document(selected_image, document)

## Ported from Libraries/LibWeb/CSS/StyleValues/ImageSetStyleValue.cpp:151 Web::CSS::ImageSetStyleValue::load_any_resources (override).
pub func css_image_set_style_value_load_any_resources_layout_node_with_style_impl(base: CssAbstractImageStyleValue*, layout_node: LayoutNodeWithStyle*):
    let this = (CssImageSetStyleValue*)base
    css_image_set_style_value_update_selected_image_for_layout_node(this, layout_node)
    if let selected_image = this.m_selected_image:
        css_abstract_image_style_value_load_any_resources_dom_document(selected_image, layout_node_document((LayoutNode*)layout_node))

## Ported from Libraries/LibWeb/CSS/StyleValues/ImageSetStyleValue.cpp:158 Web::CSS::ImageSetStyleValue::update_selected_image_for_layout_node.
pub func css_image_set_style_value_update_selected_image_for_layout_node(this: CssImageSetStyleValue*, layout_node: LayoutNodeWithStyle*):
    let node = (LayoutNode*)layout_node
    var abstract_element: DomAbstractElement? = none
    if layout_node_is_generated_for_pseudo_element(node):
        if let pseudo_element_generator = layout_node_pseudo_element_generator(node):
            var element: DomAbstractElement = ---
            dom_abstract_element_construct(&element, pseudo_element_generator, layout_node_generated_for_pseudo_element(node))
            abstract_element = element
    elif let dom_node = layout_node_dom_node(node):
        if dom_node_is_element(dom_node):
            var element: DomAbstractElement = ---
            dom_abstract_element_construct(&element, (DomElement*)dom_node)
            abstract_element = element

    let context = CssCalculationResolutionContext(length_resolution_context = css_length_resolution_context_for_layout_node(node), abstract_element = abstract_element)
    let dpr = page_client_device_pixels_per_css_pixel(page_client(dom_document_page(layout_node_document(node))))

    if let image = css_image_set_style_value_select_image(this, dpr, context):
        if this.m_selected_image != image:
            css_style_value_set_style_sheet(image.css_style_value(), this.m_style_sheet)
            this.m_selected_image = image

## Ported from Libraries/LibWeb/CSS/StyleValues/ImageSetStyleValue.cpp:180 Web::CSS::ImageSetStyleValue::natural_width (override).
pub func css_image_set_style_value_natural_width_impl(base: CssAbstractImageStyleValue*) -> gfx.CssPixels?:
    let this = (CssImageSetStyleValue*)base
    if let selected_image = this.m_selected_image:
        return css_abstract_image_style_value_natural_width(selected_image)
    return none

## Ported from Libraries/LibWeb/CSS/StyleValues/ImageSetStyleValue.cpp:187 Web::CSS::ImageSetStyleValue::natural_height (override).
pub func css_image_set_style_value_natural_height_impl(base: CssAbstractImageStyleValue*) -> gfx.CssPixels?:
    let this = (CssImageSetStyleValue*)base
    if let selected_image = this.m_selected_image:
        return css_abstract_image_style_value_natural_height(selected_image)
    return none

## Ported from Libraries/LibWeb/CSS/StyleValues/ImageSetStyleValue.cpp:194 Web::CSS::ImageSetStyleValue::natural_aspect_ratio (override).
pub func css_image_set_style_value_natural_aspect_ratio_impl(base: CssAbstractImageStyleValue*) -> gfx.CssPixelFraction?:
    let this = (CssImageSetStyleValue*)base
    if let selected_image = this.m_selected_image:
        return css_abstract_image_style_value_natural_aspect_ratio(selected_image)
    return none

## Ported from Libraries/LibWeb/CSS/StyleValues/ImageSetStyleValue.cpp:201 Web::CSS::ImageSetStyleValue::resolve_for_size (override).
pub func css_image_set_style_value_resolve_for_size_impl(base: CssAbstractImageStyleValue*, layout_node: LayoutNodeWithStyle*, size: gfx.CssPixelSize):
    let this = (CssImageSetStyleValue*)base
    css_image_set_style_value_update_selected_image_for_layout_node(this, layout_node)
    if let selected_image = this.m_selected_image:
        css_abstract_image_style_value_resolve_for_size(selected_image, layout_node, size)

## Ported from Libraries/LibWeb/CSS/StyleValues/ImageSetStyleValue.cpp:208 Web::CSS::ImageSetStyleValue::is_paintable (override).
pub func css_image_set_style_value_is_paintable_impl(base: CssAbstractImageStyleValue*) -> bool:
    let this = (CssImageSetStyleValue*)base
    if let selected_image = this.m_selected_image:
        return css_abstract_image_style_value_is_paintable(selected_image)
    return false

## Ported from Libraries/LibWeb/CSS/StyleValues/ImageSetStyleValue.cpp:215 Web::CSS::ImageSetStyleValue::paint (override).
pub func css_image_set_style_value_paint_impl(base: CssAbstractImageStyleValue*, context: DisplayListRecordingContext*, dest_rect: gfx.DevicePixelRect, image_rendering: css_data.ImageRendering):
    let this = (CssImageSetStyleValue*)base
    if let selected_image = this.m_selected_image:
        css_abstract_image_style_value_paint(selected_image, context, dest_rect, image_rendering)

## Ported from Libraries/LibWeb/CSS/StyleValues/ImageSetStyleValue.cpp:221 Web::CSS::ImageSetStyleValue::color_if_single_pixel_bitmap (override).
pub func css_image_set_style_value_color_if_single_pixel_bitmap_impl(base: CssAbstractImageStyleValue*) -> gfx.Color?:
    let this = (CssImageSetStyleValue*)base
    if let selected_image = this.m_selected_image:
        return css_abstract_image_style_value_color_if_single_pixel_bitmap(selected_image)
    return none

## Ported from Libraries/LibWeb/CSS/StyleValues/ImageSetStyleValue.h:47 Web::CSS::ImageSetStyleValue::selected_image.
pub func css_image_set_style_value_selected_image(this: CssImageSetStyleValue*) -> CssAbstractImageStyleValue*?:
    return this.m_selected_image

## Ported from Libraries/LibWeb/CSS/StyleValues/ImageSetStyleValue.cpp:228 Web::CSS::ImageSetStyleValue::set_style_sheet (override).
pub func css_image_set_style_value_set_style_sheet_impl(base: CssStyleValue*, style_sheet: CssCssStyleSheet*?):
    let this = (CssImageSetStyleValue*)base
    css_style_value_set_style_sheet_impl(base, style_sheet)
    this.m_style_sheet = style_sheet

    # Propagate the style sheet to candidate images whose type() filter does not exclude them. This ensures the
    # candidate images register themselves as pending image resources on the style sheet, so their fetches start when
    # the style sheet is associated with the document, properly delaying the document's load event.
    for option in ak.vector_span_const(&this.m_options):
        if css_image_set_option_is_excluded_by_type(&option):
            continue
        css_style_value_set_style_sheet(option.image.css_style_value(), style_sheet)

## Ported from Libraries/LibWeb/CSS/StyleValues/ImageSetStyleValue.cpp:243 Web::CSS::ImageSetStyleValue::absolutized (override).
pub func css_image_set_style_value_absolutized_impl(base: CssStyleValue*, context: CssComputationContext) -> CssStyleValue*:
    let this = (CssImageSetStyleValue*)base
    var options = ak.Vector[CssImageSetStyleValueOption]()
    ak.vector_ensure_capacity(&options, ak.vector_size(&this.m_options))
    for option in ak.vector_span_const(&this.m_options):
        let image = css_style_value_absolutized(option.image.css_style_value(), context)
        assert(css_style_value_is_abstract_image(image))
        ak.vector_append_t(&options, CssImageSetStyleValueOption(image = css_style_value_as_abstract_image(image), resolution = css_style_value_absolutized(option.resolution, context), type_ = option.type_))
    return css_image_set_style_value_create(options).css_style_value()