Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / 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