dymokomi/luce-browser-engine
Source of release 0.6.0
0.6.0 / src / web / dom / abstract_element.lucb
#==============================================================================================
#
# abstract_element - DOM::AbstractElement: an element or one of its pseudo-elements
#
# DESCRIPTION:
# Port of LibWeb/DOM/AbstractElement.cpp (lines 1-235) and the inline functions of
# AbstractElement.h, with its AK::Traits (hash and equality). Style computation and
# layout use an AbstractElement wherever the subject may be a pseudo-element; each
# accessor forwards to the element with the pseudo-element, or to its PseudoElement.
#
#==============================================================================================
# mark: Construction and edges ==================================================================
## Ported from AbstractElement.cpp:15 Web::DOM::AbstractElement::AbstractElement.
pub func dom_abstract_element_construct(this: DomAbstractElement*, element: DomElement*, pseudo_element: css_data.PseudoElement? = none):
this.m_element = element
this.m_pseudo_element = pseudo_element
this.m_inheritance_override = none
## Ported from AbstractElement.cpp:21 Web::DOM::AbstractElement::AbstractElement.
pub func dom_abstract_element_construct_2(this: DomAbstractElement*, element: DomElement*, pseudo_element: css_data.PseudoElement? = none):
this.m_element = element
this.m_pseudo_element = pseudo_element
this.m_inheritance_override = none
## `AbstractElement { element, pseudo_element }` as a value.
func dom_abstract_element_make(element: DomElement*, pseudo_element: css_data.PseudoElement? = none) -> DomAbstractElement:
var result: DomAbstractElement = ---
dom_abstract_element_construct(&result, element, pseudo_element)
return result
## Ported from AbstractElement.cpp:27 Web::DOM::AbstractElement::visit.
pub func dom_abstract_element_visit(this: const DomAbstractElement*, visitor: gc.CellVisitor*):
gc.cell_visitor_visit_t_2(visitor, this.m_element)
gc.cell_visitor_visit_t(visitor, this.m_inheritance_override)
## Ported from AbstractElement.cpp:33 Web::DOM::AbstractElement::document.
pub func dom_abstract_element_document(this: const DomAbstractElement*) -> DomDocument*:
return dom_node_document(this.m_element.dom_node())
# mark: Tree counting ===========================================================================
## Ported from AbstractElement.cpp:38 Web::DOM::AbstractElement::tree_counting_function_resolution_context.
pub func dom_abstract_element_tree_counting_function_resolution_context(this: const DomAbstractElement*) -> DomAbstractElementTreeCountingFunctionResolutionContext:
# FIXME: When used on an element-backed pseudo-element which is also a real element, the tree counting functions
# resolve for that real element. For other pseudo elements, they resolve as if they were resolved against
# the originating element. It follows that for nested pseudo elements the resolution will recursively walk
# the originating elements until a real element is found.
# FIXME: A tree counting function is a tree-scoped reference where it references an implicit tree-scoped name for
# the element it resolves against. This is done to not leak tree information to an outer tree. A tree
# counting function that is scoped to an outer tree relative to the element it resolves against, will alway
# resolve to 0.
let element_to_resolve_tree_counting_function_against = this.m_element
# The sibling-count() functional notation represents, as an <integer>, the total number of child elements in the
# parent of the element on which the notation is used.
let parent = dom_node_parent_element(element_to_resolve_tree_counting_function_against.dom_node())
# If there is no parent we are the root node
let parent_element = parent else return DomAbstractElementTreeCountingFunctionResolutionContext(sibling_count = 1, sibling_index = 1)
var count: usize = 0
var index: usize = 0
var child_node = tree_node_first_child_of_type(parent_element.dom_node(), &dom_element_class)
while let child = child_node:
count += 1
if child == element_to_resolve_tree_counting_function_against.dom_node():
index = count
child_node = (DomNode*?)dom_non_document_type_child_node_next_element_sibling(child)
return DomAbstractElementTreeCountingFunctionResolutionContext(sibling_count = count, sibling_index = index)
# mark: Layout nodes and the tree ===============================================================
## Ported from AbstractElement.cpp:74 Web::DOM::AbstractElement::layout_node.
pub func dom_abstract_element_layout_node(this: DomAbstractElement*) -> LayoutNodeWithStyle*?:
if let pseudo_element = this.m_pseudo_element:
return dom_element_get_pseudo_element_node(this.m_element, pseudo_element)
return dom_element_layout_node(this.m_element)
## Ported from AbstractElement.cpp:81 Web::DOM::AbstractElement::unsafe_layout_node.
pub func dom_abstract_element_unsafe_layout_node(this: DomAbstractElement*) -> LayoutNodeWithStyle*?:
if let pseudo_element = this.m_pseudo_element:
return dom_element_get_pseudo_element_node(this.m_element, pseudo_element)
return dom_element_unsafe_layout_node(this.m_element)
## Ported from AbstractElement.cpp:88 Web::DOM::AbstractElement::parent_element.
pub func dom_abstract_element_parent_element(this: const DomAbstractElement*) -> DomElement*?:
if this.m_pseudo_element != none:
return this.m_element
return dom_node_parent_element(this.m_element.dom_node())
## Ported from AbstractElement.cpp:95 Web::DOM::AbstractElement::element_to_inherit_style_from.
pub func dom_abstract_element_element_to_inherit_style_from(this: const DomAbstractElement*) -> DomAbstractElement?:
if let inheritance_override = this.m_inheritance_override:
return dom_abstract_element_make(inheritance_override)
let element = dom_element_element_to_inherit_style_from(this.m_element, this.m_pseudo_element)
let found = element else return none
return dom_abstract_element_make(found)
## Ported from AbstractElement.cpp:108 Web::DOM::AbstractElement::walk_layout_tree.
pub func dom_abstract_element_walk_layout_tree(this: DomAbstractElement*, walk_method: DomAbstractElementWalkMethod) -> DomAbstractElement?:
# NB: Called during style recalculation.
let start = dom_abstract_element_unsafe_layout_node(this) else return none
var node: LayoutNode*? = start.layout_node()
while true:
let current = node else return none
match walk_method:
.previous:
node = tree_node_previous_in_pre_order(current)
.previous_sibling:
node = tree_node_previous_sibling(current)
_:
trap("VERIFY_NOT_REACHED")
let walked = node else return none
if let dom_node = layout_node_dom_node(walked):
if let previous_element = as_if_dom_element(dom_node):
return dom_abstract_element_make(previous_element)
if layout_node_is_generated_for_pseudo_element(walked):
let generator = layout_node_pseudo_element_generator(walked) else trap("VERIFY: pseudo-element generator")
return dom_abstract_element_make(generator, layout_node_generated_for_pseudo_element(walked))
## Ported from AbstractElement.cpp:135 Web::DOM::AbstractElement::is_before.
pub func dom_abstract_element_is_before(this: const DomAbstractElement*, other: DomAbstractElement) -> bool:
# NB: Called during style recalculation.
let this_node = dom_abstract_element_unsafe_layout_node_const(this)
let other_node = dom_abstract_element_unsafe_layout_node_const(&other)
let this_layout_node = this_node else return false
let other_layout_node = other_node else return false
return tree_node_is_before(this_layout_node.layout_node(), other_layout_node.layout_node())
# mark: Style ===================================================================================
## Ported from AbstractElement.cpp:143 Web::DOM::AbstractElement::computed_properties.
pub func dom_abstract_element_computed_properties(this: const DomAbstractElement*) -> CssComputedProperties*?:
return dom_element_computed_properties(this.m_element, this.m_pseudo_element)
## Ported from AbstractElement.cpp:148 Web::DOM::AbstractElement::custom_property_data.
pub func dom_abstract_element_custom_property_data(this: const DomAbstractElement*) -> const CssCustomPropertyData*?:
return dom_element_custom_property_data(this.m_element, this.m_pseudo_element)
## Ported from AbstractElement.cpp:153 Web::DOM::AbstractElement::set_custom_property_data.
pub func dom_abstract_element_set_custom_property_data(this: DomAbstractElement*, data: const CssCustomPropertyData*?):
dom_element_set_custom_property_data(this.m_element, this.m_pseudo_element, data)
## Ported from AbstractElement.cpp:158 Web::DOM::AbstractElement::get_custom_property.
pub func dom_abstract_element_get_custom_property(this: const DomAbstractElement*, name: ak.FlyString) -> CssStyleValue*?:
let data = dom_abstract_element_custom_property_data(this) else return none
if let property = css_custom_property_data_get(data, name):
return property.value
return none
## Ported from AbstractElement.cpp:168 Web::DOM::AbstractElement::cascaded_properties.
pub func dom_abstract_element_cascaded_properties(this: const DomAbstractElement*) -> CssCascadedProperties*?:
return dom_element_cascaded_properties(this.m_element, this.m_pseudo_element)
## Ported from AbstractElement.cpp:173 Web::DOM::AbstractElement::set_cascaded_properties.
pub func dom_abstract_element_set_cascaded_properties(this: DomAbstractElement*, cascaded_properties: CssCascadedProperties*?):
dom_element_set_cascaded_properties(this.m_element, this.m_pseudo_element, cascaded_properties)
# mark: Counters ================================================================================
## Ported from AbstractElement.cpp:178 Web::DOM::AbstractElement::has_non_empty_counters_set.
pub func dom_abstract_element_has_non_empty_counters_set(this: const DomAbstractElement*) -> bool:
if let pseudo_element = this.m_pseudo_element:
let pseudo = dom_element_get_pseudo_element(this.m_element, pseudo_element) else trap("VERIFY: pseudo-element")
return dom_pseudo_element_has_non_empty_counters_set(pseudo)
return dom_element_has_non_empty_counters_set(this.m_element)
## Ported from AbstractElement.cpp:185 Web::DOM::AbstractElement::counters_set.
pub func dom_abstract_element_counters_set(this: const DomAbstractElement*) -> const CssCountersSet*?:
if let pseudo_element = this.m_pseudo_element:
let pseudo = dom_element_get_pseudo_element(this.m_element, pseudo_element) else trap("VERIFY: pseudo-element")
return dom_pseudo_element_counters_set(pseudo)
return dom_element_counters_set(this.m_element)
## Ported from AbstractElement.cpp:192 Web::DOM::AbstractElement::ensure_counters_set.
pub func dom_abstract_element_ensure_counters_set(this: DomAbstractElement*) -> CssCountersSet*:
if let pseudo_element = this.m_pseudo_element:
let pseudo = dom_element_get_pseudo_element(this.m_element, pseudo_element) else trap("VERIFY: pseudo-element")
return dom_pseudo_element_ensure_counters_set(pseudo)
return dom_element_ensure_counters_set(this.m_element)
## Ported from AbstractElement.cpp:199 Web::DOM::AbstractElement::set_counters_set.
pub func dom_abstract_element_set_counters_set(this: DomAbstractElement*, counters_set: CssCountersSet*?):
if let pseudo_element = this.m_pseudo_element:
let pseudo = dom_element_get_pseudo_element(this.m_element, pseudo_element) else trap("VERIFY: pseudo-element")
dom_pseudo_element_set_counters_set(pseudo, counters_set)
else:
dom_element_set_counters_set(this.m_element, counters_set)
# mark: Debugging, scope and animations =========================================================
## Ported from AbstractElement.cpp:208 Web::DOM::AbstractElement::debug_description.
pub func dom_abstract_element_debug_description(this: const DomAbstractElement*) -> ak.String:
if let pseudo_element = this.m_pseudo_element:
var builder = ak.string_builder_new()
let element_description = dom_node_debug_description(this.m_element.dom_node())
ak.string_builder_append_string_view(&builder, ak.string_bytes_as_string_view(&element_description))
ak.string_builder_append(&builder, "::")
ak.string_builder_append_string_view(&builder, css_data.pseudo_element_name(pseudo_element))
return ak.string_builder_to_string_without_validation(&builder)
return dom_node_debug_description(this.m_element.dom_node())
## Ported from AbstractElement.cpp:220 Web::DOM::AbstractElement::style_scope.
# C++ returns `StyleScope const&`: a pointer to the scope (r39: a copy would build its rule cache in the copy).
pub func dom_abstract_element_style_scope(this: const DomAbstractElement*) -> CssStyleScope*:
return dom_node_style_scope(this.m_element.dom_node())
## Ported from AbstractElement.cpp:225 Web::DOM::AbstractElement::css_defined_animations.
pub func dom_abstract_element_css_defined_animations(this: const DomAbstractElement*) -> ak.HashMap[ak.FlyString, CssAnimation*, ak.FlyStringTraits]*?:
return animations_animatable_css_defined_animations(&this.m_element.animatable, this.m_pseudo_element)
## Ported from AbstractElement.cpp:230 Web::DOM::AbstractElement::set_has_css_defined_animations.
pub func dom_abstract_element_set_has_css_defined_animations(this: DomAbstractElement*):
animations_animatable_set_has_css_defined_animations(&this.m_element.animatable)
# mark: AbstractElement.h =======================================================================
## Ported from AbstractElement.h:25 Web::DOM::AbstractElement::element.
pub func dom_abstract_element_element(this: DomAbstractElement*) -> DomElement*:
return this.m_element
## Ported from AbstractElement.h:26 Web::DOM::AbstractElement::element.
pub func dom_abstract_element_element_const(this: const DomAbstractElement*) -> DomElement*:
return this.m_element
## Ported from AbstractElement.h:27 Web::DOM::AbstractElement::pseudo_element.
pub func dom_abstract_element_pseudo_element(this: const DomAbstractElement*) -> css_data.PseudoElement?:
return this.m_pseudo_element
## Ported from AbstractElement.h:30 Web::DOM::AbstractElement::layout_node.
pub func dom_abstract_element_layout_node_const(this: const DomAbstractElement*) -> LayoutNodeWithStyle*?:
return dom_abstract_element_layout_node((DomAbstractElement*)this)
## Ported from AbstractElement.h:33 Web::DOM::AbstractElement::unsafe_layout_node.
pub func dom_abstract_element_unsafe_layout_node_const(this: const DomAbstractElement*) -> LayoutNodeWithStyle*?:
return dom_abstract_element_unsafe_layout_node((DomAbstractElement*)this)
## Ported from AbstractElement.h:43 Web::DOM::AbstractElement::previous_in_tree_order.
pub func dom_abstract_element_previous_in_tree_order(this: DomAbstractElement*) -> DomAbstractElement?:
return dom_abstract_element_walk_layout_tree(this, DomAbstractElementWalkMethod.previous)
## Ported from AbstractElement.h:44 Web::DOM::AbstractElement::previous_sibling_in_tree_order.
pub func dom_abstract_element_previous_sibling_in_tree_order(this: DomAbstractElement*) -> DomAbstractElement?:
return dom_abstract_element_walk_layout_tree(this, DomAbstractElementWalkMethod.previous_sibling)
## Ported from AbstractElement.h:47 Web::DOM::AbstractElement::set_inheritance_override.
pub func dom_abstract_element_set_inheritance_override(this: DomAbstractElement*, element: DomElement*):
this.m_inheritance_override = element
## Ported from AbstractElement.h:86 AK::Traits<Web::DOM::AbstractElement>::hash.
pub func dom_abstract_element_traits_hash(key: const DomAbstractElement*) -> u32:
var pseudo_element_hash: u32 = 0xffffffff # -1 converted to unsigned
if let pseudo_element = key.m_pseudo_element:
pseudo_element_hash = (u32)pseudo_element
return ak.pair_int_hash(ak.ptr_hash_void(key.m_element), pseudo_element_hash)
## AK::Traits<Web::DOM::AbstractElement>::equals (DefaultTraits: `operator==`, defaulted over all members).
pub func dom_abstract_element_traits_equals(a: const DomAbstractElement*, b: const DomAbstractElement*) -> bool:
return a.m_element == b.m_element and a.m_pseudo_element == b.m_pseudo_element and a.m_inheritance_override == b.m_inheritance_override