teksilo_widgets/rich_text/

context_menu.rs

// SPDX-License-Identifier: MPL-2.0
// SPDX-FileCopyrightText: 2026 FernTech

//! Default right-click context menu for `RichTextEditor`.
//!
//! Uses the framework's built-in
//! [`context_menu(factory)`](teksilo_core::widget_builder::WidgetBuilder::context_menu)
//! infrastructure: a fresh menu widget is created on every right-click,
//! shown at the pointer position, and torn down on dismissal. That
//! machinery lives in `teksilo-core::widget_tree::pointer_router::show_context_menu_for`
//! — we just hand it a factory.
//!
//! ## Why no Actions / Intents for the built-in items
//!
//! The framework's `show_context_menu_for` adds the menu widget at the
//! **top of the arena** (via `add_boxed`). It is *not* a child of the
//! editor. So an intent fired from a menu item walks up the menu's own
//! subtree and terminates there — it never reaches any `Action`
//! registered on the editor.
//!
//! Additionally, when the menu dismisses (the tap's default behaviour)
//! the whole subtree flips dormant recursively in the same
//! `collect_from_ctx` call, *before* the tree's pending-intent queue
//! drains. Any `Action` inside the dormant subtree is skipped by
//! `dispatch_intent`'s `is_active` gate.
//!
//! Both problems go away by **not using Actions for the default menu**.
//! Each `MenuItem`'s `on_activate_fn` closure captures a clone of the
//! editor's [`SharedState`] and calls the corresponding
//! `rt_clipboard::*` function directly. The work happens inline, during
//! the tap handler, while the menu subtree is still active — no
//! dispatch-timing concerns at all.
//!
//! ## Reserved intent names (external observation only)
//!
//! After doing the work directly, each closure also fires a
//! `teksilo.rich_text.*` intent for applications that want to observe
//! (e.g. telemetry, undo-stack annotation, clipboard-manager mirroring).
//! These intents reach ancestor Actions through the normal walk chain —
//! the intent walk starts from the *editor* (via
//! `EventContext::send_intent` which anchors on `source_widget`,
//! which for a PointerDown is the hit widget — but we're dispatching
//! from inside the menu item, which is top-level, so the walk
//! terminates without reaching the editor).
//!
//! Since the framework's `show_context_menu_for` makes the menu
//! top-level, intent observation via this path doesn't reach the host
//! app either. Applications that want to observe or override should
//! use the slot instead (see `RichTextEditor::context_menu`). The
//! reserved intent names are reserved for a future reworked dispatch
//! but are not currently useful — we emit them anyway so the contract
//! is stable.
//!
//! ## Slot-based replacement
//!
//! `RichTextEditor::context_menu` accepts a user-provided factory
//! that replaces the default entirely. The user's factory returns
//! whatever widget they want — typically a `MenuList`, but any
//! `Widget` works (a `Panel` with custom chrome, a domain-specific
//! command palette, etc.).

use teksilo_i18n::tr_widget;

use teksilo_core::intent::Intent;
use teksilo_core::shortcut::StandardEdit;
use teksilo_core::widget::Widget;
use teksilo_core::widget_builder::ContextMenuTrigger;

use crate::menu_item::MenuItem;
use crate::menu_list::MenuList;

use super::clipboard as rt_clipboard;
use super::policy::{ClipboardPolicy, EditCommandKind, PolicyBundle};
use super::state::SharedState;

/// Intent fired when the user activates the **Cut** item of the
/// built-in context menu. Reserved for the framework — applications
/// that want bespoke cut semantics should replace the menu via
/// [`RichTextEditor::context_menu`](super::RichTextEditor::context_menu)
/// rather than registering a custom `Action` against this name.
pub const INTENT_CUT: &str = "teksilo.rich_text.cut";

/// Intent fired by the built-in Copy menu item.
pub const INTENT_COPY: &str = "teksilo.rich_text.copy";

/// Intent fired by the built-in Paste menu item.
pub const INTENT_PASTE: &str = "teksilo.rich_text.paste";

/// Intent fired by the built-in Paste Unformatted menu item.
pub const INTENT_PASTE_UNFORMATTED: &str = "teksilo.rich_text.paste_unformatted";

/// Intent fired by the built-in Select All menu item.
pub const INTENT_SELECT_ALL: &str = "teksilo.rich_text.select_all";

/// Build the default context-menu factory for the given editor
/// state and policy.
///
/// The returned closure is installed on the editor's arena node via
/// [`HandlerSet::context_menu`](teksilo_core::widget_builder::HandlerSet::context_menu);
/// the framework calls it on each right-click to produce a **fresh**
/// menu subtree. That freshness matters: each invocation recomputes
/// item enabled-state from the live editor state + live clipboard at
/// the instant the user right-clicks, so greyed entries never lie.
pub(super) fn default_factory(state: SharedState) -> RichTextContextMenuFactory {
    // The closure is called each right-click. `state` is captured
    // once and cloned for each menu item's action closure; the
    // `Rc<RefCell<...>>` behind `SharedState` makes that cheap. The
    // built-in menu is unconditional — it always returns
    // `Some(menu)`, whatever the position. Callers needing a
    // position-aware menu install their own via
    // `RichTextEditor::context_menu`.
    Box::new(move |pos, ctx| {
        // Reposition the caret to the click point (unless it lands inside the
        // current selection) so Paste — and every other item — acts where the
        // user right-clicked, matching the single-line field and the platform
        // convention. Without this a right-click leaves the caret wherever it
        // last was, and Paste inserted there instead of under the cursor.
        //
        // A pointer's point only. The keyboard's menu is anchored in the
        // middle of the editor, and moving the caret there sent the menu's
        // Paste to a place the user had never been.
        if ctx
            .context_menu_trigger()
            .is_none_or(ContextMenuTrigger::is_pointer)
        {
            super::mouse::reposition_caret_for_context_menu(&state, pos);
        }
        let state_for_build = state.clone();
        Some(Box::new(build_menu(state_for_build)) as Box<dyn Widget>)
    })
}

/// Construct the `MenuList` for the current editor / policy state.
/// Called from the factory on every right-click.
fn build_menu(state: SharedState) -> MenuList {
    let mut list = MenuList::new();

    // Read the policy **now**, not at build time: the command filter is
    // swappable on a mounted editor (`RichTextEditor::set_command_filter`), and
    // a menu built from a stale snapshot would keep offering Cut after the host
    // switched the surface to forward-only drafting.
    let policy: PolicyBundle = state.borrow().policy;

    let has_selection = state.borrow().cursor.has_selection();
    let doc_non_empty = !state
        .borrow()
        .document
        .to_plain_text()
        .unwrap_or_default()
        .is_empty();

    // --- Cut -----------------------------------------------------
    // Two independent gates, and both are load-bearing: `ClipboardPolicy`
    // answers "does this surface have a clipboard at all", while the command
    // filter answers "may this surface take text away". A forward-only editor
    // says yes to the first and no to the second — checking only the clipboard
    // policy would leave a working Cut in the menu of an editor whose Ctrl+X is
    // blocked.
    if policy.clipboard_policy.allows_cut() && policy.command_filter.accepts(EditCommandKind::Cut) {
        list = list.item(row_cut(&state).enabled(has_selection));
    }

    // --- Copy ----------------------------------------------------
    list = list.item(row_copy(&state).enabled(has_selection));

    // --- Paste ---------------------------------------------------
    // Availability: at factory-call time, probe the clipboard handle
    // via the EventContext path. But here, inside the factory, we have
    // no EventContext. We can only check what the editor itself knows
    // — the stashed `rich_clipboard_fragment` isn't the right signal.
    // Leave Paste always enabled when the policy allows; the closure
    // itself silently no-ops if the clipboard is empty (matches the
    // existing Ctrl+V behaviour).
    if policy.clipboard_policy.allows_paste() {
        list = list.item(row_paste(&state));
    }

    // --- Paste Unformatted ---------------------------------------
    if policy.clipboard_policy.allows_paste_unformatted() {
        let state_for_pu = state.clone();
        list = list.item(
            MenuItem::new(tr_widget!(menu_paste_unformatted()))
                .for_shortcut(StandardEdit::PastePlain.id())
                .on_activate_fn(move |evt_ctx| {
                    let mut st = state_for_pu.borrow_mut();
                    rt_clipboard::paste_unformatted(&mut st, evt_ctx);
                    drop(st);
                    super::sync_cursor_signals(&state_for_pu);
                    evt_ctx.request_frame();
                    evt_ctx.send_intent(Intent::new(INTENT_PASTE_UNFORMATTED));
                }),
        );
    }

    // --- Toggle blockquote ---------------------------------------
    // Only meaningful when the editor accepts mutations (read-only
    // presets get the minimal menu — Cut/Copy/Paste/Select-All).
    if policy
        .command_filter
        .accepts(EditCommandKind::ToggleBlockquote)
    {
        let state_for_bq = state.clone();
        // Greyed out where the toggle would do nothing: a selection across a
        // frame boundary, or a wrap that would take a quote past the nesting
        // ceiling. `toggle_blockquote` itself stops by the same rule.
        let available = super::nesting::toggle_is_available(&state.borrow());
        let in_quote = state.borrow().cursor.is_in_blockquote();
        let label = if in_quote {
            tr_widget!(menu_remove_blockquote())
        } else {
            tr_widget!(menu_toggle_blockquote())
        };
        list = list.separator();
        list = list.item(
            MenuItem::new(label)
                .enabled(available)
                .on_activate_fn(move |evt_ctx| {
                    super::nesting::toggle_blockquote(&state_for_bq.borrow());
                    super::sync_cursor_signals(&state_for_bq);
                    evt_ctx.request_frame();
                }),
        );
    }

    // Separator before Select All under the full policy; read-only
    // presets keep the menu minimal (no separator).
    if matches!(policy.clipboard_policy, ClipboardPolicy::Full) {
        list = list.separator();
    }

    // --- Select All ----------------------------------------------
    list = list.item(row_select_all(&state).enabled(doc_non_empty));

    list
}

// ---------------------------------------------------------------------------
// The four rows, built once and used twice
// ---------------------------------------------------------------------------
//
// The right-click menu and the touch **selection toolbar** offer the same four
// commands, so they are the same four rows. Each builder returns the row without
// an `enabled` gate: the menu adds one (a greyed row is the desktop convention),
// while the toolbar *omits* a command it cannot offer (which is what every
// platform's touch toolbar does) through `MenuList::item_when`. See
// `docs/text-touch-editing.md`.

/// Cut the selection.
fn row_cut(state: &SharedState) -> MenuItem {
    let state = state.clone();
    MenuItem::new(tr_widget!(menu_cut()))
        .for_shortcut(StandardEdit::Cut.id())
        .on_activate_fn(move |evt_ctx| {
            let mut st = state.borrow_mut();
            rt_clipboard::cut(&mut st, evt_ctx);
            drop(st);
            super::sync_cursor_signals(&state);
            evt_ctx.request_frame();
            evt_ctx.send_intent(Intent::new(INTENT_CUT));
        })
}

/// Copy the selection.
fn row_copy(state: &SharedState) -> MenuItem {
    let state = state.clone();
    MenuItem::new(tr_widget!(menu_copy()))
        .for_shortcut(StandardEdit::Copy.id())
        .on_activate_fn(move |evt_ctx| {
            let mut st = state.borrow_mut();
            rt_clipboard::copy(&mut st, evt_ctx);
            drop(st);
            evt_ctx.send_intent(Intent::new(INTENT_COPY));
        })
}

/// Paste at the caret.
fn row_paste(state: &SharedState) -> MenuItem {
    let state = state.clone();
    MenuItem::new(tr_widget!(menu_paste()))
        .for_shortcut(StandardEdit::Paste.id())
        .on_activate_fn(move |evt_ctx| {
            let mut st = state.borrow_mut();
            rt_clipboard::paste(&mut st, evt_ctx);
            drop(st);
            super::sync_cursor_signals(&state);
            evt_ctx.request_frame();
            evt_ctx.send_intent(Intent::new(INTENT_PASTE));
        })
}

/// Select the whole document.
fn row_select_all(state: &SharedState) -> MenuItem {
    let state = state.clone();
    MenuItem::new(tr_widget!(menu_select_all()))
        .for_shortcut(StandardEdit::SelectAll.id())
        .on_activate_fn(move |evt_ctx| {
            {
                let mut st = state.borrow_mut();
                st.cursor
                    .select(teksilo_text::text_document::SelectionType::Document);
                st.select_all_level = 0;
                st.select_all_anchor_cell = None;
            }
            super::sync_cursor_signals(&state);
            evt_ctx.request_frame();
            evt_ctx.send_intent(Intent::new(INTENT_SELECT_ALL));
        })
}

/// The selection toolbar a finger raises: the same four rows, each shown only
/// while the controller says the surface will honour it **and** this editor's
/// own policy allows it.
///
/// Built once per `build()` rather than per raise, because it is overlay content
/// and an `EventContext` cannot add widgets. Reactive visibility does the work a
/// fresh build would: the rows are gated on the controller's published
/// [`ClipboardActions`](teksilo_core::text_touch::ClipboardActions) — derived
/// from the surface's own `is_editable` / `allows_copy` / selection — **and** on
/// the live `PolicyBundle`, which a host may swap on a mounted editor. The
/// controller cannot see the second: `TextHitSource` reports whether copying is
/// allowed, but not whether *this* editor's command filter has vetoed Cut or its
/// clipboard policy has withdrawn Paste.
pub(super) fn selection_toolbar(
    state: SharedState,
    affordances: teksilo_core::text_touch::TextAffordances,
) -> Box<dyn Widget> {
    use teksilo_core::text_touch::TextAction;
    let offers = |action: TextAction, allowed: fn(&PolicyBundle) -> bool| {
        let aff = affordances.clone();
        let state = state.clone();
        affordances.version_signal().map(move |_| {
            allowed(&state.borrow().policy)
                && aff.toolbar().is_some_and(|t| t.actions.contains(&action))
        })
    };
    Box::new(
        MenuList::new()
            .item_when(
                row_cut(&state),
                offers(TextAction::Cut, |p| {
                    p.clipboard_policy.allows_cut()
                        && p.command_filter.accepts(EditCommandKind::Cut)
                }),
            )
            .item_when(
                row_copy(&state),
                offers(TextAction::Copy, |p| {
                    p.clipboard_policy.allows_copy()
                        && p.command_filter.accepts(EditCommandKind::Copy)
                }),
            )
            .item_when(
                row_paste(&state),
                offers(TextAction::Paste, |p| p.clipboard_policy.allows_paste()),
            )
            .item_when(
                row_select_all(&state),
                offers(TextAction::SelectAll, |_| true),
            ),
    )
}

/// Resolve which factory (if any) the editor should install for its
/// arena node's `context_menu_factory`. Precedence:
///
/// 1. **User factory** (supplied via `RichTextEditor::context_menu`) —
///    always wins when provided. The host app is explicitly replacing
///    the default.
/// 2. **Default factory** when `default_context_menu` is enabled
///    (the default) and no user factory is set.
/// 3. **No factory** when the host called
///    `default_context_menu(false)` — right-click bubbles past the
///    widget unhandled; `context_target_at` remains available so the
///    app can render its own menu from outside.
pub(super) fn resolve_factory(
    user_factory: Option<RichTextContextMenuFactory>,
    default_enabled: bool,
    state: SharedState,
) -> Option<RichTextContextMenuFactory> {
    if let Some(user) = user_factory {
        return Some(user);
    }
    if default_enabled {
        return Some(default_factory(state));
    }
    None
}

/// Internal alias — same shape as the framework's
/// [`teksilo_core::widget_builder::ContextMenuFactory`]. Re-declared
/// locally so the rich-text module doesn't have to thread the public
/// alias through every signature.
pub(super) type RichTextContextMenuFactory = Box<
    dyn Fn(
        teksilo_canvas::Point,
        &mut teksilo_core::widget::EventContext,
    ) -> Option<Box<dyn Widget>>,
>;

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn intent_names_use_reserved_teksilo_prefix() {
        // The `teksilo.` prefix is the framework's reserved namespace
        // for built-in plumbing; applications that want to register
        // custom intents should use their own prefix. Locking the
        // strings makes any rename a deliberate, breaking change.
        assert_eq!(INTENT_CUT, "teksilo.rich_text.cut");
        assert_eq!(INTENT_COPY, "teksilo.rich_text.copy");
        assert_eq!(INTENT_PASTE, "teksilo.rich_text.paste");
        assert_eq!(
            INTENT_PASTE_UNFORMATTED,
            "teksilo.rich_text.paste_unformatted"
        );
        assert_eq!(INTENT_SELECT_ALL, "teksilo.rich_text.select_all");
    }
}