dymokomi/luce-browser-engine
Source of release 0.6.0
0.6.0 / 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