Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-render

Source of release 0.6.1

0.6.1 / src / display_list / border_radii_data.lucb

#==============================================================================================
#
#   border_radii_data - corner radii in CSS and device pixels
#
#   DESCRIPTION:
#       Port of Libraries/LibWeb/Painting/BorderRadiiData.h (lines 1-161) and
#       BorderRadiiData.cpp (lines 1-54): CornerRadius and CornerRadii (device pixels, with
#       the point-in-rounded-rect test and the box-shadow spread adjustment), BorderRadiusData
#       and BorderRadiiData (CSS pixels). The conversions to device pixels (`as_corner`,
#       `as_corners`) read a DevicePixelConverter and stay in the engine (DESIGN.md ยง4.1.3).
#
#       Copyright (c) 2020, Andreas Kling <andreas@ladybird.org>
#       Copyright (c) 2021-2023, Sam Atkins <atkinssj@serenityos.org>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: CornerRadius, BorderRadiusData =========================================================

## Ported from Libraries/LibWeb/Painting/BorderRadiiData.h:21 Web::Painting::CornerRadius::operator bool.
pub func corner_radius_to_bool(this: const CornerRadius*) -> bool:
    return this.horizontal_radius > 0 and this.vertical_radius > 0

## Ported from Libraries/LibWeb/Painting/BorderRadiiData.cpp:22 Web::Painting::add_spread_distance_to_border_radius.
# https://drafts.csswg.org/css-backgrounds/#shadow-shape
func add_spread_distance_to_border_radius(border_radius: i32*, spread_distance: i32):
    if *border_radius == 0 or spread_distance == 0:
        return

    # To preserve the box's shape when spread is applied, the corner radii of the shadow are also increased (decreased,
    # for inner shadows) from the border-box (padding-box) radii by adding (subtracting) the spread distance (and flooring
    # at zero). However, in order to create a sharper corner when the border radius is small (and thus ensure continuity
    # between round and sharp corners), when the border radius is less than the spread distance (or in the case of an inner
    # shadow, less than the absolute value of a negative spread distance), the spread distance is first multiplied by the
    # proportion 1 + (r-1)^3, where r is the ratio of the border radius to the spread distance, in calculating the corner
    # radii of the spread shadow shape.
    if *border_radius > ak.abs_i32(spread_distance):
        *border_radius += spread_distance
    else:
        let r = (f32)*border_radius / (f32)ak.abs_i32(spread_distance)
        # C++ `int += float`: the sum is computed in float and truncated back to int.
        *border_radius = (i32)((f32)*border_radius + (f32)spread_distance * (1.0 + ak.pow_f32(r - 1.0, 3.0)))

## Ported from Libraries/LibWeb/Painting/BorderRadiiData.h:33 Web::Painting::BorderRadiusData::operator bool.
pub func border_radius_data_to_bool(this: const BorderRadiusData*) -> bool:
    let zero = gfx.CssPixels(m_value = 0)
    return gfx.css_pixels_cmp(&this.horizontal_radius, zero) > 0 and gfx.css_pixels_cmp(&this.vertical_radius, zero) > 0

## Ported from Libraries/LibWeb/Painting/BorderRadiiData.h:38 Web::Painting::BorderRadiusData::shrink.
pub func border_radius_data_shrink(this: BorderRadiusData*, horizontal: gfx.CssPixels, vertical: gfx.CssPixels):
    let zero = gfx.CssPixels(m_value = 0)
    if gfx.css_pixels_cmp(&this.horizontal_radius, zero) != 0:
        this.horizontal_radius = css_pixels_max(zero, gfx.css_pixels_sub(&this.horizontal_radius, horizontal))
    if gfx.css_pixels_cmp(&this.vertical_radius, zero) != 0:
        this.vertical_radius = css_pixels_max(zero, gfx.css_pixels_sub(&this.vertical_radius, vertical))

## AK::max(a, b) for CSSPixels: `a < b ? b : a`.
func css_pixels_max(a: gfx.CssPixels, b: gfx.CssPixels) -> gfx.CssPixels:
    return b if gfx.css_pixels_cmp(&a, b) < 0 else a

# mark: CornerRadii ============================================================================

## Ported from Libraries/LibWeb/Painting/BorderRadiiData.h:53 Web::Painting::CornerRadii::has_any_radius.
pub func corner_radii_has_any_radius(this: const CornerRadii*) -> bool:
    return corner_radius_to_bool(&this.top_left) or corner_radius_to_bool(&this.top_right) or corner_radius_to_bool(&this.bottom_right) or corner_radius_to_bool(&this.bottom_left)

## Ported from Libraries/LibWeb/Painting/BorderRadiiData.cpp:42 Web::Painting::CornerRadii::adjust_corners_for_spread_distance.
pub func corner_radii_adjust_corners_for_spread_distance(this: CornerRadii*, spread_distance: i32):
    add_spread_distance_to_border_radius(&this.top_left.horizontal_radius, spread_distance)
    add_spread_distance_to_border_radius(&this.top_left.vertical_radius, spread_distance)
    add_spread_distance_to_border_radius(&this.top_right.horizontal_radius, spread_distance)
    add_spread_distance_to_border_radius(&this.top_right.vertical_radius, spread_distance)
    add_spread_distance_to_border_radius(&this.bottom_right.horizontal_radius, spread_distance)
    add_spread_distance_to_border_radius(&this.bottom_right.vertical_radius, spread_distance)
    add_spread_distance_to_border_radius(&this.bottom_left.horizontal_radius, spread_distance)
    add_spread_distance_to_border_radius(&this.bottom_left.vertical_radius, spread_distance)

## The C++ `outside_ellipse` lambda of CornerRadii::contains: whether (px, py) lies outside
## the ellipse of radii `r` centred at (cx, cy).
func corner_radii_outside_ellipse(r: const CornerRadius*, px: i32, py: i32, cx: i32, cy: i32) -> bool:
    let dx = (f32)(px - cx) / (f32)r.horizontal_radius
    let dy = (f32)(py - cy) / (f32)r.vertical_radius
    return dx * dx + dy * dy > 1.0

## Ported from Libraries/LibWeb/Painting/BorderRadiiData.h:60 Web::Painting::CornerRadii::contains.
pub func corner_radii_contains(this: const CornerRadii*, point: gfx.IntPoint, rect: gfx.DevicePixelRect) -> bool:
    if not gfx.device_pixel_rect_contains_int_point(&rect, point):
        return false

    if not corner_radii_has_any_radius(this):
        return true

    let px = gfx.int_point_x(&point)
    let py = gfx.int_point_y(&point)

    if corner_radius_to_bool(&this.top_left):
        let cx = gfx.device_pixel_rect_left(&rect) + this.top_left.horizontal_radius
        let cy = gfx.device_pixel_rect_top(&rect) + this.top_left.vertical_radius
        if px < cx and py < cy and corner_radii_outside_ellipse(&this.top_left, px, py, cx, cy):
            return false

    if corner_radius_to_bool(&this.top_right):
        let cx = gfx.device_pixel_rect_right(&rect) - this.top_right.horizontal_radius
        let cy = gfx.device_pixel_rect_top(&rect) + this.top_right.vertical_radius
        if px > cx and py < cy and corner_radii_outside_ellipse(&this.top_right, px, py, cx, cy):
            return false

    if corner_radius_to_bool(&this.bottom_right):
        let cx = gfx.device_pixel_rect_right(&rect) - this.bottom_right.horizontal_radius
        let cy = gfx.device_pixel_rect_bottom(&rect) - this.bottom_right.vertical_radius
        if px > cx and py > cy and corner_radii_outside_ellipse(&this.bottom_right, px, py, cx, cy):
            return false

    if corner_radius_to_bool(&this.bottom_left):
        let cx = gfx.device_pixel_rect_left(&rect) + this.bottom_left.horizontal_radius
        let cy = gfx.device_pixel_rect_bottom(&rect) - this.bottom_left.vertical_radius
        if px < cx and py > cy and corner_radii_outside_ellipse(&this.bottom_left, px, py, cx, cy):
            return false

    return true

# mark: BorderRadiiData ========================================================================

## Ported from Libraries/LibWeb/Painting/BorderRadiiData.h:115 Web::Painting::BorderRadiiData::has_any_radius.
pub func border_radii_data_has_any_radius(this: const BorderRadiiData*) -> bool:
    return border_radius_data_to_bool(&this.top_left) or border_radius_data_to_bool(&this.top_right) or border_radius_data_to_bool(&this.bottom_right) or border_radius_data_to_bool(&this.bottom_left)

## The C++ `to_corner` lambda of BorderRadiiData::contains.
func border_radius_data_to_corner(r: const BorderRadiusData*) -> CornerRadius:
    return CornerRadius(horizontal_radius = (i32)gfx.css_pixels_to_float_const(&r.horizontal_radius), vertical_radius = (i32)gfx.css_pixels_to_float_const(&r.vertical_radius))

## Ported from Libraries/LibWeb/Painting/BorderRadiiData.h:120 Web::Painting::BorderRadiiData::contains.
pub func border_radii_data_contains(this: const BorderRadiiData*, point: gfx.CssPixelPoint, rect: gfx.CssPixelRect) -> bool:
    if not gfx.css_pixel_rect_contains_css_pixel_point(&rect, point):
        return false

    if not border_radii_data_has_any_radius(this):
        return true

    let corners = CornerRadii(top_left = border_radius_data_to_corner(&this.top_left), top_right = border_radius_data_to_corner(&this.top_right),
                              bottom_right = border_radius_data_to_corner(&this.bottom_right), bottom_left = border_radius_data_to_corner(&this.bottom_left))
    return corner_radii_contains(&corners, css_pixel_point_to_int_point(point), css_pixel_rect_to_int_rect(rect))

## Ported from Libraries/LibWeb/Painting/BorderRadiiData.h:135 Web::Painting::BorderRadiiData::shrink.
pub func border_radii_data_shrink(this: BorderRadiiData*, top: gfx.CssPixels, right: gfx.CssPixels, bottom: gfx.CssPixels, left: gfx.CssPixels):
    border_radius_data_shrink(&this.top_left, left, top)
    border_radius_data_shrink(&this.top_right, right, top)
    border_radius_data_shrink(&this.bottom_right, right, bottom)
    border_radius_data_shrink(&this.bottom_left, left, bottom)

## Ported from Libraries/LibWeb/Painting/BorderRadiiData.h:143 Web::Painting::BorderRadiiData::inflate.
pub func border_radii_data_inflate(this: BorderRadiiData*, top: gfx.CssPixels, right: gfx.CssPixels, bottom: gfx.CssPixels, left: gfx.CssPixels):
    border_radii_data_shrink(this, gfx.css_pixels_neg(&top), gfx.css_pixels_neg(&right), gfx.css_pixels_neg(&bottom), gfx.css_pixels_neg(&left))