Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / web / painting / svg_maskable.lucb

#==============================================================================================
#
#   svg_maskable - Painting::SVGMaskable: the <mask> and <clipPath> of an SVG paintable
#
#   DESCRIPTION:
#       Port of LibWeb/Painting/SVGMaskable.cpp (lines 1-128) and SVGMaskable.h: the mask and
#       clip boxes of a graphics element's layout node, the areas and kind of its mask and
#       clip path, and their display lists (the mask's or clip path's subtree painted with
#       the target's accumulated SVG transform).
#
#       SVGMaskable is a stateful mixin (DESIGN.md §2.5): `this` is the struct inside an
#       SVGGraphicsPaintable or an SVGForeignObjectPaintable, and `as_if<SVGGraphicsPaintable>`
#       of it finds the paintable through its class's mixin offsets.
#
#       Copyright (c) 2024-2026, Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: The mask and clip boxes ================================================================

## Ported from Libraries/LibWeb/Painting/SVGMaskable.cpp:19 Web::Painting::first_child_layout_node_of_type: the
## template over the layout class takes its ClassInfo (DESIGN.md §2.4).
func paint_first_child_layout_node_of_type(graphics_element: SvgGraphicsElement*, class_info: const ak.ClassInfo*) -> LayoutNode*?:
    # NB: Called during painting.
    let layout_node = dom_node_unsafe_layout_node(graphics_element.dom_node()) else return none
    return tree_node_first_child_of_type(layout_node, class_info)

## Ported from Libraries/LibWeb/Painting/SVGMaskable.cpp:27 Web::Painting::get_mask_box.
func paint_get_mask_box(graphics_element: SvgGraphicsElement*) -> LayoutSvgMaskBox*?:
    return (LayoutSvgMaskBox*?)paint_first_child_layout_node_of_type(graphics_element, &layout_svg_mask_box_class)

## Ported from Libraries/LibWeb/Painting/SVGMaskable.cpp:32 Web::Painting::get_clip_box.
func paint_get_clip_box(graphics_element: SvgGraphicsElement*) -> LayoutSvgClipBox*?:
    return (LayoutSvgClipBox*?)paint_first_child_layout_node_of_type(graphics_element, &layout_svg_clip_box_class)

## `as<SVG::SVGGraphicsElement const>(*dom_node_of_svg())`.
func paint_svg_maskable_graphics_element(this: PaintSvgMaskable*) -> SvgGraphicsElement*:
    return as_svg_graphics_element(paint_svg_maskable_dom_node_of_svg(this) else trap("VERIFY: an SVG maskable has a DOM node"))

# mark: Areas and kinds =========================================================================

## Ported from Libraries/LibWeb/Painting/SVGMaskable.cpp:37 Web::Painting::SVGMaskable::get_svg_mask_area.
pub func paint_svg_maskable_get_svg_mask_area(this: PaintSvgMaskable*) -> gfx.CssPixelRect?:
    let graphics_element = paint_svg_maskable_graphics_element(this)
    if let mask_box = paint_get_mask_box(graphics_element):
        let mask_paintable_box = layout_box_paintable_box(mask_box.layout_box()) else trap("VERIFY: a mask box has a paintable box")
        return svg_mask_element_resolve_masking_area(layout_svg_mask_box_dom_node(mask_box), paint_paintable_box_absolute_border_box_rect(mask_paintable_box))
    return none

## Ported from Libraries/LibWeb/Painting/SVGMaskable.cpp:45 Web::Painting::SVGMaskable::get_svg_clip_area.
pub func paint_svg_maskable_get_svg_clip_area(this: PaintSvgMaskable*) -> gfx.CssPixelRect?:
    let graphics_element = paint_svg_maskable_graphics_element(this)
    let clip_box = paint_get_clip_box(graphics_element) else return none

    let clip_paintable = as_paint_svg_paintable(layout_box_paintable_box(clip_box.layout_box()) else trap("VERIFY: a clip box has a paintable box"))

    var clip_path_transform = paint_svg_maskable_target_svg_transform(this)
    gfx.affine_transform_multiply(&clip_path_transform, svg_graphics_element_element_transform(layout_svg_clip_box_dom_node(clip_box).svg_graphics_element()))
    # An empty clipping path will completely clip away the element that had the clip-path property applied.
    return paint_svg_paintable_clip_path_geometry_bounds(clip_paintable, clip_path_transform) else gfx.CssPixelRect(m_location = gfx.CssPixelPoint(m_x = layout_zero_px(), m_y = layout_zero_px()), m_size = gfx.CssPixelSize(m_width = layout_zero_px(), m_height = layout_zero_px()))

## Ported from Libraries/LibWeb/Painting/SVGMaskable.cpp:59 Web::Painting::mask_type_to_gfx_mask_kind.
func paint_mask_type_to_gfx_mask_kind(mask_type: css_data.MaskType) -> gfx.MaskKind:
    match mask_type:
        .alpha:
            return gfx.MaskKind.alpha
        .luminance:
            return gfx.MaskKind.luminance
        _:
            trap("VERIFY_NOT_REACHED")

## Ported from Libraries/LibWeb/Painting/SVGMaskable.cpp:71 Web::Painting::SVGMaskable::get_svg_mask_type.
pub func paint_svg_maskable_get_svg_mask_type(this: PaintSvgMaskable*) -> gfx.MaskKind?:
    let graphics_element = paint_svg_maskable_graphics_element(this)
    if let mask_box = paint_get_mask_box(graphics_element):
        return paint_mask_type_to_gfx_mask_kind(css_computed_values_mask_type(&layout_node_computed_values(mask_box.layout_node()).computed_values))
    return none

# mark: Display lists ===========================================================================

## Ported from Libraries/LibWeb/Painting/SVGMaskable.cpp:79 Web::Painting::paint_mask_or_clip_to_display_list.
func paint_paint_mask_or_clip_to_display_list(context: DisplayListRecordingContext*, target_svg_transform: gfx.AffineTransform, paintable: PaintPaintableBox*, area: gfx.CssPixelRect, is_clip_path: bool) -> display_list.DisplayList*?:
    let mask_rect = display_list_recording_context_enclosing_device_rect(context, area)
    let mask_display_list = display_list.display_list_create(display_list.accumulated_visual_context_tree_create())
    var display_list_recorder = display_list.display_list_recorder_new(mask_display_list)
    let mask_location = gfx.device_pixel_rect_location(&mask_rect)
    display_list.display_list_recorder_translate(&display_list_recorder, gfx.int_point_neg(&mask_location))
    var paint_context = display_list_recording_context_clone(context, &display_list_recorder)
    let mask_element = as_svg_graphics_element(paint_paintable_dom_node(paintable.paint_paintable()) else trap("VERIFY: a mask or clip paintable has a DOM node"))
    # Layout computes transforms only within the mask/clip subtree, so prepend the target's accumulated transform here.
    var svg_transform = target_svg_transform
    gfx.affine_transform_multiply(&svg_transform, svg_graphics_element_element_transform(mask_element))
    display_list_recording_context_set_svg_transform(&paint_context, svg_transform)
    display_list_recording_context_set_draw_svg_geometry_for_clip_path(&paint_context, is_clip_path)
    paint_stacking_context_paint_svg(&paint_context, paintable, PaintPhase.foreground)
    return mask_display_list

## Ported from Libraries/LibWeb/Painting/SVGMaskable.cpp:100 Web::Painting::SVGMaskable::target_svg_transform.
func paint_svg_maskable_target_svg_transform(this: PaintSvgMaskable*) -> gfx.AffineTransform:
    # Only SVGGraphicsPaintable carries an SVG transform; other targets (e.g. foreign objects) use identity.
    let paintable = paint_svg_maskable_paintable(this)
    if let svg_graphics_paintable = as_if_paint_svg_graphics_paintable(paintable):
        let computed_transforms = paint_svg_graphics_paintable_computed_transforms(svg_graphics_paintable)
        return paint_svg_graphics_paintable_computed_transforms_svg_transform(&computed_transforms)
    return layout_identity_affine_transform()

## The paintable an SVGMaskable base belongs to (the C++ cross-cast from the mixin to the cell): found through the
## mixin offsets of its class.
func paint_svg_maskable_paintable(this: PaintSvgMaskable*) -> PaintPaintable*:
    let mixins = (const MixinOffsets*)(this.vtable.class_info.mixins else trap("VERIFY: the class of an SVG maskable has mixins"))
    let offset = mixins.svg_maskable else trap("VERIFY: the class of an SVG maskable has an SVGMaskable base")
    return (PaintPaintable*)((u8*)this - offset)

## Ported from Libraries/LibWeb/Painting/SVGMaskable.cpp:108 Web::Painting::SVGMaskable::calculate_svg_mask_display_list.
pub func paint_svg_maskable_calculate_svg_mask_display_list(this: PaintSvgMaskable*, context: DisplayListRecordingContext*, mask_area: gfx.CssPixelRect) -> display_list.DisplayList*?:
    let graphics_element = paint_svg_maskable_graphics_element(this)
    let mask_box = paint_get_mask_box(graphics_element) else return none
    let mask_paintable = (PaintPaintableBox*)(layout_node_first_paintable(mask_box.layout_node()) else trap("VERIFY: a mask box has a paintable"))
    return paint_paint_mask_or_clip_to_display_list(context, paint_svg_maskable_target_svg_transform(this), mask_paintable, mask_area, false)

## Ported from Libraries/LibWeb/Painting/SVGMaskable.cpp:118 Web::Painting::SVGMaskable::calculate_svg_clip_display_list.
pub func paint_svg_maskable_calculate_svg_clip_display_list(this: PaintSvgMaskable*, context: DisplayListRecordingContext*, clip_area: gfx.CssPixelRect) -> display_list.DisplayList*?:
    let graphics_element = paint_svg_maskable_graphics_element(this)
    let clip_box = paint_get_clip_box(graphics_element) else return none
    let clip_paintable = (PaintPaintableBox*)(layout_node_first_paintable(clip_box.layout_node()) else trap("VERIFY: a clip box has a paintable"))
    return paint_paint_mask_or_clip_to_display_list(context, paint_svg_maskable_target_svg_transform(this), clip_paintable, clip_area, true)

## Ported from Libraries/LibWeb/Painting/SVGMaskable.h:19 Web::Painting::SVGMaskable::dom_node_of_svg (virtual).
pub func paint_svg_maskable_dom_node_of_svg_impl(this: PaintSvgMaskable*) -> DomNode*?:
    trap("pure virtual: Web::Painting::SVGMaskable::dom_node_of_svg")