Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / painting / replaced_element_common.lucb

#==============================================================================================
#
#   replaced_element_common - Painting: where a replaced element's content is painted
#
#   DESCRIPTION:
#       Port of LibWeb/Painting/ReplacedElementCommon.cpp (lines 1-99): the device rect a
#       replaced element's content (an image, a video frame, a canvas) is painted into, sized
#       by object-fit and placed by object-position within the paintable's content box.
#
#       Copyright (c) 2026-present, the Ladybird developers.
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

## `CSSPixelFraction(n)`.
func paint_fraction_of_int(n: i64) -> gfx.CssPixelFraction:
    var fraction: gfx.CssPixelFraction = ---
    gfx.css_pixel_fraction_construct_int(&fraction, n)
    return fraction

## Ported from Libraries/LibWeb/Painting/ReplacedElementCommon.cpp:14 Web::Painting::get_replaced_box_painting_area.
## Answers the C++ Gfx::IntRect as a DevicePixelRect (the integer device rect type).
pub func paint_get_replaced_box_painting_area(paintable: PaintPaintableBox*, context: const DisplayListRecordingContext*, object_fit: css_data.ObjectFit, content_size: gfx.IntSize) -> gfx.DevicePixelRect:
    if gfx.int_size_is_empty(&content_size):
        return gfx.DevicePixelRect()

    let paintable_rect = paint_paintable_box_absolute_rect(paintable)
    if gfx.css_pixel_rect_is_empty(&paintable_rect):
        return gfx.DevicePixelRect()

    let paintable_rect_device_pixels = display_list_recording_context_rounded_device_rect(context, paintable_rect)

    let paintable_width = gfx.css_pixel_rect_width(&paintable_rect)
    let paintable_height = gfx.css_pixel_rect_height(&paintable_rect)
    let bitmap_aspect_ratio = gfx.div_css_pixels_int(gfx.CssPixels.from_int(content_size.m_height), content_size.m_width)
    let image_aspect_ratio = paintable_height.div(paintable_width)

    var scale_x = paint_fraction_of_int(1)
    var scale_y = paint_fraction_of_int(1)

    var fit = object_fit
    if fit == css_data.ObjectFit.scale_down:
        if gfx.lt_int(paintable_width, content_size.m_width) or gfx.lt_int(paintable_height, content_size.m_height):
            fit = css_data.ObjectFit.contain
        else:
            fit = css_data.ObjectFit.none_

    match fit:
        .fill:
            scale_x = gfx.div_css_pixels_int(paintable_width, content_size.m_width)
            scale_y = gfx.div_css_pixels_int(paintable_height, content_size.m_height)
        .contain:
            if gfx.css_pixel_fraction_cmp_css_pixel_fraction(&bitmap_aspect_ratio, image_aspect_ratio) >= 0:
                scale_x = gfx.div_css_pixels_int(paintable_height, content_size.m_height)
                scale_y = scale_x
            else:
                scale_x = gfx.div_css_pixels_int(paintable_width, content_size.m_width)
                scale_y = scale_x
        .cover:
            if gfx.css_pixel_fraction_cmp_css_pixel_fraction(&bitmap_aspect_ratio, image_aspect_ratio) >= 0:
                scale_x = gfx.div_css_pixels_int(paintable_width, content_size.m_width)
                scale_y = scale_x
            else:
                scale_x = gfx.div_css_pixels_int(paintable_height, content_size.m_height)
                scale_y = scale_x
        .scale_down:
            trap("VERIFY_NOT_REACHED")  # handled outside the switch-case
        .none_:
            _ = 0
        _: trap("VERIFY_NOT_REACHED")

    let scaled_bitmap_width = gfx.CssPixels.from_int(content_size.m_width).mul_fraction(scale_x)
    let scaled_bitmap_height = gfx.CssPixels.from_int(content_size.m_height).mul_fraction(scale_y)

    let residual_horizontal = paintable_width.sub(scaled_bitmap_width)
    let residual_vertical = paintable_height.sub(scaled_bitmap_height)

    # https://drafts.csswg.org/css-images/#the-object-position
    let object_position = css_computed_values_object_position(&paint_paintable_computed_values(paintable.paint_paintable()).computed_values)
    let layout_node = paint_paintable_layout_node(paintable.paint_paintable())

    var offset_x = gfx.CssPixels.from_raw(0)
    if object_position.edge_x == css_data.PositionEdge.left:
        offset_x = css_percentage_or_to_px(&object_position.offset_x.percentage_or, layout_node, residual_horizontal)
    elif object_position.edge_x == css_data.PositionEdge.right:
        offset_x = residual_horizontal.sub(css_percentage_or_to_px(&object_position.offset_x.percentage_or, layout_node, residual_horizontal))

    var offset_y = gfx.CssPixels.from_raw(0)
    if object_position.edge_y == css_data.PositionEdge.top:
        offset_y = css_percentage_or_to_px(&object_position.offset_y.percentage_or, layout_node, residual_vertical)
    elif object_position.edge_y == css_data.PositionEdge.bottom:
        offset_y = residual_vertical.sub(css_percentage_or_to_px(&object_position.offset_y.percentage_or, layout_node, residual_vertical))

    return gfx.DevicePixelRect(
        m_location = gfx.IntPoint(
            m_x = gfx.device_pixel_rect_x(&paintable_rect_device_pixels) + display_list_recording_context_rounded_device_pixels(context, offset_x),
            m_y = gfx.device_pixel_rect_y(&paintable_rect_device_pixels) + display_list_recording_context_rounded_device_pixels(context, offset_y)),
        m_size = gfx.IntSize(
            m_width = display_list_recording_context_rounded_device_pixels(context, scaled_bitmap_width),
            m_height = display_list_recording_context_rounded_device_pixels(context, scaled_bitmap_height)))