oak-gpui/crates/editor/src/mouse_context_menu.rs

use crate::{
    ConfirmCodeAction, Copy, CopyAndTrim, CopyPermalinkToLine, Cut, DebuggerEvaluateSelectedText,
    DisplayPoint, DisplaySnapshot, Editor, FindAllReferences, GoToDeclaration, GoToDefinition,
    GoToImplementation, GoToTypeDefinition, Paste, Rename, RevealInFileManager, SelectMode,
    ToDisplayPoint, ToggleCodeActions,
    actions::{Format, FormatSelections},
    code_context_menus::CodeActionContents,
    selections_collection::SelectionsCollection,
};
use feature_flags::{Debugger, FeatureFlagAppExt as _};
use gpui::prelude::FluentBuilder;
use gpui::{
    Context, DismissEvent, Entity, FocusHandle, Focusable as _, Pixels, Point, Subscription, Task,
    Window,
};
use std::ops::Range;
use text::PointUtf16;
use ui::ContextMenu;
use util::ResultExt;
use workspace::OpenInTerminal;

#[derive(Debug)]
pub enum MenuPosition {
    /// When the editor is scrolled, the context menu stays on the exact
    /// same position on the screen, never disappearing.
    PinnedToScreen(Point<Pixels>),
    /// When the editor is scrolled, the context menu follows the position it is associated with.
    /// Disappears when the position is no longer visible.
    PinnedToEditor {
        source: multi_buffer::Anchor,
        offset: Point<Pixels>,
    },
}

pub struct MouseCodeAction {
    pub actions: CodeActionContents,
    pub buffer: Entity<language::Buffer>,
}

pub struct MouseContextMenu {
    pub(crate) position: MenuPosition,
    pub(crate) context_menu: Entity<ui::ContextMenu>,
    pub(crate) code_action: Option<MouseCodeAction>,
    _subscription: Subscription,
}

enum CodeActionLoadState {
    Loading,
    Loaded(CodeActionContents),
}

impl std::fmt::Debug for MouseContextMenu {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("MouseContextMenu")
            .field("position", &self.position)
            .field("context_menu", &self.context_menu)
            .finish()
    }
}

impl MouseContextMenu {
    pub(crate) fn pinned_to_editor(
        editor: &mut Editor,
        source: multi_buffer::Anchor,
        position: Point<Pixels>,
        code_action: Option<MouseCodeAction>,
        context_menu: Entity<ui::ContextMenu>,
        window: &mut Window,
        cx: &mut Context<Editor>,
    ) -> Option<Self> {
        let editor_snapshot = editor.snapshot(window, cx);
        let content_origin = editor.last_bounds?.origin
            + Point {
                x: editor.gutter_dimensions.width,
                y: Pixels(0.0),
            };
        let source_position = editor.to_pixel_point(source, &editor_snapshot, window)?;
        let menu_position = MenuPosition::PinnedToEditor {
            source,
            offset: position - (source_position + content_origin),
        };
        return Some(MouseContextMenu::new(
            menu_position,
            context_menu,
            code_action,
            window,
            cx,
        ));
    }

    pub(crate) fn new(
        position: MenuPosition,
        context_menu: Entity<ui::ContextMenu>,
        code_action: Option<MouseCodeAction>,
        window: &mut Window,
        cx: &mut Context<Editor>,
    ) -> Self {
        let context_menu_focus = context_menu.focus_handle(cx);
        window.focus(&context_menu_focus);

        let _subscription = cx.subscribe_in(
            &context_menu,
            window,
            move |editor, _, _event: &DismissEvent, window, cx| {
                editor.mouse_context_menu.take();
                if context_menu_focus.contains_focused(window, cx) {
                    window.focus(&editor.focus_handle(cx));
                }
            },
        );

        Self {
            position,
            context_menu,
            code_action,
            _subscription,
        }
    }
}

fn display_ranges<'a>(
    display_map: &'a DisplaySnapshot,
    selections: &'a SelectionsCollection,
) -> impl Iterator<Item = Range<DisplayPoint>> + 'a {
    let pending = selections
        .pending
        .as_ref()
        .map(|pending| &pending.selection);
    selections
        .disjoint
        .iter()
        .chain(pending)
        .map(move |s| s.start.to_display_point(display_map)..s.end.to_display_point(display_map))
}

pub fn deploy_context_menu(
    editor: &mut Editor,
    position: Option<Point<Pixels>>,
    point: DisplayPoint,
    window: &mut Window,
    cx: &mut Context<Editor>,
) {
    if !editor.is_focused(window) {
        window.focus(&editor.focus_handle(cx));
    }

    // Don't show context menu for inline editors
    if !editor.mode().is_full() {
        return;
    }

    let display_map = editor.selections.display_map(cx);
    let source_anchor = display_map.display_point_to_anchor(point, text::Bias::Right);
    if let Some(custom) = editor.custom_context_menu.take() {
        let menu = custom(editor, point, window, cx);
        editor.custom_context_menu = Some(custom);
        let Some(menu) = menu else {
            return;
        };
        set_context_menu(editor, menu, source_anchor, position, None, window, cx);
    } else {
        // Don't show the context menu if there isn't a project associated with this editor
        let Some(project) = editor.project.clone() else {
            return;
        };

        let display_map = editor.selections.display_map(cx);
        let buffer = &editor.snapshot(window, cx).buffer_snapshot;
        let anchor = buffer.anchor_before(point.to_point(&display_map));
        if !display_ranges(&display_map, &editor.selections).any(|r| r.contains(&point)) {
            // Move the cursor to the clicked location so that dispatched actions make sense
            editor.change_selections(None, window, cx, |s| {
                s.clear_disjoint();
                s.set_pending_anchor_range(anchor..anchor, SelectMode::Character);
            });
        }

        let focus = window.focused(cx);
        let has_reveal_target = editor.target_file(cx).is_some();
        let has_selections = editor
            .selections
            .all::<PointUtf16>(cx)
            .into_iter()
            .any(|s| !s.is_empty());
        let has_git_repo = anchor.buffer_id.is_some_and(|buffer_id| {
            project
                .read(cx)
                .git_store()
                .read(cx)
                .repository_and_path_for_buffer_id(buffer_id, cx)
                .is_some()
        });

        let evaluate_selection = command_palette_hooks::CommandPaletteFilter::try_global(cx)
            .map_or(false, |filter| {
                !filter.is_hidden(&DebuggerEvaluateSelectedText)
            });

        let menu = build_context_menu(
            focus,
            has_selections,
            has_reveal_target,
            has_git_repo,
            evaluate_selection,
            Some(CodeActionLoadState::Loading),
            window,
            cx,
        );

        set_context_menu(editor, menu, source_anchor, position, None, window, cx);

        let mut actions_task = editor.code_actions_task.take();
        cx.spawn_in(window, async move |editor, cx| {
            while let Some(prev_task) = actions_task {
                prev_task.await.log_err();
                actions_task = editor.update(cx, |this, _| this.code_actions_task.take())?;
            }
            let action = ToggleCodeActions {
                deployed_from_indicator: Some(point.row()),
            };
            let context_menu_task = editor.update_in(cx, |editor, window, cx| {
                let code_actions_task = editor.prepare_code_actions_task(&action, window, cx);
                Some(cx.spawn_in(window, async move |editor, cx| {
                    let code_action_result = code_actions_task.await;
                    if let Ok(editor_task) = editor.update_in(cx, |editor, window, cx| {
                        let Some(mouse_context_menu) = editor.mouse_context_menu.take() else {
                            return Task::ready(Ok::<_, anyhow::Error>(()));
                        };
                        if mouse_context_menu
                            .context_menu
                            .focus_handle(cx)
                            .contains_focused(window, cx)
                        {
                            window.focus(&editor.focus_handle(cx));
                        }
                        drop(mouse_context_menu);
                        let (state, code_action) =
                            if let Some((buffer, actions)) = code_action_result {
                                (
                                    CodeActionLoadState::Loaded(actions.clone()),
                                    Some(MouseCodeAction { actions, buffer }),
                                )
                            } else {
                                (
                                    CodeActionLoadState::Loaded(CodeActionContents::default()),
                                    None,
                                )
                            };
                        let menu = build_context_menu(
                            window.focused(cx),
                            has_selections,
                            has_reveal_target,
                            has_git_repo,
                            evaluate_selection,
                            Some(state),
                            window,
                            cx,
                        );
                        set_context_menu(
                            editor,
                            menu,
                            source_anchor,
                            position,
                            code_action,
                            window,
                            cx,
                        );
                        Task::ready(Ok(()))
                    }) {
                        editor_task.await
                    } else {
                        Ok(())
                    }
                }))
            })?;
            if let Some(task) = context_menu_task {
                task.await?;
            }
            Ok::<_, anyhow::Error>(())
        })
        .detach_and_log_err(cx);
    };
}

fn build_context_menu(
    focus: Option<FocusHandle>,
    has_selections: bool,
    has_reveal_target: bool,
    has_git_repo: bool,
    evaluate_selection: bool,
    code_action_load_state: Option<CodeActionLoadState>,
    window: &mut Window,
    cx: &mut Context<Editor>,
) -> Entity<ContextMenu> {
    ui::ContextMenu::build(window, cx, |menu, _window, cx| {
        let menu = menu
            .on_blur_subscription(Subscription::new(|| {}))
            .when_some(code_action_load_state, |menu, state| {
                match state {
                    CodeActionLoadState::Loading => menu.disabled_action(
                        "Loading code actions...",
                        Box::new(ConfirmCodeAction {
                            item_ix: None,
                            from_mouse_context_menu: true,
                        }),
                    ),
                    CodeActionLoadState::Loaded(actions) => {
                        if actions.is_empty() {
                            menu.disabled_action(
                                "No code actions available",
                                Box::new(ConfirmCodeAction {
                                    item_ix: None,
                                    from_mouse_context_menu: true,
                                }),
                            )
                        } else {
                            actions
                                .iter()
                                .filter(|action| {
                                    if action
                                        .as_task()
                                        .map(|task| {
                                            matches!(task.task_type(), task::TaskType::Debug(_))
                                        })
                                        .unwrap_or(false)
                                    {
                                        cx.has_flag::<Debugger>()
                                    } else {
                                        true
                                    }
                                })
                                .enumerate()
                                .fold(menu, |menu, (ix, action)| {
                                    menu.action(
                                        action.label(),
                                        Box::new(ConfirmCodeAction {
                                            item_ix: Some(ix),
                                            from_mouse_context_menu: true,
                                        }),
                                    )
                                })
                        }
                    }
                }
                .separator()
            })
            .when(evaluate_selection && has_selections, |builder| {
                builder
                    .action("Evaluate Selection", Box::new(DebuggerEvaluateSelectedText))
                    .separator()
            })
            .action("Go to Definition", Box::new(GoToDefinition))
            .action("Go to Declaration", Box::new(GoToDeclaration))
            .action("Go to Type Definition", Box::new(GoToTypeDefinition))
            .action("Go to Implementation", Box::new(GoToImplementation))
            .action("Find All References", Box::new(FindAllReferences))
            .separator()
            .action("Rename Symbol", Box::new(Rename))
            .action("Format Buffer", Box::new(Format))
            .when(has_selections, |cx| {
                cx.action("Format Selections", Box::new(FormatSelections))
            })
            .separator()
            .action("Cut", Box::new(Cut))
            .action("Copy", Box::new(Copy))
            .action("Copy and trim", Box::new(CopyAndTrim))
            .action("Paste", Box::new(Paste))
            .separator()
            .map(|builder| {
                let reveal_in_finder_label = if cfg!(target_os = "macos") {
                    "Reveal in Finder"
                } else {
                    "Reveal in File Manager"
                };
                const OPEN_IN_TERMINAL_LABEL: &str = "Open in Terminal";
                if has_reveal_target {
                    builder
                        .action(reveal_in_finder_label, Box::new(RevealInFileManager))
                        .action(OPEN_IN_TERMINAL_LABEL, Box::new(OpenInTerminal))
                } else {
                    builder
                        .disabled_action(reveal_in_finder_label, Box::new(RevealInFileManager))
                        .disabled_action(OPEN_IN_TERMINAL_LABEL, Box::new(OpenInTerminal))
                }
            })
            .map(|builder| {
                const COPY_PERMALINK_LABEL: &str = "Copy Permalink";
                if has_git_repo {
                    builder.action(COPY_PERMALINK_LABEL, Box::new(CopyPermalinkToLine))
                } else {
                    builder.disabled_action(COPY_PERMALINK_LABEL, Box::new(CopyPermalinkToLine))
                }
            });
        match focus {
            Some(focus) => menu.context(focus),
            None => menu,
        }
    })
}

fn set_context_menu(
    editor: &mut Editor,
    context_menu: Entity<ui::ContextMenu>,
    source_anchor: multi_buffer::Anchor,
    position: Option<Point<Pixels>>,
    code_action: Option<MouseCodeAction>,
    window: &mut Window,
    cx: &mut Context<Editor>,
) {
    editor.mouse_context_menu = match position {
        Some(position) => MouseContextMenu::pinned_to_editor(
            editor,
            source_anchor,
            position,
            code_action,
            context_menu,
            window,
            cx,
        ),
        None => {
            let character_size = editor.character_size(window);
            let menu_position = MenuPosition::PinnedToEditor {
                source: source_anchor,
                offset: gpui::point(character_size.width, character_size.height),
            };
            Some(MouseContextMenu::new(
                menu_position,
                context_menu,
                code_action,
                window,
                cx,
            ))
        }
    };
    cx.notify();
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{editor_tests::init_test, test::editor_lsp_test_context::EditorLspTestContext};
    use indoc::indoc;

    #[gpui::test]
    async fn test_mouse_context_menu(cx: &mut gpui::TestAppContext) {
        init_test(cx, |_| {});

        let mut cx = EditorLspTestContext::new_rust(
            lsp::ServerCapabilities {
                hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
                ..Default::default()
            },
            cx,
        )
        .await;

        cx.set_state(indoc! {"
            fn teˇst() {
                do_work();
            }
        "});
        let point = cx.display_point(indoc! {"
            fn test() {
                do_wˇork();
            }
        "});
        cx.editor(|editor, _window, _app| assert!(editor.mouse_context_menu.is_none()));
        cx.update_editor(|editor, window, cx| {
            deploy_context_menu(editor, Some(Default::default()), point, window, cx)
        });

        cx.assert_editor_state(indoc! {"
            fn test() {
                do_wˇork();
            }
        "});
        cx.editor(|editor, _window, _app| assert!(editor.mouse_context_menu.is_some()));
    }
}