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))