Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / web / page / event_handler_3.lucb

#==============================================================================================
#
#   event_handler_3 - Web::EventHandler: mouse up and down, starting a character, word or
#   paragraph selection, and the default actions of a mouse down
#
#   DESCRIPTION:
#       Port of Libraries/LibWeb/Page/EventHandler.cpp lines 1005-1382 (handle_mouseup,
#       initiate_character_selection, initiate_word_selection, initiate_paragraph_selection,
#       run_mousedown_default_actions, handle_mousedown).
#
#       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 up ================================================================================

## handle_mouseup's ScopeGuard: clear the mousedown tracking and stop updating the selection.
func event_handler_mouseup_cleanup(this: EventHandler*, middle_button_autoscrolled: bool, button: u32):
    event_handler_clear_mousedown_tracking(this)
    event_handler_stop_updating_selection(this)

    if middle_button_autoscrolled and button == (u32)UiEventsMouseButton.middle:
        event_handler_release_middle_button_scroll_handler(this)

## The captures of handle_mouseup's nested navigable dispatch (`[=]`).
struct EventHandlerMouseupDispatch:
    var screen_position: gfx.CssPixelPoint
    var button: u32
    var buttons: u32
    var modifiers: u32

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

## Ported from EventHandler.cpp:1005 Web::EventHandler::handle_mouseup.
pub func event_handler_handle_mouseup(this: EventHandler*, visual_viewport_position: gfx.CssPixelPoint, screen_position: gfx.CssPixelPoint, button: u32, buttons: u32, modifiers: u32) -> EventResult:
    var middle_button_autoscrolled = false
    if let handler = this.m_middle_button_scroll_handler:
        middle_button_autoscrolled = middle_button_scroll_handler_mouse_has_moved_beyond_dead_zone(handler)

    defer event_handler_mouseup_cleanup(this, middle_button_autoscrolled, button)

    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.drop, visual_viewport_position, screen_position, button, buttons, modifiers, 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

    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_up)

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

    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

    let click_count = this.m_mousedown_click_count
    if click_count <= 0:
        return EventResult.dropped

    if paintable == none:
        assert(chrome_widget == none)

        # NB: Always fire a mouseup event if we've fired a mousedown event. Otherwise, web pages will not have a
        #     chance to end a drag that went outside the window.
        if gc.weak_ptr(&this.m_mousedown_target) != none:
            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())
            var html_element: DomNode*? = none
            if let element = dom_document_html_element(document):
                html_element = element.dom_node()
            _ = event_handler_dispatch_a_pointer_event_for_a_device_that_supports_hover(this, EventHandlerPointerEventType.pointer_up, html_element, none, coordinates, screen_position, gfx.CssPixelPoint(), button, buttons, modifiers, click_count)
            return EventResult.handled

        return EventResult.dropped

    let target = paintable else trap("unreachable")
    let computed_values = paint_paintable_computed_values(target)
    let pointer_events = css_computed_values_pointer_events(&computed_values.computed_values)
    if pointer_events == css_data.PointerEvents.none_:
        return EventResult.cancelled

    var node = dom_node_for_event_dispatch(target)
    if node == none:
        return EventResult.dropped

    let captures = new EventHandlerMouseupDispatch(screen_position = screen_position, button = button, 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_mouseup_dispatch, context = captures)):
        return result

    # 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
    if not parent_element_for_event_dispatch(target, &node, &layout_node):
        return EventResult.dropped
    let dispatch_node = node else trap("unreachable")

    let coordinates = event_handler_compute_mouse_event_coordinates(this, visual_viewport_position, viewport_position, target, layout_node else trap("unreachable"))
    _ = event_handler_dispatch_a_pointer_event_for_a_device_that_supports_hover(this, EventHandlerPointerEventType.pointer_up, dispatch_node, chrome_widget, coordinates, screen_position, gfx.CssPixelPoint(), button, buttons, modifiers, click_count)

    # FIXME: Per spec, the click target should be the nearest common inclusive ancestor of the pointerdown
    #        and pointerup targets. Currently we require an exact match.
    # NB: If the middle button was used to scroll, suppress click and activation behavior.
    if (DomNode*?)dispatch_node == gc.weak_ptr(&this.m_mousedown_target) and not middle_button_autoscrolled:
        if event_handler_fire_click_events(this, dispatch_node, coordinates, screen_position, button, buttons, modifiers, click_count) and chrome_widget == none:
            # NB: Event dispatches above may have run JS that invalidated layout.
            dom_document_update_layout(html_navigable_active_document(this.m_navigable) else trap("no active document"), DomUpdateLayoutReason.event_handler_run_activation_behavior)

            # FIXME: Currently cannot spawn a new top-level browsing context for new tab operations, because the
            #        new top-level browsing context would be in another process. To fix this, there needs to be
            #        some way to be able to communicate with browsing contexts in remote WebContent processes, and
            #        then step 8 of this algorithm needs to be implemented in Navigable::choose_a_navigable:
            #        https://html.spec.whatwg.org/multipage/document-sequences.html#the-rules-for-choosing-a-navigable
            event_handler_run_activation_behavior(this, dispatch_node, button, modifiers)

    return EventResult.handled

# mark: Starting a selection ====================================================================

## Ported from EventHandler.cpp:1114 Web::EventHandler::initiate_character_selection.
pub func event_handler_initiate_character_selection(this: EventHandler*, document: DomDocument*, hit: PaintHitTestResult, user_select: css_data.UserSelect, shift_held: bool) -> bool:
    let hit_node = paint_paintable_dom_node(hit.paintable else trap("no paintable")) else trap("no DOM node")

    let index = hit.index_in_node
    if let active_target = dom_document_active_input_events_target(document, hit_node):
        this.m_mouse_selection_target = active_target

        if shift_held:
            input_events_target_set_selection_focus(active_target, hit_node, index)
        else:
            input_events_target_set_selection_anchor(active_target, hit_node, index)
    else:
        this.m_mouse_selection_target = none

        if let selection = dom_document_get_selection(document):
            let anchor_node = selection_selection_anchor_node(selection)
            if anchor_node != none and shift_held:
                set_user_selection(anchor_node, (usize)selection_selection_anchor_offset(selection), hit_node, index, selection, user_select)
            else:
                set_user_selection(hit_node, index, hit_node, index, selection, user_select)

    this.m_selection_mode = EventHandlerSelectionMode.character
    return true

## Ported from EventHandler.cpp:1141 Web::EventHandler::initiate_word_selection.
pub func event_handler_initiate_word_selection(this: EventHandler*, document: DomDocument*, hit: PaintHitTestResult, user_select: css_data.UserSelect) -> bool:
    let paintable = hit.paintable else trap("no paintable")
    if not is_paint_text_paintable(paintable):
        return false

    let hit_paintable = as_paint_text_paintable(paintable)
    let hit_node = as_dom_text(paint_paintable_dom_node(paintable) else trap("no DOM node"))

    var previous_boundary: usize = 0
    var next_boundary: usize = 0

    if dom_text_is_password_input(hit_node):
        next_boundary = (usize)dom_character_data_length_in_utf16_code_units(hit_node.dom_character_data())
    else:
        let segmenter = event_handler_word_segmenter(this)
        let text = layout_text_node_text_for_rendering(paint_text_paintable_layout_node(hit_paintable))
        web_unicode.segmenter_set_segmented_text_utf16_view(segmenter, ak.utf16_string_base_utf16_view(&text.utf16_string_base))

        previous_boundary = (usize)(web_unicode.segmenter_previous_boundary(segmenter, hit.index_in_node, web_unicode.SegmenterInclusive.yes) else 0)
        next_boundary = (usize)(web_unicode.segmenter_next_boundary(segmenter, hit.index_in_node, web_unicode.SegmenterInclusive.no) else (u64)dom_node_length(hit_node.dom_node()))

    this.m_selection_mode = EventHandlerSelectionMode.word
    this.m_selection_origin = dom_range_create_dom_node(hit_node.dom_node(), (u32)previous_boundary, hit_node.dom_node(), (u32)next_boundary)

    if let target = dom_document_active_input_events_target(document, hit_node.dom_node()):
        this.m_mouse_selection_target = target
        input_events_target_set_selection_anchor(target, hit_node.dom_node(), previous_boundary)
        input_events_target_set_selection_focus(target, hit_node.dom_node(), next_boundary)
    elif let selection = dom_document_get_selection(document):
        this.m_mouse_selection_target = none
        set_user_selection(hit_node.dom_node(), previous_boundary, hit_node.dom_node(), next_boundary, selection, user_select)

    this.m_selection_mode = EventHandlerSelectionMode.word
    return true

## Ported from EventHandler.cpp:1178 Web::EventHandler::initiate_paragraph_selection.
pub func event_handler_initiate_paragraph_selection(this: EventHandler*, document: DomDocument*, hit: PaintHitTestResult, user_select: css_data.UserSelect) -> bool:
    let dom_node = paint_paintable_dom_node(hit.paintable else trap("no paintable")) else trap("no DOM node")
    if not is_dom_text(dom_node):
        return false

    let hit_node = as_dom_text(dom_node)
    let hit_index = hit.index_in_node

    # For input/textarea elements, select the current line (delimited by newlines).
    if let target = dom_document_active_input_events_target(document, hit_node.dom_node()):
        let data = dom_character_data_data(hit_node.dom_character_data())
        let text = ak.utf16_string_base_utf16_view(&data.utf16_string_base)
        let line_start = find_line_start(text, hit_index)
        let line_end = find_line_end(text, hit_index)

        this.m_selection_mode = EventHandlerSelectionMode.paragraph
        this.m_selection_origin = dom_range_create_dom_node(hit_node.dom_node(), (u32)line_start, hit_node.dom_node(), (u32)line_end)
        this.m_mouse_selection_target = target
        input_events_target_set_selection_anchor(target, hit_node.dom_node(), line_start)
        input_events_target_set_selection_focus(target, hit_node.dom_node(), line_end)
    elif let selection = dom_document_get_selection(document):
        # For regular content, find paragraph boundaries within the containing block.
        let origin = find_paragraph_range(hit_node, (u32)hit_index)
        this.m_selection_origin = origin

        this.m_selection_mode = EventHandlerSelectionMode.paragraph
        this.m_mouse_selection_target = none

        let range = origin.dom_abstract_range()
        set_user_selection(dom_abstract_range_start_container(range), (usize)dom_abstract_range_start_offset(range), dom_abstract_range_end_container(range), (usize)dom_abstract_range_end_offset(range), selection, user_select)

    this.m_selection_mode = EventHandlerSelectionMode.paragraph
    return true

# mark: Mouse down ==============================================================================

## Ported from EventHandler.cpp:1211 Web::EventHandler::run_mousedown_default_actions.
func event_handler_run_mousedown_default_actions(this: EventHandler*, document: DomDocument*, visual_viewport_position: gfx.CssPixelPoint, viewport_position: gfx.CssPixelPoint, button: u32, modifiers: u32, click_count: i32):
    if this.m_middle_button_scroll_handler != none:
        event_handler_release_middle_button_scroll_handler(this)
        return

    if button == (u32)UiEventsMouseButton.middle:
        if not page_enable_autoscroll(html_navigable_page(this.m_navigable)):
            return

        let hit = paint_paintable_box_hit_test(event_handler_paint_root(this) else trap("no paint root"), visual_viewport_position, PaintHitTestType.exact) else return
        let hit_paintable = hit.paintable else trap("no paintable")

        var node = paint_paintable_dom_node(hit_paintable)
        while let current = node:
            if as_if_form_associated_text_control_element(current) != none:
                return
            if let anchor = as_if_html_anchor_element(current):
                if dom_element_has_attribute(anchor.dom_element(), html_attribute_names_href):
                    return
            node = dom_node_parent_or_shadow_host_node(current)

        if let container = middle_button_scroll_handler_find_scrollable_ancestor(document, hit_paintable):
            # make<MiddleButtonScrollHandler>(*container, visual_viewport_position)
            let handler = new MiddleButtonScrollHandler(m_container_element = container, m_origin = visual_viewport_position, m_mouse_position = visual_viewport_position, m_fractional_delta = gfx.CssPixelPoint(), m_mouse_has_moved_beyond_dead_zone = false) else trap("out of memory")
            middle_button_scroll_handler_construct(handler, container, visual_viewport_position)
            this.m_middle_button_scroll_handler = handler

        return

    if button != (u32)UiEventsMouseButton.primary:
        return
    if os.macos:
        if (modifiers & (u32)UiEventsKeyModifier.mod_ctrl) != 0:
            return

    # https://html.spec.whatwg.org/multipage/interaction.html#data-model:click-focusable-5
    # When a user activates a click focusable focusable area, the user agent must run the focusing steps on that
    # focusable area with focus trigger set to "click".
    # NOTE: Note that focusing is not an activation behavior, i.e. calling the click() method on an element or
    #       dispatching a synthetic click event on it won't cause the element to get focused.
    if let focus_candidate = event_handler_focus_candidate_for_position(this, viewport_position):
        html_run_focusing_steps(focus_candidate, none, HtmlFocusTrigger.click)
    elif let focused_area = dom_document_focused_area(document):
        html_run_unfocusing_steps(focused_area)

    # NB: Focusing may have invalidated layout.
    dom_document_update_layout(document, DomUpdateLayoutReason.event_handler_handle_mouse_down)
    let paint_root = event_handler_paint_root(this) else return

    # NB: Now we can do selection with a cursor hit test.
    let cursor_hit = paint_paintable_box_hit_test(paint_root, visual_viewport_position, PaintHitTestType.text_cursor) else return
    let cursor_paintable = cursor_hit.paintable else trap("no paintable")

    if paint_paintable_dom_node(cursor_paintable) == none:
        return

    # https://drafts.csswg.org/css-ui/#valdef-user-select-none
    # Attempting to start a selection in an element where user-select is none, such as by clicking in it or starting a
    # drag in it, must not cause a pre-existing selection to become unselected or to be affected in any way.
    let user_select = layout_node_user_select_used_value(paint_paintable_layout_node(cursor_paintable))
    if user_select == css_data.UserSelect.none_:
        return

    var selection_started = false
    if click_count == 3:
        selection_started = event_handler_initiate_paragraph_selection(this, document, cursor_hit, user_select)
    elif click_count == 2:
        selection_started = event_handler_initiate_word_selection(this, document, cursor_hit, user_select)
    else:
        selection_started = event_handler_initiate_character_selection(this, document, cursor_hit, user_select, (modifiers & (u32)UiEventsKeyModifier.mod_shift) != 0)
    if not selection_started:
        return
    assert(this.m_selection_mode != EventHandlerSelectionMode.none_)

    if let container = auto_scroll_handler_find_scrollable_ancestor(cursor_paintable):
        # make<AutoScrollHandler>(m_navigable, *container)
        let handler = new AutoScrollHandler(m_navigable = this.m_navigable, m_container_element = container, m_mouse_position = gfx.CssPixelPoint(), m_fractional_delta = gfx.CssPixelPoint(), m_active = false) else trap("out of memory")
        auto_scroll_handler_construct(handler, this.m_navigable, container)
        this.m_auto_scroll_handler = handler

## The captures of handle_mousedown's nested navigable dispatch (`[=]`).
struct EventHandlerMousedownDispatch:
    var screen_position: gfx.CssPixelPoint
    var button: u32
    var buttons: u32
    var modifiers: u32
    var click_count: i32

## handle_mousedown's dispatch to a nested navigable's event handler.
func event_handler_mousedown_dispatch(context: void*?, event_handler: EventHandler*, position: gfx.CssPixelPoint) -> EventResult:
    let captures = (EventHandlerMousedownDispatch*)(context else trap("no captures"))
    return event_handler_handle_mousedown(event_handler, position, captures.screen_position, captures.button, captures.buttons, captures.modifiers, captures.click_count)

## Ported from EventHandler.cpp:1293 Web::EventHandler::handle_mousedown.
pub func event_handler_handle_mousedown(this: EventHandler*, visual_viewport_position: gfx.CssPixelPoint, screen_position: gfx.CssPixelPoint, button: u32, buttons: u32, modifiers: u32, click_count: i32) -> EventResult:
    if event_handler_should_ignore_device_input_event(this):
        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_down)

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

    var node: DomNode*? = none

    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
    else:
        return EventResult.dropped
    let target = paintable else trap("no paintable")

    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_)

    node = dom_node_for_event_dispatch(target)

    if node == none:
        return EventResult.dropped

    this.m_mousedown_click_count = click_count

    let captures = new EventHandlerMousedownDispatch(screen_position = screen_position, button = button, buttons = buttons, modifiers = modifiers, click_count = click_count) 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_mousedown_dispatch, context = captures)):
        return result

    page_set_focused_navigable(html_navigable_page(this.m_navigable), this.m_navigable)

    # 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
    if not parent_element_for_event_dispatch(target, &node, &layout_node):
        return EventResult.dropped
    let dispatch_node = node else trap("unreachable")

    this.m_mousedown_target = gc.make_weak(dispatch_node)
    this.m_mousedown_visual_viewport_position = visual_viewport_position

    let coordinates = event_handler_compute_mouse_event_coordinates(this, visual_viewport_position, viewport_position, target, layout_node else trap("unreachable"))
    if not event_handler_dispatch_a_pointer_event_for_a_device_that_supports_hover(this, EventHandlerPointerEventType.pointer_down, dispatch_node, chrome_widget, coordinates, screen_position, gfx.CssPixelPoint(), button, buttons, modifiers, click_count):
        return EventResult.cancelled

    # FIXME: The spec allows this to be fired following mousedown or mouseup. The native behavior on Windows is to
    #        do so in mouseup, so we should make this configurable by the UI.
    if button == (u32)UiEventsMouseButton.secondary:
        event_handler_maybe_show_context_menu(this, dispatch_node, coordinates, screen_position, viewport_position, buttons, modifiers)
    elif os.macos and button == (u32)UiEventsMouseButton.primary and (modifiers & (u32)UiEventsKeyModifier.mod_ctrl) != 0:
        event_handler_maybe_show_context_menu(this, dispatch_node, coordinates, screen_position, viewport_position, buttons, modifiers)
    else:
        this.m_mousedown_target_is_drag_candidate = button == (u32)UiEventsMouseButton.primary

    # 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_down)
    if event_handler_paint_root(this) == none:
        return EventResult.accepted

    if chrome_widget == none:
        event_handler_run_mousedown_default_actions(this, document, visual_viewport_position, viewport_position, button, modifiers, click_count)

    return EventResult.handled