Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / web / painting / table_borders_painting.lucb

#==============================================================================================
#
#   table_borders_painting - Painting::TableBordersPainting: table cell borders in the
#   collapsing and separated border models
#
#   DESCRIPTION:
#       Port of Libraries/LibWeb/Painting/TableBordersPainting.cpp (lines 1-449): the cells of a
#       table snapped to device pixel grid lines, the edges each cell contributes (right and down
#       neighbours, the table's first and last rows and columns), sorted at intersections the way
#       other browsers resolve them and painted, then the cells with border radii. A table with
#       separated borders paints each cell's own borders.
#
#       Copyright (c) 2023, the SerenityOS developers.
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: Cells =====================================================================================

## Ported from Libraries/LibWeb/Painting/TableBordersPainting.cpp:19 CellCoordinates::operator==.
pub func cell_coordinates_eq(this: const CellCoordinates*, other: CellCoordinates) -> bool:
    return this.row_index == other.row_index and this.column_index == other.column_index

## Ported from Libraries/LibWeb/Painting/TableBordersPainting.cpp:36 Web::Painting::collect_cell_boxes.
func paint_collect_cell_boxes(cell_boxes: ak.Vector[PaintPaintableBox*]*, table_paintable: PaintPaintableBox*):
    for child in paint_paintable_children(table_paintable.paint_paintable()):
        let child_box = as_if_paint_paintable_box(child) else continue
        let display = paint_paintable_display(child)
        if css_display_is_table_cell(&display):
            ak.vector_append_t(cell_boxes, child_box)
        else:
            paint_collect_cell_boxes(cell_boxes, child_box)

## Ported from Libraries/LibWeb/Painting/TableBordersPainting.cpp:79 Web::Painting::row_index_for_element_kind.
func paint_row_index_for_element_kind(index: usize, element_kind: PaintPaintableBoxConflictingElementKind) -> u64?:
    match element_kind:
        .cell, .row, .row_group:
            return (u64)index
        _:
            return none

## Ported from Libraries/LibWeb/Painting/TableBordersPainting.cpp:92 Web::Painting::column_index_for_element_kind.
func paint_column_index_for_element_kind(index: usize, element_kind: PaintPaintableBoxConflictingElementKind) -> u64?:
    match element_kind:
        .cell, .column, .column_group:
            return (u64)index
        _:
            return none

## Ported from Libraries/LibWeb/Painting/TableBordersPainting.cpp:105 Web::Painting::half_ceil.
func paint_half_ceil(width: i32) -> i32:
    return (i32)math.ceil((f64)width / 2.0)

## Ported from Libraries/LibWeb/Painting/TableBordersPainting.cpp:110 Web::Painting::half_floor.
func paint_half_floor(width: i32) -> i32:
    return (i32)math.floor((f64)width / 2.0)

## `DevicePixelRect { x, y, width, height }`.
func paint_table_device_rect(x: i32, y: i32, width: i32, height: i32) -> gfx.DevicePixelRect:
    var rect: gfx.DevicePixelRect = ---
    gfx.device_pixel_rect_construct_i32(&rect, x, y, width, height)
    return rect

# mark: Edges =====================================================================================

## Ported from Libraries/LibWeb/Painting/TableBordersPainting.cpp:115 Web::Painting::make_right_cell_edge.
func paint_make_right_cell_edge(right_cell_rect: gfx.DevicePixelRect, cell_rect: gfx.DevicePixelRect, borders_data: PaintDeviceBordersDataWithElementKind, coordinates: CellCoordinates) -> PaintBorderEdgePaintingInfo:
    let connect_top_offset = paint_half_ceil(borders_data.top.border_data.width)
    let connect_excess_height = connect_top_offset + paint_half_floor(borders_data.bottom.border_data.width)
    let right_border_rect = paint_table_device_rect(
        gfx.device_pixel_rect_x(&right_cell_rect) - paint_half_ceil(borders_data.right.border_data.width),
        gfx.device_pixel_rect_y(&cell_rect) - connect_top_offset,
        borders_data.right.border_data.width,
        ak.max(gfx.device_pixel_rect_height(&cell_rect), gfx.device_pixel_rect_height(&right_cell_rect)) + connect_excess_height)
    return PaintBorderEdgePaintingInfo(rect = right_border_rect,
                                       border_data_with_element_kind = borders_data.right,
                                       direction = PaintEdgeDirection.vertical,
                                       row = paint_row_index_for_element_kind(coordinates.row_index, borders_data.right.element_kind),
                                       column = paint_column_index_for_element_kind(coordinates.column_index, borders_data.right.element_kind))

## Ported from Libraries/LibWeb/Painting/TableBordersPainting.cpp:138 Web::Painting::make_down_cell_edge.
func paint_make_down_cell_edge(down_cell_rect: gfx.DevicePixelRect, cell_rect: gfx.DevicePixelRect, borders_data: PaintDeviceBordersDataWithElementKind, coordinates: CellCoordinates) -> PaintBorderEdgePaintingInfo:
    let connect_left_offset = paint_half_ceil(borders_data.left.border_data.width)
    let connect_excess_width = connect_left_offset + paint_half_floor(borders_data.right.border_data.width)
    let down_border_rect = paint_table_device_rect(
        gfx.device_pixel_rect_x(&cell_rect) - connect_left_offset,
        gfx.device_pixel_rect_y(&down_cell_rect) - paint_half_ceil(borders_data.bottom.border_data.width),
        ak.max(gfx.device_pixel_rect_width(&cell_rect), gfx.device_pixel_rect_width(&down_cell_rect)) + connect_excess_width,
        borders_data.bottom.border_data.width)
    return PaintBorderEdgePaintingInfo(rect = down_border_rect,
                                       border_data_with_element_kind = borders_data.bottom,
                                       direction = PaintEdgeDirection.horizontal,
                                       row = paint_row_index_for_element_kind(coordinates.row_index, borders_data.bottom.element_kind),
                                       column = paint_column_index_for_element_kind(coordinates.column_index, borders_data.bottom.element_kind))

## Ported from Libraries/LibWeb/Painting/TableBordersPainting.cpp:161 Web::Painting::make_first_row_top_cell_edge.
func paint_make_first_row_top_cell_edge(cell_rect: gfx.DevicePixelRect, borders_data: PaintDeviceBordersDataWithElementKind, coordinates: CellCoordinates) -> PaintBorderEdgePaintingInfo:
    let connect_left_offset = paint_half_ceil(borders_data.left.border_data.width)
    let connect_excess_width = connect_left_offset + paint_half_floor(borders_data.right.border_data.width)
    let top_border_rect = paint_table_device_rect(
        gfx.device_pixel_rect_x(&cell_rect) - connect_left_offset,
        gfx.device_pixel_rect_y(&cell_rect) - paint_half_ceil(borders_data.top.border_data.width),
        gfx.device_pixel_rect_width(&cell_rect) + connect_excess_width,
        borders_data.top.border_data.width)
    return PaintBorderEdgePaintingInfo(rect = top_border_rect,
                                       border_data_with_element_kind = borders_data.top,
                                       direction = PaintEdgeDirection.horizontal,
                                       row = paint_row_index_for_element_kind(coordinates.row_index, borders_data.top.element_kind),
                                       column = paint_column_index_for_element_kind(coordinates.column_index, borders_data.top.element_kind))

## Ported from Libraries/LibWeb/Painting/TableBordersPainting.cpp:180 Web::Painting::make_last_row_bottom_cell_edge.
func paint_make_last_row_bottom_cell_edge(cell_rect: gfx.DevicePixelRect, borders_data: PaintDeviceBordersDataWithElementKind, coordinates: CellCoordinates) -> PaintBorderEdgePaintingInfo:
    let connect_left_offset = paint_half_ceil(borders_data.left.border_data.width)
    let connect_excess_width = connect_left_offset + paint_half_floor(borders_data.right.border_data.width)
    let bottom_border_rect = paint_table_device_rect(
        gfx.device_pixel_rect_x(&cell_rect) - connect_left_offset,
        gfx.device_pixel_rect_y(&cell_rect) + gfx.device_pixel_rect_height(&cell_rect) - paint_half_ceil(borders_data.bottom.border_data.width),
        gfx.device_pixel_rect_width(&cell_rect) + connect_excess_width,
        borders_data.bottom.border_data.width)
    return PaintBorderEdgePaintingInfo(rect = bottom_border_rect,
                                       border_data_with_element_kind = borders_data.bottom,
                                       direction = PaintEdgeDirection.horizontal,
                                       row = paint_row_index_for_element_kind(coordinates.row_index, borders_data.bottom.element_kind),
                                       column = paint_column_index_for_element_kind(coordinates.column_index, borders_data.bottom.element_kind))

## Ported from Libraries/LibWeb/Painting/TableBordersPainting.cpp:199 Web::Painting::make_first_column_left_cell_edge.
func paint_make_first_column_left_cell_edge(cell_rect: gfx.DevicePixelRect, borders_data: PaintDeviceBordersDataWithElementKind, coordinates: CellCoordinates) -> PaintBorderEdgePaintingInfo:
    let connect_top_offset = paint_half_ceil(borders_data.top.border_data.width)
    let connect_excess_height = connect_top_offset + paint_half_floor(borders_data.bottom.border_data.width)
    let left_border_rect = paint_table_device_rect(
        gfx.device_pixel_rect_x(&cell_rect) - paint_half_ceil(borders_data.left.border_data.width),
        gfx.device_pixel_rect_y(&cell_rect) - connect_top_offset,
        borders_data.left.border_data.width,
        gfx.device_pixel_rect_height(&cell_rect) + connect_excess_height)
    return PaintBorderEdgePaintingInfo(rect = left_border_rect,
                                       border_data_with_element_kind = borders_data.left,
                                       direction = PaintEdgeDirection.vertical,
                                       row = paint_row_index_for_element_kind(coordinates.row_index, borders_data.left.element_kind),
                                       column = paint_column_index_for_element_kind(coordinates.column_index, borders_data.left.element_kind))

## Ported from Libraries/LibWeb/Painting/TableBordersPainting.cpp:218 Web::Painting::make_last_column_right_cell_edge.
func paint_make_last_column_right_cell_edge(cell_rect: gfx.DevicePixelRect, borders_data: PaintDeviceBordersDataWithElementKind, coordinates: CellCoordinates) -> PaintBorderEdgePaintingInfo:
    let connect_top_offset = paint_half_ceil(borders_data.top.border_data.width)
    let connect_excess_height = connect_top_offset + paint_half_floor(borders_data.bottom.border_data.width)
    let right_border_rect = paint_table_device_rect(
        gfx.device_pixel_rect_x(&cell_rect) + gfx.device_pixel_rect_width(&cell_rect) - paint_half_ceil(borders_data.right.border_data.width),
        gfx.device_pixel_rect_y(&cell_rect) - connect_top_offset,
        borders_data.right.border_data.width,
        gfx.device_pixel_rect_height(&cell_rect) + connect_excess_height)
    return PaintBorderEdgePaintingInfo(rect = right_border_rect,
                                       border_data_with_element_kind = borders_data.right,
                                       direction = PaintEdgeDirection.vertical,
                                       row = paint_row_index_for_element_kind(coordinates.row_index, borders_data.right.element_kind),
                                       column = paint_column_index_for_element_kind(coordinates.column_index, borders_data.right.element_kind))

## Ported from Libraries/LibWeb/Painting/TableBordersPainting.cpp:237 Web::Painting::css_border_data_from_device_border_data.
func paint_css_border_data_from_device_border_data(device_border_data: PaintDeviceBorderData) -> display_list.BorderData:
    return display_list.BorderData(color = device_border_data.color, line_style = device_border_data.line_style, width = gfx.CssPixels.from_int(device_border_data.width))

# mark: Painting the collected edges ==============================================================

## The comparator of paint_collected_edges' quick_sort.
func paint_collected_edges_less_than(context: void*?, a: const PaintBorderEdgePaintingInfo*, b: const PaintBorderEdgePaintingInfo*) -> bool:
    let a_border_data = a.border_data_with_element_kind.border_data
    let b_border_data = b.border_data_with_element_kind.border_data
    if a_border_data.line_style == b_border_data.line_style and a_border_data.width == b_border_data.width:
        if (i32)b.border_data_with_element_kind.element_kind < (i32)a.border_data_with_element_kind.element_kind:
            return true
        elif (i32)b.border_data_with_element_kind.element_kind > (i32)a.border_data_with_element_kind.element_kind:
            return false
        # Here the element kind is the same, thus the coordinates are either both set or not set.
        assert((a.column != none) == (b.column != none))
        assert((a.row != none) == (b.row != none))
        if let a_column = a.column:
            let b_column = b.column else trap("VERIFY: both columns are set")
            if b_column < a_column:
                return true
            elif b_column > a_column:
                return false
        if let a_row = a.row:
            let b_row = b.row else trap("VERIFY: both rows are set")
            return b_row < a_row
        return false
    return layout_table_formatting_context_border_is_less_specific(
        paint_css_border_data_from_device_border_data(a_border_data),
        paint_css_border_data_from_device_border_data(b_border_data))

## Ported from Libraries/LibWeb/Painting/TableBordersPainting.cpp:246 Web::Painting::paint_collected_edges.
func paint_paint_collected_edges(context: DisplayListRecordingContext*, border_edge_painting_info_list: ak.Vector[PaintBorderEdgePaintingInfo]*):
    # This sorting step isn't part of the specification, but it matches the behavior of other browsers at border intersections, which aren't
    # part of border conflict resolution in the specification but it's still desirable to handle them in a way which is consistent with it.
    # See https://www.w3.org/TR/CSS22/tables.html#border-conflict-resolution for reference.
    ak.quick_sort_t_collection_t_less_than(ak.vector_span(border_edge_painting_info_list), ak.Function2[const PaintBorderEdgePaintingInfo*, const PaintBorderEdgePaintingInfo*, bool](call = paint_collected_edges_less_than, context = none))

    for border_edge_painting_info in ak.vector_span(border_edge_painting_info_list):
        let border_data_with_element_kind = border_edge_painting_info.border_data_with_element_kind
        let width = border_data_with_element_kind.border_data.width
        if width <= 0:
            continue
        let color = border_data_with_element_kind.border_data.color
        let border_style = border_data_with_element_kind.border_data.line_style
        let p1 = gfx.device_pixel_rect_top_left(&border_edge_painting_info.rect)
        let p2 = gfx.device_pixel_rect_top_right(&border_edge_painting_info.rect) if border_edge_painting_info.direction == PaintEdgeDirection.horizontal else gfx.device_pixel_rect_bottom_left(&border_edge_painting_info.rect)

        if border_style == css_data.LineStyle.dotted:
            display_list.display_list_recorder_draw_line(display_list_recording_context_display_list_recorder(context), p1, p2, color, width, gfx.LineStyle.dotted)
        elif border_style == css_data.LineStyle.dashed:
            display_list.display_list_recorder_draw_line(display_list_recording_context_display_list_recorder(context), p1, p2, color, width, gfx.LineStyle.dashed)
        else:
            # FIXME: Support the remaining line styles instead of rendering them as solid.
            var rect: gfx.DevicePixelRect = ---
            gfx.device_pixel_rect_construct_int_point(&rect, gfx.device_pixel_rect_location(&border_edge_painting_info.rect), gfx.device_pixel_rect_size(&border_edge_painting_info.rect))
            display_list.display_list_recorder_fill_rect(display_list_recording_context_display_list_recorder(context), rect, color)

# mark: Snapping cells and their borders ==========================================================

## Ported from Libraries/LibWeb/Painting/TableBordersPainting.cpp:300 Web::Painting::snap_cells_to_device_coordinates.
func paint_snap_cells_to_device_coordinates(cell_coordinates_to_box: const ak.HashMap[CellCoordinates, PaintPaintableBox*, CellCoordinatesTraits]*, row_count: usize, column_count: usize, context: const DisplayListRecordingContext*) -> ak.HashMap[CellCoordinates, gfx.DevicePixelRect, CellCoordinatesTraits]:
    var y_line_start_coordinates = ak.Vector[i32]()
    var y_line_end_coordinates = ak.Vector[i32]()
    ak.vector_resize(&y_line_start_coordinates, row_count + 1)
    ak.vector_resize(&y_line_end_coordinates, row_count + 1)
    var x_line_start_coordinates = ak.Vector[i32]()
    var x_line_end_coordinates = ak.Vector[i32]()
    ak.vector_resize(&x_line_start_coordinates, column_count + 1)
    ak.vector_resize(&x_line_end_coordinates, column_count + 1)
    for kv in ak.hash_map_begin_const(cell_coordinates_to_box):
        let cell_box = kv.value
        let coordinates = paint_paintable_box_table_cell_coordinates(cell_box) else trap("VERIFY: a table cell has coordinates")
        let start_row_index = coordinates.row_index
        let end_row_index = start_row_index + coordinates.row_span
        let cell_rect = paint_paintable_box_absolute_border_box_rect(cell_box)
        *ak.vector_at(&y_line_start_coordinates, start_row_index) = ak.max(display_list_recording_context_rounded_device_pixels(context, gfx.css_pixel_rect_y(&cell_rect)), *ak.vector_at(&y_line_start_coordinates, start_row_index))
        *ak.vector_at(&y_line_end_coordinates, end_row_index) = ak.max(display_list_recording_context_rounded_device_pixels(context, gfx.css_pixel_rect_y(&cell_rect).add(gfx.css_pixel_rect_height(&cell_rect))), *ak.vector_at(&y_line_end_coordinates, end_row_index))
        let start_column_index = coordinates.column_index
        let end_column_index = start_column_index + coordinates.column_span
        *ak.vector_at(&x_line_start_coordinates, start_column_index) = ak.max(display_list_recording_context_rounded_device_pixels(context, gfx.css_pixel_rect_x(&cell_rect)), *ak.vector_at(&x_line_start_coordinates, start_column_index))
        *ak.vector_at(&x_line_end_coordinates, end_column_index) = ak.max(display_list_recording_context_rounded_device_pixels(context, gfx.css_pixel_rect_x(&cell_rect).add(gfx.css_pixel_rect_width(&cell_rect))), *ak.vector_at(&x_line_end_coordinates, end_column_index))
    var cell_coordinates_to_device_rect = ak.HashMap[CellCoordinates, gfx.DevicePixelRect, CellCoordinatesTraits]()
    for kv in ak.hash_map_begin_const(cell_coordinates_to_box):
        let cell_box = kv.value
        let coordinates = paint_paintable_box_table_cell_coordinates(cell_box) else trap("VERIFY: a table cell has coordinates")
        let start_row_index = coordinates.row_index
        let end_row_index = start_row_index + coordinates.row_span
        let height = *ak.vector_at(&y_line_end_coordinates, end_row_index) - *ak.vector_at(&y_line_start_coordinates, start_row_index)
        let start_column_index = coordinates.column_index
        let end_column_index = start_column_index + coordinates.column_span
        let width = *ak.vector_at(&x_line_end_coordinates, end_column_index) - *ak.vector_at(&x_line_start_coordinates, start_column_index)
        _ = ak.hash_map_set(&cell_coordinates_to_device_rect, kv.key, paint_table_device_rect(*ak.vector_at(&x_line_start_coordinates, start_column_index), *ak.vector_at(&y_line_start_coordinates, start_row_index), width, height))
    return cell_coordinates_to_device_rect

## Ported from Libraries/LibWeb/Painting/TableBordersPainting.cpp:336 Web::Painting::device_border_data_from_css_border_data.
func paint_device_border_data_from_css_border_data(border_data_with_element_kind: PaintPaintableBoxBorderDataWithElementKind, context: const DisplayListRecordingContext*) -> PaintDeviceBorderDataWithElementKind:
    return PaintDeviceBorderDataWithElementKind(
        border_data = PaintDeviceBorderData(
            color = border_data_with_element_kind.border_data.color,
            line_style = border_data_with_element_kind.border_data.line_style,
            width = display_list_recording_context_rounded_device_pixels(context, border_data_with_element_kind.border_data.width)),
        element_kind = border_data_with_element_kind.element_kind)

## `cell_box.box_model().border.<edge> == 0 ? CSS::BorderData() : cell_box.computed_values().border_<edge>()` for the four edges.
func paint_table_cell_borders_data(cell_box: PaintPaintableBox*) -> display_list.BordersData:
    let border = paint_paintable_box_box_model(cell_box).border
    let computed_values = &paint_paintable_computed_values(cell_box.paint_paintable()).computed_values
    var none_border = display_list.BorderData()
    display_list.border_data_init_fields(&none_border)
    return display_list.BordersData(
        top = none_border if gfx.eq_css_pixels_int(border.top, 0) else css_computed_values_border_top(computed_values),
        right = none_border if gfx.eq_css_pixels_int(border.right, 0) else css_computed_values_border_right(computed_values),
        bottom = none_border if gfx.eq_css_pixels_int(border.bottom, 0) else css_computed_values_border_bottom(computed_values),
        left = none_border if gfx.eq_css_pixels_int(border.left, 0) else css_computed_values_border_left(computed_values))

## A cell's borders: its override borders data without the element kinds, or its own borders.
func paint_table_cell_borders_data_or_override(cell_box: PaintPaintableBox*) -> display_list.BordersData:
    if let override_borders_data = paint_paintable_box_override_borders_data(cell_box):
        return paint_paintable_box_remove_element_kind_from_borders_data(override_borders_data)
    return paint_table_cell_borders_data(cell_box)

## Ported from Libraries/LibWeb/Painting/TableBordersPainting.cpp:348 Web::Painting::paint_separate_cell_borders.
func paint_paint_separate_cell_borders(cell_box: PaintPaintableBox*, cell_coordinates_to_device_rect: const ak.HashMap[CellCoordinates, gfx.DevicePixelRect, CellCoordinatesTraits]*, context: DisplayListRecordingContext*):
    let borders_data = paint_table_cell_borders_data_or_override(cell_box)
    let coordinates = paint_paintable_box_table_cell_coordinates(cell_box) else trap("VERIFY: a table cell has coordinates")
    let cell_rect = *(ak.hash_map_get_k_const(cell_coordinates_to_device_rect, CellCoordinates(row_index = coordinates.row_index, column_index = coordinates.column_index)) else trap("VERIFY: the cell has a device rect"))
    let radii = paint_paintable_box_normalized_border_radii_data(cell_box)
    paint_paint_all_borders(display_list_recording_context_display_list_recorder(context), cell_rect, border_radii_data_as_corners(&radii, display_list_recording_context_device_pixel_converter(context)), borders_data_to_device_pixels(&borders_data, *context))

# mark: paint_table_borders =======================================================================

## Ported from Libraries/LibWeb/Painting/TableBordersPainting.cpp:360 Web::Painting::paint_table_borders.
pub func paint_paint_table_borders(context: DisplayListRecordingContext*, table_paintable: PaintPaintableBox*):
    # Partial implementation of painting according to the collapsing border model:
    # https://www.w3.org/TR/CSS22/tables.html#collapsing-borders
    var cell_boxes = ak.Vector[PaintPaintableBox*]()
    paint_collect_cell_boxes(&cell_boxes, table_paintable)
    var border_edge_painting_info_list = ak.Vector[PaintBorderEdgePaintingInfo]()
    var cell_coordinates_to_box = ak.HashMap[CellCoordinates, PaintPaintableBox*, CellCoordinatesTraits]()
    var row_count: usize = 0
    var column_count: usize = 0
    for cell_box in ak.vector_span(&cell_boxes):
        let coordinates = paint_paintable_box_table_cell_coordinates(cell_box) else trap("VERIFY: a table cell has coordinates")
        _ = ak.hash_map_set(&cell_coordinates_to_box, CellCoordinates(row_index = coordinates.row_index, column_index = coordinates.column_index), cell_box)
        row_count = ak.max(row_count, coordinates.row_index + coordinates.row_span)
        column_count = ak.max(column_count, coordinates.column_index + coordinates.column_span)
    let cell_coordinates_to_device_rect = paint_snap_cells_to_device_coordinates(&cell_coordinates_to_box, row_count, column_count, context)
    let table_border_collapse = css_computed_values_border_collapse(&paint_paintable_computed_values(table_paintable.paint_paintable()).computed_values)
    for cell_box in ak.vector_span(&cell_boxes):
        if table_border_collapse == css_data.BorderCollapse.separate:
            if css_computed_values_empty_cells(&paint_paintable_computed_values(cell_box.paint_paintable()).computed_values) == css_data.EmptyCells.hide and not tree_node_has_children(cell_box.paint_paintable()):
                continue
            paint_paint_separate_cell_borders(cell_box, &cell_coordinates_to_device_rect, context)
            continue
        var css_borders_data: PaintPaintableBoxBordersDataWithElementKind = ---
        if let override_borders_data = paint_paintable_box_override_borders_data(cell_box):
            css_borders_data = override_borders_data
        else:
            let own = paint_table_cell_borders_data(cell_box)
            css_borders_data = PaintPaintableBoxBordersDataWithElementKind(
                top = PaintPaintableBoxBorderDataWithElementKind(border_data = own.top, element_kind = PaintPaintableBoxConflictingElementKind.cell),
                right = PaintPaintableBoxBorderDataWithElementKind(border_data = own.right, element_kind = PaintPaintableBoxConflictingElementKind.cell),
                bottom = PaintPaintableBoxBorderDataWithElementKind(border_data = own.bottom, element_kind = PaintPaintableBoxConflictingElementKind.cell),
                left = PaintPaintableBoxBorderDataWithElementKind(border_data = own.left, element_kind = PaintPaintableBoxConflictingElementKind.cell))
        let borders_data = PaintDeviceBordersDataWithElementKind(
            top = paint_device_border_data_from_css_border_data(css_borders_data.top, context),
            right = paint_device_border_data_from_css_border_data(css_borders_data.right, context),
            bottom = paint_device_border_data_from_css_border_data(css_borders_data.bottom, context),
            left = paint_device_border_data_from_css_border_data(css_borders_data.left, context))
        let coordinates = paint_paintable_box_table_cell_coordinates(cell_box) else trap("VERIFY: a table cell has coordinates")
        let cell_rect = *(ak.hash_map_get_k_const(&cell_coordinates_to_device_rect, CellCoordinates(row_index = coordinates.row_index, column_index = coordinates.column_index)) else trap("VERIFY: the cell has a device rect"))
        let right_cell_coordinates = CellCoordinates(row_index = coordinates.row_index, column_index = coordinates.column_index + coordinates.column_span)
        let maybe_right_cell = ak.hash_map_get_k_const(&cell_coordinates_to_device_rect, right_cell_coordinates)
        let down_cell_coordinates = CellCoordinates(row_index = coordinates.row_index + coordinates.row_span, column_index = coordinates.column_index)
        let maybe_down_cell = ak.hash_map_get_k_const(&cell_coordinates_to_device_rect, down_cell_coordinates)
        if let right_cell = maybe_right_cell:
            ak.vector_append_t(&border_edge_painting_info_list, paint_make_right_cell_edge(*right_cell, cell_rect, borders_data, right_cell_coordinates))
        if let down_cell = maybe_down_cell:
            ak.vector_append_t(&border_edge_painting_info_list, paint_make_down_cell_edge(*down_cell, cell_rect, borders_data, down_cell_coordinates))
        if coordinates.row_index == 0:
            ak.vector_append_t(&border_edge_painting_info_list, paint_make_first_row_top_cell_edge(cell_rect, borders_data, CellCoordinates(row_index = 0, column_index = coordinates.column_index)))
        if coordinates.row_index + coordinates.row_span == row_count:
            ak.vector_append_t(&border_edge_painting_info_list, paint_make_last_row_bottom_cell_edge(cell_rect, borders_data, CellCoordinates(row_index = row_count - 1, column_index = coordinates.column_index)))
        if coordinates.column_index == 0:
            ak.vector_append_t(&border_edge_painting_info_list, paint_make_first_column_left_cell_edge(cell_rect, borders_data, CellCoordinates(row_index = coordinates.row_index, column_index = 0)))
        if coordinates.column_index + coordinates.column_span == column_count:
            ak.vector_append_t(&border_edge_painting_info_list, paint_make_last_column_right_cell_edge(cell_rect, borders_data, CellCoordinates(row_index = coordinates.row_index, column_index = column_count - 1)))

    paint_paint_collected_edges(context, &border_edge_painting_info_list)

    for cell_box in ak.vector_span(&cell_boxes):
        let border_radii_data = paint_paintable_box_normalized_border_radii_data(cell_box)
        let converter = display_list_recording_context_device_pixel_converter(context)
        let top_left = border_radius_data_as_corner(&border_radii_data.top_left, converter)
        let top_right = border_radius_data_as_corner(&border_radii_data.top_right, converter)
        let bottom_right = border_radius_data_as_corner(&border_radii_data.bottom_right, converter)
        let bottom_left = border_radius_data_as_corner(&border_radii_data.bottom_left, converter)
        if not display_list.corner_radius_to_bool(&top_left) and not display_list.corner_radius_to_bool(&top_right) and not display_list.corner_radius_to_bool(&bottom_left) and not display_list.corner_radius_to_bool(&bottom_right):
            continue
        else:
            let borders_data = paint_table_cell_borders_data_or_override(cell_box)
            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(cell_box)), border_radii_data_as_corners(&border_radii_data, converter), borders_data_to_device_pixels(&borders_data, *context))