From 438f202dfe24bcd66827c8fa011e2c253e25067e Mon Sep 17 00:00:00 2001 From: squid Date: Tue, 17 Nov 2026 22:10:52 +0100 Subject: [PATCH] Added right click menu for tabs --- src/main.rs | 291 +++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 286 insertions(+), 5 deletions(-) diff --git a/src/main.rs b/src/main.rs index 7e13e75..263f1a5 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1836,6 +1836,14 @@ struct TerminalMenu { pointer: Point, } +#[derive(Debug, Clone, Copy, PartialEq)] +struct TabMenu { + window: window::Id, + tab: Tab, + pointer: Point, + split_open: bool, +} + impl TerminalSelection { fn ordered(self) -> ((u16, u16), (u16, u16)) { if self.anchor <= self.focus { @@ -1952,6 +1960,7 @@ struct Moorly { drag: Option, modifiers: keyboard::Modifiers, terminal_menu: Option, + tab_menu: Option, theme: theme::Preference, saved_theme: theme::Preference, theme_choice: ThemeChoice, @@ -5183,6 +5192,7 @@ impl Default for Moorly { drag: None, modifiers: keyboard::Modifiers::default(), terminal_menu: None, + tab_menu: None, theme, saved_theme: theme, theme_choice: theme_choice.clone(), @@ -5287,6 +5297,10 @@ enum Message { TerminalMenuCopy(u32), TerminalMenuPaste(u32), CloseTerminalMenu, + OpenTabMenu(window::Id, Tab), + CloseTabMenu, + ToggleTabSplitMenu, + TabMenuDuplicate(window::Id, Tab), TerminalPasteContents(u32, Option), ModifiersChanged(keyboard::Modifiers), TerminalKey { @@ -5620,6 +5634,7 @@ fn update(state: &mut Moorly, message: Message) -> Task { } } Message::TerminalRightClick(window, id) => { + state.tab_menu = None; // Shift always opens the menu, whatever the plain right-click // setting is. Otherwise the setting decides. if state.modifiers.shift() @@ -5664,6 +5679,57 @@ fn update(state: &mut Moorly, message: Message) -> Task { return paste_terminal_clipboard(id); } Message::CloseTerminalMenu => state.terminal_menu = None, + Message::OpenTabMenu(window, tab) => { + if tab == Tab::Start { + state.tab_menu = None; + return Task::none(); + } + + let pointer = state + .windows + .get(&window) + .and_then(|window_state| window_state.pointer) + .unwrap_or(Point::ORIGIN); + + state.terminal_menu = None; + if let Some(window_state) = state.windows.get_mut(&window) { + window_state.menu_open = false; + window_state.tabs_submenu_open = false; + window_state.quick_menu_open = false; + } + state.tab_menu = Some(TabMenu { + window, + tab, + pointer, + split_open: false, + }); + } + Message::CloseTabMenu => state.tab_menu = None, + Message::ToggleTabSplitMenu => { + if let Some(menu) = state.tab_menu.as_mut() { + menu.split_open = !menu.split_open; + } + } + Message::TabMenuDuplicate(window, tab) => { + state.tab_menu = None; + + return match tab { + Tab::Terminal(id) => { + let profile = state + .terminal_sessions + .get(&id) + .map(|terminal| terminal.profile.clone()); + + match profile { + Some(profile) => start_terminal_profile(state, window, profile, false), + None => Task::none(), + } + } + Tab::Blank(_) => update(state, Message::AddTab(window)), + Tab::Settings => Task::none(), + Tab::Start => Task::none(), + }; + } Message::ModifiersChanged(modifiers) => state.modifiers = modifiers, Message::TerminalPasteContents(id, contents) => { if let Some(bytes) = paste_contents(contents) @@ -6144,6 +6210,7 @@ fn update(state: &mut Moorly, message: Message) -> Task { } } Message::CloseTab(window, tab) => { + state.tab_menu = None; let was_active = close_tab(state, window, tab); return Task::batch([ @@ -8164,7 +8231,8 @@ fn tab_view( .on_exit(Message::HoverTab { tab, hovered: false, - }); + }) + .on_right_press(Message::OpenTabMenu(window, tab)); tooltip( content, @@ -11968,10 +12036,13 @@ impl canvas::Program for TerminalCanvas<'_> { .and_capture(), ) } - canvas::Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Right)) => Some( - canvas::Action::publish(Message::TerminalRightClick(self.window, self.id)) - .and_capture(), - ), + canvas::Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Right)) => { + self.cell_at(cursor, bounds)?; + Some( + canvas::Action::publish(Message::TerminalRightClick(self.window, self.id)) + .and_capture(), + ) + } canvas::Event::Mouse(mouse::Event::CursorMoved { .. }) => { if !*dragging { return None; @@ -12212,6 +12283,126 @@ fn draw_run( } } +/// Context menu shown when a tab is right-clicked. +fn tab_context_menu(state: &Moorly, window: window::Id) -> Option> { + let menu = state.tab_menu?; + if menu.window != window { + return None; + } + + let window_state = state.windows.get(&window)?; + let width = 200.0; + let height = 100.0; + let max_x = (window_state.size.width - width - 8.0).max(8.0); + let max_y = (window_state.size.height - height - 8.0).max(8.0); + let x = menu.pointer.x.clamp(8.0, max_x); + let y = menu.pointer.y.clamp(8.0, max_y); + + let mut items = column![].spacing(4); + if menu.tab == Tab::Settings { + items = items.push( + button(text("Duplicate").width(Length::Fill)) + .on_press_maybe(None) + .height(MENU_ITEM_HEIGHT) + .padding([4, 8]) + .style(button::text), + ); + } else { + items = items.push(menu_item( + "Duplicate", + None, + Message::TabMenuDuplicate(window, menu.tab), + )); + } + items = items.push(menu_item("Split ▸", None, Message::ToggleTabSplitMenu)); + items = items.push(rule::horizontal(1)).push(menu_item( + "Close", + None, + Message::CloseTab(window, menu.tab), + )); + + let panel = container(items) + .width(width) + .padding(MENU_PADDING) + .style(theme::menu); + + let main_layer = container(panel) + .width(Length::Fill) + .height(Length::Fill) + .align_x(Alignment::Start) + .align_y(Alignment::Start) + .padding(Padding { + top: y, + left: x, + ..Padding::ZERO + }); + + if !menu.split_open { + return Some(main_layer.into()); + } + + // Flyout placed beside the parent menu, flipped to the left when there is + // no room on the right. + let submenu_width = 150.0; + let submenu_height = 70.0; + let gap = 4.0; + let submenu_x = if x + width + gap + submenu_width <= window_state.size.width - 8.0 { + x + width + gap + } else { + (x - submenu_width - gap).max(8.0) + }; + let submenu_y = (y + MENU_PADDING + MENU_ITEM_HEIGHT + 4.0).clamp( + 8.0, + (window_state.size.height - submenu_height - 8.0).max(8.0), + ); + + let submenu = container( + column![ + split_submenu_item("Horizontally"), + split_submenu_item("Vertically"), + ] + .spacing(4), + ) + .width(submenu_width) + .padding(MENU_PADDING) + .style(theme::menu); + let submenu = mouse_area(submenu).on_press(Message::Ignore); + + let submenu_layer = container(submenu) + .width(Length::Fill) + .height(Length::Fill) + .align_x(Alignment::Start) + .align_y(Alignment::Start) + .padding(Padding { + top: submenu_y, + left: submenu_x, + ..Padding::ZERO + }); + + Some( + stack![main_layer, submenu_layer] + .width(Length::Fill) + .height(Length::Fill) + .into(), + ) +} + +/// Greyed-out split option. Splitting panes is not implemented yet, so the +/// menu shows the entries without pretending they do something. +fn split_submenu_item(label: &'static str) -> Element<'static, Message> { + button(text(label).width(Length::Fill)) + .on_press_maybe(None) + .height(MENU_ITEM_HEIGHT) + .padding(Padding { + top: 4.0, + right: 8.0, + bottom: 4.0, + left: 24.0, + }) + .style(button::text) + .into() +} + fn terminal_context_menu(state: &Moorly, window: window::Id) -> Option> { let menu = state.terminal_menu.as_ref()?; if menu.window != window { @@ -12757,12 +12948,14 @@ fn view(state: &Moorly, window: window::Id) -> Element<'_, Message> { let palette = command_palette_layer(state, window); let dialog = profile_dialog_layer(state, window); let terminal_menu = terminal_context_menu(state, window); + let tab_menu = tab_context_menu(state, window); let dir_picker = state.dir_picker.as_ref(); if state.notifications.is_empty() && palette.is_none() && dialog.is_none() && terminal_menu.is_none() + && tab_menu.is_none() && dir_picker.is_none() { return content; @@ -12828,6 +13021,21 @@ fn view(state: &Moorly, window: window::Id) -> Element<'_, Message> { ); } + if tab_menu.is_some() { + let backdrop = mouse_area( + container(space::horizontal()) + .width(Length::Fill) + .height(Length::Fill), + ) + .on_press(Message::CloseTabMenu); + + root = root.push(backdrop); + } + + if let Some(menu) = tab_menu { + root = root.push(menu); + } + root.width(Length::Fill).height(Length::Fill).into() } @@ -12876,6 +13084,7 @@ mod tests { drag: None, modifiers: keyboard::Modifiers::default(), terminal_menu: None, + tab_menu: None, theme: theme::Preference::default(), saved_theme: theme::Preference::default(), theme_choice: super::ThemeChoice::BuiltIn(theme::Preference::default()), @@ -13980,6 +14189,78 @@ mod tests { assert!(fade.interpolate(0.0, 1.0, end) < 0.01); } + #[test] + fn right_clicking_a_tab_opens_its_menu_and_dismisses_the_terminal_menu() { + let (mut state, window, id) = terminal_for_session_end(super::SessionEnd::Keep); + state.terminal_menu = Some(super::TerminalMenu { + window, + id, + pointer: iced::Point::ORIGIN, + }); + + let _ = update(&mut state, Message::OpenTabMenu(window, Tab::Terminal(id))); + + assert_eq!(state.tab_menu.unwrap().tab, Tab::Terminal(id)); + assert!(state.terminal_menu.is_none()); + } + + #[test] + fn tab_context_menu_can_close_the_tab() { + let (mut state, window, id) = terminal_for_session_end(super::SessionEnd::Keep); + state.tab_menu = Some(super::TabMenu { + window, + tab: Tab::Terminal(id), + pointer: iced::Point::new(20.0, 20.0), + split_open: false, + }); + + let mut ui = iced_test::simulator(super::view(&state, window)); + ui.click("Close").unwrap(); + + let messages: Vec<_> = ui.into_messages().collect(); + assert!(messages.iter().any(|message| matches!( + message, + Message::CloseTab(_, Tab::Terminal(tab_id)) if *tab_id == id + ))); + + for message in messages { + let _ = update(&mut state, message); + } + assert!(state.tab_menu.is_none()); + } + + #[test] + fn split_submenu_renders_as_a_flyout() { + let (mut state, window, id) = terminal_for_session_end(super::SessionEnd::Keep); + state.tab_menu = Some(super::TabMenu { + window, + tab: Tab::Terminal(id), + pointer: iced::Point::new(20.0, 20.0), + split_open: true, + }); + + let mut ui = iced_test::simulator(super::view(&state, window)); + assert!(ui.find("Horizontally").is_ok()); + assert!(ui.find("Vertically").is_ok()); + } + + #[test] + fn duplicating_a_terminal_tab_opens_another_session() { + let (mut state, window, id) = terminal_for_session_end(super::SessionEnd::Keep); + let before = state.windows[&window].tabs.len(); + + let _ = update( + &mut state, + Message::TabMenuDuplicate(window, Tab::Terminal(id)), + ); + + assert_eq!(state.windows[&window].tabs.len(), before + 1); + assert!(matches!( + state.windows[&window].active_tab, + Some(Tab::Terminal(new_id)) if new_id != id + )); + } + #[test] fn tab_scroll_buttons_follow_the_viewport() { let mut state = state();