Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / painting / paintable_box_2.lucb

#==============================================================================================
#
#   paintable_box_2 - Painting::PaintableBox: scrollbars, painting and transforms
#
#   DESCRIPTION:
#       Port of LibWeb/Painting/PaintableBox.cpp (lines 520-992): the scrollbar rectangles and
#       thumb geometry, PaintableBox::paint (backgrounds, borders, collapsed table borders,
#       outlines, scrollbars and the resizer), the middle button scroll indicator and the
#       inspector overlay, the stacking context and z-index, border, backdrop filter,
#       background and box shadow painting, normalized border radii, and the mapping of points
#       and rects through the accumulated visual contexts.
#
#       Copyright (c) 2022-2023, Andreas Kling <andreas@ladybird.org>
#       Copyright (c) 2022-2025, Sam Atkins <sam@ladybird.org>
#       Copyright (c) 2024-2026, Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
#       Copyright (c) 2025, Jelle Raaijmakers <jelle@ladybird.org>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: Scrollbar geometry ========================================================================

## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:520 Web::Painting::PaintableBox::absolute_scrollbar_rect.
pub func paint_paintable_box_absolute_scrollbar_rect(this: PaintPaintableBox*, direction: PaintPaintableBoxScrollDirection, with_gutter: bool, metrics: ChromeMetrics) -> gfx.CssPixelRect?:
    if not paint_paintable_box_could_be_scrolled_by_wheel_event_paint_paintable_box_scroll_dir(this, direction):
        return none

    if css_computed_values_scrollbar_width(&paint_paintable_computed_values(this.paint_paintable()).computed_values) == css_data.ScrollbarWidth.none_:
        return none

    let is_horizontal = direction == PaintPaintableBoxScrollDirection.horizontal
    let adjusting_for_resizer = paint_paintable_box_has_resizer(this)

    let rect_thickness = metrics.scroll_gutter_thickness if with_gutter else metrics.scroll_thumb_thickness_thin.add(metrics.scroll_thumb_padding_thin)
    var scrollbar_rect = paint_paintable_box_absolute_padding_box_rect(this)
    let zero = gfx.CssPixels.from_int(0)

    if is_horizontal:
        if not adjusting_for_resizer and paint_paintable_box_could_be_scrolled_by_wheel_event_paint_paintable_box_scroll_dir(this, PaintPaintableBoxScrollDirection.vertical):
            gfx.css_pixel_rect_set_width(&scrollbar_rect, ak.max(zero, gfx.css_pixel_rect_width(&scrollbar_rect).sub(metrics.scroll_gutter_thickness)))
            if paint_paintable_box_is_chrome_mirrored(this):
                gfx.css_pixel_rect_set_x(&scrollbar_rect, gfx.css_pixel_rect_x(&scrollbar_rect).add(metrics.scroll_gutter_thickness))
        elif adjusting_for_resizer:
            gfx.css_pixel_rect_set_width(&scrollbar_rect, paint_paintable_box_available_scrollbar_length(this, PaintPaintableBoxScrollDirection.horizontal, metrics))
            if paint_paintable_box_is_chrome_mirrored(this):
                gfx.css_pixel_rect_set_x(&scrollbar_rect, gfx.css_pixel_rect_x(&scrollbar_rect).add(metrics.resize_gripper_size))
        gfx.css_pixel_rect_set_y(&scrollbar_rect, ak.max(zero, gfx.css_pixel_rect_bottom(&scrollbar_rect).sub(rect_thickness)))
        gfx.css_pixel_rect_set_height(&scrollbar_rect, rect_thickness)
    else:
        if adjusting_for_resizer:
            gfx.css_pixel_rect_set_height(&scrollbar_rect, paint_paintable_box_available_scrollbar_length(this, PaintPaintableBoxScrollDirection.vertical, metrics))
        if not paint_paintable_box_is_chrome_mirrored(this):
            gfx.css_pixel_rect_set_x(&scrollbar_rect, ak.max(zero, gfx.css_pixel_rect_right(&scrollbar_rect).sub(rect_thickness)))
        gfx.css_pixel_rect_set_width(&scrollbar_rect, rect_thickness)
    return scrollbar_rect

## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:557 Web::Painting::PaintableBox::compute_scrollbar_data.
pub func paint_paintable_box_compute_scrollbar_data(this: PaintPaintableBox*, direction: PaintPaintableBoxScrollDirection, metrics: ChromeMetrics, scroll_state_snapshot: const display_list.ScrollStateSnapshot*? = none) -> PaintPaintableBoxScrollbarData?:
    let is_horizontal = direction == PaintPaintableBoxScrollDirection.horizontal
    let orientation = gfx.Orientation.horizontal if is_horizontal else gfx.Orientation.vertical
    let computed_values = &paint_paintable_computed_values(this.paint_paintable()).computed_values
    let overflow = css_computed_values_overflow_x(computed_values) if is_horizontal else css_computed_values_overflow_y(computed_values)

    if overflow != css_data.Overflow.scroll and not paint_paintable_box_could_be_scrolled_by_wheel_event_paint_paintable_box_scroll_dir(this, direction):
        return none

    if this.m_own_scroll_frame_index == 0:
        return none

    let scrollable_overflow_rect = paint_paintable_box_scrollable_overflow_rect(this) else trap("VERIFY: no scrollable overflow rect")
    let scrollable_overflow_length = gfx.css_pixel_rect_primary_size_for_orientation(&scrollable_overflow_rect, orientation)
    if gfx.eq_css_pixels_int(scrollable_overflow_length, 0):
        return none

    let scrollbar = this.m_horizontal_scrollbar if is_horizontal else this.m_vertical_scrollbar
    var with_gutter = false
    if let existing = scrollbar:
        with_gutter = paint_scrollbar_is_enlarged(existing)
    let scrollbar_rect = paint_paintable_box_absolute_scrollbar_rect(this, direction, with_gutter, metrics) else return none

    var thumb_thickness = metrics.scroll_thumb_thickness_thin
    var thumb_margin = metrics.scroll_thumb_padding_thin
    if with_gutter:
        thumb_thickness = metrics.scroll_thumb_thickness
        thumb_margin = gfx.CssPixels.from_f64(gfx.div_css_pixels_f64(metrics.scroll_gutter_thickness.sub(metrics.scroll_thumb_thickness), 2.0))
    let zero = gfx.CssPixels.from_int(0)
    let scrollbar_length = gfx.css_pixel_rect_primary_size_for_orientation(&scrollbar_rect, orientation)
    let usable_scrollbar_length = ak.max(zero, scrollbar_length.sub(gfx.mul_int_css_pixels(2, thumb_margin)))
    let padding_box_rect = paint_paintable_box_absolute_padding_box_rect(this)
    let scrollport_size = gfx.css_pixel_rect_primary_size_for_orientation(&padding_box_rect, orientation)
    let min_thumb_length = ak.min(usable_scrollbar_length, metrics.scroll_thumb_min_length)
    let thumb_length = ak.max(usable_scrollbar_length.mul_fraction(scrollport_size.div(scrollable_overflow_length)), min_thumb_length)

    var zero_ratio: gfx.CssPixelFraction = ---
    gfx.css_pixel_fraction_construct_int(&zero_ratio, 0)
    var scrollbar_data = PaintPaintableBoxScrollbarData(gutter_rect = gfx.CssPixelRect(), thumb_rect = scrollbar_rect, thumb_travel_to_scroll_ratio = zero_ratio)

    gfx.css_pixel_rect_set_primary_size_for_orientation(&scrollbar_data.thumb_rect, orientation, thumb_length)
    gfx.css_pixel_rect_set_secondary_size_for_orientation(&scrollbar_data.thumb_rect, orientation, thumb_thickness)
    gfx.css_pixel_rect_translate_primary_offset_for_orientation(&scrollbar_data.thumb_rect, orientation, thumb_margin)
    if with_gutter or (not is_horizontal and paint_paintable_box_is_chrome_mirrored(this)):
        gfx.css_pixel_rect_translate_secondary_offset_for_orientation(&scrollbar_data.thumb_rect, orientation, thumb_margin)
    if with_gutter:
        scrollbar_data.gutter_rect = scrollbar_rect
    if scrollable_overflow_length.gt(scrollport_size):
        scrollbar_data.thumb_travel_to_scroll_ratio = usable_scrollbar_length.sub(thumb_length).div(scrollable_overflow_length.sub(scrollport_size))

    if let snapshot = scroll_state_snapshot:
        let own_offset = display_list.scroll_state_snapshot_device_offset_for_index(snapshot, this.m_own_scroll_frame_index)
        let device_scroll_offset = -own_offset.m_x if is_horizontal else -own_offset.m_y
        let device_pixels_per_css_pixel = (f32)page_client_device_pixels_per_css_pixel(page_client(dom_document_page(paint_paintable_document(this.paint_paintable()))))
        let thumb_offset = gfx.css_pixels_nearest_value_for_f32(device_scroll_offset / device_pixels_per_css_pixel).mul_fraction(scrollbar_data.thumb_travel_to_scroll_ratio)
        gfx.css_pixel_rect_translate_primary_offset_for_orientation(&scrollbar_data.thumb_rect, orientation, thumb_offset)

    return scrollbar_data

# mark: Painting ==================================================================================

## The `empty_cells_property_applies` lambda of PaintableBox::paint.
func paint_paintable_box_empty_cells_property_applies(this: PaintPaintableBox*) -> bool:
    let display = paint_paintable_display(this.paint_paintable())
    return css_display_is_internal_table(&display) and css_computed_values_empty_cells(&paint_paintable_computed_values(this.paint_paintable()).computed_values) == css_data.EmptyCells.hide and not tree_node_has_children(this.paint_paintable())

## The `paint_resizer_line` lambda of PaintableBox::paint.
func paint_paintable_box_paint_resizer_line(recorder: display_list.DisplayListRecorder*, rect: gfx.DevicePixelRect, bottom_left_resizer: bool, step: i32, color: gfx.Color):
    let from_ = gfx.IntPoint(m_x = gfx.device_pixel_rect_left(&rect) + step if bottom_left_resizer else gfx.device_pixel_rect_right(&rect) - step, m_y = gfx.device_pixel_rect_bottom(&rect))
    let to = gfx.IntPoint(m_x = gfx.device_pixel_rect_left(&rect) if bottom_left_resizer else gfx.device_pixel_rect_right(&rect), m_y = gfx.device_pixel_rect_bottom(&rect) - step)
    display_list.display_list_recorder_draw_line(recorder, from_, to, color, 1, gfx.LineStyle.solid)

## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:613 Web::Painting::PaintableBox::paint (override).
pub func paint_paintable_box_paint_impl(base: PaintPaintable*, context: DisplayListRecordingContext*, phase: PaintPhase):
    let this = (PaintPaintableBox*)base
    if not paint_paintable_is_visible(base):
        return

    let computed_values = &paint_paintable_computed_values(base).computed_values

    if phase == PaintPhase.background and not paint_paintable_box_empty_cells_property_applies(this):
        paint_paintable_box_paint_backdrop_filter(this, context)
        paint_paintable_box_paint_background(this, context)
        paint_paintable_box_paint_box_shadow(this, context)

    let display = paint_paintable_display(base)
    let is_table_with_collapsed_borders = css_display_is_table_inside(&display) and css_computed_values_border_collapse(computed_values) == css_data.BorderCollapse.collapse
    if not css_display_is_table_cell(&display) and not is_table_with_collapsed_borders and phase == PaintPhase.border:
        paint_paintable_box_paint_border(this, context)

    if (css_display_is_table_inside(&display) or css_computed_values_border_collapse(computed_values) == css_data.BorderCollapse.collapse) and phase == PaintPhase.table_collapsed_border:
        paint_paint_table_borders(context, this)

    if phase == PaintPhase.outline:
        if let outline_data = paint_paintable_box_outline_data(this):
            let outline_offset = paint_paintable_box_outline_offset(this)
            var border_radius_data = paint_paintable_box_normalized_border_radii_data(this, PaintPaintableBoxShrinkRadiiForBorders.no)
            var borders_rect = paint_paintable_box_absolute_border_box_rect(this)

            var outline_offset_x = outline_offset
            var outline_offset_y = outline_offset
            # "Both the height and the width of the outside of the shape drawn by the outline should not
            # become smaller than twice the computed value of the outline-width property to make sure
            # that an outline can be rendered even with large negative values."
            # https://www.w3.org/TR/css-ui-4/#outline-offset
            # So, if the horizontal outline offset is > half the borders_rect's width then we set it to that.
            # (And the same for y)
            let half_width = layout_div_int(gfx.css_pixel_rect_width(&borders_rect), 2)
            let half_height = layout_div_int(gfx.css_pixel_rect_height(&borders_rect), 2)
            if half_width.add(outline_offset_x).lt(gfx.CssPixels.from_int(0)):
                outline_offset_x = layout_div_int(gfx.css_pixel_rect_width(&borders_rect).neg(), 2)
            if half_height.add(outline_offset_y).lt(gfx.CssPixels.from_int(0)):
                outline_offset_y = layout_div_int(gfx.css_pixel_rect_height(&borders_rect).neg(), 2)

            display_list.border_radii_data_inflate(&border_radius_data, outline_data.top.width.add(outline_offset_y), outline_data.right.width.add(outline_offset_x), outline_data.bottom.width.add(outline_offset_y), outline_data.left.width.add(outline_offset_x))
            gfx.css_pixel_rect_inflate_css_pixels_css_pixels_css_pixels(&borders_rect, outline_data.top.width.add(outline_offset_y), outline_data.right.width.add(outline_offset_x), outline_data.bottom.width.add(outline_offset_y), outline_data.left.width.add(outline_offset_x))

            paint_paint_all_borders(display_list_recording_context_display_list_recorder(context), display_list_recording_context_rounded_device_rect(context, borders_rect), border_radii_data_as_corners(&border_radius_data, display_list_recording_context_device_pixel_converter(context)), borders_data_to_device_pixels(&outline_data, *context))

    if phase == PaintPhase.overlay:
        let metrics = display_list_recording_context_chrome_metrics(context)

        if (paint_g_paint_viewport_scrollbars or not paint_paintable_is_viewport_paintable(base)) and css_computed_values_scrollbar_width(computed_values) != css_data.ScrollbarWidth.none_:
            let scrollbar_colors = css_computed_values_scrollbar_color(computed_values)

            let directions: PaintPaintableBoxScrollDirection[2] = [PaintPaintableBoxScrollDirection.vertical, PaintPaintableBoxScrollDirection.horizontal]
            for direction in directions:
                let scrollbar_data = paint_paintable_box_compute_scrollbar_data(this, direction, metrics) else continue
                display_list.display_list_recorder_paint_scrollbar(display_list_recording_context_display_list_recorder(context),
                                                                   this.m_own_scroll_frame_index,
                                                                   display_list_recording_context_rounded_device_rect(context, scrollbar_data.gutter_rect),
                                                                   display_list_recording_context_rounded_device_rect(context, scrollbar_data.thumb_rect),
                                                                   gfx.css_pixel_fraction_to_double(&scrollbar_data.thumb_travel_to_scroll_ratio),
                                                                   scrollbar_colors.thumb_color,
                                                                   scrollbar_colors.track_color,
                                                                   direction == PaintPaintableBoxScrollDirection.vertical)

        if let resizer_rect = paint_paintable_box_absolute_resizer_rect(this, metrics):
            let bottom_left_resizer = paint_paintable_box_is_chrome_mirrored(this)
            let padding = metrics.resize_gripper_padding
            let half_padding = layout_div_int(padding, 2)
            let shrunken = gfx.css_pixel_rect_shrunken_css_pixels_css_pixels(&resizer_rect, padding, padding)
            let css_rect = gfx.css_pixel_rect_translated_css_pixels_css_pixels(&shrunken, half_padding if bottom_left_resizer else layout_div_int(padding.neg(), 2), layout_div_int(padding.neg(), 2))
            let rect = display_list_recording_context_rounded_device_rect(context, css_rect)
            let dark = gfx.color_new_u8_u8_u8_u8(0, 0, 0, 100)
            let light = gfx.color_new_u8_u8_u8_u8(255, 255, 255, 100)
            let recorder = display_list_recording_context_display_list_recorder(context)
            var step = (gfx.device_pixel_rect_width(&rect) // 3) - 1
            while step < gfx.device_pixel_rect_width(&rect):
                paint_paintable_box_paint_resizer_line(recorder, rect, bottom_left_resizer, step, light)
                paint_paintable_box_paint_resizer_line(recorder, rect, bottom_left_resizer, step + 1, dark)
                step += gfx.device_pixel_rect_width(&rect) // 3

        paint_paintable_box_paint_middle_button_scroll_indicator(this, context)

## The `paint_arrow` lambda of PaintableBox::paint_middle_button_scroll_indicator.
func paint_paintable_box_paint_arrow(recorder: display_list.DisplayListRecorder*, p1: gfx.FloatPoint, p2: gfx.FloatPoint, p3: gfx.FloatPoint, color: gfx.Color):
    var path = gfx.Path()
    gfx.path_move_to(&path, p1)
    gfx.path_line_to(&path, p2)
    gfx.path_line_to(&path, p3)
    gfx.path_close(&path)

    display_list.display_list_recorder_fill_path(recorder, display_list.DisplayListRecorderFillPathParams(path = path, paint_style_or_color = display_list.PaintStyleOrColor.color(color)))

## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:713 Web::Painting::PaintableBox::paint_middle_button_scroll_indicator.
pub func paint_paintable_box_paint_middle_button_scroll_indicator(this: PaintPaintableBox*, context: DisplayListRecordingContext*):
    let white = gfx.color_new_named_color(gfx.ColorNamedColor.white)
    let circle_color = gfx.color_with_alpha(&white, 220)
    let arrow_color = gfx.color_new_named_color(gfx.ColorNamedColor.dark_gray)

    let radius: i32 = 16
    let arrow_size: f32 = 6.0
    let arrow_offset: f32 = 8.0

    if not paint_paintable_is_viewport_paintable(this.paint_paintable()):
        return

    let navigable = paint_paintable_navigable(this.paint_paintable()) else return

    let handler = event_handler_middle_button_scroll_handler(html_navigable_event_handler(navigable)) else return

    let recorder = display_list_recording_context_display_list_recorder(context)
    let device_origin = display_list_recording_context_rounded_device_point(context, middle_button_scroll_handler_origin(handler))

    let circle = gfx.DevicePixelRect(m_location = gfx.IntPoint(m_x = device_origin.m_x - radius, m_y = device_origin.m_y - radius), m_size = gfx.IntSize(m_width = radius * 2, m_height = radius * 2))
    display_list.display_list_recorder_fill_ellipse(recorder, circle, circle_color)
    display_list.display_list_recorder_draw_ellipse(recorder, circle, arrow_color, 1)

    let x = (f32)device_origin.m_x
    let y = (f32)device_origin.m_y

    # FIXME: We could paint a subset of these arrows depending on which direction the container may be scrolled.
    paint_paintable_box_paint_arrow(recorder, gfx.FloatPoint(m_x = x, m_y = y - arrow_offset - arrow_size), gfx.FloatPoint(m_x = x - arrow_size, m_y = y - arrow_offset), gfx.FloatPoint(m_x = x + arrow_size, m_y = y - arrow_offset), arrow_color)
    paint_paintable_box_paint_arrow(recorder, gfx.FloatPoint(m_x = x, m_y = y + arrow_offset + arrow_size), gfx.FloatPoint(m_x = x - arrow_size, m_y = y + arrow_offset), gfx.FloatPoint(m_x = x + arrow_size, m_y = y + arrow_offset), arrow_color)
    paint_paintable_box_paint_arrow(recorder, gfx.FloatPoint(m_x = x - arrow_offset - arrow_size, m_y = y), gfx.FloatPoint(m_x = x - arrow_offset, m_y = y - arrow_size), gfx.FloatPoint(m_x = x - arrow_offset, m_y = y + arrow_size), arrow_color)
    paint_paintable_box_paint_arrow(recorder, gfx.FloatPoint(m_x = x + arrow_offset + arrow_size, m_y = y), gfx.FloatPoint(m_x = x + arrow_offset, m_y = y - arrow_size), gfx.FloatPoint(m_x = x + arrow_offset, m_y = y + arrow_size), arrow_color)

## The `paint_inspector_rect` lambda of PaintableBox::paint_inspector_overlay_internal.
func paint_paintable_box_paint_inspector_rect(context: DisplayListRecordingContext*, rect: gfx.CssPixelRect, color: gfx.Color):
    let device_rect = display_list_recording_context_enclosing_device_rect(context, rect)
    display_list.display_list_recorder_fill_rect(display_list_recording_context_display_list_recorder(context), device_rect, gfx.color_with_alpha(&color, 100))
    display_list.display_list_recorder_draw_rect(display_list_recording_context_display_list_recorder(context), device_rect, color)

## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:762 Web::Painting::PaintableBox::paint_inspector_overlay_internal (override).
pub func paint_paintable_box_paint_inspector_overlay_internal_impl(base: PaintPaintable*, context: DisplayListRecordingContext*):
    let this = (PaintPaintableBox*)base
    let content_rect = paint_paintable_box_absolute_united_content_rect(this)
    let margin_rect = paint_united_rect_for_continuation_chain(this, PaintUnitedRect.margin_box)
    let border_rect = paint_paintable_box_absolute_united_border_box_rect(this)
    let padding_rect = paint_paintable_box_absolute_united_padding_box_rect(this)

    paint_paintable_box_paint_inspector_rect(context, margin_rect, gfx.color_new_named_color(gfx.ColorNamedColor.yellow))
    paint_paintable_box_paint_inspector_rect(context, padding_rect, gfx.color_new_named_color(gfx.ColorNamedColor.cyan))
    paint_paintable_box_paint_inspector_rect(context, border_rect, gfx.color_new_named_color(gfx.ColorNamedColor.green))
    paint_paintable_box_paint_inspector_rect(context, content_rect, gfx.color_new_named_color(gfx.ColorNamedColor.magenta))

    let font = platform_font_plugin_default_font(platform_font_plugin_the(), 12.0) else trap("no default font")

    var builder = ak.string_builder_new_mode(ak.StringBuilderMode.utf16)
    let description = paint_paintable_debug_description(base)
    ak.string_builder_append_string_view(&builder, ak.string_bytes_as_string_view(&description))
    dump_appendff(&builder, " {}x{} @ {},{}", [
        dump_arg_css_pixels(gfx.css_pixel_rect_width(&border_rect)),
        dump_arg_css_pixels(gfx.css_pixel_rect_height(&border_rect)),
        dump_arg_css_pixels(gfx.css_pixel_rect_x(&border_rect)),
        dump_arg_css_pixels(gfx.css_pixel_rect_y(&border_rect)),
    ])
    let size_text = ak.string_builder_to_utf16_string(&builder)
    var size_text_rect = border_rect
    gfx.css_pixel_rect_set_y(&size_text_rect, gfx.css_pixel_rect_y(&border_rect).add(gfx.css_pixel_rect_height(&border_rect)))
    gfx.css_pixel_rect_set_top(&size_text_rect, gfx.css_pixel_rect_top(&size_text_rect))
    gfx.css_pixel_rect_set_width(&size_text_rect, gfx.css_pixels_nearest_value_for_f32(web_fonts.font_width(font, ak.utf16_string_base_utf16_view(&size_text.utf16_string_base))).add(gfx.CssPixels.from_int(4)))
    gfx.css_pixel_rect_set_height(&size_text_rect, gfx.css_pixels_nearest_value_for_f32(web_fonts.font_pixel_size(font)).add(gfx.CssPixels.from_int(4)))
    let size_text_device_rect = display_list_recording_context_enclosing_device_rect(context, size_text_rect)
    let palette = display_list_recording_context_palette(context)
    let recorder = display_list_recording_context_display_list_recorder(context)
    display_list.display_list_recorder_fill_rect(recorder, size_text_device_rect, gfx.palette_color(&palette, gfx.ColorRole.tooltip))
    display_list.display_list_recorder_draw_rect(recorder, size_text_device_rect, gfx.palette_threed_shadow1(&palette))
    let scaled_font = web_fonts.font_with_size(font, web_fonts.font_point_size(font) * (f32)display_list_recording_context_device_pixels_per_css_pixel(context))
    display_list.display_list_recorder_draw_text(recorder, size_text_device_rect, &size_text, scaled_font, gfx.TextAlignment.center, gfx.palette_color(&palette, gfx.ColorRole.tooltip_text))

# mark: Stacking contexts =========================================================================

## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:803 Web::Painting::PaintableBox::set_stacking_context.
pub func paint_paintable_box_set_stacking_context(this: PaintPaintableBox*, stacking_context: PaintStackingContext*):
    this.m_stacking_context = stacking_context

## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:808 Web::Painting::PaintableBox::invalidate_stacking_context.
pub func paint_paintable_box_invalidate_stacking_context(this: PaintPaintableBox*):
    this.m_stacking_context = none

## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:813 Web::Painting::PaintableBox::effective_z_index.
pub func paint_paintable_box_effective_z_index(this: PaintPaintableBox*) -> i32?:
    # https://drafts.csswg.org/css2/#z-index
    # Applies to: positioned elements
    if paint_paintable_is_positioned(this.paint_paintable()):
        return css_computed_values_z_index(&paint_paintable_computed_values(this.paint_paintable()).computed_values)

    return none

# mark: Borders, backgrounds and shadows ==========================================================

## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:823 Web::Painting::PaintableBox::remove_element_kind_from_borders_data.
pub func paint_paintable_box_remove_element_kind_from_borders_data(borders_data: PaintPaintableBoxBordersDataWithElementKind) -> display_list.BordersData:
    return display_list.BordersData(
        top = borders_data.top.border_data,
        right = borders_data.right.border_data,
        bottom = borders_data.bottom.border_data,
        left = borders_data.left.border_data,
    )

## `CSS::BorderData()`: a default border (transparent, no line style, zero width).
func paint_default_border_data() -> display_list.BorderData:
    var border_data = display_list.BorderData()
    display_list.border_data_init_fields(&border_data)
    return border_data

## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:833 Web::Painting::PaintableBox::paint_border (virtual).
pub func paint_paintable_box_paint_border_impl(this: PaintPaintableBox*, context: DisplayListRecordingContext*):
    var borders_data: display_list.BordersData = ---
    if let override_borders_data = this.m_override_borders_data:
        borders_data = paint_paintable_box_remove_element_kind_from_borders_data(override_borders_data)
    else:
        let computed_values = &paint_paintable_computed_values(this.paint_paintable()).computed_values
        let border = this.m_box_model.border
        borders_data = display_list.BordersData(
            top = paint_default_border_data() if gfx.eq_css_pixels_int(border.top, 0) else css_computed_values_border_top(computed_values),
            right = paint_default_border_data() if gfx.eq_css_pixels_int(border.right, 0) else css_computed_values_border_right(computed_values),
            bottom = paint_default_border_data() if gfx.eq_css_pixels_int(border.bottom, 0) else css_computed_values_border_bottom(computed_values),
            left = paint_default_border_data() if gfx.eq_css_pixels_int(border.left, 0) else css_computed_values_border_left(computed_values),
        )
    let radii = paint_paintable_box_normalized_border_radii_data(this)
    paint_paint_all_borders(display_list_recording_context_display_list_recorder(context), display_list_recording_context_rounded_device_rect(context, paint_paintable_box_absolute_border_box_rect(this)), border_radii_data_as_corners(&radii, display_list_recording_context_device_pixel_converter(context)), borders_data_to_device_pixels(&borders_data, *context))

## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:844 Web::Painting::PaintableBox::paint_backdrop_filter (virtual).
pub func paint_paintable_box_paint_backdrop_filter_impl(this: PaintPaintableBox*, context: DisplayListRecordingContext*):
    let backdrop_filter = css_computed_values_backdrop_filter(&paint_paintable_computed_values(this.paint_paintable()).computed_values)
    if not css_filter_has_filters(&backdrop_filter):
        return

    let resolved = paint_resolve_css_filter(backdrop_filter, this)
    let backdrop_region = display_list_recording_context_rounded_device_rect(context, paint_paintable_box_absolute_border_box_rect(this))
    let border_radii_data = paint_paintable_box_normalized_border_radii_data(this)
    var corner_clipper: PaintScopedCornerRadiusClip = ---
    paint_scoped_corner_radius_clip_construct(&corner_clipper, context, backdrop_region, border_radii_data)
    defer paint_scoped_corner_radius_clip_destruct(&corner_clipper)
    if let gfx_filter = paint_to_gfx_filter(resolved, display_list_recording_context_device_pixels_per_css_pixel(context)):
        display_list.display_list_recorder_apply_backdrop_filter(display_list_recording_context_display_list_recorder(context), backdrop_region, border_radii_data_as_corners(&border_radii_data, display_list_recording_context_device_pixel_converter(context)), gfx_filter)

## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:856 Web::Painting::PaintableBox::paint_background (virtual).
pub func paint_paintable_box_paint_background_impl(this: PaintPaintableBox*, context: DisplayListRecordingContext*):
    let document = paint_paintable_document(this.paint_paintable())
    # If the body's background properties were propagated to the root element, do not re-paint the body's background.
    let layout_node = paint_paintable_box_layout_node_with_style_and_box_metrics(this)
    if layout_node_with_style_is_body(layout_node.layout_node_with_style()):
        let html_element = dom_document_html_element(document) else trap("a body without an html element")
        if html_html_element_should_use_body_background_properties(html_element):
            return

    let computed_values = &paint_paintable_computed_values(this.paint_paintable()).computed_values

    var background_rect = gfx.CssPixelRect()
    var background_color = css_computed_values_background_color(computed_values)
    var own_layers = css_computed_values_background_layers(computed_values)
    var background_layers: const ak.Vector[CssBackgroundLayerData]*? = &own_layers

    # https://drafts.csswg.org/css-backgrounds/#root-background
    let is_root = layout_node_is_root_element(layout_node.layout_node())
    if is_root:
        background_rect = paint_paintable_box_absolute_border_box_rect(this)

        let html_element = as_html_html_element(layout_node_dom_node(layout_node.layout_node()) else trap("the root element has no DOM node"))
        if html_html_element_should_use_body_background_properties(html_element):
            background_layers = dom_document_background_layers(document)
            background_color = dom_document_background_color(document)
    else:
        background_rect = paint_paintable_box_absolute_padding_box_rect(this)

    # HACK: If the Box has a border, use the bordered_rect to paint the background.
    #       This way if we have a border-radius there will be no gap between the filling and actual border.
    if css_computed_values_border_top(computed_values).width != gfx.CssPixels.from_int(0) or css_computed_values_border_right(computed_values).width != gfx.CssPixels.from_int(0) or css_computed_values_border_bottom(computed_values).width != gfx.CssPixels.from_int(0) or css_computed_values_border_left(computed_values).width != gfx.CssPixels.from_int(0):
        background_rect = paint_paintable_box_absolute_border_box_rect(this)

    let border_radii = paint_paintable_box_normalized_border_radii_data(this)

    var resolved_background = PaintResolvedBackground()
    if let layers = background_layers:
        resolved_background = paint_resolve_background_layers(*layers, this, background_color, css_computed_values_background_color_clip(computed_values), background_rect, border_radii)

    if is_root:
        let navigable = paint_paintable_navigable(this.paint_paintable()) else trap("the root element's document has no navigable")
        var canvas_rect = html_navigable_viewport_rect(navigable)
        if let overflow_rect = paint_paintable_box_scrollable_overflow_rect(this):
            gfx.css_pixel_rect_unite(&canvas_rect, overflow_rect)
        gfx.css_pixel_rect_unite(&resolved_background.background_rect, canvas_rect)
        gfx.css_pixel_rect_unite(&resolved_background.color_box.rect, canvas_rect)

    # If the body's background was propagated to the root element, use the body's image-rendering value.
    var image_rendering = css_computed_values_image_rendering(computed_values)
    if layout_node_is_root_element(paint_paintable_layout_node(this.paint_paintable())):
        if let html_element = dom_document_html_element(document):
            if html_html_element_should_use_body_background_properties(html_element):
                image_rendering = dom_document_background_image_rendering(document)

    paint_paint_background(context, this, image_rendering, resolved_background, border_radii)

## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:910 Web::Painting::PaintableBox::paint_box_shadow (virtual).
pub func paint_paintable_box_paint_box_shadow_impl(this: PaintPaintableBox*, context: DisplayListRecordingContext*):
    let computed_values = &paint_paintable_computed_values(this.paint_paintable()).computed_values
    var box_shadow_layers = css_computed_values_box_shadow(computed_values)
    if ak.vector_is_empty(&box_shadow_layers):
        return
    var resolved_box_shadow_data: ak.Vector[PaintShadowData]
    ak.vector_ensure_capacity(&resolved_box_shadow_data, ak.vector_size(&box_shadow_layers))
    for layer in ak.vector_span(&box_shadow_layers):
        ak.vector_unchecked_append_u(&resolved_box_shadow_data, paint_shadow_data_from_css(layer, paint_paintable_layout_node(this.paint_paintable())))
    let borders_data = display_list.BordersData(
        top = css_computed_values_border_top(computed_values),
        right = css_computed_values_border_right(computed_values),
        bottom = css_computed_values_border_bottom(computed_values),
        left = css_computed_values_border_left(computed_values),
    )
    paint_paint_box_shadow(context, paint_paintable_box_absolute_border_box_rect(this), paint_paintable_box_absolute_padding_box_rect(this),
                           borders_data, paint_paintable_box_normalized_border_radii_data(this), resolved_box_shadow_data)

## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:929 Web::Painting::PaintableBox::normalized_border_radii_data.
pub func paint_paintable_box_normalized_border_radii_data(this: PaintPaintableBox*, shrink: PaintPaintableBoxShrinkRadiiForBorders = PaintPaintableBoxShrinkRadiiForBorders.no) -> display_list.BorderRadiiData:
    var border_radii_data = paint_paintable_box_border_radii_data(this)
    if shrink == PaintPaintableBoxShrinkRadiiForBorders.yes:
        let computed_values = &paint_paintable_computed_values(this.paint_paintable()).computed_values
        display_list.border_radii_data_shrink(&border_radii_data, css_computed_values_border_top(computed_values).width, css_computed_values_border_right(computed_values).width, css_computed_values_border_bottom(computed_values).width, css_computed_values_border_left(computed_values).width)
    return border_radii_data

# mark: Visual contexts ===========================================================================

## `document().page().client().device_pixels_per_css_pixel()` as a float.
func paint_paintable_box_pixel_ratio(this: PaintPaintableBox*) -> f32:
    return (f32)page_client_device_pixels_per_css_pixel(page_client(dom_document_page(paint_paintable_document(this.paint_paintable()))))

## The document's ViewportPaintable.
func paint_paintable_box_viewport_paintable(this: PaintPaintableBox*) -> PaintViewportPaintable*:
    return dom_document_paintable(paint_paintable_document(this.paint_paintable())) else trap("the document has no paintable")

## `point.to_type<float>() * pixel_ratio`.
func paint_css_point_to_device_float(point: gfx.CssPixelPoint, pixel_ratio: f32) -> gfx.FloatPoint:
    return gfx.FloatPoint(m_x = point.m_x.to_float() * pixel_ratio, m_y = point.m_y.to_float() * pixel_ratio)

## `(point / pixel_ratio).to_type<CSSPixels>()`.
func paint_device_float_to_css_point(point: gfx.FloatPoint, pixel_ratio: f32) -> gfx.CssPixelPoint:
    return gfx.CssPixelPoint(gfx.CssPixels.from_f32(point.m_x / pixel_ratio), gfx.CssPixels.from_f32(point.m_y / pixel_ratio))

## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:937 Web::Painting::PaintableBox::transform_point_to_local.
pub func paint_paintable_box_transform_point_to_local(this: PaintPaintableBox*, screen_position: gfx.CssPixelPoint) -> gfx.CssPixelPoint?:
    if this.m_accumulated_visual_context_index == 0:
        return screen_position
    let pixel_ratio = paint_paintable_box_pixel_ratio(this)
    let viewport_paintable = paint_paintable_box_viewport_paintable(this)
    let scroll_state = paint_viewport_paintable_scroll_state_snapshot(viewport_paintable)
    let visual_context_tree = paint_viewport_paintable_visual_context_tree(viewport_paintable)
    let result = display_list.accumulated_visual_context_tree_transform_point_for_hit_test(visual_context_tree, this.m_accumulated_visual_context_index, paint_css_point_to_device_float(screen_position, pixel_ratio), &scroll_state) else return none
    return paint_device_float_to_css_point(result, pixel_ratio)

## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:950 Web::Painting::PaintableBox::transform_point_to_local_for_descendants.
pub func paint_paintable_box_transform_point_to_local_for_descendants(this: PaintPaintableBox*, screen_position: gfx.CssPixelPoint) -> gfx.CssPixelPoint?:
    if this.m_accumulated_visual_context_for_descendants_index == 0:
        return screen_position
    let pixel_ratio = paint_paintable_box_pixel_ratio(this)
    let viewport_paintable = paint_paintable_box_viewport_paintable(this)
    let scroll_state = paint_viewport_paintable_scroll_state_snapshot(viewport_paintable)
    let visual_context_tree = paint_viewport_paintable_visual_context_tree(viewport_paintable)
    let result = display_list.accumulated_visual_context_tree_transform_point_for_hit_test(visual_context_tree, this.m_accumulated_visual_context_for_descendants_index, paint_css_point_to_device_float(screen_position, pixel_ratio), &scroll_state) else return none
    return paint_device_float_to_css_point(result, pixel_ratio)

## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:963 Web::Painting::PaintableBox::transform_rect_to_viewport.
pub func paint_paintable_box_transform_rect_to_viewport(this: PaintPaintableBox*, rect: gfx.CssPixelRect) -> gfx.CssPixelRect:
    if this.m_accumulated_visual_context_index == 0:
        return rect
    let pixel_ratio = paint_paintable_box_pixel_ratio(this)
    let viewport_paintable = paint_paintable_box_viewport_paintable(this)
    let scroll_state = paint_viewport_paintable_scroll_state_snapshot(viewport_paintable)
    let visual_context_tree = paint_viewport_paintable_visual_context_tree(viewport_paintable)
    let float_rect = gfx.css_pixel_rect_to_type_f32(&rect)
    let device_rect = gfx.float_rect_mul(&float_rect, pixel_ratio)
    let result = display_list.accumulated_visual_context_tree_transform_rect_to_viewport(visual_context_tree, this.m_accumulated_visual_context_index, device_rect, &scroll_state)
    let css_rect = gfx.float_rect_mul(&result, 1.0 / pixel_ratio)
    return gfx.float_rect_to_type_css_pixels(&css_rect)

## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:974 Web::Painting::PaintableBox::inverse_transform_point.
pub func paint_paintable_box_inverse_transform_point(this: PaintPaintableBox*, screen_position: gfx.CssPixelPoint) -> gfx.CssPixelPoint:
    if this.m_accumulated_visual_context_index == 0:
        return screen_position
    let pixel_ratio = paint_paintable_box_pixel_ratio(this)
    let visual_context_tree = paint_viewport_paintable_visual_context_tree(paint_paintable_box_viewport_paintable(this))
    let result = display_list.accumulated_visual_context_tree_inverse_transform_point(visual_context_tree, this.m_accumulated_visual_context_index, paint_css_point_to_device_float(screen_position, pixel_ratio))
    return paint_device_float_to_css_point(result, pixel_ratio)

## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:984 Web::Painting::PaintableBox::transform_to_local_coordinates.
pub func paint_paintable_box_transform_to_local_coordinates(this: PaintPaintableBox*, screen_position: gfx.CssPixelPoint) -> gfx.CssPixelPoint:
    return paint_paintable_box_transform_point_to_local(this, screen_position) else screen_position