Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / svg / svg_pattern_element.lucb

#==============================================================================================
#
#   svg_pattern_element - SVG::SVGPatternElement: <pattern>
#
#   DESCRIPTION:
#       Port of LibWeb/SVG/SVGPatternElement.cpp (lines 1-387) with the inline members of
#       SVGPatternElement.h (https://svgwg.org/svg2-draft/pservers.html#Patterns): the
#       patternUnits, patternContentUnits, patternTransform, x, y, width and height attributes
#       (each inherited through the href chain of linked patterns, as is the element whose
#       children are the content), and the pattern paint style: the pattern box's content
#       recorded into a tile display list.
#
#       `HashTable<SVGPatternElement const*>` of seen patterns is SvgPatternElementSet.
#
#==============================================================================================

## `HashTable<SVGPatternElement const*>`: the patterns an href chain has visited.
type SvgPatternElementSet = ak.HashTable[SvgPatternElement*, ak.PtrTraits[SvgPatternElement]]

# mark: Construction and attributes ==============================================================

## Ported from Libraries/LibWeb/SVG/SVGPatternElement.cpp:29 Web::SVG::SVGPatternElement::SVGPatternElement.
pub func svg_pattern_element_construct(this: SvgPatternElement*, document: DomDocument*, qualified_name: DomQualifiedName):
    svg_element_construct(this.svg_element(), document, qualified_name)
    # The vptrs of the mixin bases move to SVGPatternElement's tables.
    let element = this.svg_element()
    element.element.slottable_mixin.vtable = &svg_pattern_element_slottable_mixin_vtable
    element.element.aria_mixin.vtable = &svg_pattern_element_aria_mixin_vtable
    element.element.animatable.vtable = &svg_pattern_element_animatable_vtable
    element.global_event_handlers.vtable = &svg_pattern_element_global_event_handlers_vtable
    this.svg_fit_to_view_box.vtable = &svg_pattern_element_svg_fit_to_view_box_vtable
    this.svg_fit_to_view_box.class_id = this.cell().class_id

## Ported from Libraries/LibWeb/SVG/SVGPatternElement.cpp:34 Web::SVG::SVGPatternElement::initialize (override).
pub func svg_pattern_element_initialize_impl(base: JsCell*, realm: Realm*):
    let this = (SvgPatternElement*)base
    web_set_prototype_for_interface(base, realm, BindInterfaceName.svg_pattern_element)
    svg_element_initialize_impl(base, realm)
    svg_fit_to_view_box_initialize(&this.svg_fit_to_view_box, realm)

## Ported from Libraries/LibWeb/SVG/SVGPatternElement.cpp:41 Web::SVG::SVGPatternElement::visit_edges (override).
pub func svg_pattern_element_visit_edges_impl(base: gc.Cell*, visitor: gc.CellVisitor*):
    let this = (SvgPatternElement*)base
    svg_element_visit_edges_impl(base, visitor)
    svg_svguri_reference_mixin_visit_edges(&this.svguri_reference_mixin, visitor)
    svg_fit_to_view_box_visit_edges(&this.svg_fit_to_view_box, visitor)

## Ported from Libraries/LibWeb/SVG/SVGPatternElement.cpp:48 Web::SVG::SVGPatternElement::attribute_changed (override).
pub func svg_pattern_element_attribute_changed_impl(base: DomElement*, name: ak.FlyString, old_value: ak.String?, value: ak.String?, namespace_: ak.FlyString?):
    let this = (SvgPatternElement*)base
    svg_element_attribute_changed_impl(base, name, old_value, value, namespace_)
    svg_fit_to_view_box_attribute_changed(&this.svg_fit_to_view_box, base, name, value)

    let value_text = value else ak.String()  # value.value_or(String {})
    let value_view = ak.string_bytes_as_string_view(&value_text)
    if ak.fly_string_eq_fly_string(&name, &svg_attribute_names_pattern_units):
        this.m_pattern_units = svg_attribute_parser_parse_units(value_view)
    elif ak.fly_string_eq_fly_string(&name, &svg_attribute_names_pattern_content_units):
        this.m_pattern_content_units = svg_attribute_parser_parse_units(value_view)
    elif ak.fly_string_eq_fly_string(&name, &svg_attribute_names_pattern_transform):
        if let transform_list = svg_attribute_parser_parse_transform_string_view(value_view):
            this.m_pattern_transform = svg_transform_from_transform_list(ak.vector_span_const(&transform_list))
        else:
            this.m_pattern_transform = none
    elif ak.fly_string_eq_fly_string(&name, &svg_attribute_names_x):
        this.m_x = svg_attribute_parser_parse_number_percentage(value_view)
    elif ak.fly_string_eq_fly_string(&name, &svg_attribute_names_y):
        this.m_y = svg_attribute_parser_parse_number_percentage(value_view)
    elif ak.fly_string_eq_fly_string(&name, &svg_attribute_names_width):
        this.m_width = svg_attribute_parser_parse_number_percentage(value_view)
    elif ak.fly_string_eq_fly_string(&name, &svg_attribute_names_height):
        this.m_height = svg_attribute_parser_parse_number_percentage(value_view)

# mark: The href chain ===========================================================================

## Ported from Libraries/LibWeb/SVG/SVGPatternElement.cpp:74 Web::SVG::SVGPatternElement::linked_pattern.
func svg_pattern_element_linked_pattern(this: SvgPatternElement*, seen_patterns: SvgPatternElementSet*) -> SvgPatternElement*?:
    # FIXME: This can only resolve same-document references. The spec allows cross-document references.
    let element_this = this.dom_element()
    let link = dom_element_get_attribute(element_this, svg_attribute_names_href) if dom_element_has_attribute(element_this, svg_attribute_names_href) else dom_element_get_attribute(element_this, ak.fly_string_from_str("xlink:href"))
    let href = link else return none
    if ak.string_is_empty(&href):
        return none

    let document = dom_node_document(this.dom_node())
    let url = dom_document_encoding_parse_url(document, ak.string_bytes_as_string_view(&href)) else return none

    let id = web_url.url_fragment(&url) else return none
    if ak.string_is_empty(&id):
        return none

    let element = dom_parent_node_get_element_by_id(document.dom_parent_node(), ak.fly_string_from_string(id)) else return none

    if element.dom_node() == this.dom_node():
        return none
    let pattern = as_if_svg_pattern_element(element) else return none

    # Detect circular references in the template chain.
    if ak.hash_table_set(seen_patterns, pattern) != ak.HashSetResult.inserted_new_entry:
        return none

    return pattern

## Ported from Libraries/LibWeb/SVG/SVGPatternElement.cpp:106 Web::SVG::SVGPatternElement::pattern_content_element.
pub func svg_pattern_element_pattern_content_element(this: SvgPatternElement*) -> SvgPatternElement*?:
    var seen_patterns: SvgPatternElementSet
    return svg_pattern_element_pattern_content_element_impl(this, &seen_patterns)

## Ported from Libraries/LibWeb/SVG/SVGPatternElement.cpp:112 Web::SVG::SVGPatternElement::pattern_content_element_impl.
func svg_pattern_element_pattern_content_element_impl(this: SvgPatternElement*, seen_patterns: SvgPatternElementSet*) -> SvgPatternElement*?:
    if dom_parent_node_child_element_count(this.dom_parent_node()) > 0:
        return this
    if let pattern = svg_pattern_element_linked_pattern(this, seen_patterns):
        return svg_pattern_element_pattern_content_element_impl(pattern, seen_patterns)
    return none

## Ported from Libraries/LibWeb/SVG/SVGPatternElement.cpp:122 Web::SVG::SVGPatternElement::pattern_units.
# https://svgwg.org/svg2-draft/pservers.html#PatternElementPatternUnitsAttribute
pub func svg_pattern_element_pattern_units(this: SvgPatternElement*) -> SvgUnits:
    var seen_patterns: SvgPatternElementSet
    return svg_pattern_element_pattern_units_impl(this, &seen_patterns)

## Ported from Libraries/LibWeb/SVG/SVGPatternElement.cpp:128 Web::SVG::SVGPatternElement::pattern_units_impl.
func svg_pattern_element_pattern_units_impl(this: SvgPatternElement*, seen_patterns: SvgPatternElementSet*) -> SvgUnits:
    if let value = this.m_pattern_units:
        return value
    if let pattern = svg_pattern_element_linked_pattern(this, seen_patterns):
        return svg_pattern_element_pattern_units_impl(pattern, seen_patterns)
    # Initial value: objectBoundingBox
    return SvgUnits.object_bounding_box

## Ported from Libraries/LibWeb/SVG/SVGPatternElement.cpp:139 Web::SVG::SVGPatternElement::pattern_content_units.
# https://svgwg.org/svg2-draft/pservers.html#PatternElementPatternContentUnitsAttribute
pub func svg_pattern_element_pattern_content_units(this: SvgPatternElement*) -> SvgUnits:
    var seen_patterns: SvgPatternElementSet
    return svg_pattern_element_pattern_content_units_impl(this, &seen_patterns)

## Ported from Libraries/LibWeb/SVG/SVGPatternElement.cpp:145 Web::SVG::SVGPatternElement::pattern_content_units_impl.
func svg_pattern_element_pattern_content_units_impl(this: SvgPatternElement*, seen_patterns: SvgPatternElementSet*) -> SvgUnits:
    if let value = this.m_pattern_content_units:
        return value
    if let pattern = svg_pattern_element_linked_pattern(this, seen_patterns):
        return svg_pattern_element_pattern_content_units_impl(pattern, seen_patterns)
    # Initial value: userSpaceOnUse
    return SvgUnits.user_space_on_use

## Ported from Libraries/LibWeb/SVG/SVGPatternElement.cpp:156 Web::SVG::SVGPatternElement::pattern_transform.
# https://svgwg.org/svg2-draft/pservers.html#PatternElementPatternTransformAttribute
pub func svg_pattern_element_pattern_transform(this: SvgPatternElement*) -> gfx.AffineTransform?:
    var seen_patterns: SvgPatternElementSet
    return svg_pattern_element_pattern_transform_impl(this, &seen_patterns)

## Ported from Libraries/LibWeb/SVG/SVGPatternElement.cpp:162 Web::SVG::SVGPatternElement::pattern_transform_impl.
func svg_pattern_element_pattern_transform_impl(this: SvgPatternElement*, seen_patterns: SvgPatternElementSet*) -> gfx.AffineTransform?:
    if this.m_pattern_transform != none:
        return this.m_pattern_transform
    if let pattern = svg_pattern_element_linked_pattern(this, seen_patterns):
        return svg_pattern_element_pattern_transform_impl(pattern, seen_patterns)
    return none

## Ported from Libraries/LibWeb/SVG/SVGPatternElement.cpp:172 Web::SVG::SVGPatternElement::pattern_x.
# https://svgwg.org/svg2-draft/pservers.html#PatternElementXAttribute
pub func svg_pattern_element_pattern_x(this: SvgPatternElement*) -> SvgNumberPercentage:
    var seen_patterns: SvgPatternElementSet
    return svg_pattern_element_pattern_x_impl(this, &seen_patterns)

## Ported from Libraries/LibWeb/SVG/SVGPatternElement.cpp:178 Web::SVG::SVGPatternElement::pattern_x_impl.
func svg_pattern_element_pattern_x_impl(this: SvgPatternElement*, seen_patterns: SvgPatternElementSet*) -> SvgNumberPercentage:
    if let value = this.m_x:
        return value
    if let pattern = svg_pattern_element_linked_pattern(this, seen_patterns):
        return svg_pattern_element_pattern_x_impl(pattern, seen_patterns)
    return svg_number_percentage_create_number(0.0)

## Ported from Libraries/LibWeb/SVG/SVGPatternElement.cpp:188 Web::SVG::SVGPatternElement::pattern_y.
# https://svgwg.org/svg2-draft/pservers.html#PatternElementYAttribute
pub func svg_pattern_element_pattern_y(this: SvgPatternElement*) -> SvgNumberPercentage:
    var seen_patterns: SvgPatternElementSet
    return svg_pattern_element_pattern_y_impl(this, &seen_patterns)

## Ported from Libraries/LibWeb/SVG/SVGPatternElement.cpp:194 Web::SVG::SVGPatternElement::pattern_y_impl.
func svg_pattern_element_pattern_y_impl(this: SvgPatternElement*, seen_patterns: SvgPatternElementSet*) -> SvgNumberPercentage:
    if let value = this.m_y:
        return value
    if let pattern = svg_pattern_element_linked_pattern(this, seen_patterns):
        return svg_pattern_element_pattern_y_impl(pattern, seen_patterns)
    return svg_number_percentage_create_number(0.0)

## Ported from Libraries/LibWeb/SVG/SVGPatternElement.cpp:204 Web::SVG::SVGPatternElement::pattern_width.
# https://svgwg.org/svg2-draft/pservers.html#PatternElementWidthAttribute
pub func svg_pattern_element_pattern_width(this: SvgPatternElement*) -> SvgNumberPercentage:
    var seen_patterns: SvgPatternElementSet
    return svg_pattern_element_pattern_width_impl(this, &seen_patterns)

## Ported from Libraries/LibWeb/SVG/SVGPatternElement.cpp:210 Web::SVG::SVGPatternElement::pattern_width_impl.
func svg_pattern_element_pattern_width_impl(this: SvgPatternElement*, seen_patterns: SvgPatternElementSet*) -> SvgNumberPercentage:
    if let value = this.m_width:
        return value
    if let pattern = svg_pattern_element_linked_pattern(this, seen_patterns):
        return svg_pattern_element_pattern_width_impl(pattern, seen_patterns)
    return svg_number_percentage_create_number(0.0)

## Ported from Libraries/LibWeb/SVG/SVGPatternElement.cpp:220 Web::SVG::SVGPatternElement::pattern_height.
# https://svgwg.org/svg2-draft/pservers.html#PatternElementHeightAttribute
pub func svg_pattern_element_pattern_height(this: SvgPatternElement*) -> SvgNumberPercentage:
    var seen_patterns: SvgPatternElementSet
    return svg_pattern_element_pattern_height_impl(this, &seen_patterns)

## Ported from Libraries/LibWeb/SVG/SVGPatternElement.cpp:226 Web::SVG::SVGPatternElement::pattern_height_impl.
func svg_pattern_element_pattern_height_impl(this: SvgPatternElement*, seen_patterns: SvgPatternElementSet*) -> SvgNumberPercentage:
    if let value = this.m_height:
        return value
    if let pattern = svg_pattern_element_linked_pattern(this, seen_patterns):
        return svg_pattern_element_pattern_height_impl(pattern, seen_patterns)
    return svg_number_percentage_create_number(0.0)

# mark: The paint style ==========================================================================

## Ported from Libraries/LibWeb/SVG/SVGPatternElement.cpp:235 Web::SVG::SVGPatternElement::to_gfx_paint_style.
pub func svg_pattern_element_to_gfx_paint_style(this: SvgPatternElement*, paint_context: SvgPaintContext, recording_context: DisplayListRecordingContext*, target_layout_node: LayoutNode*) -> display_list.SvgPaintServerPaintStyle*?:
    let content_element = svg_pattern_element_pattern_content_element(this) else return none

    var pattern_box: LayoutSvgPatternBox*? = none
    # target_layout_node.for_each_child_of_type<Layout::SVGPatternBox>(...)
    for child in layout_node_children(target_layout_node):
        if let candidate = as_if_layout_svg_pattern_box(child):
            if layout_svg_pattern_box_dom_node(candidate).dom_node() == content_element.dom_node():
                pattern_box = candidate
                break
    let found_pattern_box = pattern_box else return none

    let pattern_paintable = layout_box_paintable_box(found_pattern_box.layout_box()) else return none

    var tile_x: f32 = 0.0
    var tile_y: f32 = 0.0
    var tile_width: f32 = 0.0
    var tile_height: f32 = 0.0
    if svg_pattern_element_pattern_units(this) == SvgUnits.object_bounding_box:
        # For objectBoundingBox, values are fractions of the bounding box.
        # NumberPercentage::value() already normalizes percentages to 0-1 range.
        let bbox = &paint_context.path_bounding_box
        let pattern_x = svg_pattern_element_pattern_x(this)
        let pattern_y = svg_pattern_element_pattern_y(this)
        let pattern_width = svg_pattern_element_pattern_width(this)
        let pattern_height = svg_pattern_element_pattern_height(this)
        tile_x = svg_number_percentage_value(&pattern_x) * gfx.float_rect_width(bbox) + gfx.float_rect_x(bbox)
        tile_y = svg_number_percentage_value(&pattern_y) * gfx.float_rect_height(bbox) + gfx.float_rect_y(bbox)
        tile_width = svg_number_percentage_value(&pattern_width) * gfx.float_rect_width(bbox)
        tile_height = svg_number_percentage_value(&pattern_height) * gfx.float_rect_height(bbox)
    else:
        # For userSpaceOnUse, resolve percentages relative to the viewport.
        let viewport = &paint_context.viewport
        let pattern_x = svg_pattern_element_pattern_x(this)
        let pattern_y = svg_pattern_element_pattern_y(this)
        let pattern_width = svg_pattern_element_pattern_width(this)
        let pattern_height = svg_pattern_element_pattern_height(this)
        tile_x = svg_number_percentage_resolve_relative_to(&pattern_x, gfx.float_rect_width(viewport))
        tile_y = svg_number_percentage_resolve_relative_to(&pattern_y, gfx.float_rect_height(viewport))
        tile_width = svg_number_percentage_resolve_relative_to(&pattern_width, gfx.float_rect_width(viewport))
        tile_height = svg_number_percentage_resolve_relative_to(&pattern_height, gfx.float_rect_height(viewport))

    if tile_width <= 0.0 or tile_height <= 0.0:
        return none

    let unmapped_tile_rect = gfx.FloatRect(m_location = gfx.FloatPoint(m_x = tile_x, m_y = tile_y), m_size = gfx.FloatSize(m_width = tile_width, m_height = tile_height))
    var tile_rect = gfx.affine_transform_map_f32_float_rect(&paint_context.paint_transform, unmapped_tile_rect)

    if gfx.float_rect_is_empty(&tile_rect):
        return none

    let svg_node = (LayoutSvgsvgBox*?)tree_node_first_ancestor_of_type(target_layout_node, &layout_svgsvg_box_class) else return none
    let svg_paintable_box = layout_box_paintable_box(svg_node.layout_box()) else return none
    let svg_element_rect = paint_paintable_box_absolute_rect(svg_paintable_box)
    let rounded_svg_offset = display_list_recording_context_rounded_device_point(recording_context, svg_element_rect.m_location)
    let svg_offset = gfx.int_point_to_type_f32(&rounded_svg_offset)
    gfx.float_rect_translate_by_float_point(&tile_rect, svg_offset)

    let tile_display_list = display_list.display_list_create(display_list.accumulated_visual_context_tree_create())
    var display_list_recorder = display_list.display_list_recorder_new(tile_display_list)
    let mapped_origin = gfx.affine_transform_map_f32_float_point(&paint_context.paint_transform, gfx.FloatPoint(m_x = 0.0, m_y = 0.0))
    let content_origin = gfx.float_point_add(&mapped_origin, svg_offset)
    let content_origin_int = gfx.float_point_to_type_i32(&content_origin)
    display_list.display_list_recorder_translate(&display_list_recorder, gfx.int_point_neg(&content_origin_int))
    var paint_context_copy = display_list_recording_context_clone(recording_context, &display_list_recorder)

    var target_svg_transform = layout_identity_affine_transform()  # Gfx::AffineTransform target_svg_transform;
    let first_paintable = layout_node_first_paintable(target_layout_node) else trap("VERIFY: target_layout_node.first_paintable()")
    if let svg_graphics_paintable = as_if_paint_svg_graphics_paintable(first_paintable):
        let computed_transforms = paint_svg_graphics_paintable_computed_transforms(svg_graphics_paintable)
        target_svg_transform = paint_svg_graphics_paintable_computed_transforms_svg_transform(&computed_transforms)
    display_list_recording_context_set_svg_transform(&paint_context_copy, target_svg_transform)

    paint_stacking_context_paint_svg(&paint_context_copy, pattern_paintable, PaintPhase.foreground)

    var user_space_pattern_transform: gfx.AffineTransform? = none
    let computed_properties = dom_element_computed_properties(this.dom_element()) else trap("VERIFY: computed_properties()")
    var css_transformations = css_computed_properties_transformations(computed_properties)
    if not ak.vector_is_empty(&css_transformations):
        var matrix = gfx.float_matrix4_x4_identity()
        var transform_valid = true
        for css_transform in ak.vector_span(&css_transformations):
            let result = css_transformation_style_value_to_matrix(css_transform, pattern_paintable) catch:
                transform_valid = false
                break
            matrix = gfx.float_matrix4_x4_mul(&matrix, result)
        if transform_valid:
            user_space_pattern_transform = gfx.extract_2d_affine_transform(&matrix)
    else:
        user_space_pattern_transform = svg_pattern_element_pattern_transform(this)

    var device_pattern_transform: gfx.AffineTransform? = none
    if let user_space_transform = user_space_pattern_transform:
        if gfx.affine_transform_inverse(&user_space_transform) == none:
            return none
        # patternTransform is defined in user space, but the tile rect and shader operate in device pixel space.
        # Convert by conjugating with paint_transform.
        if let inv = gfx.affine_transform_inverse(&paint_context.paint_transform):
            var transform = paint_context.paint_transform
            gfx.affine_transform_multiply(&transform, user_space_transform)
            gfx.affine_transform_multiply(&transform, inv)
            device_pattern_transform = transform

    # (the display list's upcasts are private to it: an embedded base is first, so a cast is the upcast)
    return (display_list.SvgPaintServerPaintStyle*)display_list.svg_pattern_paint_style_create(tile_display_list, tile_rect, device_pattern_transform)

# mark: The SVG DOM ==============================================================================

## Ported from Libraries/LibWeb/SVG/SVGPatternElement.cpp:340 Web::SVG::SVGPatternElement::x.
# https://svgwg.org/svg2-draft/pservers.html#PatternElementXAttribute
pub func svg_pattern_element_x(this: SvgPatternElement*) -> SvgAnimatedLength*:
    # FIXME: Populate the unit type when it is parsed (0 here is "unknown").
    # FIXME: Create a proper animated value when animations are supported.
    let realm = dom_element_realm(this.dom_element())
    let base_length = svg_length_create(realm, 0, svg_number_percentage_or_zero_value(this.m_x), SvgLengthReadOnly.no)
    let anim_length = svg_length_create(realm, 0, svg_number_percentage_or_zero_value(this.m_x), SvgLengthReadOnly.yes)
    return svg_animated_length_create(realm, base_length, anim_length)

## Ported from Libraries/LibWeb/SVG/SVGPatternElement.cpp:350 Web::SVG::SVGPatternElement::y.
# https://svgwg.org/svg2-draft/pservers.html#PatternElementYAttribute
pub func svg_pattern_element_y(this: SvgPatternElement*) -> SvgAnimatedLength*:
    # FIXME: Populate the unit type when it is parsed (0 here is "unknown").
    # FIXME: Create a proper animated value when animations are supported.
    let realm = dom_element_realm(this.dom_element())
    let base_length = svg_length_create(realm, 0, svg_number_percentage_or_zero_value(this.m_y), SvgLengthReadOnly.no)
    let anim_length = svg_length_create(realm, 0, svg_number_percentage_or_zero_value(this.m_y), SvgLengthReadOnly.yes)
    return svg_animated_length_create(realm, base_length, anim_length)

## Ported from Libraries/LibWeb/SVG/SVGPatternElement.cpp:360 Web::SVG::SVGPatternElement::width.
# https://svgwg.org/svg2-draft/pservers.html#PatternElementWidthAttribute
pub func svg_pattern_element_width(this: SvgPatternElement*) -> SvgAnimatedLength*:
    # FIXME: Populate the unit type when it is parsed (0 here is "unknown").
    # FIXME: Create a proper animated value when animations are supported.
    let realm = dom_element_realm(this.dom_element())
    let base_length = svg_length_create(realm, 0, svg_number_percentage_or_zero_value(this.m_width), SvgLengthReadOnly.no)
    let anim_length = svg_length_create(realm, 0, svg_number_percentage_or_zero_value(this.m_width), SvgLengthReadOnly.yes)
    return svg_animated_length_create(realm, base_length, anim_length)

## Ported from Libraries/LibWeb/SVG/SVGPatternElement.cpp:370 Web::SVG::SVGPatternElement::height.
# https://svgwg.org/svg2-draft/pservers.html#PatternElementHeightAttribute
pub func svg_pattern_element_height(this: SvgPatternElement*) -> SvgAnimatedLength*:
    # FIXME: Populate the unit type when it is parsed (0 here is "unknown").
    # FIXME: Create a proper animated value when animations are supported.
    let realm = dom_element_realm(this.dom_element())
    let base_length = svg_length_create(realm, 0, svg_number_percentage_or_zero_value(this.m_height), SvgLengthReadOnly.no)
    let anim_length = svg_length_create(realm, 0, svg_number_percentage_or_zero_value(this.m_height), SvgLengthReadOnly.yes)
    return svg_animated_length_create(realm, base_length, anim_length)

## Ported from Libraries/LibWeb/SVG/SVGPatternElement.h:48 Web::SVG::SVGPatternElement::create_layout_node (override).
pub func svg_pattern_element_create_layout_node_impl(base: DomElement*, arg0: CssComputedProperties*) -> LayoutNode*?:
    return none