Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / web / page / event_handler_4.lucb

#==============================================================================================
#
#   event_handler_4 - Web::EventHandler: mouse moves and leaving, drag and drop, pinch zoom,
#   sequential focus, the focus candidate of a position, keyboard and input events
#
#   DESCRIPTION:
#       Port of Libraries/LibWeb/Page/EventHandler.cpp lines 1384-1799 (handle_mousemove through
#       input_event).
#
#       Copyright (c) 2020, Andreas Kling <andreas@ladybird.org>
#       Copyright (c) 2023, Linus Groh <linusg@serenityos.org>
#       Copyright (c) 2026, Jelle Raaijmakers <jelle@ladybird.org>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: Mouse moves =============================================================================

## handle_mousemove's DRAG_THRESHOLD.
let event_handler_drag_threshold: i64 = 5

## The captures of handle_mousemove's nested navigable dispatch (`[screen_position, buttons, modifiers]`).
struct EventHandlerMousemoveDispatch:
    var screen_position: gfx.CssPixelPoint
    var buttons: u32
    var modifiers: u32

## handle_mousemove's dispatch to a nested navigable's event handler.
func event_handler_mousemove_dispatch(context: void*?, event_handler: EventHandler*, position: gfx.CssPixelPoint) -> EventResult:
    let captures = (EventHandlerMousemoveDispatch*)(context else trap("no captures"))
    return event_handler_handle_mousemove(event_handler, position, captures.screen_position, captures.buttons, captures.modifiers)

## Ported from EventHandler.cpp:1384 Web::EventHandler::handle_mousemove.
pub func event_handler_handle_mousemove(this: EventHandler*, visual_viewport_position: gfx.CssPixelPoint, screen_position: gfx.CssPixelPoint, buttons: u32, modifiers: u32) -> EventResult:
    if event_handler_should_ignore_device_input_event(this):
        if this.m_mousedown_target_is_drag_candidate:
            return event_handler_handle_drag_and_drop_event(this, DragEventType.drag_move, visual_viewport_position, screen_position, (u32)UiEventsMouseButton.primary, buttons, modifiers, ak.Vector[HtmlSelectedFile]())
        return EventResult.dropped

    let document = html_navigable_active_document(this.m_navigable) else return EventResult.dropped
    if not dom_document_is_fully_active(document):
        return EventResult.dropped

    let viewport_position = css_visual_viewport_map_to_layout_viewport(dom_document_visual_viewport(document), visual_viewport_position)
    dom_document_update_layout(document, DomUpdateLayoutReason.event_handler_handle_mouse_move)

    if event_handler_paint_root(this) == none:
        return EventResult.dropped

    if this.m_mousedown_target_is_drag_candidate:
        let drag_threshold = gfx.CssPixels.from_int(event_handler_drag_threshold)
        let delta = gfx.css_pixel_point_sub(&visual_viewport_position, this.m_mousedown_visual_viewport_position else trap("Optional::operator*() on an empty optional"))

        if delta.m_x.abs().compare(drag_threshold) >= 0 or delta.m_y.abs().compare(drag_threshold) >= 0:
            let result = event_handler_handle_drag_and_drop_event(this, DragEventType.drag_start, visual_viewport_position, screen_position, (u32)UiEventsMouseButton.primary, buttons, modifiers, ak.Vector[HtmlSelectedFile]())

            if result == EventResult.handled:
                set_page_cursor(html_navigable_page(this.m_navigable), gfx.Cursor.standard_cursor(gfx.StandardCursor.drag))
                event_handler_stop_updating_selection(this)

                return EventResult.handled

            if result == EventResult.cancelled:
                this.m_mousedown_target_is_drag_candidate = false

            # NB: Dispatching an event may have disturbed the world.
            if html_navigable_active_document(this.m_navigable) != (DomDocument*?)document:
                return EventResult.accepted
            dom_document_update_layout(document, DomUpdateLayoutReason.event_handler_handle_mouse_move)
            if event_handler_paint_root(this) == none:
                return EventResult.accepted

    var paintable: PaintPaintable*? = none
    var chrome_widget: PaintChromeWidget*? = none

    if let result = event_handler_target_for_mouse_position(this, visual_viewport_position):
        paintable = result.paintable
        chrome_widget = result.chrome_widget

    # ArmedScopeGuard clear_cursor: unless disarmed, the cursor is reset whenever this returns.
    var clear_cursor_armed = true
    defer event_handler_clear_cursor_unless_disarmed(this, &clear_cursor_armed)

    if let target = paintable:
        var node = dom_node_for_event_dispatch(target)

        if node == none:
            return EventResult.dropped

        let captures = new EventHandlerMousemoveDispatch(screen_position = screen_position, buttons = buttons, modifiers = modifiers) else trap("out of memory")
        if let result = dispatch_event_to_nested_navigable(target, visual_viewport_position, ak.Function2[EventHandler*, gfx.CssPixelPoint, EventResult](call = event_handler_mousemove_dispatch, context = captures)):
            clear_cursor_armed = false
            return result

        let computed_values = paint_paintable_computed_values(target)
        let pointer_events = css_computed_values_pointer_events(&computed_values.computed_values)
        # FIXME: Handle other values for pointer-events.
        assert(pointer_events != css_data.PointerEvents.none_)

        # NB: Search for the first parent of the hit target that's an element.
        #
        # https://www.w3.org/TR/uievents/#event-type-click
        # The click event type MUST be dispatched on the topmost event target indicated by the pointer.
        #
        # https://www.w3.org/TR/uievents/#topmost-event-target
        # The topmost event target MUST be the element highest in the rendering order which is capable of being an
        # event target.
        var layout_node: LayoutNode*? = none
        let found_parent_element = parent_element_for_event_dispatch(target, &node, &layout_node)

        if found_parent_element:
            let dispatch_node = node else trap("unreachable")
            event_handler_update_cursor(this, target, dispatch_node, chrome_widget)
            clear_cursor_armed = false

            let coordinates = event_handler_compute_mouse_event_coordinates(this, visual_viewport_position, viewport_position, target, layout_node else trap("unreachable"))
            let movement = event_handler_compute_mouse_event_movement(this, screen_position)
            this.m_mousemove_previous_screen_position = screen_position

            if not event_handler_dispatch_a_pointer_event_for_a_device_that_supports_hover(this, EventHandlerPointerEventType.pointer_move, dispatch_node, chrome_widget, coordinates, screen_position, movement, (u32)UiEventsMouseButton.primary, buttons, modifiers):
                return EventResult.cancelled
    elif gc.weak_ptr(&this.m_mousedown_target) != none:
        # NOTE: In some implementation environments, such as a browser, mousemove events can continue to fire if the
        #       user began a drag operation (e.g., a mouse button is pressed) and the pointing device has left the
        #       boundary of the user agent.
        let document_layout_node = dom_document_layout_node(document) else trap("no layout node")
        let coordinates = event_handler_compute_mouse_event_coordinates(this, visual_viewport_position, viewport_position, dom_node_paintable(document.dom_node()) else trap("no paintable"), document_layout_node.layout_node())
        let movement = event_handler_compute_mouse_event_movement(this, screen_position)
        this.m_mousemove_previous_screen_position = screen_position

        var html_element: DomNode*? = none
        if let element = dom_document_html_element(document):
            html_element = element.dom_node()
        if not event_handler_dispatch_a_pointer_event_for_a_device_that_supports_hover(this, EventHandlerPointerEventType.pointer_move, html_element, none, coordinates, screen_position, movement, (u32)UiEventsMouseButton.primary, buttons, modifiers):
            return EventResult.cancelled

    # NB: Dispatching an event may have disturbed the world.
    if html_navigable_active_document(this.m_navigable) != (DomDocument*?)document:
        return EventResult.accepted

    if this.m_middle_button_scroll_handler == none and not event_handler_is_handling_mouse_selection(this):
        return EventResult.handled

    dom_document_update_layout(document, DomUpdateLayoutReason.event_handler_handle_mouse_move)
    if event_handler_paint_root(this) == none:
        return EventResult.accepted

    if let handler = this.m_middle_button_scroll_handler:
        middle_button_scroll_handler_update_mouse_position(handler, visual_viewport_position)

    event_handler_update_mouse_selection(this, visual_viewport_position)
    return EventResult.handled

## handle_mousemove's clear_cursor guard (`update_cursor(nullptr, nullptr, nullptr)` unless disarmed).
func event_handler_clear_cursor_unless_disarmed(this: EventHandler*, armed: const bool*):
    if *armed:
        event_handler_update_cursor(this, none, none, none)

## Ported from EventHandler.cpp:1514 Web::EventHandler::handle_mouseleave.
pub func event_handler_handle_mouseleave(this: EventHandler*) -> EventResult:
    if event_handler_should_ignore_device_input_event(this):
        if this.m_mousedown_target_is_drag_candidate:
            let result = event_handler_handle_drag_and_drop_event(this, DragEventType.drag_end, gfx.CssPixelPoint(), gfx.CssPixelPoint(), (u32)UiEventsMouseButton.primary, (u32)UiEventsMouseButton.primary, 0, ak.Vector[HtmlSelectedFile]())
            set_page_cursor(html_navigable_page(this.m_navigable), gfx.Cursor.standard_cursor(gfx.StandardCursor.arrow))
            return result

        return EventResult.dropped

    let document = html_navigable_active_document(this.m_navigable) else return EventResult.dropped
    if not dom_document_is_fully_active(document):
        return EventResult.dropped

    dom_document_update_layout(document, DomUpdateLayoutReason.event_handler_handle_mouse_move)

    if event_handler_paint_root(this) == none:
        return EventResult.dropped

    event_handler_update_hovered_chrome_widget(this, none)
    event_handler_update_cursor(this, none, none, none)

    if gc.weak_ptr(&this.m_mousedown_target) == none:
        event_handler_track_the_effective_position_of_the_legacy_mouse_pointer(this, none)
    return EventResult.handled

# mark: Drag and drop and pinch =================================================================

## The captures of handle_drag_and_drop_event's nested navigable dispatch
## (`[type, screen_position, button, buttons, modifiers, &files]`).
struct EventHandlerDragAndDropDispatch:
    var type_: DragEventType
    var screen_position: gfx.CssPixelPoint
    var button: u32
    var buttons: u32
    var modifiers: u32
    var files: ak.Vector[HtmlSelectedFile]*

## handle_drag_and_drop_event's dispatch to a nested navigable's event handler.
func event_handler_drag_and_drop_dispatch(context: void*?, event_handler: EventHandler*, position: gfx.CssPixelPoint) -> EventResult:
    let captures = (EventHandlerDragAndDropDispatch*)(context else trap("no captures"))
    return event_handler_handle_drag_and_drop_event(event_handler, captures.type_, position, captures.screen_position, captures.button, captures.buttons, captures.modifiers, *captures.files)

## Ported from EventHandler.cpp:1544 Web::EventHandler::handle_drag_and_drop_event.
pub func event_handler_handle_drag_and_drop_event(this: EventHandler*, type_: DragEventType, visual_viewport_position: gfx.CssPixelPoint, screen_position: gfx.CssPixelPoint, button: u32, buttons: u32, modifiers: u32, a_files: ak.Vector[HtmlSelectedFile]) -> EventResult:
    var files = a_files
    let document = html_navigable_active_document(this.m_navigable) else return EventResult.dropped
    if not dom_document_is_fully_active(document):
        return EventResult.dropped

    let viewport_position = css_visual_viewport_map_to_layout_viewport(dom_document_visual_viewport(document), visual_viewport_position)

    dom_document_update_layout(document, DomUpdateLayoutReason.event_handler_handle_drag_and_drop)

    if event_handler_paint_root(this) == none:
        return EventResult.dropped

    var paintable: PaintPaintable*? = none
    if let result = event_handler_target_for_mouse_position(this, visual_viewport_position):
        paintable = result.paintable
    else:
        return EventResult.dropped
    let target = paintable else trap("no paintable")

    let node = dom_node_for_event_dispatch(target) else return EventResult.dropped

    let captures = new EventHandlerDragAndDropDispatch(type_ = type_, screen_position = screen_position, button = button, buttons = buttons, modifiers = modifiers, files = &files) else trap("out of memory")
    if let result = dispatch_event_to_nested_navigable(target, visual_viewport_position, ak.Function2[EventHandler*, gfx.CssPixelPoint, EventResult](call = event_handler_drag_and_drop_dispatch, context = captures)):
        return result

    let page_offset = event_handler_compute_mouse_event_page_offset(this, viewport_position)
    let scroll_offset = html_navigable_viewport_scroll_offset(dom_document_navigable(document) else trap("no navigable"))
    let offset = compute_mouse_event_offset(gfx.css_pixel_point_translated_css_pixel_point(&visual_viewport_position, scroll_offset), target)
    let realm = bind_platform_object_realm(document.bind_platform_object())

    match type_:
        .drag_start:
            return drag_and_drop_event_handler_handle_drag_start(this.m_drag_and_drop_event_handler, realm, gc.weak_ptr(&this.m_mousedown_target), screen_position, page_offset, viewport_position, offset, button, buttons, modifiers, files)
        .drag_move:
            return drag_and_drop_event_handler_handle_drag_move(this.m_drag_and_drop_event_handler, realm, node, screen_position, page_offset, viewport_position, offset, button, buttons, modifiers)
        .drag_end:
            return drag_and_drop_event_handler_handle_drag_leave(this.m_drag_and_drop_event_handler, realm, screen_position, page_offset, viewport_position, offset, button, buttons, modifiers)
        .drop:
            return drag_and_drop_event_handler_handle_drop(this.m_drag_and_drop_event_handler, realm, screen_position, page_offset, viewport_position, offset, button, buttons, modifiers)
        _:
            trap("VERIFY_NOT_REACHED")

## Ported from EventHandler.cpp:1593 Web::EventHandler::handle_pinch_event.
pub func event_handler_handle_pinch_event(this: EventHandler*, point: gfx.CssPixelPoint, scale_delta: f64) -> EventResult:
    let document = html_navigable_active_document(this.m_navigable) else return EventResult.dropped
    if not dom_document_is_fully_active(document):
        return EventResult.dropped

    let visual_viewport = dom_document_visual_viewport(document)
    css_visual_viewport_zoom(visual_viewport, point, scale_delta)
    return EventResult.handled

# mark: Sequential focus ========================================================================

## focus_next_element's set_focus_to_first_focusable_element lambda.
func event_handler_set_focus_to_first_focusable_element(this: EventHandler*) -> EventResult:
    let document = html_navigable_active_document(this.m_navigable) else trap("no active document")
    var element = tree_node_first_child_of_type(document.dom_node(), &dom_element_class)

    while let current = element:
        if dom_event_target_is_focusable(current.dom_event_target()):
            html_run_focusing_steps(current, none, HtmlFocusTrigger.key)
            return EventResult.handled
        element = (DomNode*?)dom_non_document_type_child_node_next_element_in_pre_order(current)

    return EventResult.dropped

## Ported from EventHandler.cpp:1606 Web::EventHandler::focus_next_element.
func event_handler_focus_next_element(this: EventHandler*) -> EventResult:
    let document = html_navigable_active_document(this.m_navigable) else return EventResult.dropped
    if not dom_document_is_fully_active(document):
        return EventResult.dropped

    var node = dom_document_focused_area(document)
    if node == none:
        return event_handler_set_focus_to_first_focusable_element(this)

    node = tree_node_next_in_pre_order(node else trap("unreachable"))
    while let current = node:
        if dom_event_target_is_focusable(current.dom_event_target()):
            break
        node = tree_node_next_in_pre_order(current)

    let focus_target = node else return event_handler_set_focus_to_first_focusable_element(this)

    html_run_focusing_steps(focus_target, none, HtmlFocusTrigger.key)
    return EventResult.handled

## focus_previous_element's set_focus_to_last_focusable_element lambda.
func event_handler_set_focus_to_last_focusable_element(this: EventHandler*) -> EventResult:
    # FIXME: This often returns the HTML element itself, which has no previous sibling.
    let document = html_navigable_active_document(this.m_navigable) else trap("no active document")
    var element = tree_node_last_child_of_type(document.dom_node(), &dom_element_class)

    while let current = element:
        if dom_event_target_is_focusable(current.dom_event_target()):
            html_run_focusing_steps(current, none, HtmlFocusTrigger.key)
            return EventResult.handled
        element = (DomNode*?)dom_non_document_type_child_node_previous_element_in_pre_order(current)

    return EventResult.dropped

## Ported from EventHandler.cpp:1640 Web::EventHandler::focus_previous_element.
func event_handler_focus_previous_element(this: EventHandler*) -> EventResult:
    let document = html_navigable_active_document(this.m_navigable) else return EventResult.dropped
    if not dom_document_is_fully_active(document):
        return EventResult.dropped

    var node = dom_document_focused_area(document)
    if node == none:
        return event_handler_set_focus_to_last_focusable_element(this)

    node = tree_node_previous_in_pre_order(node else trap("unreachable"))
    while let current = node:
        if dom_event_target_is_focusable(current.dom_event_target()):
            break
        node = tree_node_previous_in_pre_order(current)

    let focus_target = node else return event_handler_set_focus_to_last_focusable_element(this)

    html_run_focusing_steps(focus_target, none, HtmlFocusTrigger.key)
    return EventResult.handled

## Ported from EventHandler.cpp:1675 Web::EventHandler::focus_candidate_for_position.
func event_handler_focus_candidate_for_position(this: const EventHandler*, visual_viewport_position: gfx.CssPixelPoint) -> DomNode*?:
    let exact_hit = paint_paintable_box_hit_test(event_handler_paint_root_const(this) else trap("no paint root"), visual_viewport_position, PaintHitTestType.exact) else return none

    var focus_dom_node: DomNode*? = none
    if let hit_paintable = exact_hit.paintable:
        focus_dom_node = paint_paintable_dom_node(hit_paintable)

    while let current = focus_dom_node:
        if dom_event_target_is_focusable(current.dom_event_target()):
            break
        focus_dom_node = (DomNode*?)dom_node_parent_or_shadow_host(current)

    return focus_dom_node

# mark: Keyboard and input events ===============================================================

## Ported from EventHandler.cpp:1689 Web::should_ignore_keydown_event.
func should_ignore_keydown_event(code_point: u32, modifiers: u32) -> bool:
    if (modifiers & ((u32)UiEventsKeyModifier.mod_ctrl | (u32)UiEventsKeyModifier.mod_alt | (u32)UiEventsKeyModifier.mod_super)) != 0:
        return true

    # FIXME: There are probably also keys with non-zero code points that should be filtered out.
    return code_point == 0 or code_point == 27

## Ported from EventHandler.cpp:1698 Web::EventHandler::fire_keyboard_event.
func event_handler_fire_keyboard_event(this: EventHandler*, event_name: ak.FlyString, navigable: HtmlNavigable*, key: UiEventsKeyCode, modifiers: u32, code_point: u32, repeat: bool) -> EventResult:
    let document = html_navigable_active_document(navigable) else return EventResult.dropped
    if not dom_document_is_fully_active(document):
        return EventResult.dropped

    if let focused_area = dom_document_focused_area(document):
        if is_html_navigable_container(focused_area):
            let navigable_container = as_html_navigable_container(focused_area)
            if let content_navigable = html_navigable_container_content_navigable(navigable_container):
                return event_handler_fire_keyboard_event(this, event_name, content_navigable, key, modifiers, code_point, repeat)

        let event = ui_events_keyboard_event_create_from_platform_event(bind_platform_object_realm(document.bind_platform_object()), event_name, key, modifiers, code_point, repeat)
        return EventResult.accepted if dom_event_target_dispatch_event(focused_area.dom_event_target(), event) else EventResult.cancelled

    # FIXME: De-duplicate this. This is just to prevent wasting a KeyboardEvent allocation when recursing into an (i)frame.
    let event = ui_events_keyboard_event_create_from_platform_event(bind_platform_object_realm(document.bind_platform_object()), event_name, key, modifiers, code_point, repeat)

    var target: DomNode* = tree_node_root(document.dom_node())
    if let body = dom_document_body(document):
        target = body.dom_node()
    return EventResult.accepted if dom_event_target_dispatch_event(target.dom_event_target(), event) else EventResult.cancelled

## Ported from EventHandler.cpp:1725 Web::produces_character_value.
# https://w3c.github.io/uievents/#unicode-character-categories
func produces_character_value(code_point: u32) -> bool:
    # A subset of the General Category values that are defined for each Unicode code point. This subset contains all
    # the Letter (Ll, Lm, Lo, Lt, Lu), Number (Nd, Nl, No), Punctuation (Pc, Pd, Pe, Pf, Pi, Po, Ps) and Symbol (Sc,
    # Sk, Sm, So) category values.
    return web_unicode.code_point_has_letter_general_category(code_point) or web_unicode.code_point_has_number_general_category(code_point) or web_unicode.code_point_has_punctuation_general_category(code_point) or web_unicode.code_point_has_symbol_general_category(code_point)

## Ported from EventHandler.cpp:1737 Web::is_enter_key_or_interoperable_enter_key_combo.
# https://github.com/w3c/uievents/issues/183#issuecomment-448091687
func is_enter_key_or_interoperable_enter_key_combo(key: UiEventsKeyCode, modifiers: u32) -> bool:
    if key != UiEventsKeyCode.key_return:
        return false
    if modifiers == 0:
        return true
    if (modifiers & ((u32)UiEventsKeyModifier.mod_shift | (u32)UiEventsKeyModifier.mod_ctrl)) != 0:
        return true
    return false

## Ported from EventHandler.cpp:1748 Web::target_ranges_for_input_event.
func target_ranges_for_input_event(document: DomDocument*) -> ak.Vector[DomStaticRange*]:
    var target_ranges = ak.Vector[DomStaticRange*]()
    if let selection = dom_document_get_selection(document):
        if not selection_selection_is_collapsed(selection):
            if let range = selection_selection_range(selection):
                let abstract_range = range.dom_abstract_range()
                let static_range = realm_create_dom_static_range(bind_platform_object_realm(document.bind_platform_object()), dom_abstract_range_start_container(abstract_range), dom_abstract_range_start_offset(abstract_range), dom_abstract_range_end_container(abstract_range), dom_abstract_range_end_offset(abstract_range))
                ak.vector_append_t(&target_ranges, static_range)
    return target_ranges

## Ported from EventHandler.cpp:1760 Web::EventHandler::input_event.
func event_handler_input_event(this: EventHandler*, event_name: ak.FlyString, input_type: ak.FlyString, navigable: HtmlNavigable*, code_point_or_string: ak.U32OrUtf16String) -> EventResult:
    let document = html_navigable_active_document(navigable) else return EventResult.dropped
    if not dom_document_is_fully_active(document):
        return EventResult.dropped

    var input_event_init: UiEventsInputEventInit = ---
    ui_events_input_event_init_init_fields(&input_event_init)

    match code_point_or_string:
        .u32_(code_point):
            if not ak.is_unicode_control(code_point):
                input_event_init.data = ak.utf16_string_from_code_point(code_point)
        .utf16_string(string):
            input_event_init.data = string

    input_event_init.input_type = input_type

    let realm = bind_platform_object_realm(document.bind_platform_object())
    if let focused_area = dom_document_focused_area(document):
        if is_html_navigable_container(focused_area):
            let navigable_container = as_html_navigable_container(focused_area)
            if let content_navigable = html_navigable_container_content_navigable(navigable_container):
                return event_handler_input_event(this, event_name, input_type, content_navigable, code_point_or_string)

        let event = ui_events_input_event_create_from_platform_event(realm, event_name, input_event_init, target_ranges_for_input_event(document))
        return EventResult.accepted if dom_event_target_dispatch_event(focused_area.dom_event_target(), (DomEvent*)event) else EventResult.cancelled

    let event = ui_events_input_event_create_from_platform_event(realm, event_name, input_event_init, target_ranges_for_input_event(document))

    if let body = dom_document_body(document):
        return EventResult.accepted if dom_event_target_dispatch_event(body.dom_event_target(), (DomEvent*)event) else EventResult.cancelled

    return EventResult.accepted if dom_event_target_dispatch_event(tree_node_root(document.dom_node()).dom_event_target(), (DomEvent*)event) else EventResult.cancelled