Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / web / painting / border_painting_2.lucb

#==============================================================================================
#
#   border_painting_2 - Painting::BorderPainting: solid edges, all borders and outlines
#
#   DESCRIPTION:
#       Port of Libraries/LibWeb/Painting/BorderPainting.cpp (lines 251-694): the rest of
#       `paint_border` (its `draw_border` and `compute_midpoint` lambdas and the up to eight
#       points of each edge's shape, filled even-odd, joined with the next edge when it has the
#       same color), `paint_all_borders` and `borders_data_for_outline`.
#
#       Copyright (c) 2020, Andreas Kling <andreas@ladybird.org>
#       Copyright (c) 2021-2023, Sam Atkins <atkinssj@serenityos.org>
#       Copyright (c) 2022, MacDue <macdue@dueutil.tech>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: The shape of a solid edge =================================================================

## `Gfx::FloatPoint(point.to_type<int>())`.
func paint_border_float_point(point: gfx.IntPoint) -> gfx.FloatPoint:
    return gfx.FloatPoint(m_x = (f32)point.m_x, m_y = (f32)point.m_y)

## `a + b` of two Gfx::FloatPoints.
func paint_border_add(a: gfx.FloatPoint, b: gfx.FloatPoint) -> gfx.FloatPoint:
    return gfx.float_point_add(&a, b)

## `a - b` of two Gfx::FloatPoints.
func paint_border_sub(a: gfx.FloatPoint, b: gfx.FloatPoint) -> gfx.FloatPoint:
    return gfx.float_point_sub(&a, b)

## The `draw_border` lambda of paint_border: the edge's points as a closed path of lines and elliptical arcs, filled
## when `ready_to_draw` (otherwise the next edge, of the same color, is added to the same path first).
func paint_border_draw_border(painter: display_list.DisplayListRecorder*, path: gfx.Path*, color: gfx.Color, radius: display_list.CornerRadius, opposite_radius: display_list.CornerRadius, points: const ak.Vector[gfx.FloatPoint]*, joined_corner_has_inner_corner: bool, opposite_joined_corner_has_inner_corner: bool, joined_inner_corner_offset: gfx.FloatSize, opposite_joined_inner_corner_offset: gfx.FloatSize, ready_to_draw: bool):
    var current: usize = 0
    gfx.path_move_to(path, *ak.vector_at_const(points, current))
    current += 1
    gfx.path_elliptical_arc_to(path, *ak.vector_at_const(points, current), gfx.FloatSize(m_width = (f32)radius.horizontal_radius, m_height = (f32)radius.vertical_radius), 0.0, false, false)
    current += 1
    gfx.path_line_to(path, *ak.vector_at_const(points, current))
    current += 1
    if joined_corner_has_inner_corner:
        gfx.path_elliptical_arc_to(path, *ak.vector_at_const(points, current),
                                   gfx.FloatSize(m_width = (f32)radius.horizontal_radius - joined_inner_corner_offset.m_width, m_height = (f32)radius.vertical_radius - joined_inner_corner_offset.m_height),
                                   0.0, false, true)
        current += 1
    gfx.path_line_to(path, *ak.vector_at_const(points, current))
    current += 1
    if opposite_joined_corner_has_inner_corner:
        gfx.path_elliptical_arc_to(path, *ak.vector_at_const(points, current),
                                   gfx.FloatSize(m_width = (f32)opposite_radius.horizontal_radius - opposite_joined_inner_corner_offset.m_width, m_height = (f32)opposite_radius.vertical_radius - opposite_joined_inner_corner_offset.m_height),
                                   0.0, false, true)
        current += 1
    gfx.path_line_to(path, *ak.vector_at_const(points, current))
    current += 1
    gfx.path_elliptical_arc_to(path, *ak.vector_at_const(points, current), gfx.FloatSize(m_width = (f32)opposite_radius.horizontal_radius, m_height = (f32)opposite_radius.vertical_radius), 0.0, false, false)

    # If joined borders have the same color, combine them to draw together.
    if ready_to_draw:
        # The params copy the path (C++ copies a Gfx::Path by cloning it), then the path is cleared.
        display_list.display_list_recorder_fill_path(painter, display_list.DisplayListRecorderFillPathParams(path = gfx.path_clone(path), paint_style_or_color = display_list.PaintStyleOrColor.color(color), winding_rule = gfx.WindingRule.even_odd))
        gfx.path_clear(path)

## The `compute_midpoint` lambda of paint_border.
func paint_border_compute_midpoint(edge: display_list.BorderEdge, horizontal_radius: i32, vertical_radius: i32, joined_border_width: i32) -> gfx.FloatPoint:
    if horizontal_radius == 0 and vertical_radius == 0:
        return gfx.FloatPoint(m_x = 0.0, m_y = 0.0)
    if joined_border_width == 0:
        match edge:
            .top, .bottom:
                return gfx.FloatPoint(m_x = (f32)horizontal_radius, m_y = 0.0)
            .right, .left:
                return gfx.FloatPoint(m_x = 0.0, m_y = (f32)vertical_radius)
            _:
                trap("VERIFY_NOT_REACHED")
    # FIXME: this middle point rule seems not exactly the same as main browsers
    # compute the midpoint based on point whose tangent slope of 1
    # https://math.stackexchange.com/questions/3325134/find-the-points-on-the-ellipse-where-the-slope-of-the-tangent-line-is-1
    # AK::sqrt of a float (the double square root rounded to float is the float square root).
    let denominator = (f32)math.sqrt((f64)((f32)horizontal_radius * (f32)horizontal_radius + (f32)(vertical_radius * vertical_radius)))
    return gfx.FloatPoint(m_x = (f32)(horizontal_radius * horizontal_radius) / denominator,
                          m_y = (f32)(vertical_radius * vertical_radius) / denominator)

#   0 /-------------\ 7
#    / /-----------\ \
#   /-/ 3         4 \-\
#  1  2             5  6
# For each border edge, need to compute 8 points at most, then paint them as closed path.
# 8 points are the most complicated case, it happens when the joined border width is not 0 and border radius larger than border width on both side.
# If border radius is smaller than the border width, then the inner corner of the border corner is a right angle.

## The solid edge of paint_border (BorderPainting.cpp:251-585): the edge's points, then `draw_border`.
func paint_border_paint_solid_edge(painter: display_list.DisplayListRecorder*, edge: display_list.BorderEdge, rect: gfx.DevicePixelRect, radius: display_list.CornerRadius, opposite_radius: display_list.CornerRadius, borders_data: display_list.BordersDataDevicePixels, border_data: display_list.BorderDataDevicePixels, color: gfx.Color, path: gfx.Path*, last: bool):
    let width = border_data.width
    let top_left = paint_border_float_point(gfx.device_pixel_rect_top_left(&rect))
    let top_right = paint_border_float_point(gfx.device_pixel_rect_top_right(&rect))
    let bottom_left = paint_border_float_point(gfx.device_pixel_rect_bottom_left(&rect))
    let bottom_right = paint_border_float_point(gfx.device_pixel_rect_bottom_right(&rect))
    var points = ak.Vector[gfx.FloatPoint]()
    match edge:
        .top:
            let joined_border_width = borders_data.left.width
            let opposite_joined_border_width = borders_data.right.width
            let joined_corner_has_inner_corner = width < radius.vertical_radius and joined_border_width < radius.horizontal_radius
            let opposite_joined_corner_has_inner_corner = width < opposite_radius.vertical_radius and opposite_joined_border_width < opposite_radius.horizontal_radius

            let midpoint = paint_border_compute_midpoint(edge, radius.horizontal_radius, radius.vertical_radius, joined_border_width)
            let joined_corner_endpoint_offset = gfx.FloatPoint(m_x = -midpoint.m_x, m_y = (f32)radius.vertical_radius - midpoint.m_y)
            let opposite_midpoint = paint_border_compute_midpoint(edge, opposite_radius.horizontal_radius, opposite_radius.vertical_radius, opposite_joined_border_width)
            let opposite_joined_border_corner_offset = gfx.FloatPoint(m_x = opposite_midpoint.m_x, m_y = (f32)opposite_radius.vertical_radius - opposite_midpoint.m_y)

            ak.vector_append_t(&points, top_left)
            ak.vector_append_t(&points, paint_border_add(top_left, joined_corner_endpoint_offset))

            if joined_corner_has_inner_corner:
                let inner_midpoint = paint_border_compute_midpoint(edge, radius.horizontal_radius - joined_border_width, radius.vertical_radius - width, joined_border_width)
                let inner_corner_endpoint_offset = gfx.FloatPoint(m_x = -inner_midpoint.m_x, m_y = (f32)(radius.vertical_radius - width) - inner_midpoint.m_y)
                ak.vector_append_t(&points, paint_border_add(bottom_left, inner_corner_endpoint_offset))
                ak.vector_append_t(&points, bottom_left)
            else:
                let inner_right_angle_offset = gfx.FloatPoint(m_x = (f32)(joined_border_width - radius.horizontal_radius), m_y = 0.0)
                ak.vector_append_t(&points, paint_border_add(bottom_left, inner_right_angle_offset))

            if opposite_joined_corner_has_inner_corner:
                let inner_midpoint = paint_border_compute_midpoint(edge, opposite_radius.horizontal_radius - opposite_joined_border_width, opposite_radius.vertical_radius - width, opposite_joined_border_width)
                let inner_corner_endpoint_offset = gfx.FloatPoint(m_x = inner_midpoint.m_x, m_y = (f32)(opposite_radius.vertical_radius - width) - inner_midpoint.m_y)
                ak.vector_append_t(&points, bottom_right)
                ak.vector_append_t(&points, paint_border_add(bottom_right, inner_corner_endpoint_offset))
            else:
                let inner_right_angle_offset = gfx.FloatPoint(m_x = (f32)(opposite_joined_border_width - opposite_radius.horizontal_radius), m_y = 0.0)
                ak.vector_append_t(&points, paint_border_sub(bottom_right, inner_right_angle_offset))

            ak.vector_append_t(&points, paint_border_add(top_right, opposite_joined_border_corner_offset))
            ak.vector_append_t(&points, top_right)

            paint_border_draw_border(painter, path, color, radius, opposite_radius, &points,
                                     joined_corner_has_inner_corner,
                                     opposite_joined_corner_has_inner_corner,
                                     gfx.FloatSize(m_width = (f32)joined_border_width, m_height = (f32)width),
                                     gfx.FloatSize(m_width = (f32)opposite_joined_border_width, m_height = (f32)width),
                                     last or not gfx.color_eq(&color, paint_border_color(display_list.BorderEdge.right, borders_data)))
        .right:
            let joined_border_width = borders_data.top.width
            let opposite_joined_border_width = borders_data.bottom.width
            let joined_corner_has_inner_corner = width < radius.horizontal_radius and joined_border_width < radius.vertical_radius
            let opposite_joined_corner_has_inner_corner = width < opposite_radius.horizontal_radius and opposite_joined_border_width < opposite_radius.vertical_radius

            let midpoint = paint_border_compute_midpoint(edge, radius.horizontal_radius, radius.vertical_radius, joined_border_width)
            let joined_corner_endpoint_offset = gfx.FloatPoint(m_x = midpoint.m_x - (f32)radius.horizontal_radius, m_y = -midpoint.m_y)
            let opposite_midpoint = paint_border_compute_midpoint(edge, opposite_radius.horizontal_radius, opposite_radius.vertical_radius, opposite_joined_border_width)
            let opposite_joined_border_corner_offset = gfx.FloatPoint(m_x = opposite_midpoint.m_x - (f32)opposite_radius.horizontal_radius, m_y = opposite_midpoint.m_y)

            ak.vector_append_t(&points, top_right)
            ak.vector_append_t(&points, paint_border_add(top_right, joined_corner_endpoint_offset))

            if joined_corner_has_inner_corner:
                let inner_midpoint = paint_border_compute_midpoint(edge, radius.horizontal_radius - width, radius.vertical_radius - joined_border_width, joined_border_width)
                let inner_corner = gfx.FloatPoint(m_x = -(((f32)radius.horizontal_radius - inner_midpoint.m_x) - (f32)width), m_y = -inner_midpoint.m_y)
                ak.vector_append_t(&points, paint_border_add(top_left, inner_corner))
                ak.vector_append_t(&points, top_left)
            else:
                let inner_right_angle_offset = gfx.FloatPoint(m_x = 0.0, m_y = (f32)(joined_border_width - radius.horizontal_radius))
                ak.vector_append_t(&points, paint_border_add(top_left, inner_right_angle_offset))

            if opposite_joined_corner_has_inner_corner:
                let inner_midpoint = paint_border_compute_midpoint(edge, opposite_radius.horizontal_radius - width, opposite_radius.vertical_radius - opposite_joined_border_width, opposite_joined_border_width)
                let inner_corner = gfx.FloatPoint(m_x = -(((f32)opposite_radius.horizontal_radius - inner_midpoint.m_x) - (f32)width), m_y = inner_midpoint.m_y)
                ak.vector_append_t(&points, bottom_left)
                ak.vector_append_t(&points, paint_border_add(bottom_left, inner_corner))
            else:
                let inner_right_angle_offset = gfx.FloatPoint(m_x = 0.0, m_y = (f32)(opposite_joined_border_width - opposite_radius.horizontal_radius))
                ak.vector_append_t(&points, paint_border_sub(bottom_left, inner_right_angle_offset))

            ak.vector_append_t(&points, paint_border_add(bottom_right, opposite_joined_border_corner_offset))
            ak.vector_append_t(&points, bottom_right)

            paint_border_draw_border(painter, path, color, radius, opposite_radius, &points,
                                     joined_corner_has_inner_corner,
                                     opposite_joined_corner_has_inner_corner,
                                     gfx.FloatSize(m_width = (f32)width, m_height = (f32)joined_border_width),
                                     gfx.FloatSize(m_width = (f32)width, m_height = (f32)opposite_joined_border_width),
                                     last or not gfx.color_eq(&color, paint_border_color(display_list.BorderEdge.bottom, borders_data)))
        .bottom:
            let joined_border_width = borders_data.right.width
            let opposite_joined_border_width = borders_data.left.width
            let joined_corner_has_inner_corner = width < radius.vertical_radius and joined_border_width < radius.horizontal_radius
            let opposite_joined_corner_has_inner_corner = width < opposite_radius.vertical_radius and opposite_joined_border_width < opposite_radius.horizontal_radius

            let midpoint = paint_border_compute_midpoint(edge, radius.horizontal_radius, radius.vertical_radius, joined_border_width)
            let joined_corner_endpoint_offset = gfx.FloatPoint(m_x = midpoint.m_x, m_y = midpoint.m_y - (f32)radius.vertical_radius)
            let opposite_midpoint = paint_border_compute_midpoint(edge, opposite_radius.horizontal_radius, opposite_radius.vertical_radius, opposite_joined_border_width)
            let opposite_joined_border_corner_offset = gfx.FloatPoint(m_x = -opposite_midpoint.m_x, m_y = opposite_midpoint.m_y - (f32)opposite_radius.vertical_radius)

            ak.vector_append_t(&points, bottom_right)
            ak.vector_append_t(&points, paint_border_add(bottom_right, joined_corner_endpoint_offset))

            if joined_corner_has_inner_corner:
                let inner_midpoint = paint_border_compute_midpoint(edge, radius.horizontal_radius - joined_border_width, radius.vertical_radius - width, joined_border_width)
                let inner_corner = gfx.FloatPoint(m_x = inner_midpoint.m_x, m_y = -(((f32)radius.vertical_radius - inner_midpoint.m_y) - (f32)width))
                ak.vector_append_t(&points, paint_border_add(top_right, inner_corner))
                ak.vector_append_t(&points, top_right)
            else:
                let inner_right_angle_offset = gfx.FloatPoint(m_x = (f32)(joined_border_width - radius.horizontal_radius), m_y = 0.0)
                ak.vector_append_t(&points, paint_border_sub(top_right, inner_right_angle_offset))

            if opposite_joined_corner_has_inner_corner:
                let inner_midpoint = paint_border_compute_midpoint(edge, opposite_radius.horizontal_radius - opposite_joined_border_width, opposite_radius.vertical_radius - width, opposite_joined_border_width)
                let inner_corner = gfx.FloatPoint(m_x = -inner_midpoint.m_x, m_y = -(((f32)opposite_radius.vertical_radius - inner_midpoint.m_y) - (f32)width))
                ak.vector_append_t(&points, top_left)
                ak.vector_append_t(&points, paint_border_add(top_left, inner_corner))
            else:
                let inner_right_angle_offset = gfx.FloatPoint(m_x = (f32)(opposite_joined_border_width - opposite_radius.horizontal_radius), m_y = 0.0)
                ak.vector_append_t(&points, paint_border_add(top_left, inner_right_angle_offset))

            ak.vector_append_t(&points, paint_border_add(bottom_left, opposite_joined_border_corner_offset))
            ak.vector_append_t(&points, bottom_left)
            paint_border_draw_border(painter, path, color, radius, opposite_radius, &points,
                                     joined_corner_has_inner_corner,
                                     opposite_joined_corner_has_inner_corner,
                                     gfx.FloatSize(m_width = (f32)joined_border_width, m_height = (f32)width),
                                     gfx.FloatSize(m_width = (f32)opposite_joined_border_width, m_height = (f32)width),
                                     last or not gfx.color_eq(&color, paint_border_color(display_list.BorderEdge.left, borders_data)))
        .left:
            let joined_border_width = borders_data.bottom.width
            let opposite_joined_border_width = borders_data.top.width
            let joined_corner_has_inner_corner = width < radius.horizontal_radius and joined_border_width < radius.vertical_radius
            let opposite_joined_corner_has_inner_corner = width < opposite_radius.horizontal_radius and opposite_joined_border_width < opposite_radius.vertical_radius

            let midpoint = paint_border_compute_midpoint(edge, radius.horizontal_radius, radius.vertical_radius, joined_border_width)
            let joined_corner_endpoint_offset = gfx.FloatPoint(m_x = (f32)radius.horizontal_radius - midpoint.m_x, m_y = midpoint.m_y)
            let opposite_midpoint = paint_border_compute_midpoint(edge, opposite_radius.horizontal_radius, opposite_radius.vertical_radius, opposite_joined_border_width)
            let opposite_joined_border_corner_offset = gfx.FloatPoint(m_x = (f32)opposite_radius.horizontal_radius - opposite_midpoint.m_x, m_y = -opposite_midpoint.m_y)

            ak.vector_append_t(&points, bottom_left)
            ak.vector_append_t(&points, paint_border_add(bottom_left, joined_corner_endpoint_offset))

            if joined_corner_has_inner_corner:
                let inner_midpoint = paint_border_compute_midpoint(edge, radius.horizontal_radius - width, radius.vertical_radius - joined_border_width, joined_border_width)
                let inner_corner = gfx.FloatPoint(m_x = (f32)(radius.horizontal_radius - width) - inner_midpoint.m_x, m_y = inner_midpoint.m_y)
                ak.vector_append_t(&points, paint_border_add(bottom_right, inner_corner))
                ak.vector_append_t(&points, bottom_right)
            else:
                let inner_right_angle_offset = gfx.FloatPoint(m_x = 0.0, m_y = (f32)(joined_border_width - radius.vertical_radius))
                ak.vector_append_t(&points, paint_border_sub(bottom_right, inner_right_angle_offset))

            if opposite_joined_corner_has_inner_corner:
                let inner_midpoint = paint_border_compute_midpoint(edge, opposite_radius.horizontal_radius - width, opposite_radius.vertical_radius - opposite_joined_border_width, opposite_joined_border_width)
                let inner_corner = gfx.FloatPoint(m_x = (f32)(opposite_radius.horizontal_radius - width) - inner_midpoint.m_x, m_y = -inner_midpoint.m_y)
                ak.vector_append_t(&points, top_right)
                ak.vector_append_t(&points, paint_border_add(top_right, inner_corner))
            else:
                let inner_right_angle_offset = gfx.FloatPoint(m_x = 0.0, m_y = (f32)(opposite_joined_border_width - opposite_radius.vertical_radius))
                ak.vector_append_t(&points, paint_border_add(top_right, inner_right_angle_offset))
            ak.vector_append_t(&points, paint_border_add(top_left, opposite_joined_border_corner_offset))
            ak.vector_append_t(&points, top_left)

            paint_border_draw_border(painter, path, color, radius, opposite_radius, &points,
                                     joined_corner_has_inner_corner,
                                     opposite_joined_corner_has_inner_corner,
                                     gfx.FloatSize(m_width = (f32)width, m_height = (f32)joined_border_width),
                                     gfx.FloatSize(m_width = (f32)width, m_height = (f32)opposite_joined_border_width),
                                     last or not gfx.color_eq(&color, paint_border_color(display_list.BorderEdge.top, borders_data)))
        _:
            trap("VERIFY_NOT_REACHED")

# mark: All borders and outlines ==================================================================

## Ported from Libraries/LibWeb/Painting/BorderPainting.cpp:588 Web::Painting::paint_all_borders.
pub func paint_paint_all_borders(painter: display_list.DisplayListRecorder*, border_rect: gfx.DevicePixelRect, corner_radii: display_list.CornerRadii, borders_data: display_list.BordersDataDevicePixels):
    if borders_data.top.width <= 0 and borders_data.right.width <= 0 and borders_data.left.width <= 0 and borders_data.bottom.width <= 0:
        return

    var top_left = corner_radii.top_left
    var top_right = corner_radii.top_right
    var bottom_right = corner_radii.bottom_right
    var bottom_left = corner_radii.bottom_left

    # Disable border radii if the corresponding borders don't exist:
    if borders_data.bottom.width <= 0 and borders_data.left.width <= 0:
        bottom_left = display_list.CornerRadius(horizontal_radius = 0, vertical_radius = 0)
    if borders_data.bottom.width <= 0 and borders_data.right.width <= 0:
        bottom_right = display_list.CornerRadius(horizontal_radius = 0, vertical_radius = 0)
    if borders_data.top.width <= 0 and borders_data.left.width <= 0:
        top_left = display_list.CornerRadius(horizontal_radius = 0, vertical_radius = 0)
    if borders_data.top.width <= 0 and borders_data.right.width <= 0:
        top_right = display_list.CornerRadius(horizontal_radius = 0, vertical_radius = 0)

    let x = gfx.device_pixel_rect_x(&border_rect)
    let y = gfx.device_pixel_rect_y(&border_rect)
    let width = gfx.device_pixel_rect_width(&border_rect)
    let height = gfx.device_pixel_rect_height(&border_rect)
    var top_border_rect: gfx.DevicePixelRect = ---
    gfx.device_pixel_rect_construct_i32(&top_border_rect, x + top_left.horizontal_radius, y, width - top_left.horizontal_radius - top_right.horizontal_radius, borders_data.top.width)
    var right_border_rect: gfx.DevicePixelRect = ---
    gfx.device_pixel_rect_construct_i32(&right_border_rect, x + (width - borders_data.right.width), y + top_right.vertical_radius, borders_data.right.width, height - top_right.vertical_radius - bottom_right.vertical_radius)
    var bottom_border_rect: gfx.DevicePixelRect = ---
    gfx.device_pixel_rect_construct_i32(&bottom_border_rect, x + bottom_left.horizontal_radius, y + (height - borders_data.bottom.width), width - bottom_left.horizontal_radius - bottom_right.horizontal_radius, borders_data.bottom.width)
    var left_border_rect: gfx.DevicePixelRect = ---
    gfx.device_pixel_rect_construct_i32(&left_border_rect, x, y + top_left.vertical_radius, borders_data.left.width, height - top_left.vertical_radius - bottom_left.vertical_radius)

    # AK::CircularQueue<BorderEdge, 4>: always full here, so it is the four edges and the index of the first.
    let edges: display_list.BorderEdge[4] = [display_list.BorderEdge.top, display_list.BorderEdge.right, display_list.BorderEdge.bottom, display_list.BorderEdge.left]
    var head: usize = 0

    # Try to find the first border that has a different color than the previous one,
    # then start painting from that border.
    for i in 0..<4:
        _ = i
        let first_color = paint_border_color(edges[head], borders_data)
        if not gfx.color_eq(&first_color, paint_border_color(edges[(head + 1) % 4], borders_data)):
            head = (head + 1) % 4  # borders.enqueue(borders.dequeue())
            break

        head = (head + 1) % 4  # borders.enqueue(borders.dequeue())

    let last_edge = edges[(head + 3) % 4]
    var path = gfx.Path()
    for k in (usize)0..<4:
        let edge = edges[(head + k) % 4]
        match edge:
            .top:
                paint_paint_border(painter, display_list.BorderEdge.top, top_border_rect, top_left, top_right, borders_data, &path, edge == last_edge)
            .right:
                paint_paint_border(painter, display_list.BorderEdge.right, right_border_rect, top_right, bottom_right, borders_data, &path, edge == last_edge)
            .bottom:
                paint_paint_border(painter, display_list.BorderEdge.bottom, bottom_border_rect, bottom_right, bottom_left, borders_data, &path, edge == last_edge)
            .left:
                paint_paint_border(painter, display_list.BorderEdge.left, left_border_rect, bottom_left, top_left, borders_data, &path, edge == last_edge)
            _:
                trap("VERIFY_NOT_REACHED")

## Ported from Libraries/LibWeb/Painting/BorderPainting.cpp:671 Web::Painting::borders_data_for_outline.
pub func paint_borders_data_for_outline(layout_node: LayoutNode*, outline_color: gfx.Color, outline_style: css_data.OutlineStyle, outline_width: gfx.CssPixels) -> display_list.BordersData?:
    var color = outline_color
    var width = outline_width
    var line_style: css_data.LineStyle = ---
    if outline_style == css_data.OutlineStyle.auto:
        # `auto` lets us do whatever we want for the outline. 2px of the accent colour seems reasonable.
        line_style = css_data.LineStyle.solid
        let accent_color = css_keyword_style_value_create(css_data.Keyword.accentcolor).css_style_value()
        color = css_style_value_to_color(accent_color, css_color_resolution_context_for_layout_node_with_style((LayoutNodeWithStyle*)layout_node)) else trap("MUST: the accent color resolves")
        width = gfx.CssPixels.from_int(2)
    else:
        line_style = css_data.keyword_to_line_style(css_data.to_keyword_outline_style(outline_style)) else css_data.LineStyle.none_

    if gfx.color_alpha(&color) == 0 or line_style == css_data.LineStyle.none_ or gfx.eq_css_pixels_int(width, 0):
        return none

    let border_data = display_list.BorderData(color = color, line_style = line_style, width = width)
    return display_list.BordersData(top = border_data, right = border_data, bottom = border_data, left = border_data)