rdom-tui 0.4.0

//! Mouse-drag text selection — `mousedown` begins, `mousemove`
//! extends focus, `mouseup` ends.
//!
//! Called from `runtime/router/mouse/mod.rs` as default actions
//! on the mouse pipeline:
//!
//! - `begin`: tries to start a drag on `mousedown`. Returns true
//!   when the click landed on selectable text and a drag is now
//!   active — caller relies on pointer capture (which `begin` sets)
//!   to route subsequent `mousemove`/`mouseup` back here.
//! - `extend`: on `mousemove` while a drag is active, moves the
//!   selection's `focus` to the cursor's current position. Preserves
//!   the original anchor so dragging backward shrinks the selection
//!   symmetrically.
//! - `end`: clears router drag state. Pointer capture is released
//!   by the router's own `handle_up` (browser-faithful auto-release).
//!
//! ## Why pointer capture
//!
//! Without capture, dragging off the original paragraph routes
//! subsequent moves to whatever chrome happens to sit underneath —
//! selection would "jump" or freeze. Holding capture on the IFC
//! block means every move comes back to us while the button is
//! down. Matches browser `setPointerCapture` semantics.
//!
//! ## What "selectable" means here
//!
//! A click is selectable iff `dom.position_at(x, y)` returns
//! `Some(_)`. That function already walks to the innermost IFC
//! block and rejects `user-select: none` subtrees, so this file
//! doesn't duplicate those checks.

use crossterm::event::MouseEvent;

use rdom_core::Selection;

use crate::TuiDom;
use crate::layout::UserSelect;
use crate::node::is_descendant_or_self;
use crate::render::inline::inline_flow_for_text;
use crate::runtime::hit_test::HitTestExt;
use crate::runtime::router::Router;
use crate::runtime::selection::user_select;

/// Default action for `mousedown`: begin a drag-select if the
/// click landed on selectable text.
///
/// Returns `true` when a drag was started. The router uses this
/// only to keep symmetry with other default actions — the real
/// "we're dragging" signal for follow-up moves is
/// `router.selection_drag.is_some()`, set by this function.
pub(crate) fn begin(router: &mut Router, dom: &mut TuiDom, mouse: MouseEvent) -> bool {
    let Some(anchor) = dom.position_at(mouse.column, mouse.row) else {
        return false;
    };

    // Anchor must point at a real text node, not at an atomic
    // inline-block sentinel. When an IFC packer emits a fragment
    // for `Display::InlineBlock` (BFC-1 phase 3.5b), it sets
    // `text_node = node` so the fragment carries the inline-block
    // element id as its source. `position_at` happily returns a
    // Position whose `node` is that element. Engaging drag-select
    // there is wrong — atomic inline-blocks are interactive
    // widgets (`<button>`, `<input type=submit>`), not selectable
    // text. The click event must route to the widget itself, which
    // pointer capture would clobber by retargeting to the IFC
    // owner. Bail out so the click flow stays intact.
    if dom.node(anchor.node).node_type() != rdom_core::NodeType::Text {
        return false;
    }

    // `user-select: all`: a click anywhere inside the host element
    // selects its entire text content as a single unit. The drag
    // still engages capture, but `extend` becomes a no-op for the
    // duration — the highlight doesn't shrink as the user moves the
    // mouse.
    let initial = match user_select::ancestor_with(dom, anchor.node, UserSelect::All) {
        Some(host) => {
            user_select::span_all_text(dom, host).unwrap_or_else(|| Selection::caret(anchor))
        }
        None => Selection::caret(anchor),
    };
    dom.set_selection(Some(initial));

    // Hold pointer capture on the inline-flow container that holds
    // the anchor. For a classic IFC, the holder is the IFC block;
    // for an anonymous block box (BFC-1 phase 3), it's the parent
    // container — pointer capture is a per-NodeId concept, and the
    // container is the closest real node. The follow-up mousemove /
    // mouseup events route through that holder.
    let anchor_flow = inline_flow_for_text(dom, anchor.node);
    let capture_holder = anchor_flow.map(|f| f.owner()).unwrap_or(anchor.node);
    let _ = dom.set_pointer_capture(capture_holder);
    // Opt the text-selection drag into edge autoscroll (DRAG-AUTOSCROLL): when
    // the drag dwells at a scroll container's edge, the runtime scrolls it and
    // re-extends the selection at the revealed content — like a browser.
    dom.set_drag_autoscroll(true);

    router.selection_drag = anchor_flow;
    true
}

/// Default action for `mousemove` (while `router.selection_drag` is
/// set): extend the selection's focus to the cursor's current
/// position. Returns `true` when the selection actually changed —
/// caller uses it to request a redraw.
///
/// When the cursor moves outside any selectable text (onto a
/// `user-select: none` bar, into a gap, or past end-of-line) the focus
/// snaps to the nearest selectable position to the pointer via
/// [`HitTestExt::nearest_selectable_position`] — browsers extend the
/// selection past such regions rather than freezing or collapsing it.
pub(crate) fn extend(dom: &mut TuiDom, mouse: MouseEvent) -> bool {
    let Some(sel) = dom.selection().copied() else {
        return false;
    };

    // `user-select: all`: the host is selected as a unit, so the
    // drag doesn't update focus while the cursor moves.
    if user_select::ancestor_with(dom, sel.anchor.node, UserSelect::All).is_some() {
        return false;
    }

    // Prefer the hit-tested position — it may land in a DIFFERENT
    // inline-flow container, which is correct for cross-paragraph
    // drag selection (browsers let the selection span multiple
    // paragraphs). When the cursor is over non-selectable space —
    // a `user-select: none` bar, a gap, past end-of-line — `position_at`
    // yields nothing, so snap to the nearest SELECTABLE position to the
    // POINTER (not the anchor flow): dragging up over a `user-select: none`
    // chrome bar must extend to the text beyond it, not collapse the
    // selection back into the anchor block far below the cursor.
    let raw_focus = match dom.position_at(mouse.column, mouse.row) {
        Some(p) => p,
        None => match dom.nearest_selectable_position(mouse.column, mouse.row) {
            Some(p) => p,
            None => return false,
        },
    };

    // `user-select: contain`: the host traps the selection. If
    // `raw_focus` escaped the contain host, clamp it back to the
    // nearest in-host position.
    let focus = match user_select::ancestor_with(dom, sel.anchor.node, UserSelect::Contain) {
        Some(host) if !is_descendant_or_self(dom, raw_focus.node, host) => {
            match user_select::clamp_to_contain_host(dom, host, mouse) {
                Some(p) => p,
                None => return false,
            }
        }
        _ => raw_focus,
    };

    if sel.focus == focus {
        return false;
    }
    dom.set_selection(Some(Selection::new(sel.anchor, focus)));
    true
}

// `clamp_to_anchor_flow` retired: the no-position fallback now snaps to the
// nearest *selectable* flow to the pointer via
// `HitTestExt::nearest_selectable_position` (so dragging over a
// `user-select: none` bar extends past it instead of collapsing back into the
// anchor flow). The y-overshoot clamp it used lives in `position_at`'s
// `clamp_to_line_layout`, shared by both the contained and nearest paths.

/// Clear router drag state. Call from `mouseup` regardless of
/// whether the up landed on text — the pointer capture is what
/// kept the drag alive, and it's auto-released by the router.
pub(crate) fn end(router: &mut Router) {
    router.selection_drag = None;
}

// `ifc_block_of` retired — drag now stores `InlineFlow` directly,
// resolved via `inline_flow_for_text`. The pointer-capture holder
// falls back to `InlineFlow::owner()` (the container node id).