dymokomi/luce-browser-engine
Source of release 0.6.0
0.6.0 / src / web / painting / paintable_box_2.lucb
#==============================================================================================
#
# paintable_box_2 - Painting::PaintableBox: scrollbars, painting and transforms
#
# DESCRIPTION:
# Port of LibWeb/Painting/PaintableBox.cpp (lines 520-992): the scrollbar rectangles and
# thumb geometry, PaintableBox::paint (backgrounds, borders, collapsed table borders,
# outlines, scrollbars and the resizer), the middle button scroll indicator and the
# inspector overlay, the stacking context and z-index, border, backdrop filter,
# background and box shadow painting, normalized border radii, and the mapping of points
# and rects through the accumulated visual contexts.
#
# Copyright (c) 2022-2023, Andreas Kling <andreas@ladybird.org>
# Copyright (c) 2022-2025, Sam Atkins <sam@ladybird.org>
# Copyright (c) 2024-2026, Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
# Copyright (c) 2025, Jelle Raaijmakers <jelle@ladybird.org>
# SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================
# mark: Scrollbar geometry ========================================================================
## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:520 Web::Painting::PaintableBox::absolute_scrollbar_rect.
pub func paint_paintable_box_absolute_scrollbar_rect(this: PaintPaintableBox*, direction: PaintPaintableBoxScrollDirection, with_gutter: bool, metrics: ChromeMetrics) -> gfx.CssPixelRect?:
if not paint_paintable_box_could_be_scrolled_by_wheel_event_paint_paintable_box_scroll_dir(this, direction):
return none
if css_computed_values_scrollbar_width(&paint_paintable_computed_values(this.paint_paintable()).computed_values) == css_data.ScrollbarWidth.none_:
return none
let is_horizontal = direction == PaintPaintableBoxScrollDirection.horizontal
let adjusting_for_resizer = paint_paintable_box_has_resizer(this)
let rect_thickness = metrics.scroll_gutter_thickness if with_gutter else metrics.scroll_thumb_thickness_thin.add(metrics.scroll_thumb_padding_thin)
var scrollbar_rect = paint_paintable_box_absolute_padding_box_rect(this)
let zero = gfx.CssPixels.from_int(0)
if is_horizontal:
if not adjusting_for_resizer and paint_paintable_box_could_be_scrolled_by_wheel_event_paint_paintable_box_scroll_dir(this, PaintPaintableBoxScrollDirection.vertical):
gfx.css_pixel_rect_set_width(&scrollbar_rect, ak.max(zero, gfx.css_pixel_rect_width(&scrollbar_rect).sub(metrics.scroll_gutter_thickness)))
if paint_paintable_box_is_chrome_mirrored(this):
gfx.css_pixel_rect_set_x(&scrollbar_rect, gfx.css_pixel_rect_x(&scrollbar_rect).add(metrics.scroll_gutter_thickness))
elif adjusting_for_resizer:
gfx.css_pixel_rect_set_width(&scrollbar_rect, paint_paintable_box_available_scrollbar_length(this, PaintPaintableBoxScrollDirection.horizontal, metrics))
if paint_paintable_box_is_chrome_mirrored(this):
gfx.css_pixel_rect_set_x(&scrollbar_rect, gfx.css_pixel_rect_x(&scrollbar_rect).add(metrics.resize_gripper_size))
gfx.css_pixel_rect_set_y(&scrollbar_rect, ak.max(zero, gfx.css_pixel_rect_bottom(&scrollbar_rect).sub(rect_thickness)))
gfx.css_pixel_rect_set_height(&scrollbar_rect, rect_thickness)
else:
if adjusting_for_resizer:
gfx.css_pixel_rect_set_height(&scrollbar_rect, paint_paintable_box_available_scrollbar_length(this, PaintPaintableBoxScrollDirection.vertical, metrics))
if not paint_paintable_box_is_chrome_mirrored(this):
gfx.css_pixel_rect_set_x(&scrollbar_rect, ak.max(zero, gfx.css_pixel_rect_right(&scrollbar_rect).sub(rect_thickness)))
gfx.css_pixel_rect_set_width(&scrollbar_rect, rect_thickness)
return scrollbar_rect
## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:557 Web::Painting::PaintableBox::compute_scrollbar_data.
pub func paint_paintable_box_compute_scrollbar_data(this: PaintPaintableBox*, direction: PaintPaintableBoxScrollDirection, metrics: ChromeMetrics, scroll_state_snapshot: const display_list.ScrollStateSnapshot*? = none) -> PaintPaintableBoxScrollbarData?:
let is_horizontal = direction == PaintPaintableBoxScrollDirection.horizontal
let orientation = gfx.Orientation.horizontal if is_horizontal else gfx.Orientation.vertical
let computed_values = &paint_paintable_computed_values(this.paint_paintable()).computed_values
let overflow = css_computed_values_overflow_x(computed_values) if is_horizontal else css_computed_values_overflow_y(computed_values)
if overflow != css_data.Overflow.scroll and not paint_paintable_box_could_be_scrolled_by_wheel_event_paint_paintable_box_scroll_dir(this, direction):
return none
if this.m_own_scroll_frame_index == 0:
return none
let scrollable_overflow_rect = paint_paintable_box_scrollable_overflow_rect(this) else trap("VERIFY: no scrollable overflow rect")
let scrollable_overflow_length = gfx.css_pixel_rect_primary_size_for_orientation(&scrollable_overflow_rect, orientation)
if gfx.eq_css_pixels_int(scrollable_overflow_length, 0):
return none
let scrollbar = this.m_horizontal_scrollbar if is_horizontal else this.m_vertical_scrollbar
var with_gutter = false
if let existing = scrollbar:
with_gutter = paint_scrollbar_is_enlarged(existing)
let scrollbar_rect = paint_paintable_box_absolute_scrollbar_rect(this, direction, with_gutter, metrics) else return none
var thumb_thickness = metrics.scroll_thumb_thickness_thin
var thumb_margin = metrics.scroll_thumb_padding_thin
if with_gutter:
thumb_thickness = metrics.scroll_thumb_thickness
thumb_margin = gfx.CssPixels.from_f64(gfx.div_css_pixels_f64(metrics.scroll_gutter_thickness.sub(metrics.scroll_thumb_thickness), 2.0))
let zero = gfx.CssPixels.from_int(0)
let scrollbar_length = gfx.css_pixel_rect_primary_size_for_orientation(&scrollbar_rect, orientation)
let usable_scrollbar_length = ak.max(zero, scrollbar_length.sub(gfx.mul_int_css_pixels(2, thumb_margin)))
let padding_box_rect = paint_paintable_box_absolute_padding_box_rect(this)
let scrollport_size = gfx.css_pixel_rect_primary_size_for_orientation(&padding_box_rect, orientation)
let min_thumb_length = ak.min(usable_scrollbar_length, metrics.scroll_thumb_min_length)
let thumb_length = ak.max(usable_scrollbar_length.mul_fraction(scrollport_size.div(scrollable_overflow_length)), min_thumb_length)
var zero_ratio: gfx.CssPixelFraction = ---
gfx.css_pixel_fraction_construct_int(&zero_ratio, 0)
var scrollbar_data = PaintPaintableBoxScrollbarData(gutter_rect = gfx.CssPixelRect(), thumb_rect = scrollbar_rect, thumb_travel_to_scroll_ratio = zero_ratio)
gfx.css_pixel_rect_set_primary_size_for_orientation(&scrollbar_data.thumb_rect, orientation, thumb_length)
gfx.css_pixel_rect_set_secondary_size_for_orientation(&scrollbar_data.thumb_rect, orientation, thumb_thickness)
gfx.css_pixel_rect_translate_primary_offset_for_orientation(&scrollbar_data.thumb_rect, orientation, thumb_margin)
if with_gutter or (not is_horizontal and paint_paintable_box_is_chrome_mirrored(this)):
gfx.css_pixel_rect_translate_secondary_offset_for_orientation(&scrollbar_data.thumb_rect, orientation, thumb_margin)
if with_gutter:
scrollbar_data.gutter_rect = scrollbar_rect
if scrollable_overflow_length.gt(scrollport_size):
scrollbar_data.thumb_travel_to_scroll_ratio = usable_scrollbar_length.sub(thumb_length).div(scrollable_overflow_length.sub(scrollport_size))
if let snapshot = scroll_state_snapshot:
let own_offset = display_list.scroll_state_snapshot_device_offset_for_index(snapshot, this.m_own_scroll_frame_index)
let device_scroll_offset = -own_offset.m_x if is_horizontal else -own_offset.m_y
let device_pixels_per_css_pixel = (f32)page_client_device_pixels_per_css_pixel(page_client(dom_document_page(paint_paintable_document(this.paint_paintable()))))
let thumb_offset = gfx.css_pixels_nearest_value_for_f32(device_scroll_offset / device_pixels_per_css_pixel).mul_fraction(scrollbar_data.thumb_travel_to_scroll_ratio)
gfx.css_pixel_rect_translate_primary_offset_for_orientation(&scrollbar_data.thumb_rect, orientation, thumb_offset)
return scrollbar_data
# mark: Painting ==================================================================================
## The `empty_cells_property_applies` lambda of PaintableBox::paint.
func paint_paintable_box_empty_cells_property_applies(this: PaintPaintableBox*) -> bool:
let display = paint_paintable_display(this.paint_paintable())
return css_display_is_internal_table(&display) and css_computed_values_empty_cells(&paint_paintable_computed_values(this.paint_paintable()).computed_values) == css_data.EmptyCells.hide and not tree_node_has_children(this.paint_paintable())
## The `paint_resizer_line` lambda of PaintableBox::paint.
func paint_paintable_box_paint_resizer_line(recorder: display_list.DisplayListRecorder*, rect: gfx.DevicePixelRect, bottom_left_resizer: bool, step: i32, color: gfx.Color):
let from_ = gfx.IntPoint(m_x = gfx.device_pixel_rect_left(&rect) + step if bottom_left_resizer else gfx.device_pixel_rect_right(&rect) - step, m_y = gfx.device_pixel_rect_bottom(&rect))
let to = gfx.IntPoint(m_x = gfx.device_pixel_rect_left(&rect) if bottom_left_resizer else gfx.device_pixel_rect_right(&rect), m_y = gfx.device_pixel_rect_bottom(&rect) - step)
display_list.display_list_recorder_draw_line(recorder, from_, to, color, 1, gfx.LineStyle.solid)
## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:613 Web::Painting::PaintableBox::paint (override).
pub func paint_paintable_box_paint_impl(base: PaintPaintable*, context: DisplayListRecordingContext*, phase: PaintPhase):
let this = (PaintPaintableBox*)base
if not paint_paintable_is_visible(base):
return
let computed_values = &paint_paintable_computed_values(base).computed_values
if phase == PaintPhase.background and not paint_paintable_box_empty_cells_property_applies(this):
paint_paintable_box_paint_backdrop_filter(this, context)
paint_paintable_box_paint_background(this, context)
paint_paintable_box_paint_box_shadow(this, context)
let display = paint_paintable_display(base)
let is_table_with_collapsed_borders = css_display_is_table_inside(&display) and css_computed_values_border_collapse(computed_values) == css_data.BorderCollapse.collapse
if not css_display_is_table_cell(&display) and not is_table_with_collapsed_borders and phase == PaintPhase.border:
paint_paintable_box_paint_border(this, context)
if (css_display_is_table_inside(&display) or css_computed_values_border_collapse(computed_values) == css_data.BorderCollapse.collapse) and phase == PaintPhase.table_collapsed_border:
paint_paint_table_borders(context, this)
if phase == PaintPhase.outline:
if let outline_data = paint_paintable_box_outline_data(this):
let outline_offset = paint_paintable_box_outline_offset(this)
var border_radius_data = paint_paintable_box_normalized_border_radii_data(this, PaintPaintableBoxShrinkRadiiForBorders.no)
var borders_rect = paint_paintable_box_absolute_border_box_rect(this)
var outline_offset_x = outline_offset
var outline_offset_y = outline_offset
# "Both the height and the width of the outside of the shape drawn by the outline should not
# become smaller than twice the computed value of the outline-width property to make sure
# that an outline can be rendered even with large negative values."
# https://www.w3.org/TR/css-ui-4/#outline-offset
# So, if the horizontal outline offset is > half the borders_rect's width then we set it to that.
# (And the same for y)
let half_width = layout_div_int(gfx.css_pixel_rect_width(&borders_rect), 2)
let half_height = layout_div_int(gfx.css_pixel_rect_height(&borders_rect), 2)
if half_width.add(outline_offset_x).lt(gfx.CssPixels.from_int(0)):
outline_offset_x = layout_div_int(gfx.css_pixel_rect_width(&borders_rect).neg(), 2)
if half_height.add(outline_offset_y).lt(gfx.CssPixels.from_int(0)):
outline_offset_y = layout_div_int(gfx.css_pixel_rect_height(&borders_rect).neg(), 2)
display_list.border_radii_data_inflate(&border_radius_data, outline_data.top.width.add(outline_offset_y), outline_data.right.width.add(outline_offset_x), outline_data.bottom.width.add(outline_offset_y), outline_data.left.width.add(outline_offset_x))
gfx.css_pixel_rect_inflate_css_pixels_css_pixels_css_pixels(&borders_rect, outline_data.top.width.add(outline_offset_y), outline_data.right.width.add(outline_offset_x), outline_data.bottom.width.add(outline_offset_y), outline_data.left.width.add(outline_offset_x))
paint_paint_all_borders(display_list_recording_context_display_list_recorder(context), display_list_recording_context_rounded_device_rect(context, borders_rect), border_radii_data_as_corners(&border_radius_data, display_list_recording_context_device_pixel_converter(context)), borders_data_to_device_pixels(&outline_data, *context))
if phase == PaintPhase.overlay:
let metrics = display_list_recording_context_chrome_metrics(context)
if (paint_g_paint_viewport_scrollbars or not paint_paintable_is_viewport_paintable(base)) and css_computed_values_scrollbar_width(computed_values) != css_data.ScrollbarWidth.none_:
let scrollbar_colors = css_computed_values_scrollbar_color(computed_values)
let directions: PaintPaintableBoxScrollDirection[2] = [PaintPaintableBoxScrollDirection.vertical, PaintPaintableBoxScrollDirection.horizontal]
for direction in directions:
let scrollbar_data = paint_paintable_box_compute_scrollbar_data(this, direction, metrics) else continue
display_list.display_list_recorder_paint_scrollbar(display_list_recording_context_display_list_recorder(context),
this.m_own_scroll_frame_index,
display_list_recording_context_rounded_device_rect(context, scrollbar_data.gutter_rect),
display_list_recording_context_rounded_device_rect(context, scrollbar_data.thumb_rect),
gfx.css_pixel_fraction_to_double(&scrollbar_data.thumb_travel_to_scroll_ratio),
scrollbar_colors.thumb_color,
scrollbar_colors.track_color,
direction == PaintPaintableBoxScrollDirection.vertical)
if let resizer_rect = paint_paintable_box_absolute_resizer_rect(this, metrics):
let bottom_left_resizer = paint_paintable_box_is_chrome_mirrored(this)
let padding = metrics.resize_gripper_padding
let half_padding = layout_div_int(padding, 2)
let shrunken = gfx.css_pixel_rect_shrunken_css_pixels_css_pixels(&resizer_rect, padding, padding)
let css_rect = gfx.css_pixel_rect_translated_css_pixels_css_pixels(&shrunken, half_padding if bottom_left_resizer else layout_div_int(padding.neg(), 2), layout_div_int(padding.neg(), 2))
let rect = display_list_recording_context_rounded_device_rect(context, css_rect)
let dark = gfx.color_new_u8_u8_u8_u8(0, 0, 0, 100)
let light = gfx.color_new_u8_u8_u8_u8(255, 255, 255, 100)
let recorder = display_list_recording_context_display_list_recorder(context)
var step = (gfx.device_pixel_rect_width(&rect) // 3) - 1
while step < gfx.device_pixel_rect_width(&rect):
paint_paintable_box_paint_resizer_line(recorder, rect, bottom_left_resizer, step, light)
paint_paintable_box_paint_resizer_line(recorder, rect, bottom_left_resizer, step + 1, dark)
step += gfx.device_pixel_rect_width(&rect) // 3
paint_paintable_box_paint_middle_button_scroll_indicator(this, context)
## The `paint_arrow` lambda of PaintableBox::paint_middle_button_scroll_indicator.
func paint_paintable_box_paint_arrow(recorder: display_list.DisplayListRecorder*, p1: gfx.FloatPoint, p2: gfx.FloatPoint, p3: gfx.FloatPoint, color: gfx.Color):
var path = gfx.Path()
gfx.path_move_to(&path, p1)
gfx.path_line_to(&path, p2)
gfx.path_line_to(&path, p3)
gfx.path_close(&path)
display_list.display_list_recorder_fill_path(recorder, display_list.DisplayListRecorderFillPathParams(path = path, paint_style_or_color = display_list.PaintStyleOrColor.color(color)))
## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:713 Web::Painting::PaintableBox::paint_middle_button_scroll_indicator.
pub func paint_paintable_box_paint_middle_button_scroll_indicator(this: PaintPaintableBox*, context: DisplayListRecordingContext*):
let white = gfx.color_new_named_color(gfx.ColorNamedColor.white)
let circle_color = gfx.color_with_alpha(&white, 220)
let arrow_color = gfx.color_new_named_color(gfx.ColorNamedColor.dark_gray)
let radius: i32 = 16
let arrow_size: f32 = 6.0
let arrow_offset: f32 = 8.0
if not paint_paintable_is_viewport_paintable(this.paint_paintable()):
return
let navigable = paint_paintable_navigable(this.paint_paintable()) else return
let handler = event_handler_middle_button_scroll_handler(html_navigable_event_handler(navigable)) else return
let recorder = display_list_recording_context_display_list_recorder(context)
let device_origin = display_list_recording_context_rounded_device_point(context, middle_button_scroll_handler_origin(handler))
let circle = gfx.DevicePixelRect(m_location = gfx.IntPoint(m_x = device_origin.m_x - radius, m_y = device_origin.m_y - radius), m_size = gfx.IntSize(m_width = radius * 2, m_height = radius * 2))
display_list.display_list_recorder_fill_ellipse(recorder, circle, circle_color)
display_list.display_list_recorder_draw_ellipse(recorder, circle, arrow_color, 1)
let x = (f32)device_origin.m_x
let y = (f32)device_origin.m_y
# FIXME: We could paint a subset of these arrows depending on which direction the container may be scrolled.
paint_paintable_box_paint_arrow(recorder, gfx.FloatPoint(m_x = x, m_y = y - arrow_offset - arrow_size), gfx.FloatPoint(m_x = x - arrow_size, m_y = y - arrow_offset), gfx.FloatPoint(m_x = x + arrow_size, m_y = y - arrow_offset), arrow_color)
paint_paintable_box_paint_arrow(recorder, gfx.FloatPoint(m_x = x, m_y = y + arrow_offset + arrow_size), gfx.FloatPoint(m_x = x - arrow_size, m_y = y + arrow_offset), gfx.FloatPoint(m_x = x + arrow_size, m_y = y + arrow_offset), arrow_color)
paint_paintable_box_paint_arrow(recorder, gfx.FloatPoint(m_x = x - arrow_offset - arrow_size, m_y = y), gfx.FloatPoint(m_x = x - arrow_offset, m_y = y - arrow_size), gfx.FloatPoint(m_x = x - arrow_offset, m_y = y + arrow_size), arrow_color)
paint_paintable_box_paint_arrow(recorder, gfx.FloatPoint(m_x = x + arrow_offset + arrow_size, m_y = y), gfx.FloatPoint(m_x = x + arrow_offset, m_y = y - arrow_size), gfx.FloatPoint(m_x = x + arrow_offset, m_y = y + arrow_size), arrow_color)
## The `paint_inspector_rect` lambda of PaintableBox::paint_inspector_overlay_internal.
func paint_paintable_box_paint_inspector_rect(context: DisplayListRecordingContext*, rect: gfx.CssPixelRect, color: gfx.Color):
let device_rect = display_list_recording_context_enclosing_device_rect(context, rect)
display_list.display_list_recorder_fill_rect(display_list_recording_context_display_list_recorder(context), device_rect, gfx.color_with_alpha(&color, 100))
display_list.display_list_recorder_draw_rect(display_list_recording_context_display_list_recorder(context), device_rect, color)
## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:762 Web::Painting::PaintableBox::paint_inspector_overlay_internal (override).
pub func paint_paintable_box_paint_inspector_overlay_internal_impl(base: PaintPaintable*, context: DisplayListRecordingContext*):
let this = (PaintPaintableBox*)base
let content_rect = paint_paintable_box_absolute_united_content_rect(this)
let margin_rect = paint_united_rect_for_continuation_chain(this, PaintUnitedRect.margin_box)
let border_rect = paint_paintable_box_absolute_united_border_box_rect(this)
let padding_rect = paint_paintable_box_absolute_united_padding_box_rect(this)
paint_paintable_box_paint_inspector_rect(context, margin_rect, gfx.color_new_named_color(gfx.ColorNamedColor.yellow))
paint_paintable_box_paint_inspector_rect(context, padding_rect, gfx.color_new_named_color(gfx.ColorNamedColor.cyan))
paint_paintable_box_paint_inspector_rect(context, border_rect, gfx.color_new_named_color(gfx.ColorNamedColor.green))
paint_paintable_box_paint_inspector_rect(context, content_rect, gfx.color_new_named_color(gfx.ColorNamedColor.magenta))
let font = platform_font_plugin_default_font(platform_font_plugin_the(), 12.0) else trap("no default font")
var builder = ak.string_builder_new_mode(ak.StringBuilderMode.utf16)
let description = paint_paintable_debug_description(base)
ak.string_builder_append_string_view(&builder, ak.string_bytes_as_string_view(&description))
dump_appendff(&builder, " {}x{} @ {},{}", [
dump_arg_css_pixels(gfx.css_pixel_rect_width(&border_rect)),
dump_arg_css_pixels(gfx.css_pixel_rect_height(&border_rect)),
dump_arg_css_pixels(gfx.css_pixel_rect_x(&border_rect)),
dump_arg_css_pixels(gfx.css_pixel_rect_y(&border_rect)),
])
let size_text = ak.string_builder_to_utf16_string(&builder)
var size_text_rect = border_rect
gfx.css_pixel_rect_set_y(&size_text_rect, gfx.css_pixel_rect_y(&border_rect).add(gfx.css_pixel_rect_height(&border_rect)))
gfx.css_pixel_rect_set_top(&size_text_rect, gfx.css_pixel_rect_top(&size_text_rect))
gfx.css_pixel_rect_set_width(&size_text_rect, gfx.css_pixels_nearest_value_for_f32(web_fonts.font_width(font, ak.utf16_string_base_utf16_view(&size_text.utf16_string_base))).add(gfx.CssPixels.from_int(4)))
gfx.css_pixel_rect_set_height(&size_text_rect, gfx.css_pixels_nearest_value_for_f32(web_fonts.font_pixel_size(font)).add(gfx.CssPixels.from_int(4)))
let size_text_device_rect = display_list_recording_context_enclosing_device_rect(context, size_text_rect)
let palette = display_list_recording_context_palette(context)
let recorder = display_list_recording_context_display_list_recorder(context)
display_list.display_list_recorder_fill_rect(recorder, size_text_device_rect, gfx.palette_color(&palette, gfx.ColorRole.tooltip))
display_list.display_list_recorder_draw_rect(recorder, size_text_device_rect, gfx.palette_threed_shadow1(&palette))
let scaled_font = web_fonts.font_with_size(font, web_fonts.font_point_size(font) * (f32)display_list_recording_context_device_pixels_per_css_pixel(context))
display_list.display_list_recorder_draw_text(recorder, size_text_device_rect, &size_text, scaled_font, gfx.TextAlignment.center, gfx.palette_color(&palette, gfx.ColorRole.tooltip_text))
# mark: Stacking contexts =========================================================================
## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:803 Web::Painting::PaintableBox::set_stacking_context.
pub func paint_paintable_box_set_stacking_context(this: PaintPaintableBox*, stacking_context: PaintStackingContext*):
this.m_stacking_context = stacking_context
## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:808 Web::Painting::PaintableBox::invalidate_stacking_context.
pub func paint_paintable_box_invalidate_stacking_context(this: PaintPaintableBox*):
this.m_stacking_context = none
## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:813 Web::Painting::PaintableBox::effective_z_index.
pub func paint_paintable_box_effective_z_index(this: PaintPaintableBox*) -> i32?:
# https://drafts.csswg.org/css2/#z-index
# Applies to: positioned elements
if paint_paintable_is_positioned(this.paint_paintable()):
return css_computed_values_z_index(&paint_paintable_computed_values(this.paint_paintable()).computed_values)
return none
# mark: Borders, backgrounds and shadows ==========================================================
## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:823 Web::Painting::PaintableBox::remove_element_kind_from_borders_data.
pub func paint_paintable_box_remove_element_kind_from_borders_data(borders_data: PaintPaintableBoxBordersDataWithElementKind) -> display_list.BordersData:
return display_list.BordersData(
top = borders_data.top.border_data,
right = borders_data.right.border_data,
bottom = borders_data.bottom.border_data,
left = borders_data.left.border_data,
)
## `CSS::BorderData()`: a default border (transparent, no line style, zero width).
func paint_default_border_data() -> display_list.BorderData:
var border_data = display_list.BorderData()
display_list.border_data_init_fields(&border_data)
return border_data
## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:833 Web::Painting::PaintableBox::paint_border (virtual).
pub func paint_paintable_box_paint_border_impl(this: PaintPaintableBox*, context: DisplayListRecordingContext*):
var borders_data: display_list.BordersData = ---
if let override_borders_data = this.m_override_borders_data:
borders_data = paint_paintable_box_remove_element_kind_from_borders_data(override_borders_data)
else:
let computed_values = &paint_paintable_computed_values(this.paint_paintable()).computed_values
let border = this.m_box_model.border
borders_data = display_list.BordersData(
top = paint_default_border_data() if gfx.eq_css_pixels_int(border.top, 0) else css_computed_values_border_top(computed_values),
right = paint_default_border_data() if gfx.eq_css_pixels_int(border.right, 0) else css_computed_values_border_right(computed_values),
bottom = paint_default_border_data() if gfx.eq_css_pixels_int(border.bottom, 0) else css_computed_values_border_bottom(computed_values),
left = paint_default_border_data() if gfx.eq_css_pixels_int(border.left, 0) else css_computed_values_border_left(computed_values),
)
let radii = paint_paintable_box_normalized_border_radii_data(this)
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(this)), border_radii_data_as_corners(&radii, display_list_recording_context_device_pixel_converter(context)), borders_data_to_device_pixels(&borders_data, *context))
## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:844 Web::Painting::PaintableBox::paint_backdrop_filter (virtual).
pub func paint_paintable_box_paint_backdrop_filter_impl(this: PaintPaintableBox*, context: DisplayListRecordingContext*):
let backdrop_filter = css_computed_values_backdrop_filter(&paint_paintable_computed_values(this.paint_paintable()).computed_values)
if not css_filter_has_filters(&backdrop_filter):
return
let resolved = paint_resolve_css_filter(backdrop_filter, this)
let backdrop_region = display_list_recording_context_rounded_device_rect(context, paint_paintable_box_absolute_border_box_rect(this))
let border_radii_data = paint_paintable_box_normalized_border_radii_data(this)
var corner_clipper: PaintScopedCornerRadiusClip = ---
paint_scoped_corner_radius_clip_construct(&corner_clipper, context, backdrop_region, border_radii_data)
defer paint_scoped_corner_radius_clip_destruct(&corner_clipper)
if let gfx_filter = paint_to_gfx_filter(resolved, display_list_recording_context_device_pixels_per_css_pixel(context)):
display_list.display_list_recorder_apply_backdrop_filter(display_list_recording_context_display_list_recorder(context), backdrop_region, border_radii_data_as_corners(&border_radii_data, display_list_recording_context_device_pixel_converter(context)), gfx_filter)
## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:856 Web::Painting::PaintableBox::paint_background (virtual).
pub func paint_paintable_box_paint_background_impl(this: PaintPaintableBox*, context: DisplayListRecordingContext*):
let document = paint_paintable_document(this.paint_paintable())
# If the body's background properties were propagated to the root element, do not re-paint the body's background.
let layout_node = paint_paintable_box_layout_node_with_style_and_box_metrics(this)
if layout_node_with_style_is_body(layout_node.layout_node_with_style()):
let html_element = dom_document_html_element(document) else trap("a body without an html element")
if html_html_element_should_use_body_background_properties(html_element):
return
let computed_values = &paint_paintable_computed_values(this.paint_paintable()).computed_values
var background_rect = gfx.CssPixelRect()
var background_color = css_computed_values_background_color(computed_values)
var own_layers = css_computed_values_background_layers(computed_values)
var background_layers: const ak.Vector[CssBackgroundLayerData]*? = &own_layers
# https://drafts.csswg.org/css-backgrounds/#root-background
let is_root = layout_node_is_root_element(layout_node.layout_node())
if is_root:
background_rect = paint_paintable_box_absolute_border_box_rect(this)
let html_element = as_html_html_element(layout_node_dom_node(layout_node.layout_node()) else trap("the root element has no DOM node"))
if html_html_element_should_use_body_background_properties(html_element):
background_layers = dom_document_background_layers(document)
background_color = dom_document_background_color(document)
else:
background_rect = paint_paintable_box_absolute_padding_box_rect(this)
# HACK: If the Box has a border, use the bordered_rect to paint the background.
# This way if we have a border-radius there will be no gap between the filling and actual border.
if css_computed_values_border_top(computed_values).width != gfx.CssPixels.from_int(0) or css_computed_values_border_right(computed_values).width != gfx.CssPixels.from_int(0) or css_computed_values_border_bottom(computed_values).width != gfx.CssPixels.from_int(0) or css_computed_values_border_left(computed_values).width != gfx.CssPixels.from_int(0):
background_rect = paint_paintable_box_absolute_border_box_rect(this)
let border_radii = paint_paintable_box_normalized_border_radii_data(this)
var resolved_background = PaintResolvedBackground()
if let layers = background_layers:
resolved_background = paint_resolve_background_layers(*layers, this, background_color, css_computed_values_background_color_clip(computed_values), background_rect, border_radii)
if is_root:
let navigable = paint_paintable_navigable(this.paint_paintable()) else trap("the root element's document has no navigable")
var canvas_rect = html_navigable_viewport_rect(navigable)
if let overflow_rect = paint_paintable_box_scrollable_overflow_rect(this):
gfx.css_pixel_rect_unite(&canvas_rect, overflow_rect)
gfx.css_pixel_rect_unite(&resolved_background.background_rect, canvas_rect)
gfx.css_pixel_rect_unite(&resolved_background.color_box.rect, canvas_rect)
# If the body's background was propagated to the root element, use the body's image-rendering value.
var image_rendering = css_computed_values_image_rendering(computed_values)
if layout_node_is_root_element(paint_paintable_layout_node(this.paint_paintable())):
if let html_element = dom_document_html_element(document):
if html_html_element_should_use_body_background_properties(html_element):
image_rendering = dom_document_background_image_rendering(document)
paint_paint_background(context, this, image_rendering, resolved_background, border_radii)
## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:910 Web::Painting::PaintableBox::paint_box_shadow (virtual).
pub func paint_paintable_box_paint_box_shadow_impl(this: PaintPaintableBox*, context: DisplayListRecordingContext*):
let computed_values = &paint_paintable_computed_values(this.paint_paintable()).computed_values
var box_shadow_layers = css_computed_values_box_shadow(computed_values)
if ak.vector_is_empty(&box_shadow_layers):
return
var resolved_box_shadow_data: ak.Vector[PaintShadowData]
ak.vector_ensure_capacity(&resolved_box_shadow_data, ak.vector_size(&box_shadow_layers))
for layer in ak.vector_span(&box_shadow_layers):
ak.vector_unchecked_append_u(&resolved_box_shadow_data, paint_shadow_data_from_css(layer, paint_paintable_layout_node(this.paint_paintable())))
let borders_data = display_list.BordersData(
top = css_computed_values_border_top(computed_values),
right = css_computed_values_border_right(computed_values),
bottom = css_computed_values_border_bottom(computed_values),
left = css_computed_values_border_left(computed_values),
)
paint_paint_box_shadow(context, paint_paintable_box_absolute_border_box_rect(this), paint_paintable_box_absolute_padding_box_rect(this),
borders_data, paint_paintable_box_normalized_border_radii_data(this), resolved_box_shadow_data)
## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:929 Web::Painting::PaintableBox::normalized_border_radii_data.
pub func paint_paintable_box_normalized_border_radii_data(this: PaintPaintableBox*, shrink: PaintPaintableBoxShrinkRadiiForBorders = PaintPaintableBoxShrinkRadiiForBorders.no) -> display_list.BorderRadiiData:
var border_radii_data = paint_paintable_box_border_radii_data(this)
if shrink == PaintPaintableBoxShrinkRadiiForBorders.yes:
let computed_values = &paint_paintable_computed_values(this.paint_paintable()).computed_values
display_list.border_radii_data_shrink(&border_radii_data, css_computed_values_border_top(computed_values).width, css_computed_values_border_right(computed_values).width, css_computed_values_border_bottom(computed_values).width, css_computed_values_border_left(computed_values).width)
return border_radii_data
# mark: Visual contexts ===========================================================================
## `document().page().client().device_pixels_per_css_pixel()` as a float.
func paint_paintable_box_pixel_ratio(this: PaintPaintableBox*) -> f32:
return (f32)page_client_device_pixels_per_css_pixel(page_client(dom_document_page(paint_paintable_document(this.paint_paintable()))))
## The document's ViewportPaintable.
func paint_paintable_box_viewport_paintable(this: PaintPaintableBox*) -> PaintViewportPaintable*:
return dom_document_paintable(paint_paintable_document(this.paint_paintable())) else trap("the document has no paintable")
## `point.to_type<float>() * pixel_ratio`.
func paint_css_point_to_device_float(point: gfx.CssPixelPoint, pixel_ratio: f32) -> gfx.FloatPoint:
return gfx.FloatPoint(m_x = point.m_x.to_float() * pixel_ratio, m_y = point.m_y.to_float() * pixel_ratio)
## `(point / pixel_ratio).to_type<CSSPixels>()`.
func paint_device_float_to_css_point(point: gfx.FloatPoint, pixel_ratio: f32) -> gfx.CssPixelPoint:
return gfx.CssPixelPoint(gfx.CssPixels.from_f32(point.m_x / pixel_ratio), gfx.CssPixels.from_f32(point.m_y / pixel_ratio))
## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:937 Web::Painting::PaintableBox::transform_point_to_local.
pub func paint_paintable_box_transform_point_to_local(this: PaintPaintableBox*, screen_position: gfx.CssPixelPoint) -> gfx.CssPixelPoint?:
if this.m_accumulated_visual_context_index == 0:
return screen_position
let pixel_ratio = paint_paintable_box_pixel_ratio(this)
let viewport_paintable = paint_paintable_box_viewport_paintable(this)
let scroll_state = paint_viewport_paintable_scroll_state_snapshot(viewport_paintable)
let visual_context_tree = paint_viewport_paintable_visual_context_tree(viewport_paintable)
let result = display_list.accumulated_visual_context_tree_transform_point_for_hit_test(visual_context_tree, this.m_accumulated_visual_context_index, paint_css_point_to_device_float(screen_position, pixel_ratio), &scroll_state) else return none
return paint_device_float_to_css_point(result, pixel_ratio)
## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:950 Web::Painting::PaintableBox::transform_point_to_local_for_descendants.
pub func paint_paintable_box_transform_point_to_local_for_descendants(this: PaintPaintableBox*, screen_position: gfx.CssPixelPoint) -> gfx.CssPixelPoint?:
if this.m_accumulated_visual_context_for_descendants_index == 0:
return screen_position
let pixel_ratio = paint_paintable_box_pixel_ratio(this)
let viewport_paintable = paint_paintable_box_viewport_paintable(this)
let scroll_state = paint_viewport_paintable_scroll_state_snapshot(viewport_paintable)
let visual_context_tree = paint_viewport_paintable_visual_context_tree(viewport_paintable)
let result = display_list.accumulated_visual_context_tree_transform_point_for_hit_test(visual_context_tree, this.m_accumulated_visual_context_for_descendants_index, paint_css_point_to_device_float(screen_position, pixel_ratio), &scroll_state) else return none
return paint_device_float_to_css_point(result, pixel_ratio)
## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:963 Web::Painting::PaintableBox::transform_rect_to_viewport.
pub func paint_paintable_box_transform_rect_to_viewport(this: PaintPaintableBox*, rect: gfx.CssPixelRect) -> gfx.CssPixelRect:
if this.m_accumulated_visual_context_index == 0:
return rect
let pixel_ratio = paint_paintable_box_pixel_ratio(this)
let viewport_paintable = paint_paintable_box_viewport_paintable(this)
let scroll_state = paint_viewport_paintable_scroll_state_snapshot(viewport_paintable)
let visual_context_tree = paint_viewport_paintable_visual_context_tree(viewport_paintable)
let float_rect = gfx.css_pixel_rect_to_type_f32(&rect)
let device_rect = gfx.float_rect_mul(&float_rect, pixel_ratio)
let result = display_list.accumulated_visual_context_tree_transform_rect_to_viewport(visual_context_tree, this.m_accumulated_visual_context_index, device_rect, &scroll_state)
let css_rect = gfx.float_rect_mul(&result, 1.0 / pixel_ratio)
return gfx.float_rect_to_type_css_pixels(&css_rect)
## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:974 Web::Painting::PaintableBox::inverse_transform_point.
pub func paint_paintable_box_inverse_transform_point(this: PaintPaintableBox*, screen_position: gfx.CssPixelPoint) -> gfx.CssPixelPoint:
if this.m_accumulated_visual_context_index == 0:
return screen_position
let pixel_ratio = paint_paintable_box_pixel_ratio(this)
let visual_context_tree = paint_viewport_paintable_visual_context_tree(paint_paintable_box_viewport_paintable(this))
let result = display_list.accumulated_visual_context_tree_inverse_transform_point(visual_context_tree, this.m_accumulated_visual_context_index, paint_css_point_to_device_float(screen_position, pixel_ratio))
return paint_device_float_to_css_point(result, pixel_ratio)
## Ported from Libraries/LibWeb/Painting/PaintableBox.cpp:984 Web::Painting::PaintableBox::transform_to_local_coordinates.
pub func paint_paintable_box_transform_to_local_coordinates(this: PaintPaintableBox*, screen_position: gfx.CssPixelPoint) -> gfx.CssPixelPoint:
return paint_paintable_box_transform_point_to_local(this, screen_position) else screen_position