Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / painting / viewport_paintable_2.lucb

#==============================================================================================
#
#   viewport_paintable_2 - Painting::ViewportPaintable: visual contexts, scroll state and
#                          selection states
#
#   DESCRIPTION:
#       Port of LibWeb/Painting/ViewportPaintable.cpp (lines 175-596): the device-pixel CSS
#       transform, perspective and overflow clip of a box, the accumulated visual context tree
#       (effects, transforms, CSS clips, clip paths, perspectives, overflow clips and scrolls of
#       every paintable box), refreshing sticky and scroll offsets, and the selection state of
#       each paintable for a range.
#
#       Copyright (c) 2023, Andreas Kling <andreas@ladybird.org>
#       Copyright (c) 2024-2026, Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: Transforms and clips =======================================================================

## Ported from Libraries/LibWeb/Painting/ViewportPaintable.cpp:175 Web::Painting::effective_css_clip_rect.
func paint_effective_css_clip_rect(css_clip: gfx.CssPixelRect) -> gfx.CssPixelRect:
    let zero = gfx.CssPixels.from_int(0)
    if gfx.css_pixel_rect_width(&css_clip).lt(zero) or gfx.css_pixel_rect_height(&css_clip).lt(zero):
        return gfx.CssPixelRect(gfx.CssPixelPoint(), gfx.CssPixelSize())
    return css_clip

## Ported from Libraries/LibWeb/Painting/ViewportPaintable.cpp:186 Web::Painting::scale_matrix_for_device_pixels.
# Converts a CSS-pixel-space 4x4 matrix to device-pixel-space.
# - Translation column (column 3, rows 0-2) is scaled up by DPR
# - Perspective row (row 3, columns 0-2) is scaled down by DPR
# - All other elements are unaffected (the scale factors cancel out)
func paint_scale_matrix_for_device_pixels(matrix: gfx.FloatMatrix4X4, scale: f32) -> gfx.FloatMatrix4X4:
    var result = matrix
    *gfx.float_matrix4_x4_at(&result, 0, 3) *= scale
    *gfx.float_matrix4_x4_at(&result, 1, 3) *= scale
    *gfx.float_matrix4_x4_at(&result, 2, 3) *= scale
    *gfx.float_matrix4_x4_at(&result, 3, 0) /= scale
    *gfx.float_matrix4_x4_at(&result, 3, 1) /= scale
    *gfx.float_matrix4_x4_at(&result, 3, 2) /= scale
    return result

## `matrix * transform->to_matrix(paintable_box).release_value()`.
func paint_multiply_by_transformation(matrix: gfx.FloatMatrix4X4, transform: CssTransformationStyleValue*, paintable_box: PaintPaintableBox*?) -> gfx.FloatMatrix4X4:
    let transform_matrix = css_transformation_style_value_to_matrix(transform, paintable_box) else trap("release_value: the transformation has no matrix")
    return gfx.float_matrix4_x4_mul(&matrix, transform_matrix)

## Ported from Libraries/LibWeb/Painting/ViewportPaintable.cpp:197 Web::Painting::compute_transform.
func paint_compute_transform(paintable_box: PaintPaintableBox*, computed_values: const CssComputedValues*, pixel_ratio: f64) -> display_list.TransformData?:
    if not paint_paintable_box_has_css_transform(paintable_box):
        return none

    var matrix = gfx.float_matrix4_x4_identity()
    if let translate = css_computed_values_translate(computed_values):
        matrix = paint_multiply_by_transformation(matrix, translate, paintable_box)
    if let rotate = css_computed_values_rotate(computed_values):
        matrix = paint_multiply_by_transformation(matrix, rotate, paintable_box)
    if let scale_transform = css_computed_values_scale(computed_values):
        matrix = paint_multiply_by_transformation(matrix, scale_transform, paintable_box)
    var transformations = css_computed_values_transformations(computed_values)
    for transform in ak.vector_span(&transformations):
        matrix = paint_multiply_by_transformation(matrix, transform, paintable_box)
    let css_transform_origin = css_computed_values_transform_origin(computed_values)
    let reference_box = paint_paintable_box_transform_reference_box(paintable_box)
    let layout_node = paint_paintable_layout_node(paintable_box.paint_paintable())
    let origin = gfx.CssPixelPoint(
        gfx.css_pixel_rect_left(&reference_box).add(css_percentage_or_to_px(&css_transform_origin.x.percentage_or, layout_node, gfx.css_pixel_rect_width(&reference_box))),
        gfx.css_pixel_rect_top(&reference_box).add(css_percentage_or_to_px(&css_transform_origin.y.percentage_or, layout_node, gfx.css_pixel_rect_height(&reference_box))),
    )
    let scale = (f32)pixel_ratio
    let device_origin = gfx.FloatPoint(m_x = origin.m_x.to_float() * scale, m_y = origin.m_y.to_float() * scale)
    return display_list.TransformData(matrix = paint_scale_matrix_for_device_pixels(matrix, scale), origin = device_origin)

## `Gfx::translation_matrix(Vector3<float>(x, y, 0))`.
func paint_translation_matrix_xy(x: f32, y: f32) -> gfx.FloatMatrix4X4:
    return gfx.translation_matrix(gfx.FloatVector3(m_data = [x, y, 0.0]))

## Ported from Libraries/LibWeb/Painting/ViewportPaintable.cpp:223 Web::Painting::compute_perspective_matrix.
# https://drafts.csswg.org/css-transforms-2/#perspective-matrix
func paint_compute_perspective_matrix(paintable_box: PaintPaintableBox*, computed_values: const CssComputedValues*) -> gfx.FloatMatrix4X4?:
    let perspective = css_computed_values_perspective(computed_values) else return none

    # The perspective matrix is computed as follows:

    # 1. Start with the identity matrix.
    # 2. Translate by the computed X and Y values of 'perspective-origin'
    # https://drafts.csswg.org/css-transforms-2/#perspective-origin-property
    # Percentages: refer to the size of the reference box
    let reference_box = paint_paintable_box_transform_reference_box(paintable_box)
    let perspective_origin_value = css_computed_values_perspective_origin(computed_values)
    let perspective_origin = css_position_resolved(&perspective_origin_value, paint_paintable_layout_node(paintable_box.paint_paintable()), reference_box)
    let computed_x = perspective_origin.m_x.to_float()
    let computed_y = perspective_origin.m_y.to_float()
    var perspective_matrix = paint_translation_matrix_xy(computed_x, computed_y)

    # 3. Multiply by the matrix that would be obtained from the 'perspective()' transform function, where the
    #    length is provided by the value of the perspective property
    # NB: Length values less than 1px being clamped to 1px is handled by the perspective() function already.
    # FIXME: Create the matrix directly.
    var values: ak.Vector[CssStyleValue*]
    ak.vector_append_t(&values, css_length_style_value_create(css_length_make_px_css_pixels(perspective)).css_style_value())
    let perspective_function = css_transformation_style_value_create(css_data.PropertyId.transform, css_data.TransformFunction.perspective, values)
    perspective_matrix = paint_multiply_by_transformation(perspective_matrix, perspective_function, none)

    # 4. Translate by the negated computed X and Y values of 'perspective-origin'
    perspective_matrix = gfx.float_matrix4_x4_mul(&perspective_matrix, paint_translation_matrix_xy(-computed_x, -computed_y))
    return perspective_matrix

## Ported from Libraries/LibWeb/Painting/ViewportPaintable.cpp:250 Web::Painting::compute_clip_data.
func paint_compute_clip_data(paintable_box: PaintPaintableBox*, computed_values: const CssComputedValues*, converter: const PaintDevicePixelConverter*) -> display_list.ClipData?:
    var overflow_x = css_computed_values_overflow_x(computed_values)
    var overflow_y = css_computed_values_overflow_y(computed_values)

    # https://drafts.csswg.org/css-contain-2/#paint-containment
    # 1. The contents of the element including any ink or scrollable overflow must be clipped to the overflow clip
    #    edge of the paint containment box, taking corner clipping into account. This does not include the creation of
    #    any mechanism to access or indicate the presence of the clipped content; nor does it inhibit the creation of
    #    any such mechanism through other properties, such as overflow, resize, or text-overflow.
    #    NOTE: This clipping shape respects overflow-clip-margin, allowing an element with paint containment
    #          to still slightly overflow its normal bounds.
    if layout_node_has_paint_containment(paint_paintable_layout_node(paintable_box.paint_paintable())):
        # NOTE: Note: The behavior is described in this paragraph is equivalent to changing 'overflow-x: visible' into
        #       'overflow-x: clip' and 'overflow-y: visible' into 'overflow-y: clip' at used value time, while leaving other
        #       values of 'overflow-x' and 'overflow-y' unchanged.
        overflow_x = css_data.Overflow.clip
        overflow_y = css_data.Overflow.clip

    let has_hidden_overflow = overflow_x != css_data.Overflow.visible or overflow_y != css_data.Overflow.visible

    if has_hidden_overflow and paint_paintable_box_overflow_property_applies(paintable_box):
        var clip_rect = paint_paintable_box_absolute_padding_box_rect(paintable_box)

        # https://drafts.csswg.org/css-overflow-3/#propdef-overflow
        # 'clip'
        #    This value indicates that the box’s content is clipped to its overflow clip edge
        let overflow_clip_edge = paint_paintable_box_overflow_clip_edge_rect(paintable_box)
        let max_value = gfx.CssPixels.from_int(gfx.css_pixels_max_integer_value)
        if overflow_x == css_data.Overflow.visible:
            gfx.css_pixel_rect_set_left(&clip_rect, gfx.CssPixels.from_int(0))
            gfx.css_pixel_rect_set_right(&clip_rect, max_value)
        elif overflow_x == css_data.Overflow.clip:
            gfx.css_pixel_rect_set_left(&clip_rect, gfx.css_pixel_rect_left(&overflow_clip_edge))
            gfx.css_pixel_rect_set_right(&clip_rect, gfx.css_pixel_rect_right(&overflow_clip_edge))
        if overflow_y == css_data.Overflow.visible:
            gfx.css_pixel_rect_set_top(&clip_rect, gfx.CssPixels.from_int(0))
            gfx.css_pixel_rect_set_bottom(&clip_rect, max_value)
        elif overflow_y == css_data.Overflow.clip:
            gfx.css_pixel_rect_set_top(&clip_rect, gfx.css_pixel_rect_top(&overflow_clip_edge))
            gfx.css_pixel_rect_set_bottom(&clip_rect, gfx.css_pixel_rect_bottom(&overflow_clip_edge))

        # https://drafts.csswg.org/css-overflow-3/#corner-clipping
        # As mentioned in CSS Backgrounds 3 § 4.3 Corner Clipping, the clipping region established by 'overflow' can be
        # rounded:
        # - When 'overflow-x' and 'overflow-y' compute to 'hidden', 'scroll', or 'auto', the clipping region is rounded
        #   based on the border radius, adjusted to the padding edge, as described in CSS Backgrounds 3 § 4.2 Corner
        #   Shaping.
        # - When both 'overflow-x' and 'overflow-y' compute to 'clip', the clipping region is rounded as described in § 3.2
        #   Expanding Clipping Bounds: the 'overflow-clip-margin' property.
        # - However, when one of 'overflow-x' or 'overflow-y' computes to 'clip' and the other computes to 'visible', the
        #   clipping region is not rounded.
        # FIXME: Adjust the border radii for the overflow-clip-margin case. (see https://drafts.csswg.org/css-overflow-4/#valdef-overflow-clip-margin-length-0 )
        var radii = display_list.BorderRadiiData()
        if overflow_x != css_data.Overflow.visible and overflow_y != css_data.Overflow.visible:
            radii = paint_paintable_box_normalized_border_radii_data(paintable_box, PaintPaintableBoxShrinkRadiiForBorders.yes)
        return display_list.ClipData(rect = paint_device_pixel_converter_rounded_device_rect(converter, clip_rect), corner_radii = border_radii_data_as_corners(&radii, *converter))

    return none

# mark: Accumulated visual contexts ================================================================

## The `make_effects_data` lambda of ViewportPaintable::assign_accumulated_visual_contexts.
func paint_viewport_paintable_make_effects_data(box: PaintPaintableBox*, pixel_ratio: f64) -> display_list.EffectsData?:
    let computed_values = &paint_paintable_computed_values(box.paint_paintable()).computed_values
    let gfx_filter = paint_to_gfx_filter(paint_paintable_box_filter(box), pixel_ratio)
    let effects = display_list.EffectsData(
        opacity = css_computed_values_opacity(computed_values),
        blend_mode = paint_mix_blend_mode_to_compositing_and_blending_operator(css_computed_values_mix_blend_mode(computed_values)),
        gfx_filter = gfx_filter,
    )
    if not display_list.effects_data_needs_layer(&effects):
        return none
    return effects

## The fill rule of a basic shape (the visit in assign_accumulated_visual_contexts).
func paint_basic_shape_fill_rule(basic_shape: CssBasicShape) -> gfx.WindingRule:
    match basic_shape:
        .css_polygon(polygon): return polygon.fill_rule
        .css_path(path): return path.fill_rule
        _: return gfx.WindingRule.nonzero

## Ported from Libraries/LibWeb/Painting/ViewportPaintable.cpp:304 Web::Painting::ViewportPaintable::assign_accumulated_visual_contexts.
pub func paint_viewport_paintable_assign_accumulated_visual_contexts(this: PaintViewportPaintable*):
    let tree = display_list.accumulated_visual_context_tree_create()
    this.m_visual_context_tree = tree

    let document = paint_paintable_document(this.paint_paintable())
    let pixel_ratio = page_client_device_pixels_per_css_pixel(page_client(dom_document_page(document)))
    var converter: PaintDevicePixelConverter = ---
    paint_device_pixel_converter_construct(&converter, pixel_ratio)
    let scale = (f32)pixel_ratio

    # Create visual viewport transform as root (if not identity)
    this.m_visual_viewport_context_index = 0
    let transform = css_visual_viewport_transform(dom_document_visual_viewport(document))
    if not gfx.affine_transform_is_identity(&transform):
        let matrix = paint_scale_matrix_for_device_pixels(gfx.affine_transform_to_matrix(&transform), scale)
        this.m_visual_viewport_context_index = display_list.accumulated_visual_context_tree_append(tree, display_list.VisualContextData.transform_data(display_list.TransformData(matrix = matrix, origin = gfx.FloatPoint(m_x = 0.0, m_y = 0.0))), 0)

    let own_scroll_frame_index = paint_paintable_box_own_scroll_frame_index(this.paint_paintable_box())
    var viewport_state_for_descendants = this.m_visual_viewport_context_index
    if own_scroll_frame_index != 0:
        viewport_state_for_descendants = display_list.accumulated_visual_context_tree_append(tree, display_list.VisualContextData.scroll_data(display_list.ScrollData(scroll_frame_index = own_scroll_frame_index, is_sticky = false)), this.m_visual_viewport_context_index)
    paint_paintable_box_set_accumulated_visual_context(this.paint_paintable_box(), 0)
    paint_paintable_box_set_accumulated_visual_context_for_descendants(this.paint_paintable_box(), viewport_state_for_descendants)

    # for_each_in_subtree_of_type<PaintableBox>
    for paintable in paint_paintable_subtree(this.paint_paintable()):
        let paintable_box = as_if_paint_paintable_box(paintable) else continue
        let parent = tree_node_parent(paintable) else continue
        let visual_parent = as_if_paint_paintable_box(parent) else continue

        # Resolve filters before make_effects_data reads them.
        let paintable_box_computed_values = &paint_paintable_computed_values(paintable).computed_values
        let filter = css_computed_values_filter(paintable_box_computed_values)
        if css_filter_has_filters(&filter):
            paint_paintable_box_set_filter(paintable_box, paint_resolve_css_filter(filter, paintable_box))
        else:
            paint_paintable_box_set_filter(paintable_box, PaintResolvedCssFilter())

        var inherited_state: u64 = 0

        if paint_paintable_is_fixed_position(paintable):
            inherited_state = this.m_visual_viewport_context_index
        elif paint_paintable_is_absolutely_positioned(paintable):
            # For position: absolute, use containing block's state to correctly escape scroll containers.
            let containing = paint_paintable_containing_block(paintable) else trap("an absolutely positioned box without a containing block")
            inherited_state = paint_paintable_box_accumulated_visual_context_for_descendants_index(containing)

            # Abspos elements escape scroll containers and overflow clips of non-positioned
            # ancestors, but cannot escape stacking contexts created by intermediate effects
            # (opacity, mix-blend-mode, isolation). Walk from visual parent to containing
            # block and collect these intermediate effects.
            # NOTE: transforms/perspectives/filters establish containing blocks for abspos,
            #       so they cannot appear as intermediates.
            var intermediate_effects: ak.Vector[display_list.EffectsData]
            var ancestor_or_none: PaintPaintable*? = visual_parent.paint_paintable()
            while let ancestor = ancestor_or_none:
                if ancestor == containing.paint_paintable():
                    break
                ancestor_or_none = tree_node_parent(ancestor)
                let ancestor_box = as_if_paint_paintable_box(ancestor) else continue
                if let effects = paint_viewport_paintable_make_effects_data(ancestor_box, pixel_ratio):
                    ak.vector_append_t(&intermediate_effects, effects)
            var index = ak.vector_size(&intermediate_effects)
            while index > 0:
                index -= 1
                inherited_state = display_list.accumulated_visual_context_tree_append(tree, display_list.VisualContextData.effects_data(*ak.vector_at(&intermediate_effects, index)), inherited_state)
        else:
            # For position: relative/static, use visual parent's state directly.
            # This avoids duplicate transform/perspective allocations that would occur with
            # the containing block + intermediate walk approach.
            inherited_state = paint_paintable_box_accumulated_visual_context_for_descendants_index(visual_parent)

        # Build this element's own state from inherited state.
        var own_state = inherited_state

        if paint_paintable_is_sticky_position(paintable):
            # For sticky elements, use enclosing_scroll_frame which holds the sticky frame.
            # own_scroll_frame may be a different scroll frame if the sticky element also has scrollable overflow.
            let sticky_idx = paint_paintable_box_enclosing_scroll_frame_index(paintable_box)
            if sticky_idx != 0 and display_list.scroll_frame_is_sticky(display_list.scroll_state_frame_at(&this.m_scroll_state, sticky_idx)):
                own_state = display_list.accumulated_visual_context_tree_append(tree, display_list.VisualContextData.scroll_data(display_list.ScrollData(scroll_frame_index = sticky_idx, is_sticky = true)), own_state)

        let computed_values = &paint_paintable_computed_values(paintable).computed_values

        if let effects = paint_viewport_paintable_make_effects_data(paintable_box, pixel_ratio):
            own_state = display_list.accumulated_visual_context_tree_append(tree, display_list.VisualContextData.effects_data(effects), own_state)

        if let transform_data = paint_compute_transform(paintable_box, computed_values, pixel_ratio):
            paint_paintable_box_set_has_non_invertible_css_transform(paintable_box, not gfx.float_matrix4_x4_is_invertible(&transform_data.matrix))
            own_state = display_list.accumulated_visual_context_tree_append(tree, display_list.VisualContextData.transform_data(transform_data), own_state)
        else:
            paint_paintable_box_set_has_non_invertible_css_transform(paintable_box, false)

        if let css_clip = paint_paintable_box_get_clip_rect(paintable_box):
            let effective_rect = paint_effective_css_clip_rect(css_clip)
            own_state = display_list.accumulated_visual_context_tree_append(tree, display_list.VisualContextData.clip_data(display_list.ClipData(rect = paint_device_pixel_converter_rounded_device_rect(&converter, effective_rect), corner_radii = display_list.CornerRadii())), own_state)

        # FIXME: Support other geometry boxes. See: https://drafts.fxtf.org/css-masking/#typedef-geometry-box
        if let clip_path = css_computed_values_clip_path(computed_values):
            if css_clip_path_reference_is_basic_shape(&clip_path):
                let masking_area = paint_paintable_box_absolute_border_box_rect(paintable_box)
                let reference_box = gfx.CssPixelRect(gfx.CssPixelPoint(), gfx.css_pixel_rect_size(&masking_area))
                let basic_shape = css_clip_path_reference_basic_shape(&clip_path)
                var path = css_basic_shape_style_value_to_path(basic_shape, reference_box, paint_paintable_layout_node(paintable))
                let top_left = gfx.css_pixel_rect_top_left(&masking_area)
                gfx.path_offset(&path, gfx.FloatPoint(m_x = top_left.m_x.to_float(), m_y = top_left.m_y.to_float()))
                let fill_rule = paint_basic_shape_fill_rule(css_basic_shape_style_value_basic_shape(basic_shape))
                var device_transform = gfx.AffineTransform()
                gfx.affine_transform_construct(&device_transform)
                _ = gfx.affine_transform_set_scale_f32(&device_transform, scale, scale)
                let device_path = gfx.path_copy_transformed(&path, device_transform)
                let device_bounding_rect = paint_device_pixel_converter_rounded_device_rect(&converter, masking_area)
                own_state = display_list.accumulated_visual_context_tree_append(tree, display_list.VisualContextData.clip_path_data(display_list.ClipPathData(path = device_path, bounding_rect = device_bounding_rect, fill_rule = fill_rule)), own_state)

        paint_paintable_box_set_accumulated_visual_context(paintable_box, own_state)

        # Build state for descendants: own state + perspective + clip + scroll.
        var state_for_descendants = own_state

        if let perspective_matrix = paint_compute_perspective_matrix(paintable_box, computed_values):
            let scaled_matrix = paint_scale_matrix_for_device_pixels(perspective_matrix, scale)
            state_for_descendants = display_list.accumulated_visual_context_tree_append(tree, display_list.VisualContextData.perspective_data(display_list.PerspectiveData(matrix = scaled_matrix)), state_for_descendants)

        if let clip_data = paint_compute_clip_data(paintable_box, computed_values, &converter):
            state_for_descendants = display_list.accumulated_visual_context_tree_append(tree, display_list.VisualContextData.clip_data(clip_data), state_for_descendants)

        let box_own_scroll_frame_index = paint_paintable_box_own_scroll_frame_index(paintable_box)
        if box_own_scroll_frame_index != 0:
            let is_sticky_without_scrollable_overflow = paint_paintable_is_sticky_position(paintable) and paint_paintable_box_enclosing_scroll_frame_index(paintable_box) == box_own_scroll_frame_index
            if not is_sticky_without_scrollable_overflow:
                state_for_descendants = display_list.accumulated_visual_context_tree_append(tree, display_list.VisualContextData.scroll_data(display_list.ScrollData(scroll_frame_index = box_own_scroll_frame_index, is_sticky = false)), state_for_descendants)

        paint_paintable_box_set_accumulated_visual_context_for_descendants(paintable_box, state_for_descendants)

# mark: Scroll state ===============================================================================

## Ported from Libraries/LibWeb/Painting/ViewportPaintable.cpp:451 Web::Painting::ViewportPaintable::refresh_scroll_state.
pub func paint_viewport_paintable_refresh_scroll_state(this: PaintViewportPaintable*):
    if not this.m_needs_to_refresh_scroll_state:
        return
    this.m_needs_to_refresh_scroll_state = false

    for entry in display_list.scroll_state_for_each_sticky_frame(&this.m_scroll_state):
        let idx = entry.index
        let frame = entry.frame
        let nearest_scrolling_ancestor_index = display_list.scroll_state_nearest_scrolling_ancestor(&this.m_scroll_state, idx)
        if nearest_scrolling_ancestor_index == 0 or not display_list.scroll_frame_has_sticky_constraints(frame):
            continue

        let sticky_data = display_list.scroll_frame_sticky_constraints(frame)
        let sticky_insets = sticky_data.insets
        let scroll_ancestor_paintable = scroll_frame_paintable_box(display_list.scroll_state_frame_at(&this.m_scroll_state, nearest_scrolling_ancestor_index))

        # For nested sticky elements, the parent sticky's offset is applied via cumulative_offset.
        # We need to adjust all position calculations to account for this, so we work in the
        # coordinate space where the parent sticky is at its current (offset) position.
        var parent_sticky_offset = gfx.CssPixelPoint()
        let parent_idx = display_list.scroll_frame_parent_index(frame)
        if parent_idx != 0 and display_list.scroll_frame_is_sticky(display_list.scroll_state_frame_at(&this.m_scroll_state, parent_idx)):
            parent_sticky_offset = display_list.scroll_state_cumulative_offset(&this.m_scroll_state, parent_idx)

        let sticky_position_in_ancestor = gfx.css_pixel_point_add(&sticky_data.position_relative_to_scroll_ancestor, parent_sticky_offset)

        var containing_block_region = sticky_data.containing_block_region
        if sticky_data.needs_parent_offset_adjustment:
            gfx.css_pixel_rect_translate_by_css_pixel_point(&containing_block_region, parent_sticky_offset)
        let min_offset_within_containing_block = gfx.css_pixel_rect_top_left(&containing_block_region)
        let max_offset_within_containing_block = gfx.CssPixelPoint(
            gfx.css_pixel_rect_right(&containing_block_region).sub(sticky_data.border_box_size.m_width),
            gfx.css_pixel_rect_bottom(&containing_block_region).sub(sticky_data.border_box_size.m_height))

        let scrollport_rect = gfx.CssPixelRect(paint_paintable_box_scroll_offset(scroll_ancestor_paintable), sticky_data.scrollport_size)
        var sticky_offset = gfx.CssPixelPoint()

        if let top = sticky_insets.top:
            if gfx.css_pixel_rect_top(&scrollport_rect).gt(sticky_position_in_ancestor.m_y.sub(top)):
                gfx.css_pixel_point_set_y(&sticky_offset, ak.min(gfx.css_pixel_rect_top(&scrollport_rect).add(top), max_offset_within_containing_block.m_y).sub(sticky_position_in_ancestor.m_y))
        if let left = sticky_insets.left:
            if gfx.css_pixel_rect_left(&scrollport_rect).gt(sticky_position_in_ancestor.m_x.sub(left)):
                gfx.css_pixel_point_set_x(&sticky_offset, ak.min(gfx.css_pixel_rect_left(&scrollport_rect).add(left), max_offset_within_containing_block.m_x).sub(sticky_position_in_ancestor.m_x))
        if let bottom = sticky_insets.bottom:
            if gfx.css_pixel_rect_bottom(&scrollport_rect).lt(sticky_position_in_ancestor.m_y.add(sticky_data.border_box_size.m_height).add(bottom)):
                gfx.css_pixel_point_set_y(&sticky_offset, ak.max(gfx.css_pixel_rect_bottom(&scrollport_rect).sub(sticky_data.border_box_size.m_height).sub(bottom), min_offset_within_containing_block.m_y).sub(sticky_position_in_ancestor.m_y))
        if let right = sticky_insets.right:
            if gfx.css_pixel_rect_right(&scrollport_rect).lt(sticky_position_in_ancestor.m_x.add(sticky_data.border_box_size.m_width).add(right)):
                gfx.css_pixel_point_set_x(&sticky_offset, ak.max(gfx.css_pixel_rect_right(&scrollport_rect).sub(sticky_data.border_box_size.m_width).sub(right), min_offset_within_containing_block.m_x).sub(sticky_position_in_ancestor.m_x))

        display_list.scroll_frame_set_own_offset(frame, sticky_offset)

    for entry in display_list.scroll_state_for_each_scroll_frame(&this.m_scroll_state):
        let scroll_offset = paint_paintable_box_scroll_offset(scroll_frame_paintable_box(entry.frame))
        display_list.scroll_frame_set_own_offset(entry.frame, gfx.css_pixel_point_neg(&scroll_offset))

    let document = paint_paintable_document(this.paint_paintable())
    this.m_scroll_state_snapshot = display_list.scroll_state_snapshot(&this.m_scroll_state, page_client_device_pixels_per_css_pixel(page_client(dom_document_page(document))))

# mark: Selection ==================================================================================

## Ported from Libraries/LibWeb/Painting/ViewportPaintable.cpp:515 Web::Painting::ViewportPaintable::selection.
pub func paint_viewport_paintable_selection(this: PaintViewportPaintable*) -> SelectionSelection*?:
    return dom_document_get_selection(paint_paintable_document(this.paint_paintable()))

## Ported from Libraries/LibWeb/Painting/ViewportPaintable.cpp:520 Web::Painting::ViewportPaintable::recompute_selection_states.
pub func paint_viewport_paintable_recompute_selection_states(this: PaintViewportPaintable*, range: DomRange*):
    # 1. Start by resetting the selection state of all layout nodes to None.
    for paintable in paint_paintable_inclusive_subtree(this.paint_paintable()):
        paint_paintable_set_selection_state(paintable, PaintPaintableSelectionState.none_)

    let abstract_range = range.dom_abstract_range()
    let start_container = dom_abstract_range_start_container(abstract_range)
    let end_container = dom_abstract_range_end_container(abstract_range)
    let start_node = dom_abstract_range_start(abstract_range).node
    let end_node = dom_abstract_range_end(abstract_range).node

    # 2. If the selection starts and ends in the same node:
    if start_container == end_container:
        # 1. If the selection starts and ends at the same offset, return.
        if dom_abstract_range_start_offset(abstract_range) == dom_abstract_range_end_offset(abstract_range):
            # NOTE: A zero-length selection should not be visible.
            return

        # 2. If it's a text node, mark it as StartAndEnd and return.
        if is_dom_text(start_container) and not dom_node_is_inert(start_node):
            if let paintable = dom_node_unsafe_paintable(start_container):
                paint_paintable_set_selection_state(paintable, PaintPaintableSelectionState.start_and_end)
            return

    # 3. Mark the selection start node as Start (if text) or Full (if anything else).
    if let paintable = dom_node_unsafe_paintable(start_container):
        if not dom_node_is_inert(start_node):
            if is_dom_text(start_container):
                paint_paintable_set_selection_state(paintable, PaintPaintableSelectionState.start)
            else:
                paint_paintable_set_selection_state(paintable, PaintPaintableSelectionState.full)

    # 4. Mark the nodes between the start and end of the selection as Full.
    var start_at = tree_node_child_at_index(start_container, (usize)dom_abstract_range_start_offset(abstract_range))
    # If the start container has no child at that index, we need to start on the node right after the start container.
    if start_at == none:
        if let last_child = tree_node_last_child(start_container):
            start_at = tree_node_next_in_pre_order(last_child)
        else:
            start_at = tree_node_next_in_pre_order(start_container)

    let stop_at = tree_node_child_at_index(end_container, (usize)dom_abstract_range_end_offset(abstract_range))
    # Only stop at the end container if it has no children that may need to be included.
    var node_or_none = start_at
    while let node = node_or_none:
        if node_or_none == stop_at or (node == end_container and not tree_node_has_children(end_container)):
            break
        node_or_none = tree_node_next_in_pre_order_t(node, end_container)
        if dom_node_is_inert(node):
            continue
        if let paintable = dom_node_unsafe_paintable(node):
            paint_paintable_set_selection_state(paintable, PaintPaintableSelectionState.full)

    # 5. Mark the selection end node as End if it is a text node.
    if let paintable = dom_node_unsafe_paintable(end_container):
        if not dom_node_is_inert(end_node) and is_dom_text(end_container):
            paint_paintable_set_selection_state(paintable, PaintPaintableSelectionState.end)

## Ported from Libraries/LibWeb/Painting/ViewportPaintable.cpp:585 Web::Painting::ViewportPaintable::handle_mousewheel (override).
pub func paint_viewport_paintable_handle_mousewheel_impl(base: PaintPaintable*, arg0: gfx.CssPixelPoint, arg1: u32, arg2: u32, wheel_delta_x: i32, wheel_delta_y: i32) -> bool:
    _ = base
    _ = arg0
    _ = arg1
    _ = arg2
    _ = wheel_delta_x
    _ = wheel_delta_y
    return false