Added tab handling, tab scroll, wheel scrolling for tabs

This commit is contained in:
Squid committed 2026-10-31 00:14:44 +01:00
1 parent 143f43a407
commit 1f5da251dc
1 file changed
+411 -32
+411 -32
View File
@@ -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<Message> {
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<Tab>,
active_tab: Option<Tab>,
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<Message> {
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<Message> {
operation::scroll_by(TAB_SCROLL_ID, operation::AbsoluteOffset { x, y: 0.0 })
}
fn scroll_tabs_to_end() -> Task<Message> {
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<f32> {
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<Message> {
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)
.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,10 +527,13 @@ 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![
let theme_field = container(
stack![
container(
pick_list(
theme::Preference::ALL,
@@ -321,33 +551,92 @@ fn view(state: &Moorly) -> Element<'_, Message> {
)
.padding(Padding::ZERO.left(8.0)),
]
.width(Length::Fill);
.width(Length::Fill),
)
.width(Length::Fill)
.height(THEME_FIELD_HEIGHT)
.align_y(Alignment::Center);
let menu_items = column![theme_field].spacing(4);
let menu_items = menu_items
.push(menu_item(
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("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();