From 1f5da251dc056d104117faa76c6358d4da5b617e Mon Sep 17 00:00:00 2001 From: squid Date: Sat, 31 Oct 2026 00:14:44 +0100 Subject: [PATCH] Added tab handling, tab scroll, wheel scrolling for tabs --- src/main.rs | 481 ++++++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 430 insertions(+), 51 deletions(-) diff --git a/src/main.rs b/src/main.rs index fd2e353..d0069c5 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,7 +1,9 @@ use iced::widget::{ - button, column, container, mouse_area, pick_list, row, rule, space, stack, text, tooltip, + button, column, container, mouse_area, pick_list, row, rule, scrollable, space, stack, text, + tooltip, }; -use iced::{Alignment, Element, Length, Padding, Subscription, Task, keyboard}; +use iced::widget::{Id, operation}; +use iced::{Alignment, Element, Length, Padding, Subscription, Task, keyboard, mouse}; #[allow(dead_code)] mod terminal; @@ -14,6 +16,16 @@ const HAMBURGER_WIDTH: f32 = 32.0; const MAX_TAB_TITLE: usize = 20; /// Fixed height for rows in the hamburger menu. const MENU_ITEM_HEIGHT: f32 = 24.0; +/// Fixed height of the hamburger row inside the menu panel. +const HAMBURGER_ROW_HEIGHT: f32 = 24.0; +/// Fixed height of the theme picker field inside the menu panel. +const THEME_FIELD_HEIGHT: f32 = 40.0; +/// Panel padding of the hamburger menu. +const MENU_PADDING: f32 = 4.0; +/// Pixels moved per press of a tab-strip scroll button. +const TAB_SCROLL_STEP: f32 = 120.0; +/// Identifies the tab-strip scrollable for programmatic scrolling. +const TAB_SCROLL_ID: Id = Id::new("tab-strip"); fn main() -> iced::Result { iced::application(Moorly::default, update, view) @@ -28,31 +40,62 @@ fn subscription(_state: &Moorly) -> Subscription { keyboard::Event::KeyPressed { key: keyboard::Key::Character(key), modifiers, + repeat: false, .. } if key.as_str() == "," && modifiers.control() => { Some(Message::SelectTab(Tab::Settings)) } + keyboard::Event::KeyPressed { + key: keyboard::Key::Character(key), + modifiers, + repeat: false, + .. + } if cfg!(debug_assertions) + && key.eq_ignore_ascii_case("t") + && modifiers.control() + && modifiers.shift() => + { + Some(Message::AddTab) + } + keyboard::Event::KeyPressed { + key: keyboard::Key::Character(key), + modifiers, + repeat: false, + .. + } if key.eq_ignore_ascii_case("w") + && modifiers.control() + && modifiers.shift() => + { + Some(Message::CloseActiveTab) + } _ => None, }) } struct Moorly { menu_open: bool, + tabs_submenu_open: bool, theme: theme::Preference, tabs: Vec, active_tab: Option, settings_section: SettingsSection, + next_blank_tab: u32, + tab_offset: f32, + tab_viewport_width: f32, + tab_content_width: f32, } #[derive(Debug, Clone, Copy, PartialEq, Eq)] enum Tab { Settings, + Blank(u32), } impl Tab { - fn label(self) -> &'static str { + fn title(self) -> String { match self { - Self::Settings => "Settings", + Self::Settings => "Settings".to_owned(), + Self::Blank(number) => format!("temp {number}"), } } } @@ -83,10 +126,15 @@ impl Default for Moorly { fn default() -> Self { Self { menu_open: false, + tabs_submenu_open: false, theme: theme::load(), tabs: Vec::new(), active_tab: None, settings_section: SettingsSection::default(), + next_blank_tab: 1, + tab_offset: 0.0, + tab_viewport_width: 0.0, + tab_content_width: 0.0, } } } @@ -95,46 +143,174 @@ impl Default for Moorly { enum Message { ToggleMenu, CloseMenu, + ToggleTabsSubmenu, + AddTab, + CloseActiveTab, + CloseOtherTabs, SetTheme(theme::Preference), SelectTab(Tab), CloseTab(Tab), SelectSettingsSection(SettingsSection), + TabsScrolled(scrollable::Viewport), + ScrollTabs(mouse::ScrollDelta), + ScrollTabsBy(f32), Quit, } fn update(state: &mut Moorly, message: Message) -> Task { match message { - Message::ToggleMenu => state.menu_open = !state.menu_open, - Message::CloseMenu => state.menu_open = false, + Message::ToggleMenu => { + state.menu_open = !state.menu_open; + state.tabs_submenu_open = false; + } + Message::CloseMenu => { + state.menu_open = false; + state.tabs_submenu_open = false; + } + Message::ToggleTabsSubmenu => { + state.tabs_submenu_open = !state.tabs_submenu_open; + } + Message::AddTab => { + let tab = Tab::Blank(state.next_blank_tab); + state.next_blank_tab += 1; + state.tabs.push(tab); + state.active_tab = Some(tab); + state.menu_open = false; + state.tabs_submenu_open = false; + return scroll_tabs_to_end(); + } + Message::CloseActiveTab => { + if let Some(tab) = state.active_tab { + close_tab(state, tab); + } + state.menu_open = false; + state.tabs_submenu_open = false; + return reveal_active_tab(state); + } + Message::CloseOtherTabs => { + match state.active_tab { + Some(active) => { + state.tabs.retain(|tab| *tab == active); + if active != Tab::Settings { + state.settings_section = SettingsSection::default(); + } + } + None => state.tabs.clear(), + } + state.menu_open = false; + state.tabs_submenu_open = false; + } Message::SetTheme(preference) => { state.theme = preference; state.menu_open = false; + state.tabs_submenu_open = false; theme::save(preference); } Message::SelectTab(tab) => { - if !state.tabs.contains(&tab) { + let is_new = !state.tabs.contains(&tab); + if is_new { state.tabs.push(tab); } state.active_tab = Some(tab); state.menu_open = false; + state.tabs_submenu_open = false; + + // New tabs land at the end, so bring that end into view. + if is_new { + return scroll_tabs_to_end(); + } } Message::CloseTab(tab) => { - state.tabs.retain(|open| *open != tab); - if state.active_tab == Some(tab) { - state.active_tab = state.tabs.first().copied(); - } - // Drop the tab's page state along with the tab itself. - if tab == Tab::Settings { - state.settings_section = SettingsSection::default(); + if close_tab(state, tab) { + return reveal_active_tab(state); } } Message::SelectSettingsSection(section) => state.settings_section = section, + Message::TabsScrolled(viewport) => { + state.tab_offset = viewport.absolute_offset().x; + state.tab_viewport_width = viewport.bounds().width; + state.tab_content_width = viewport.content_bounds().width; + } + Message::ScrollTabs(delta) => { + let amount = match delta { + mouse::ScrollDelta::Lines { y, .. } => y * 60.0, + mouse::ScrollDelta::Pixels { x, y } => x + y, + }; + return scroll_tabs_by(amount); + } + Message::ScrollTabsBy(amount) => return scroll_tabs_by(amount), Message::Quit => std::process::exit(0), } Task::none() } +fn scroll_tabs_by(x: f32) -> Task { + operation::scroll_by(TAB_SCROLL_ID, operation::AbsoluteOffset { x, y: 0.0 }) +} + +fn scroll_tabs_to_end() -> Task { + operation::snap_to(TAB_SCROLL_ID, operation::RelativeOffset::END) +} + +/// Removes a tab and keeps the selection sensible: the next tab on the right +/// takes over, falling back to the new last tab. Returns whether the active +/// tab was the one closed. +fn close_tab(state: &mut Moorly, tab: Tab) -> bool { + let Some(index) = state.tabs.iter().position(|open| *open == tab) else { + return false; + }; + let was_active = state.active_tab == Some(tab); + state.tabs.remove(index); + + if was_active { + state.active_tab = state + .tabs + .get(index) + .or_else(|| state.tabs.last()) + .copied(); + } + + // Drop the tab's page state along with the tab itself. + if tab == Tab::Settings { + state.settings_section = SettingsSection::default(); + } + + was_active +} + +/// Estimated scroll delta that brings the active tab into view, or `None` +/// when it already is (or the strip does not overflow). +fn tab_reveal_delta(state: &Moorly) -> Option { + let index = state + .active_tab + .and_then(|active| state.tabs.iter().position(|tab| *tab == active))?; + + let count = state.tabs.len() as f32; + if count == 0.0 || state.tab_content_width <= state.tab_viewport_width { + return None; + } + + // ponytail: assumes roughly equal tab widths; good enough for visibility. + let tab_width = state.tab_content_width / count; + let start = index as f32 * tab_width; + let visible_start = state.tab_offset; + let visible_end = visible_start + state.tab_viewport_width; + + if start >= visible_start && start + tab_width <= visible_end { + return None; + } + + let target = (start - (state.tab_viewport_width - tab_width) / 2.0).max(0.0); + Some(target - state.tab_offset) +} + +fn reveal_active_tab(state: &Moorly) -> Task { + tab_reveal_delta(state) + .map(scroll_tabs_by) + .unwrap_or(Task::none()) +} + fn hamburger(open: bool) -> iced::widget::Button<'static, Message> { let icon: Element<'static, Message> = if open { stack![ @@ -152,6 +328,7 @@ fn hamburger(open: bool) -> iced::widget::Button<'static, Message> { button(icon) .on_press(Message::ToggleMenu) + .width(HAMBURGER_WIDTH) .padding([2, 8]) .style(button::text) } @@ -168,11 +345,11 @@ fn fit_title(title: &str) -> String { } fn tab_view(tab: Tab, active: bool) -> Element<'static, Message> { - let title = tab.label(); + let title = tab.title(); let content = container( row![ - button(text(fit_title(title)).size(12)) + button(text(fit_title(&title)).size(12)) .on_press(Message::SelectTab(tab)) .padding([1, 4]) .style(button::text), @@ -250,7 +427,7 @@ fn menu_item( if let Some(shortcut) = shortcut { content = content .push(space::horizontal()) - .push(container(rule::vertical(12)).padding([0, 6])) + .push(container(rule::vertical(1)).height(12).padding([0, 6])) .push(text(shortcut).size(11)); } @@ -262,6 +439,40 @@ fn menu_item( .style(button::text) } +/// Vertical offset of the Tabs row inside the menu column, so the chevron +/// column can place its `< |` alongside it. Keep in sync with the layout. +fn tabs_row_top() -> f32 { + let mut top = THEME_FIELD_HEIGHT + 4.0 + MENU_ITEM_HEIGHT + 4.0; + + if cfg!(debug_assertions) { + top += MENU_ITEM_HEIGHT + 4.0; + } + + top +} + +/// Vertical offset of the Tabs row from the top of the menu panel, so the +/// submenu can start at the same height. +fn tabs_submenu_top() -> f32 { + MENU_PADDING + HAMBURGER_ROW_HEIGHT + 2.0 + tabs_row_top() +} + +fn scroll_button(symbol: &'static str, delta: f32, enabled: bool) -> iced::widget::Button<'static, Message> { + button(text(symbol).size(17)) + .on_press_maybe(enabled.then_some(Message::ScrollTabsBy(delta))) + .padding([0, 6]) + .style(button::text) +} + +/// Whether the tab strip can still scroll left/right, based on the last +/// viewport it reported. +fn tab_scroll_limits(state: &Moorly) -> (bool, bool) { + let max_offset = (state.tab_content_width - state.tab_viewport_width).max(0.0); + let can_scroll_left = state.tab_offset > 0.5; + let can_scroll_right = state.tab_offset < max_offset - 0.5; + (can_scroll_left, can_scroll_right) +} + fn view(state: &Moorly) -> Element<'_, Message> { // Tab strip: push tab widgets into this row as they get added. let mut tab_row = row![].spacing(2); @@ -269,12 +480,28 @@ fn view(state: &Moorly) -> Element<'_, Message> { tab_row = tab_row.push(tab_view(tab, state.active_tab == Some(tab))); } - let tabs = container(tab_row) + let tab_strip = scrollable(tab_row) + .direction(scrollable::Direction::Horizontal( + scrollable::Scrollbar::hidden(), + )) + .id(TAB_SCROLL_ID) .width(Length::Fill) .height(Length::Fill) - .align_y(Alignment::Center); + .on_scroll(Message::TabsScrolled); + + // Convert vertical wheel input into horizontal tab-strip scrolling. + let tab_strip = mouse_area(tab_strip).on_scroll(Message::ScrollTabs); + + let (can_scroll_left, can_scroll_right) = tab_scroll_limits(state); + + let mut bar = row![ + tab_strip, + scroll_button("◀", -TAB_SCROLL_STEP, can_scroll_left), + scroll_button("▶", TAB_SCROLL_STEP, can_scroll_right), + ] + .spacing(2) + .align_y(Alignment::Center); - let mut bar = row![tabs].align_y(Alignment::Center); if state.menu_open { // The dropdown draws the close button over this spot. bar = bar.push(space::horizontal().width(HAMBURGER_WIDTH)); @@ -291,7 +518,7 @@ fn view(state: &Moorly) -> Element<'_, Message> { let main_area: Element<'_, Message> = match state.active_tab { Some(Tab::Settings) => settings_page(state), - None => container(column![]) + _ => container(column![]) .width(Length::Fill) .height(Length::Fill) .into(), @@ -300,54 +527,116 @@ fn view(state: &Moorly) -> Element<'_, Message> { let base = column![menubar, main_area]; if !state.menu_open { - return base.into(); + // Keep the root a `stack` so the tab strip's scroll state survives + // opening/closing the menu. + return stack![base].into(); } - let theme_field = stack![ - container( - pick_list( - theme::Preference::ALL, - Some(state.theme), - Message::SetTheme + let theme_field = container( + stack![ + container( + pick_list( + theme::Preference::ALL, + Some(state.theme), + Message::SetTheme + ) + .width(Length::Fill), ) - .width(Length::Fill), - ) - .width(Length::Fill) - .padding(Padding::ZERO.top(6.0)), - container( - container(text("Theme").size(11)) - .padding([0, 4]) - .style(theme::field_label), - ) - .padding(Padding::ZERO.left(8.0)), - ] - .width(Length::Fill); + .width(Length::Fill) + .padding(Padding::ZERO.top(6.0)), + container( + container(text("Theme").size(11)) + .padding([0, 4]) + .style(theme::field_label), + ) + .padding(Padding::ZERO.left(8.0)), + ] + .width(Length::Fill), + ) + .width(Length::Fill) + .height(THEME_FIELD_HEIGHT) + .align_y(Alignment::Center); let menu_items = column![theme_field].spacing(4); + let mut menu_items = menu_items.push(menu_item( + "Settings", + Some("Ctrl+,"), + Message::SelectTab(Tab::Settings), + )); + + if cfg!(debug_assertions) { + menu_items = menu_items.push(menu_item( + "temp Add Tab", + Some("Ctrl+Shift+T"), + Message::AddTab, + )); + } + let menu_items = menu_items - .push(menu_item( - "Settings", - Some("Ctrl+,"), - Message::SelectTab(Tab::Settings), - )) + .push(menu_item("Tabs", None, Message::ToggleTabsSubmenu)) .push(rule::horizontal(1)) - .push(menu_item("Quit", None, Message::Quit)); + .push(menu_item("Quit", None, Message::Quit)) + .width(Length::Fill); + + // The `< |` marker owns its own column; menu rows start to its right. + let tabs_marker = container( + column![ + space::vertical().height(tabs_row_top()), + container( + row![ + text("<").size(12), + container(rule::vertical(1)).height(12).padding([0, 6]), + ] + .align_y(Alignment::Center), + ) + .height(MENU_ITEM_HEIGHT) + .align_y(Alignment::Center), + ], + ) + .width(24); let menu = container( column![ container(hamburger(true)) .width(Length::Fill) - .align_x(Alignment::End), - menu_items, + .height(HAMBURGER_ROW_HEIGHT) + .align_x(Alignment::End) + .align_y(Alignment::Center), + row![tabs_marker, menu_items].align_y(Alignment::Start), ] .spacing(2), ) - .width(200) - .padding(4) + .width(220) + .padding(MENU_PADDING) .style(theme::menu); - let dropdown = container(menu) + let tabs_submenu = container( + column![ + menu_item( + "Close Active Tab", + Some("Ctrl+Shift+W"), + Message::CloseActiveTab, + ), + menu_item("Close all other tabs", None, Message::CloseOtherTabs), + ] + .spacing(4), + ) + .width(220) + .padding(MENU_PADDING) + .style(theme::menu); + + // Push the submenu down so its first row starts level with the Tabs row. + let tabs_submenu = container(tabs_submenu) + .padding(Padding::ZERO.top(tabs_submenu_top() - MENU_PADDING)); + + let mut dropdown_row = row![].spacing(0).align_y(Alignment::Start); + if state.tabs_submenu_open { + dropdown_row = dropdown_row.push(tabs_submenu); + } + dropdown_row = dropdown_row.push(menu); + + let dropdown = container(dropdown_row) .width(Length::Fill) .height(Length::Fill) .align_x(Alignment::End) @@ -375,10 +664,15 @@ mod tests { fn state() -> Moorly { Moorly { menu_open: false, + tabs_submenu_open: false, theme: theme::Preference::default(), tabs: Vec::new(), active_tab: None, settings_section: super::SettingsSection::default(), + next_blank_tab: 1, + tab_offset: 0.0, + tab_viewport_width: 0.0, + tab_content_width: 0.0, } } @@ -392,6 +686,91 @@ mod tests { assert_eq!(fitted.chars().count(), 20); } + #[test] + fn tab_scroll_buttons_follow_the_viewport() { + let mut state = state(); + state.tab_viewport_width = 200.0; + state.tab_content_width = 500.0; + + state.tab_offset = 0.0; + assert_eq!(super::tab_scroll_limits(&state), (false, true)); + + state.tab_offset = 150.0; + assert_eq!(super::tab_scroll_limits(&state), (true, true)); + + state.tab_offset = 300.0; + assert_eq!(super::tab_scroll_limits(&state), (true, false)); + } + + #[test] + fn add_tab_appends_a_new_blank_tab() { + let mut state = state(); + let _ = update(&mut state, Message::SelectTab(Tab::Settings)); + let _ = update(&mut state, Message::AddTab); + let _ = update(&mut state, Message::AddTab); + + assert_eq!( + state.tabs, + vec![Tab::Settings, Tab::Blank(1), Tab::Blank(2)] + ); + assert_eq!(state.active_tab, Some(Tab::Blank(2))); + assert_eq!(state.tabs[1].title(), "temp 1"); + assert_eq!(state.tabs[2].title(), "temp 2"); + } + + #[test] + fn revealing_active_tab_only_scrolls_when_needed() { + let mut state = state(); + state.tabs = (1..=10).map(Tab::Blank).collect(); + state.active_tab = Some(Tab::Blank(10)); + state.tab_viewport_width = 400.0; + state.tab_content_width = 1000.0; + + state.tab_offset = 600.0; + assert_eq!(super::tab_reveal_delta(&state), None); + + state.tab_offset = 0.0; + assert!(super::tab_reveal_delta(&state).unwrap() > 0.0); + } + + #[test] + fn close_other_tabs_keeps_only_the_active_one() { + let mut state = state(); + let _ = update(&mut state, Message::SelectTab(Tab::Settings)); + let _ = update(&mut state, Message::AddTab); + let _ = update(&mut state, Message::AddTab); + + let _ = update(&mut state, Message::CloseOtherTabs); + assert_eq!(state.tabs, vec![Tab::Blank(2)]); + assert_eq!(state.active_tab, Some(Tab::Blank(2))); + } + + #[test] + fn close_active_tab_shortcut_closes_selected_tab() { + let mut state = state(); + let _ = update(&mut state, Message::SelectTab(Tab::Settings)); + let _ = update(&mut state, Message::AddTab); + + let _ = update(&mut state, Message::CloseActiveTab); + assert_eq!(state.tabs, vec![Tab::Settings]); + assert_eq!(state.active_tab, Some(Tab::Settings)); + } + + #[test] + fn closing_selects_the_next_tab_then_the_last() { + let mut state = state(); + let _ = update(&mut state, Message::SelectTab(Tab::Settings)); + let _ = update(&mut state, Message::AddTab); + let _ = update(&mut state, Message::AddTab); + + let _ = update(&mut state, Message::SelectTab(Tab::Blank(1))); + let _ = update(&mut state, Message::CloseTab(Tab::Blank(1))); + assert_eq!(state.active_tab, Some(Tab::Blank(2))); + + let _ = update(&mut state, Message::CloseTab(Tab::Blank(2))); + assert_eq!(state.active_tab, Some(Tab::Settings)); + } + #[test] fn closing_active_tab_unloads_it() { let mut state = state();