Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / svg / svg_image_element.lucb

#==============================================================================================
#
#   svg_image_element - SVG::SVGImageElement: <image>
#
#   DESCRIPTION:
#       Port of LibWeb/SVG/SVGImageElement.cpp (lines 1-297) with the inline members of
#       SVGImageElement.h (https://svgwg.org/svg2-draft/embedded.html#ImageElement): x, y,
#       width and height, the href (SVGURIReferenceMixin; the XLink-namespaced href is used only
#       without a plain one), the fetch of the image through a SharedResourceRequest (P2), the
#       frame animation timer, the bounding box, and the Layout::ImageProvider overrides the
#       SVGImageBox reads.
#
#==============================================================================================

# mark: Construction =============================================================================

## The SVGImageElement an ImageProvider base belongs to (the C++ `this` adjustment).
func svg_image_element_from_image_provider(base: LayoutImageProvider*) -> SvgImageElement*:
    return (SvgImageElement*)((u8*)base - memory.offset_of(SvgImageElement, image_provider))

## The animation timer's handler: `[this] { animate(); }`.
func svg_image_element_on_animation_timer(context: void*?):
    svg_image_element_animate((SvgImageElement*)(context else trap("no image element")))

## Ported from Libraries/LibWeb/SVG/SVGImageElement.cpp:26 Web::SVG::SVGImageElement::SVGImageElement.
pub func svg_image_element_construct(this: SvgImageElement*, document: DomDocument*, qualified_name: DomQualifiedName):
    svg_graphics_element_construct(this.svg_graphics_element(), document, qualified_name)
    # The Layout::ImageProvider base (no state) gets its table, then the vptrs of the mixin bases move to
    # SVGImageElement's tables.
    this.image_provider.vtable = &svg_image_element_image_provider_vtable
    this.image_provider.class_id = this.cell().class_id
    let element = this.svg_element()
    element.element.slottable_mixin.vtable = &svg_image_element_slottable_mixin_vtable
    element.element.aria_mixin.vtable = &svg_image_element_aria_mixin_vtable
    element.element.animatable.vtable = &svg_image_element_animatable_vtable
    element.global_event_handlers.vtable = &svg_image_element_global_event_handlers_vtable

    let timer = core_timer_create()
    this.m_animation_timer = timer
    timer.on_timeout = ak.Function0[unit](call = svg_image_element_on_animation_timer, context = this)

## Ported from Libraries/LibWeb/SVG/SVGImageElement.cpp:35 Web::SVG::SVGImageElement::initialize (override).
pub func svg_image_element_initialize_impl(base: JsCell*, realm: Realm*):
    web_set_prototype_for_interface(base, realm, BindInterfaceName.svg_image_element)
    svg_graphics_element_initialize_impl(base, realm)

## Ported from Libraries/LibWeb/SVG/SVGImageElement.cpp:41 Web::SVG::SVGImageElement::visit_edges (override).
pub func svg_image_element_visit_edges_impl(base: gc.Cell*, visitor: gc.CellVisitor*):
    let this = (SvgImageElement*)base
    svg_element_visit_edges_impl(base, visitor)
    layout_image_provider_image_provider_visit_edges(&this.image_provider, visitor)
    svg_svguri_reference_mixin_visit_edges(&this.svguri_reference_mixin, visitor)
    gc.cell_visitor_visit_t(visitor, this.m_x)
    gc.cell_visitor_visit_t(visitor, this.m_y)
    gc.cell_visitor_visit_t(visitor, this.m_width)
    gc.cell_visitor_visit_t(visitor, this.m_height)
    gc.cell_visitor_visit_t(visitor, this.m_resource_request)

## `MUST(length()->base_val()->set_value(parse_coordinate(value.value_or(String {})).value_or(0)))`.
func svg_image_element_set_length_from_attribute(length: SvgAnimatedLength*, value: ak.String?):
    let value_text = value else ak.String()
    let parsed_value = svg_attribute_parser_parse_coordinate_string_view(ak.string_bytes_as_string_view(&value_text))
    svg_length_set_value(svg_animated_length_base_val(length), parsed_value else 0.0) else trap("MUST: SVGLength::set_value")

## Ported from Libraries/LibWeb/SVG/SVGImageElement.cpp:53 Web::SVG::SVGImageElement::attribute_changed (override).
pub func svg_image_element_attribute_changed_impl(base: DomElement*, name: ak.FlyString, old_value: ak.String?, value: ak.String?, namespace_: ak.FlyString?):
    let this = (SvgImageElement*)base
    svg_graphics_element_attribute_changed_impl(base, name, old_value, value, namespace_)

    if ak.fly_string_eq_fly_string(&name, &svg_attribute_names_x):
        svg_image_element_set_length_from_attribute(svg_image_element_x(this), value)
    elif ak.fly_string_eq_fly_string(&name, &svg_attribute_names_y):
        svg_image_element_set_length_from_attribute(svg_image_element_y(this), value)
    elif ak.fly_string_eq_fly_string(&name, &svg_attribute_names_width):
        svg_image_element_set_length_from_attribute(svg_image_element_width(this), value)
    elif ak.fly_string_eq_fly_string(&name, &svg_attribute_names_height):
        svg_image_element_set_length_from_attribute(svg_image_element_height(this), value)
    elif ak.fly_string_eq_fly_string(&name, &svg_attribute_names_href):
        # https://svgwg.org/svg2-draft/linking.html#XLinkRefAttrs
        # For backwards compatibility, elements with an ‘href’ attribute also recognize an ‘href’ attribute in the
        # XLink namespace. If the element is in the XLink namespace, it does not recognize an ‘href’ attribute in the
        # SVG namespace. When the ‘href’ attribute is present in both the XLink namespace and without a namespace, the
        # value of the attribute without a namespace shall be used. The attribute in the XLink namespace shall be ignored.
        if let attribute_namespace = namespace_:
            if ak.fly_string_eq_fly_string(&attribute_namespace, &namespace_x_link) and dom_element_has_attribute_ns(base, none, name):
                return

        var href = value
        if namespace_ == none and href == none:
            href = dom_element_get_attribute_ns(base, svg_attribute_names_href, namespace_x_link)

        svg_image_element_process_the_url(this, href)

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

## Ported from Libraries/LibWeb/SVG/SVGImageElement.cpp:87 Web::SVG::SVGImageElement::x.
# https://svgwg.org/svg2-draft/embedded.html#__svg__SVGImageElement__x
pub func svg_image_element_x(this: SvgImageElement*) -> SvgAnimatedLength*:
    if this.m_x == none:
        this.m_x = svg_element_fake_animated_length_fixme(this.svg_element())

    return this.m_x else trap("VERIFY: m_x")

## Ported from Libraries/LibWeb/SVG/SVGImageElement.cpp:96 Web::SVG::SVGImageElement::y.
# https://svgwg.org/svg2-draft/embedded.html#__svg__SVGImageElement__y
pub func svg_image_element_y(this: SvgImageElement*) -> SvgAnimatedLength*:
    if this.m_y == none:
        this.m_y = svg_element_fake_animated_length_fixme(this.svg_element())

    return this.m_y else trap("VERIFY: m_y")

## Ported from Libraries/LibWeb/SVG/SVGImageElement.cpp:105 Web::SVG::SVGImageElement::width.
# https://svgwg.org/svg2-draft/embedded.html#__svg__SVGImageElement__width
pub func svg_image_element_width(this: SvgImageElement*) -> SvgAnimatedLength*:
    if this.m_width == none:
        let realm = dom_element_realm(this.dom_element())
        let intrinsic_width = svg_image_element_intrinsic_width_impl(&this.image_provider) else gfx.css_pixels_from_int(0)
        this.m_width = svg_animated_length_create(
            realm,
            svg_length_create(realm, 0, (f32)intrinsic_width.to_double(), SvgLengthReadOnly.no),
            svg_length_create(realm, 0, 0.0, SvgLengthReadOnly.yes),
        )

    return this.m_width else trap("VERIFY: m_width")

## Ported from Libraries/LibWeb/SVG/SVGImageElement.cpp:119 Web::SVG::SVGImageElement::height.
# https://svgwg.org/svg2-draft/embedded.html#__svg__SVGImageElement__height
pub func svg_image_element_height(this: SvgImageElement*) -> SvgAnimatedLength*:
    if this.m_height == none:
        let realm = dom_element_realm(this.dom_element())
        let intrinsic_height = svg_image_element_intrinsic_height_impl(&this.image_provider) else gfx.css_pixels_from_int(0)
        this.m_height = svg_animated_length_create(
            realm,
            svg_length_create(realm, 0, (f32)intrinsic_height.to_double(), SvgLengthReadOnly.no),
            svg_length_create(realm, 0, 0.0, SvgLengthReadOnly.yes),
        )

    return this.m_height else trap("VERIFY: m_height")

## Ported from Libraries/LibWeb/SVG/SVGImageElement.cpp:132 Web::SVG::SVGImageElement::bounding_box.
pub func svg_image_element_bounding_box(this: SvgImageElement*) -> gfx.FloatRect:
    let provider = &this.image_provider
    var width: f32? = none
    if dom_element_attribute(this.dom_element(), html_attribute_names_width) != none:
        width = svg_length_value(svg_animated_length_base_val(this.m_width else trap("VERIFY: m_width")))

    var height: f32? = none
    if dom_element_attribute(this.dom_element(), html_attribute_names_height) != none:
        height = svg_length_value(svg_animated_length_base_val(this.m_height else trap("VERIFY: m_height")))

    if height == none and width != none and svg_image_element_intrinsic_aspect_ratio_impl(provider) != none:
        let ratio = svg_image_element_intrinsic_aspect_ratio_impl(provider) else trap("VERIFY: intrinsic_aspect_ratio()")
        height = (width else trap("VERIFY: width")) / gfx.css_pixel_fraction_to_float(&ratio)

    if width == none and height != none and svg_image_element_intrinsic_aspect_ratio_impl(provider) != none:
        let ratio = svg_image_element_intrinsic_aspect_ratio_impl(provider) else trap("VERIFY: intrinsic_aspect_ratio()")
        width = (height else trap("VERIFY: height")) * gfx.css_pixel_fraction_to_float(&ratio)

    if width == none:
        if let intrinsic_width = svg_image_element_intrinsic_width_impl(provider):
            width = intrinsic_width.to_float()

    if height == none:
        if let intrinsic_height = svg_image_element_intrinsic_height_impl(provider):
            height = intrinsic_height.to_float()

    # m_x ? m_x->base_val()->value() : 0.0f (and the same for y)
    var x: f32 = 0.0
    if let x_length = this.m_x:
        x = svg_length_value(svg_animated_length_base_val(x_length))
    var y: f32 = 0.0
    if let y_length = this.m_y:
        y = svg_length_value(svg_animated_length_base_val(y_length))
    return gfx.FloatRect(m_location = gfx.FloatPoint(m_x = x, m_y = y), m_size = gfx.FloatSize(m_width = width else 0.0, m_height = height else 0.0))

# mark: Fetching =================================================================================

## Ported from Libraries/LibWeb/SVG/SVGImageElement.cpp:163 Web::SVG::SVGImageElement::process_the_url.
# https://www.w3.org/TR/SVG2/linking.html#processingURL
pub func svg_image_element_process_the_url(this: SvgImageElement*, href: ak.String?):
    if href == none:
        this.m_href = none
        return
    let href_text = href else trap("VERIFY: href")

    this.m_href = dom_document_encoding_parse_url(dom_node_document(this.dom_node()), ak.string_bytes_as_string_view(&href_text))
    let url = this.m_href else return

    svg_image_element_fetch_the_document(this, url)

## fetch_the_document's callbacks: `[this, resource_request = GC::Root { m_resource_request }]` (the captures are
## managed memory, so the request needs no root).
struct SvgImageElementFetchTheDocumentCaptures:
    var this: SvgImageElement*
    var resource_request: HtmlSharedResourceRequest*

## fetch_the_document's on-finish callback.
func svg_image_element_fetch_on_finish(context: void*?):
    let captures = (SvgImageElementFetchTheDocumentCaptures*)(context else trap("fetch the document: no captures"))
    let this = captures.this
    svg_image_element_clear_load_event_delayer(this)
    let image_data = html_shared_resource_request_image_data(captures.resource_request) else trap("VERIFY: image_data()")
    if html_decoded_image_data_is_animated(image_data) and html_decoded_image_data_frame_count(image_data) > 1:
        this.m_current_frame_index = 0
        let animation_timer = this.m_animation_timer else trap("the animation timer")
        core_timer_set_interval(animation_timer, html_decoded_image_data_frame_duration(image_data, 0))
        core_timer_start(animation_timer)
    dom_node_set_needs_style_update(this.dom_node(), true)
    dom_node_set_needs_layout_update(this.dom_node(), DomSetNeedsLayoutReason.svg_image_element_fetch_the_document)

    _ = dom_event_target_dispatch_event(this.dom_event_target(), dom_event_create(dom_element_realm(this.dom_element()), html_event_names_load))

## fetch_the_document's on-fail callback.
func svg_image_element_fetch_on_fail(context: void*?):
    let captures = (SvgImageElementFetchTheDocumentCaptures*)(context else trap("fetch the document: no captures"))
    let this = captures.this
    svg_image_element_clear_load_event_delayer(this)

    _ = dom_event_target_dispatch_event(this.dom_event_target(), dom_event_create(dom_element_realm(this.dom_element()), html_event_names_error))

## `m_load_event_delayer.clear()`: destroys a held delayer.
func svg_image_element_clear_load_event_delayer(this: SvgImageElement*):
    if let delayer = this.m_load_event_delayer:
        var released = delayer
        dom_document_load_event_delayer_destruct(&released)
    this.m_load_event_delayer = none

## Ported from Libraries/LibWeb/SVG/SVGImageElement.cpp:178 Web::SVG::SVGImageElement::fetch_the_document.
# https://svgwg.org/svg2-draft/linking.html#processingURL-fetch
pub func svg_image_element_fetch_the_document(this: SvgImageElement*, url: web_url.Url):
    let document = dom_node_document(this.dom_node())
    let realm = dom_element_realm(this.dom_element())
    # m_load_event_delayer.emplace(document()): a previous delayer, if any, is destroyed first.
    svg_image_element_clear_load_event_delayer(this)
    var delayer: DomDocumentLoadEventDelayer = ---
    dom_document_load_event_delayer_construct(&delayer, document)
    this.m_load_event_delayer = delayer
    let resource_request = html_shared_resource_request_get_or_create(realm, dom_document_page(document), url)
    this.m_resource_request = resource_request
    let captures = new SvgImageElementFetchTheDocumentCaptures(this = this, resource_request = resource_request) else trap("out of memory")
    html_shared_resource_request_add_callbacks(resource_request, ak.Function0[unit](call = svg_image_element_fetch_on_finish, context = captures), ak.Function0[unit](call = svg_image_element_fetch_on_fail, context = captures))

    if html_shared_resource_request_needs_fetching(resource_request):
        let request = html_create_potential_cors_request(realm_vm(realm), url, FetchRequestDestination.image, HtmlCorsSettingAttribute.no_cors)
        fetch_request_set_client(request, dom_document_relevant_settings_object(document))
        html_shared_resource_request_fetch_resource(resource_request, realm, request)

## Ported from Libraries/LibWeb/SVG/SVGImageElement.cpp:209 Web::SVG::SVGImageElement::create_layout_node (override).
pub func svg_image_element_create_layout_node_impl(base: DomElement*, style: CssComputedProperties*) -> LayoutNode*?:
    let this = (SvgImageElement*)base
    # heap().allocate<Layout::SVGImageBox>(...): a layout node's initialize is JS::Cell's, which does nothing.
    return realm_create_layout_svg_image_box(dom_element_realm(base), dom_node_document(base.dom_node()), this.svg_graphics_element(), style).layout_node()

# mark: Layout::ImageProvider ====================================================================

## Ported from Libraries/LibWeb/SVG/SVGImageElement.cpp:214 Web::SVG::SVGImageElement::is_image_available (override).
pub func svg_image_element_is_image_available_impl(base: LayoutImageProvider*) -> bool:
    let this = svg_image_element_from_image_provider(base)
    let resource_request = this.m_resource_request else return false
    return html_shared_resource_request_image_data(resource_request) != none

## Ported from Libraries/LibWeb/SVG/SVGImageElement.cpp:219 Web::SVG::SVGImageElement::intrinsic_width (override).
pub func svg_image_element_intrinsic_width_impl(base: LayoutImageProvider*) -> gfx.CssPixels?:
    let this = svg_image_element_from_image_provider(base)
    let resource_request = this.m_resource_request else return none
    if let image_data = html_shared_resource_request_image_data(resource_request):
        return html_decoded_image_data_intrinsic_width(image_data)
    return none

## Ported from Libraries/LibWeb/SVG/SVGImageElement.cpp:228 Web::SVG::SVGImageElement::intrinsic_height (override).
pub func svg_image_element_intrinsic_height_impl(base: LayoutImageProvider*) -> gfx.CssPixels?:
    let this = svg_image_element_from_image_provider(base)
    let resource_request = this.m_resource_request else return none
    if let image_data = html_shared_resource_request_image_data(resource_request):
        return html_decoded_image_data_intrinsic_height(image_data)
    return none

## Ported from Libraries/LibWeb/SVG/SVGImageElement.cpp:237 Web::SVG::SVGImageElement::intrinsic_aspect_ratio (override).
pub func svg_image_element_intrinsic_aspect_ratio_impl(base: LayoutImageProvider*) -> gfx.CssPixelFraction?:
    let this = svg_image_element_from_image_provider(base)
    let resource_request = this.m_resource_request else return none
    if let image_data = html_shared_resource_request_image_data(resource_request):
        return html_decoded_image_data_intrinsic_aspect_ratio(image_data)
    return none

## Ported from Libraries/LibWeb/SVG/SVGImageElement.cpp:246 Web::SVG::SVGImageElement::default_image_bitmap_sized (override).
pub func svg_image_element_default_image_bitmap_sized_impl(base: LayoutImageProvider*, size: gfx.IntSize) -> gfx.ImmutableBitmap*?:
    let this = svg_image_element_from_image_provider(base)
    let resource_request = this.m_resource_request else return none
    if let data = html_shared_resource_request_image_data(resource_request):
        return html_decoded_image_data_bitmap(data, 0, size)
    return none

## Ported from Libraries/LibWeb/SVG/SVGImageElement.cpp:255 Web::SVG::SVGImageElement::current_image_bitmap_sized (override).
pub func svg_image_element_current_image_bitmap_sized_impl(base: LayoutImageProvider*, size: gfx.IntSize) -> gfx.ImmutableBitmap*?:
    let this = svg_image_element_from_image_provider(base)
    let resource_request = this.m_resource_request else return none
    if let data = html_shared_resource_request_image_data(resource_request):
        return html_decoded_image_data_bitmap(data, this.m_current_frame_index, size)
    return none

## Ported from Libraries/LibWeb/SVG/SVGImageElement.cpp:264 Web::SVG::SVGImageElement::animate.
func svg_image_element_animate(this: SvgImageElement*):
    let resource_request = this.m_resource_request else trap("VERIFY: m_resource_request")
    let image_data = html_shared_resource_request_image_data(resource_request) else return

    this.m_current_frame_index = (this.m_current_frame_index + 1) % html_decoded_image_data_frame_count(image_data)
    let current_frame_duration = html_decoded_image_data_frame_duration(image_data, this.m_current_frame_index)

    let animation_timer = this.m_animation_timer else trap("the animation timer")
    if current_frame_duration != core_timer_interval(animation_timer):
        core_timer_restart_i32(animation_timer, current_frame_duration)

    if this.m_current_frame_index == html_decoded_image_data_frame_count(image_data) -% 1:
        this.m_loops_completed += 1
        if this.m_loops_completed > 0 and this.m_loops_completed == html_decoded_image_data_loop_count(image_data):
            core_timer_stop(animation_timer)

    if let paintable = dom_node_paintable(this.dom_node()):
        paint_paintable_set_needs_repaint(paintable, InvalidateDisplayList.yes)

## Ported from Libraries/LibWeb/SVG/SVGImageElement.cpp:289 Web::SVG::SVGImageElement::decoded_image_data (override).
pub func svg_image_element_decoded_image_data_impl(base: LayoutImageProvider*) -> HtmlDecodedImageData*?:
    let this = svg_image_element_from_image_provider(base)
    let resource_request = this.m_resource_request else return none
    return html_shared_resource_request_image_data(resource_request)

## Ported from Libraries/LibWeb/SVG/SVGImageElement.h:44 Web::SVG::SVGImageElement::set_visible_in_viewport (override).
pub func svg_image_element_set_visible_in_viewport_impl(base: LayoutImageProvider*, arg0: bool):
    return

## Ported from Libraries/LibWeb/SVG/SVGImageElement.h:45 Web::SVG::SVGImageElement::to_html_element (override).
pub func svg_image_element_to_html_element_impl(base: LayoutImageProvider*) -> DomElement*?:
    return svg_image_element_from_image_provider(base).dom_element()

## Ported from Libraries/LibWeb/SVG/SVGImageElement.h:46 Web::SVG::SVGImageElement::current_frame_index (override).
pub func svg_image_element_current_frame_index_impl(base: LayoutImageProvider*) -> usize:
    return svg_image_element_from_image_provider(base).m_current_frame_index