diff --git a/src/main.rs b/src/main.rs index c476ffc..bdcba7e 100644 --- a/src/main.rs +++ b/src/main.rs @@ -3,20 +3,20 @@ use std::path::PathBuf; use serde::{Deserialize, Serialize}; +use iced::time::{Duration, Instant}; +use iced::widget::{Id, operation}; use iced::widget::{ button, column, container, mouse_area, pick_list, responsive, row, rule, scrollable, space, stack, text, text_input, toggler, tooltip, }; -use iced::widget::{Id, operation}; -use iced::time::{Duration, Instant}; use iced::{ - Alignment, Animation, Border, Color, Element, Length, Padding, Subscription, Task, keyboard, - mouse, window, + Alignment, Animation, Border, Color, Element, Length, Padding, Point, Rectangle, Shadow, Size, + Subscription, Task, Vector, keyboard, mouse, window, }; +mod notifications; #[allow(dead_code)] mod terminal; -mod notifications; mod theme; const MENUBAR_HEIGHT: f32 = 40.0; @@ -26,6 +26,25 @@ const TAB_MIN_WIDTH: f32 = 100.0; const TAB_SPACING: f32 = 2.0; /// Space kept clear for the hamburger/close button at the end of the menubar. const HAMBURGER_WIDTH: f32 = 32.0; +/// Fixed width of the two tab-strip scroll buttons. +const SCROLL_BUTTON_WIDTH: f32 = 32.0; +/// Left padding of the menubar, i.e. where the tab strip starts. +const TAB_STRIP_LEFT: f32 = 5.0; +/// Right padding of the menubar. +const MENUBAR_RIGHT_PADDING: f32 = 8.0; +/// How close to a tab-strip edge a drag must be before it auto-scrolls. +const DRAG_EDGE: f32 = 40.0; +/// Fastest auto-scroll speed while dragging, in pixels per frame. +const DRAG_SCROLL_SPEED: f32 = 16.0; +/// Size of the floating tab ghost shown while dragging. +const DRAG_GHOST_WIDTH: f32 = 190.0; +const DRAG_GHOST_HEIGHT: f32 = 30.0; +/// Layout of the in-window "move to window" drop panel. +const DROP_PANEL_WIDTH: f32 = 280.0; +const DROP_PANEL_PADDING: f32 = 6.0; +const DROP_HEADER_HEIGHT: f32 = 22.0; +const DROP_ROW_HEIGHT: f32 = 30.0; +const DROP_ROW_GAP: f32 = 2.0; /// Longest tab title shown before it gets ellipsized. const MAX_TAB_TITLE: usize = 20; /// Fixed height for rows in the hamburger menu. @@ -36,8 +55,6 @@ const HAMBURGER_ROW_HEIGHT: f32 = 24.0; 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"); /// Identifies the theme-name field so it can be focused when opened. const THEME_NAME_INPUT: Id = Id::new("theme-name"); /// Identifies the new-folder name field so it can be focused when opened. @@ -46,75 +63,133 @@ const FOLDER_NAME_INPUT: Id = Id::new("folder-name"); const PROFILE_NAME_INPUT: Id = Id::new("profile-name"); fn main() -> iced::Result { - iced::application(Moorly::default, update, view) - .title("Moorly") - .theme(|state: &Moorly| state.theme.iced()) + iced::daemon(boot, update, view) + .title(window_title) + .theme(|state: &Moorly, _window| state.theme.iced()) .subscription(subscription) .run() } +/// Opens the first window and gives it the Start tab when configured. +fn boot() -> (Moorly, Task) { + let mut state = Moorly::default(); + let settings = window::Settings { + exit_on_close_request: false, + ..window::Settings::default() + }; + let size = settings.size; + let (id, task) = window::open(settings); + state + .windows + .insert(id, WindowState::new(state.show_start_tab, size)); + state.window_order.push(id); + state.main_window = Some(id); + state.focused_window = Some(id); + (state, task.map(|_| Message::Ignore)) +} + +fn window_title(state: &Moorly, window: window::Id) -> String { + if state.main_window == Some(window) { + return "Moorly".to_owned(); + } + + match state + .windows + .get(&window) + .and_then(|state| state.active_tab) + { + Some(tab) => format!("{} - Moorly", tab.title()), + None => "Moorly".to_owned(), + } +} + +/// Raw mouse events are needed for tab dragging and cross-window drops. +fn pointer_event( + event: iced::Event, + _status: iced::event::Status, + window: window::Id, +) -> Option { + match event { + iced::Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)) => { + Some(Message::PointerPressed(window)) + } + iced::Event::Mouse(mouse::Event::ButtonReleased(mouse::Button::Left)) => { + Some(Message::PointerReleased(window)) + } + iced::Event::Mouse(mouse::Event::CursorMoved { position }) => { + Some(Message::PointerMoved(window, position)) + } + iced::Event::Mouse(mouse::Event::CursorLeft) => Some(Message::PointerLeft(window)), + _ => None, + } +} + fn subscription(state: &Moorly) -> Subscription { + let active_window = state.focused_window.or(state.main_window); let keyboard = keyboard::listen() .with(( state.saved_shortcuts.settings.clone(), state.saved_shortcuts.quit.clone(), state.shortcut_capture.is_some(), + active_window, )) - .filter_map(|((settings_shortcut, quit_shortcut, capturing), event)| { - let keyboard::Event::KeyPressed { - key, - modifiers, - repeat: false, - .. - } = event - else { - return None; - }; + .filter_map( + |((settings_shortcut, quit_shortcut, capturing, window), event)| { + let keyboard::Event::KeyPressed { + key, + modifiers, + repeat: false, + .. + } = event + else { + return None; + }; - if capturing { - return Some(Message::CaptureKey { key, modifiers }); - } - - if quit_shortcut - .as_ref() - .is_some_and(|shortcut| shortcut.matches(&key, modifiers)) - { - return Some(Message::Quit); - } - - if let Some(shortcut) = &settings_shortcut { - if shortcut.matches(&key, modifiers) { - return Some(Message::SelectTab(Tab::Settings)); + if capturing { + return Some(Message::CaptureKey { key, modifiers }); } - } - match key { - keyboard::Key::Character(key) - if cfg!(debug_assertions) - && key.eq_ignore_ascii_case("t") - && modifiers.control() - && modifiers.shift() => + if quit_shortcut + .as_ref() + .is_some_and(|shortcut| shortcut.matches(&key, modifiers)) { - Some(Message::AddTab) + return Some(Message::Quit); } - keyboard::Key::Character(key) - if cfg!(debug_assertions) - && key.eq_ignore_ascii_case("n") - && modifiers.control() - && modifiers.shift() => - { - Some(Message::ShowNotificationDemo) + + if let Some(shortcut) = &settings_shortcut { + if shortcut.matches(&key, modifiers) { + return window.map(|window| Message::SelectTab(window, Tab::Settings)); + } } - keyboard::Key::Character(key) - if key.eq_ignore_ascii_case("w") - && modifiers.control() - && modifiers.shift() => - { - Some(Message::CloseActiveTab) + + match key { + keyboard::Key::Character(key) + if cfg!(debug_assertions) + && key.eq_ignore_ascii_case("t") + && modifiers.control() + && modifiers.shift() => + { + window.map(Message::AddTab) + } + keyboard::Key::Character(key) + if cfg!(debug_assertions) + && key.eq_ignore_ascii_case("n") + && modifiers.control() + && modifiers.shift() => + { + Some(Message::ShowNotificationDemo) + } + keyboard::Key::Character(key) + if key.eq_ignore_ascii_case("w") + && modifiers.control() + && modifiers.shift() => + { + window.map(Message::CloseActiveTab) + } + _ => None, } - _ => None, - } - }); + }, + ); // Keep frames coming until the fade-out has been swapped for the new // section or the tab close icons have finished fading. @@ -127,8 +202,14 @@ fn subscription(state: &Moorly) -> Subscription { let mut subscriptions = vec![ keyboard, iced::time::every(Duration::from_secs(1)).map(|_| Message::ReloadThemes), + window::events().map(|(window, event)| Message::WindowEvent(window, event)), + iced::event::listen_with(pointer_event), ]; + if state.drag.is_some() { + subscriptions.push(iced::time::every(Duration::from_millis(16)).map(|_| Message::DragTick)); + } + if state.fade_animation.is_animating(now) || state.pending_settings_section.is_some() || tab_close_animating @@ -138,9 +219,8 @@ fn subscription(state: &Moorly) -> Subscription { // Timed notifications only need a coarse expiry timer; fades use frames. if state.notifications.has_timed() { - subscriptions.push( - iced::time::every(Duration::from_millis(250)).map(Message::NotificationTick), - ); + subscriptions + .push(iced::time::every(Duration::from_millis(250)).map(Message::NotificationTick)); } if state.notifications.is_animating(now) { @@ -307,16 +387,17 @@ impl Shortcuts { ]; if let Some((action, _)) = configurable .iter() - .find(|(action, shortcut)| { - *action != except && shortcut.as_ref() == Some(candidate) - }) + .find(|(action, shortcut)| *action != except && shortcut.as_ref() == Some(candidate)) { return Some(action.label()); } // Shortcuts that are fixed for now but still own their keys. let reserved: &[(&str, &str)] = if cfg!(debug_assertions) { - &[("Close Active Tab", "Ctrl+Shift+W"), ("Add Tab", "Ctrl+Shift+T")] + &[ + ("Close Active Tab", "Ctrl+Shift+W"), + ("Add Tab", "Ctrl+Shift+T"), + ] } else { &[("Close Active Tab", "Ctrl+Shift+W")] }; @@ -466,10 +547,7 @@ impl ProfileDraft { fn port_valid(&self) -> bool { match self.kind { - ProfileKind::Ssh => self - .port - .parse::() - .is_ok_and(|port| port <= 65534), + ProfileKind::Ssh => self.port.parse::().is_ok_and(|port| port <= 65534), _ => true, } } @@ -586,8 +664,7 @@ fn home_dir() -> PathBuf { fn default_start_path() -> String { if cfg!(windows) { - std::env::var("HOMEPATH") - .unwrap_or_else(|_| home_dir().to_string_lossy().into_owned()) + std::env::var("HOMEPATH").unwrap_or_else(|_| home_dir().to_string_lossy().into_owned()) } else { "~/".to_owned() } @@ -635,9 +712,70 @@ enum Selection { Profile { folder: usize, profile: usize }, } -struct Moorly { +/// Per-window UI state: tabs, menus and tab-strip scrolling. +struct WindowState { + tabs: Vec, + active_tab: Option, menu_open: bool, tabs_submenu_open: bool, + tab_offset: f32, + scroll_id: Id, + size: Size, + position: Option, + pointer: Option, +} + +impl WindowState { + fn new(show_start_tab: bool, size: Size) -> Self { + Self { + tabs: if show_start_tab { + vec![Tab::Start] + } else { + Vec::new() + }, + active_tab: show_start_tab.then_some(Tab::Start), + menu_open: false, + tabs_submenu_open: false, + tab_offset: 0.0, + scroll_id: Id::unique(), + size, + position: None, + pointer: None, + } + } + + fn with_tab(tab: Tab, size: Size, position: Option) -> Self { + Self { + tabs: vec![tab], + active_tab: Some(tab), + menu_open: false, + tabs_submenu_open: false, + tab_offset: 0.0, + scroll_id: Id::unique(), + size, + position, + pointer: None, + } + } +} + +/// A tab currently being dragged. `pointer` is in the source window's +/// coordinates and may leave the window while the button is held. +struct TabDrag { + window: window::Id, + tab: Tab, + origin: Point, + pointer: Point, + moved: bool, + detach: bool, +} + +struct Moorly { + windows: HashMap, + window_order: Vec, + main_window: Option, + focused_window: Option, + drag: Option, theme: theme::Preference, saved_theme: theme::Preference, theme_choice: ThemeChoice, @@ -648,8 +786,6 @@ struct Moorly { shortcuts: Shortcuts, saved_shortcuts: Shortcuts, shortcut_capture: Option, - tabs: Vec, - active_tab: Option, settings_section: SettingsSection, pending_settings_section: Option, show_start_tab: bool, @@ -679,9 +815,6 @@ struct Moorly { profile_dialog: Option, dir_picker: Option, next_blank_tab: u32, - tab_offset: f32, - tab_viewport_width: f32, - tab_content_width: f32, notifications: notifications::NotificationManager, } @@ -821,10 +954,7 @@ impl ThemeChoice { #[derive(Debug, Clone, PartialEq, Eq)] enum ThemeOption { - Theme { - choice: ThemeChoice, - selected: bool, - }, + Theme { choice: ThemeChoice, selected: bool }, Separator, } @@ -1444,19 +1574,13 @@ fn undo_settings(state: &mut Moorly) { state.colors = state.saved_colors; let (custom_toasts, toast_colors) = match &state.saved_theme_choice { - ThemeChoice::BuiltIn(_) => ( - state.builtin_custom_toasts, - state.builtin_toast_colors, - ), + ThemeChoice::BuiltIn(_) => (state.builtin_custom_toasts, state.builtin_toast_colors), ThemeChoice::Custom { id, .. } => state .custom_themes .iter() .find(|theme| theme.id == *id) .map(|theme| (theme.custom_toasts, theme.toast_colors)) - .unwrap_or(( - state.builtin_custom_toasts, - state.builtin_toast_colors, - )), + .unwrap_or((state.builtin_custom_toasts, state.builtin_toast_colors)), }; state.custom_toasts = custom_toasts; @@ -1498,10 +1622,7 @@ fn config_file(state: &Moorly) -> ConfigFile { ThemeChoice::BuiltIn(_) => None, }, hide_tab_close: state.hide_tab_close, - toast: ToastFile::from_colors( - state.builtin_custom_toasts, - &state.builtin_toast_colors, - ), + toast: ToastFile::from_colors(state.builtin_custom_toasts, &state.builtin_toast_colors), }, shortcuts: ShortcutConfig { settings: state @@ -1537,8 +1658,11 @@ impl Default for Moorly { }; Self { - menu_open: false, - tabs_submenu_open: false, + windows: HashMap::new(), + window_order: Vec::new(), + main_window: None, + focused_window: None, + drag: None, theme, saved_theme: theme, theme_choice: theme_choice.clone(), @@ -1549,12 +1673,6 @@ impl Default for Moorly { shortcuts: shortcuts.clone(), saved_shortcuts: shortcuts, shortcut_capture: None, - tabs: if show_start_tab { - vec![Tab::Start] - } else { - Vec::new() - }, - active_tab: show_start_tab.then_some(Tab::Start), settings_section: SettingsSection::default(), pending_settings_section: None, show_start_tab, @@ -1584,9 +1702,6 @@ impl Default for Moorly { profile_dialog: None, dir_picker: None, next_blank_tab: 1, - tab_offset: 0.0, - tab_viewport_width: 0.0, - tab_content_width: 0.0, notifications: notifications::NotificationManager::default(), } } @@ -1594,12 +1709,18 @@ impl Default for Moorly { #[derive(Debug, Clone)] enum Message { - ToggleMenu, - CloseMenu, - ToggleTabsSubmenu, - AddTab, - CloseActiveTab, - CloseOtherTabs, + WindowEvent(window::Id, window::Event), + PointerPressed(window::Id), + PointerMoved(window::Id, Point), + PointerReleased(window::Id), + PointerLeft(window::Id), + DragTick, + ToggleMenu(window::Id), + CloseMenu(window::Id), + ToggleTabsSubmenu(window::Id), + AddTab(window::Id), + CloseActiveTab(window::Id), + CloseOtherTabs(window::Id), SelectTheme(ThemeOption), OpenThemeNameDialog, ThemeNameChanged(String), @@ -1608,8 +1729,8 @@ enum Message { SaveTheme, UndoTheme, ReloadThemes, - SelectTab(Tab), - CloseTab(Tab), + SelectTab(window::Id, Tab), + CloseTab(window::Id, Tab), SelectSettingsSection(SettingsSection), SetShowStartTab(bool), SetFadeSettings(bool), @@ -1633,8 +1754,14 @@ enum Message { CloseAddMenu, ToggleFolder(usize), HoverFolder(Option), - HoverTab { tab: Tab, hovered: bool }, - SelectProfile { folder: usize, profile: usize }, + HoverTab { + tab: Tab, + hovered: bool, + }, + SelectProfile { + folder: usize, + profile: usize, + }, OpenProfileDialog, ProfileNameChanged(String), ProfileKindSelected(ProfileKind), @@ -1671,54 +1798,134 @@ enum Message { key: keyboard::Key, modifiers: keyboard::Modifiers, }, - TabsScrolled(scrollable::Viewport), - ScrollTabs(mouse::ScrollDelta), - ScrollTabsBy(f32), + TabsScrolled(window::Id, scrollable::Viewport), + ScrollTabs(window::Id, mouse::ScrollDelta), + ScrollTabsBy(window::Id, f32), Quit, } fn update(state: &mut Moorly, message: Message) -> Task { match message { - Message::ToggleMenu => { - state.menu_open = !state.menu_open; - state.tabs_submenu_open = false; + Message::WindowEvent(window, event) => { + return window_event(state, window, event); } - Message::CloseMenu => { - state.menu_open = false; - state.tabs_submenu_open = false; + Message::PointerPressed(window) => { + state.focused_window = Some(window); + let pending = if state.drag.is_some() { + finish_drag(state, window) + } else { + Task::none() + }; + start_tab_drag(state, window); + return pending; } - Message::ToggleTabsSubmenu => { - state.tabs_submenu_open = !state.tabs_submenu_open; + Message::PointerMoved(window, position) => { + if let Some(state) = state.windows.get_mut(&window) { + state.pointer = Some(position); + } + + if state + .drag + .as_ref() + .is_some_and(|drag| drag.window == window) + { + let detach = position.y > MENUBAR_HEIGHT + 12.0; + if let Some(drag) = state.drag.as_mut() { + drag.pointer = position; + drag.detach = detach; + drag.moved = drag.moved + || (position.x - drag.origin.x).abs() > 4.0 + || (position.y - drag.origin.y).abs() > 4.0; + } + if state.drag.as_ref().is_some_and(|drag| drag.moved) + && let Some(delta) = drag_scroll_delta(state) + { + return scroll_tabs_by(state, window, delta); + } + } } - Message::AddTab => { + Message::PointerReleased(window) => return finish_drag(state, window), + Message::PointerLeft(window) => { + if let Some(drag) = state.drag.as_mut() + && drag.window == window + { + drag.detach = true; + } + } + Message::DragTick => { + if let Some(delta) = drag_scroll_delta(state) { + let window = state.drag.as_ref().unwrap().window; + return scroll_tabs_by(state, window, delta); + } + } + Message::ToggleMenu(window) => { + if let Some(state) = state.windows.get_mut(&window) { + state.menu_open = !state.menu_open; + state.tabs_submenu_open = false; + } + } + Message::CloseMenu(window) => { + if let Some(state) = state.windows.get_mut(&window) { + state.menu_open = false; + state.tabs_submenu_open = false; + } + } + Message::ToggleTabsSubmenu(window) => { + if let Some(state) = state.windows.get_mut(&window) { + state.tabs_submenu_open = !state.tabs_submenu_open; + } + } + Message::AddTab(window) => { 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); + + if let Some(state) = state.windows.get_mut(&window) { + state.tabs.push(tab); + state.active_tab = Some(tab); + state.menu_open = false; + state.tabs_submenu_open = false; } - state.menu_open = false; - state.tabs_submenu_open = false; - return reveal_active_tab(state); + + return scroll_tabs_to_end(state, window); } - Message::CloseOtherTabs => { - match state.active_tab { - Some(active) => { - state.tabs.retain(|tab| *tab == active); - if active != Tab::Settings { - state.settings_section = SettingsSection::default(); - } + Message::CloseActiveTab(window) => { + let active = state + .windows + .get(&window) + .and_then(|state| state.active_tab); + if let Some(tab) = active { + close_tab(state, window, tab); + } + if let Some(state) = state.windows.get_mut(&window) { + state.menu_open = false; + state.tabs_submenu_open = false; + } + + return Task::batch([ + reveal_active_tab(state, window), + close_window_if_empty(state, window), + ]); + } + Message::CloseOtherTabs(window) => { + let active = state + .windows + .get(&window) + .and_then(|state| state.active_tab); + + if let Some(state) = state.windows.get_mut(&window) { + match active { + Some(active) => state.tabs.retain(|tab| *tab == active), + None => state.tabs.clear(), } - None => state.tabs.clear(), + state.menu_open = false; + state.tabs_submenu_open = false; } - state.menu_open = false; - state.tabs_submenu_open = false; + + if active != Some(Tab::Settings) { + state.settings_section = SettingsSection::default(); + } + + return close_window_if_empty(state, window); } Message::SelectTheme(option) => { if let ThemeOption::Theme { choice, .. } = option { @@ -1773,10 +1980,7 @@ fn update(state: &mut Moorly, message: Message) -> Task { state.custom_themes = load_custom_themes(); state.theme_signature = themes_signature(); state.theme_name_dialog = None; - state.theme_choice = ThemeChoice::Custom { - id, - name, - }; + state.theme_choice = ThemeChoice::Custom { id, name }; state.theme = based_on; // Creating a theme is a separate action, so it is persisted @@ -1803,10 +2007,8 @@ fn update(state: &mut Moorly, message: Message) -> Task { ) .is_some() { - if let Some(theme) = state - .custom_themes - .iter_mut() - .find(|theme| theme.id == *id) + if let Some(theme) = + state.custom_themes.iter_mut().find(|theme| theme.id == *id) { theme.colors = state.colors; theme.custom_toasts = state.custom_toasts; @@ -1907,24 +2109,34 @@ fn update(state: &mut Moorly, message: Message) -> Task { } } } - Message::SelectTab(tab) => { - let is_new = !state.tabs.contains(&tab); + Message::SelectTab(window, tab) => { + let Some(window_state) = state.windows.get_mut(&window) else { + return Task::none(); + }; + let is_new = !window_state.tabs.contains(&tab); if is_new { - state.tabs.push(tab); + window_state.tabs.push(tab); } - state.active_tab = Some(tab); - state.menu_open = false; - state.tabs_submenu_open = false; + window_state.active_tab = Some(tab); + window_state.menu_open = false; + window_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(); + return scroll_tabs_to_end(state, window); } } - Message::CloseTab(tab) => { - if close_tab(state, tab) { - return reveal_active_tab(state); - } + Message::CloseTab(window, tab) => { + let was_active = close_tab(state, window, tab); + + return Task::batch([ + if was_active { + reveal_active_tab(state, window) + } else { + Task::none() + }, + close_window_if_empty(state, window), + ]); } Message::SelectSettingsSection(section) => { if section == state.settings_section && state.pending_settings_section.is_none() { @@ -2000,9 +2212,12 @@ fn update(state: &mut Moorly, message: Message) -> Task { .title("Info"), ); state.notifications.add( - Notification::new(NotificationKind::Success, "The operation completed successfully.") - .title("Success") - .timed(Duration::from_secs(8)), + Notification::new( + NotificationKind::Success, + "The operation completed successfully.", + ) + .title("Success") + .timed(Duration::from_secs(8)), ); state.notifications.add( Notification::new( @@ -2106,8 +2321,7 @@ fn update(state: &mut Moorly, message: Message) -> Task { } Message::ProfilePortChanged(value) => { let valid = value.chars().all(|c| c.is_ascii_digit()) - && (value.is_empty() - || value.parse::().is_ok_and(|port| port <= 65534)); + && (value.is_empty() || value.parse::().is_ok_and(|port| port <= 65534)); if valid { if let Some(draft) = state.profile_dialog.as_mut() { @@ -2217,7 +2431,9 @@ fn update(state: &mut Moorly, message: Message) -> Task { return Task::none(); } - let folder_index = draft.folder.min(state.profile_folders.len().saturating_sub(1)); + let folder_index = draft + .folder + .min(state.profile_folders.len().saturating_sub(1)); let Some(folder) = state.profile_folders.get_mut(folder_index) else { return Task::none(); }; @@ -2318,19 +2534,21 @@ fn update(state: &mut Moorly, message: Message) -> Task { } } }, - 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::TabsScrolled(window, viewport) => { + if let Some(window_state) = state.windows.get_mut(&window) { + window_state.tab_offset = viewport.absolute_offset().x; + } } - Message::ScrollTabs(delta) => { + Message::ScrollTabs(window, delta) => { let amount = match delta { mouse::ScrollDelta::Lines { y, .. } => y * 60.0, mouse::ScrollDelta::Pixels { x, y } => x + y, }; - return scroll_tabs_by(amount); + return scroll_tabs_by(state, window, amount); + } + Message::ScrollTabsBy(window, amount) => { + return scroll_tabs_by(state, window, amount); } - Message::ScrollTabsBy(amount) => return scroll_tabs_by(amount), Message::Quit => std::process::exit(0), } @@ -2362,31 +2580,502 @@ fn apply_shortcut(state: &mut Moorly) { state.shortcut_capture = None; } -fn scroll_tabs_by(x: f32) -> Task { - operation::scroll_by(TAB_SCROLL_ID, operation::AbsoluteOffset { x, y: 0.0 }) +fn window_event(state: &mut Moorly, window: window::Id, event: window::Event) -> Task { + match event { + window::Event::Opened { position, size } => { + if let Some(window_state) = state.windows.get_mut(&window) { + window_state.size = size; + if position.is_some() { + window_state.position = position; + } + } + } + window::Event::Moved(position) => { + if let Some(window_state) = state.windows.get_mut(&window) { + window_state.position = Some(position); + } + } + window::Event::Resized(size) => { + if let Some(window_state) = state.windows.get_mut(&window) { + window_state.size = size; + } + } + window::Event::Focused => state.focused_window = Some(window), + window::Event::CloseRequested => { + remove_window(state, window); + + if state.windows.is_empty() { + return iced::exit(); + } + + return window::close(window); + } + window::Event::Closed => { + remove_window(state, window); + + if state.windows.is_empty() { + return iced::exit(); + } + } + _ => {} + } + + Task::none() } -fn scroll_tabs_to_end() -> Task { - operation::snap_to(TAB_SCROLL_ID, operation::RelativeOffset::END) +fn remove_window(state: &mut Moorly, window: window::Id) { + state.windows.remove(&window); + state.window_order.retain(|id| *id != window); + + if state.main_window == Some(window) { + state.main_window = None; + } + if state.focused_window == Some(window) { + state.focused_window = state.window_order.first().copied(); + } + if state + .drag + .as_ref() + .is_some_and(|drag| drag.window == window) + { + state.drag = None; + } +} + +/// Width the tab strip gets after the scroll buttons and hamburger. +fn tab_strip_width(window_width: f32) -> f32 { + (window_width + - TAB_STRIP_LEFT + - MENUBAR_RIGHT_PADDING + - 2.0 * SCROLL_BUTTON_WIDTH + - HAMBURGER_WIDTH + - 3.0 * TAB_SPACING) + .max(0.0) +} + +struct TabStripMetrics { + viewport: f32, + width: f32, + step: f32, + content: f32, + offset: f32, +} + +fn tab_strip_metrics(window_state: &WindowState) -> TabStripMetrics { + let viewport = tab_strip_width(window_state.size.width); + let count = window_state.tabs.len(); + let width = tab_width(viewport, count); + let step = width + TAB_SPACING; + let content = if count == 0 { + 0.0 + } else { + step * count as f32 - TAB_SPACING + }; + let offset = window_state.tab_offset.min((content - viewport).max(0.0)); + + TabStripMetrics { + viewport, + width, + step, + content, + offset, + } +} + +/// Index of the tab under `point`, if the point is inside the tab strip. +fn tab_index_at(state: &Moorly, window: window::Id, point: Point) -> Option { + let window_state = state.windows.get(&window)?; + + if window_state.tabs.is_empty() + || point.y < 0.0 + || point.y > MENUBAR_HEIGHT + || point.x < TAB_STRIP_LEFT + { + return None; + } + + let metrics = tab_strip_metrics(window_state); + if metrics.viewport <= 0.0 || point.x > TAB_STRIP_LEFT + metrics.viewport { + return None; + } + + let relative = point.x - TAB_STRIP_LEFT + metrics.offset; + + if relative < 0.0 || relative > metrics.content { + return None; + } + + Some(((relative / metrics.step).floor() as usize).min(window_state.tabs.len() - 1)) +} + +/// Gap the dragged tab would be inserted into: `0` is before the first tab, +/// `tabs.len()` is after the last one. +fn tab_gap_index(state: &Moorly, window: window::Id, x: f32) -> Option { + let window_state = state.windows.get(&window)?; + if window_state.tabs.is_empty() { + return Some(0); + } + + let metrics = tab_strip_metrics(window_state); + let relative = x - TAB_STRIP_LEFT + metrics.offset; + let mut gap = window_state.tabs.len(); + + for index in 0..window_state.tabs.len() { + let midpoint = index as f32 * metrics.step + metrics.width / 2.0; + if relative < midpoint { + gap = index; + break; + } + } + + Some(gap) +} + +fn start_tab_drag(state: &mut Moorly, window: window::Id) { + state.drag = None; + + let Some((pointer, menu_open)) = state + .windows + .get(&window) + .map(|window_state| (window_state.pointer, window_state.menu_open)) + else { + return; + }; + + if menu_open { + return; + } + + let Some(pointer) = pointer else { + return; + }; + let Some(index) = tab_index_at(state, window, pointer) else { + return; + }; + let Some(window_state) = state.windows.get(&window) else { + return; + }; + + state.drag = Some(TabDrag { + window, + tab: window_state.tabs[index], + origin: pointer, + pointer, + moved: false, + detach: false, + }); +} + +fn apply_tab_move(state: &mut Moorly, window: window::Id, tab: Tab, gap: usize) { + let Some(window_state) = state.windows.get_mut(&window) else { + return; + }; + let Some(current) = window_state.tabs.iter().position(|open| *open == tab) else { + return; + }; + + // Removing the tab collapses its own slot, so gaps after it shift left. + let target = if current < gap { gap - 1 } else { gap }; + if target == current { + return; + } + + window_state.tabs.remove(current); + window_state.tabs.insert(target, tab); +} + +/// Scroll delta for auto-scrolling while a tab is dragged near an edge. +fn drag_scroll_delta(state: &Moorly) -> Option { + let drag = state.drag.as_ref()?; + if drag.detach || !drag.moved { + return None; + } + + let window_state = state.windows.get(&drag.window)?; + let metrics = tab_strip_metrics(window_state); + if window_state.tabs.is_empty() + || metrics.viewport <= 0.0 + || metrics.content <= metrics.viewport + { + return None; + } + + let x = drag.pointer.x; + let left = TAB_STRIP_LEFT; + let right = left + metrics.viewport; + + if x < left + DRAG_EDGE { + let amount = ((left + DRAG_EDGE - x) / DRAG_EDGE).clamp(0.0, 1.0); + return Some(-DRAG_SCROLL_SPEED * amount); + } + + if x > right - DRAG_EDGE { + let amount = ((x - (right - DRAG_EDGE)) / DRAG_EDGE).clamp(0.0, 1.0); + return Some(DRAG_SCROLL_SPEED * amount); + } + + None +} + +// ponytail: window geometry is enough for X11/Windows drops. Wayland does not +// expose window positions, so there a drop only moves tabs when the release is +// routed directly to the destination window. +fn window_at(state: &Moorly, except: window::Id, point: Point) -> Option { + state.windows.iter().find_map(|(id, window_state)| { + if *id == except { + return None; + } + + let position = window_state.position?; + Rectangle::new(position, window_state.size) + .contains(point) + .then_some(*id) + }) +} + +fn drop_targets(state: &Moorly, source: window::Id) -> Vec<(window::Id, String)> { + state + .window_order + .iter() + .filter(|id| **id != source && state.windows.contains_key(id)) + .map(|id| (*id, window_title(state, *id))) + .collect() +} + +fn drop_panel_rect(window_state: &WindowState, count: usize) -> Rectangle { + let width = DROP_PANEL_WIDTH.min((window_state.size.width - 24.0).max(120.0)); + let height = DROP_PANEL_PADDING * 2.0 + + DROP_HEADER_HEIGHT + + count as f32 * (DROP_ROW_HEIGHT + DROP_ROW_GAP); + let x = ((window_state.size.width - width) / 2.0).max(0.0); + let y = MENUBAR_HEIGHT + 8.0; + + Rectangle::new(Point::new(x, y), Size::new(width, height)) +} + +fn drop_target_index(state: &Moorly, source: window::Id, point: Point) -> Option { + let window_state = state.windows.get(&source)?; + let targets = drop_targets(state, source); + if targets.is_empty() { + return None; + } + + let rect = drop_panel_rect(window_state, targets.len()); + if !rect.contains(point) { + return None; + } + + let row_top = rect.y + DROP_PANEL_PADDING + DROP_HEADER_HEIGHT + DROP_ROW_GAP; + if point.y < row_top { + return None; + } + + let index = ((point.y - row_top) / (DROP_ROW_HEIGHT + DROP_ROW_GAP)).floor() as usize; + (index < targets.len()).then_some(index) +} + +fn drop_target_at(state: &Moorly, source: window::Id, point: Point) -> Option { + let index = drop_target_index(state, source, point)?; + drop_targets(state, source).get(index).map(|(id, _)| *id) +} + +fn move_tab_to_window(state: &mut Moorly, source: window::Id, destination: window::Id, tab: Tab) { + let Some(source_state) = state.windows.get_mut(&source) else { + return; + }; + let Some(index) = source_state.tabs.iter().position(|open| *open == tab) else { + return; + }; + source_state.tabs.remove(index); + + if source_state.active_tab == Some(tab) { + source_state.active_tab = source_state + .tabs + .get(index) + .or_else(|| source_state.tabs.last()) + .copied(); + } + + if let Some(destination_state) = state.windows.get_mut(&destination) { + if !destination_state.tabs.contains(&tab) { + destination_state.tabs.push(tab); + } + destination_state.active_tab = Some(tab); + } + + state.focused_window = Some(destination); +} + +/// Moves a tab into a brand-new window positioned where it was dropped. +fn detach_tab( + state: &mut Moorly, + source: window::Id, + tab: Tab, + global: Option, +) -> Task { + let Some(source_state) = state.windows.get_mut(&source) else { + return Task::none(); + }; + let Some(index) = source_state.tabs.iter().position(|open| *open == tab) else { + return Task::none(); + }; + source_state.tabs.remove(index); + + if source_state.active_tab == Some(tab) { + source_state.active_tab = source_state + .tabs + .get(index) + .or_else(|| source_state.tabs.last()) + .copied(); + } + + let size = Size::new(900.0, 600.0); + let position = + global.map(|point| Point::new((point.x - 100.0).max(0.0), (point.y - 20.0).max(0.0))); + let settings = window::Settings { + size, + position: position.map_or(window::Position::Default, window::Position::Specific), + exit_on_close_request: false, + ..window::Settings::default() + }; + let (id, open) = window::open(settings); + state + .windows + .insert(id, WindowState::with_tab(tab, size, position)); + state.window_order.push(id); + state.focused_window = Some(id); + + Task::batch([ + open.map(|_| Message::Ignore), + close_window_if_empty(state, source), + ]) +} + +fn finish_drag(state: &mut Moorly, released_in: window::Id) -> Task { + let Some(drag) = state.drag.take() else { + return Task::none(); + }; + let source = drag.window; + let tab = drag.tab; + + if !drag.moved + || !state + .windows + .get(&source) + .is_some_and(|window_state| window_state.tabs.contains(&tab)) + { + return Task::none(); + } + + // Dropping directly into another window is the cross-window move path. + if released_in != source && state.windows.contains_key(&released_in) { + move_tab_to_window(state, source, released_in, tab); + return close_window_if_empty(state, source); + } + + let Some(window_state) = state.windows.get(&source) else { + return Task::none(); + }; + let outside = drag.pointer.x < 0.0 + || drag.pointer.y < 0.0 + || drag.pointer.x > window_state.size.width + || drag.pointer.y > window_state.size.height; + + // On Wayland the window under the pointer is unknowable, so the user can + // drop onto the in-window target list instead. + if (drag.detach || outside) + && let Some(destination) = drop_target_at(state, source, drag.pointer) + { + move_tab_to_window(state, source, destination, tab); + return close_window_if_empty(state, source); + } + + let global = window_state + .position + .map(|position| Point::new(position.x + drag.pointer.x, position.y + drag.pointer.y)); + + if drag.detach || outside { + if let Some(global) = global + && let Some(destination) = window_at(state, source, global) + { + move_tab_to_window(state, source, destination, tab); + return close_window_if_empty(state, source); + } + + return detach_tab(state, source, tab, global); + } + + if let Some(gap) = tab_gap_index(state, source, drag.pointer.x) { + apply_tab_move(state, source, tab, gap); + } + + Task::none() +} + +fn close_window_if_empty(state: &mut Moorly, window: window::Id) -> Task { + if !state + .windows + .get(&window) + .is_some_and(|window_state| window_state.tabs.is_empty()) + { + return Task::none(); + } + + remove_window(state, window); + + if state.windows.is_empty() { + return iced::exit(); + } + + window::close(window) +} + +fn scroll_tabs_by(state: &Moorly, window: window::Id, x: f32) -> Task { + let Some(window_state) = state.windows.get(&window) else { + return Task::none(); + }; + + operation::scroll_by( + window_state.scroll_id.clone(), + operation::AbsoluteOffset { x, y: 0.0 }, + ) +} + +fn scroll_tabs_to_end(state: &Moorly, window: window::Id) -> Task { + let Some(window_state) = state.windows.get(&window) else { + return Task::none(); + }; + + operation::snap_to( + window_state.scroll_id.clone(), + 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); +fn close_tab(state: &mut Moorly, window: window::Id, tab: Tab) -> bool { + let was_active = { + let Some(window_state) = state.windows.get_mut(&window) else { + return false; + }; + let Some(index) = window_state.tabs.iter().position(|open| *open == tab) else { + return false; + }; + let was_active = window_state.active_tab == Some(tab); + window_state.tabs.remove(index); - if was_active { - state.active_tab = state - .tabs - .get(index) - .or_else(|| state.tabs.last()) - .copied(); - } + if was_active { + window_state.active_tab = window_state + .tabs + .get(index) + .or_else(|| window_state.tabs.last()) + .copied(); + } + + was_active + }; // Drop the tab's page state along with the tab itself. if tab == Tab::Settings { @@ -2398,36 +3087,45 @@ fn close_tab(state: &mut Moorly, tab: Tab) -> bool { /// 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 +fn tab_reveal_delta(state: &Moorly, window: window::Id) -> Option { + let window_state = state.windows.get(&window)?; + let index = window_state .active_tab - .and_then(|active| state.tabs.iter().position(|tab| *tab == active))?; + .and_then(|active| window_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 { + if window_state.tabs.is_empty() { return None; } - let width = tab_width(state.tab_viewport_width, state.tabs.len()) + TAB_SPACING; - let start = index as f32 * width; - let visible_start = state.tab_offset; - let visible_end = visible_start + state.tab_viewport_width; - - if start >= visible_start && start + width <= visible_end { + let metrics = tab_strip_metrics(window_state); + if metrics.viewport <= 0.0 || metrics.content <= metrics.viewport { return None; } - let target = (start - (state.tab_viewport_width - width) / 2.0).max(0.0); - Some(target - state.tab_offset) + let start = index as f32 * metrics.step; + let visible_start = metrics.offset; + let visible_end = metrics.offset + metrics.viewport; + + if start >= visible_start && start + metrics.width <= visible_end { + return None; + } + + let target = (start - (metrics.viewport - metrics.width) / 2.0).max(0.0); + Some(target - metrics.offset) } -fn reveal_active_tab(state: &Moorly) -> Task { - tab_reveal_delta(state) - .map(scroll_tabs_by) - .unwrap_or(Task::none()) +fn reveal_active_tab(state: &Moorly, window: window::Id) -> Task { + match tab_reveal_delta(state, window) { + Some(delta) => scroll_tabs_by(state, window, delta), + None => Task::none(), + } } -fn hamburger(open: bool, text_color: Color) -> iced::widget::Button<'static, Message> { +fn hamburger( + open: bool, + text_color: Color, + window: window::Id, +) -> iced::widget::Button<'static, Message> { let icon: Element<'static, Message> = if open { stack![ text("☰").size(14), @@ -2443,7 +3141,7 @@ fn hamburger(open: bool, text_color: Color) -> iced::widget::Button<'static, Mes }; button(icon) - .on_press(Message::ToggleMenu) + .on_press(Message::ToggleMenu(window)) .width(HAMBURGER_WIDTH) .padding([2, 8]) .style(move |theme, status| theme::menubar_button(theme, status, text_color)) @@ -2517,6 +3215,7 @@ fn tab_shell( } fn tab_view( + window: window::Id, tab: Tab, active: bool, hide_close: bool, @@ -2536,23 +3235,23 @@ fn tab_view( .width(Length::Fill) .align_x(Alignment::Center), ) - .on_press(Message::SelectTab(tab)) + .on_press(Message::SelectTab(window, tab)) .padding(padding) .width(Length::Fill) .clip(true) .style(move |theme, status| { - let mut style = button::text(theme, status); - style.text_color = if active { - text_color - } else { - text_color.scale_alpha(0.6) - }; - style - }); + let mut style = button::text(theme, status); + style.text_color = if active { + text_color + } else { + text_color.scale_alpha(0.6) + }; + style + }); let close_icon = |padding: Padding| { button(text("×").size(15)) - .on_press(Message::CloseTab(tab)) + .on_press(Message::CloseTab(window, tab)) .padding(padding) .style(move |theme, status| { let mut style = button::text(theme, status); @@ -2618,10 +3317,7 @@ fn tab_view( }; let content = mouse_area(tab_element) - .on_enter(Message::HoverTab { - tab, - hovered: true, - }) + .on_enter(Message::HoverTab { tab, hovered: true }) .on_exit(Message::HoverTab { tab, hovered: false, @@ -2635,6 +3331,242 @@ fn tab_view( .into() } +/// Floating copy of the dragged tab that follows the pointer. +fn drag_ghost( + state: &Moorly, + window: window::Id, + colors: [Color; 5], +) -> Option> { + let drag = state + .drag + .as_ref() + .filter(|drag| drag.window == window && drag.moved)?; + let window_state = state.windows.get(&window)?; + + let x = + (drag.pointer.x + 12.0).clamp(0.0, (window_state.size.width - DRAG_GHOST_WIDTH).max(0.0)); + let y = + (drag.pointer.y + 12.0).clamp(0.0, (window_state.size.height - DRAG_GHOST_HEIGHT).max(0.0)); + + let text_color = colors[ColorOption::Text.index()]; + let mut background = colors[ColorOption::MainBackground.index()]; + background.a = 0.9; + let outline = colors[ColorOption::ActiveTabOutline.index()]; + + let ghost = container( + text(fit_title(&drag.tab.title())) + .size(14) + .color(text_color), + ) + .width(DRAG_GHOST_WIDTH) + .height(DRAG_GHOST_HEIGHT) + .padding([5, 10]) + .align_y(Alignment::Center) + .style(move |_| container::Style { + background: Some(background.into()), + border: Border { + color: outline, + width: 1.0, + radius: 6.0.into(), + }, + shadow: Shadow { + color: Color::BLACK.scale_alpha(0.35), + offset: Vector::new(0.0, 4.0), + blur_radius: 10.0, + }, + text_color: Some(text_color), + ..container::Style::default() + }); + + Some( + container(ghost) + .width(Length::Fill) + .height(Length::Fill) + .align_x(Alignment::Start) + .align_y(Alignment::Start) + .padding(Padding { + top: y, + left: x, + right: 0.0, + bottom: 0.0, + }) + .into(), + ) +} + +/// Vertical marker showing where the dragged tab will be inserted on release. +fn tab_drop_bar( + state: &Moorly, + window: window::Id, + colors: [Color; 5], +) -> Option> { + let drag = state + .drag + .as_ref() + .filter(|drag| drag.window == window && drag.moved && !drag.detach)?; + let window_state = state.windows.get(&window)?; + + let outside = drag.pointer.x < 0.0 + || drag.pointer.y < 0.0 + || drag.pointer.x > window_state.size.width + || drag.pointer.y > window_state.size.height; + if outside || window_state.tabs.is_empty() { + return None; + } + + let metrics = tab_strip_metrics(window_state); + if metrics.viewport <= 0.0 { + return None; + } + + let gap = tab_gap_index(state, window, drag.pointer.x)?; + let content_x = if gap == 0 { + 0.0 + } else if gap >= window_state.tabs.len() { + metrics.content + } else { + gap as f32 * metrics.step - TAB_SPACING / 2.0 + }; + let x = TAB_STRIP_LEFT + content_x - metrics.offset; + + if x < TAB_STRIP_LEFT || x > TAB_STRIP_LEFT + metrics.viewport { + return None; + } + + let accent = colors[ColorOption::Accent.index()]; + let bar = container(space::horizontal()) + .width(2.0) + .height(MENUBAR_HEIGHT - 12.0) + .style(move |_| container::Style { + background: Some(accent.into()), + border: Border { + color: Color::TRANSPARENT, + width: 0.0, + radius: 1.0.into(), + }, + ..container::Style::default() + }); + + Some( + container(bar) + .width(Length::Fill) + .height(Length::Fill) + .align_x(Alignment::Start) + .align_y(Alignment::Start) + .padding(Padding { + top: 6.0, + left: x - 1.0, + right: 0.0, + bottom: 0.0, + }) + .into(), + ) +} + +/// In-window list of other windows to drop a dragged tab onto. This is the +/// cross-window path that works on Wayland, where window positions are hidden. +fn drop_panel( + state: &Moorly, + window: window::Id, + colors: [Color; 5], +) -> Option> { + let drag = state.drag.as_ref().filter(|drag| drag.window == window)?; + let window_state = state.windows.get(&window)?; + let outside = drag.pointer.x < 0.0 + || drag.pointer.y < 0.0 + || drag.pointer.x > window_state.size.width + || drag.pointer.y > window_state.size.height; + + if !drag.detach && !outside { + return None; + } + + let targets = drop_targets(state, window); + if targets.is_empty() { + return None; + } + + let rect = drop_panel_rect(window_state, targets.len()); + let hovered = drop_target_index(state, window, drag.pointer); + let text_color = colors[ColorOption::Text.index()]; + let background = colors[ColorOption::SidebarBackground.index()]; + let outline = colors[ColorOption::ActiveTabOutline.index()]; + let accent = colors[ColorOption::Accent.index()]; + + let mut rows = column![].spacing(DROP_ROW_GAP).width(Length::Fill); + + for (index, (_, title)) in targets.iter().enumerate() { + let selected = hovered == Some(index); + rows = rows.push( + container(text(fit_title(title)).size(13).color(text_color)) + .width(Length::Fill) + .height(DROP_ROW_HEIGHT) + .padding([0, 8]) + .align_y(Alignment::Center) + .style(move |_| container::Style { + background: Some( + if selected { + accent.scale_alpha(0.35) + } else { + background + } + .into(), + ), + border: Border { + color: outline.scale_alpha(0.4), + width: if selected { 1.0 } else { 0.0 }, + radius: 4.0.into(), + }, + ..container::Style::default() + }), + ); + } + + let header = container( + text("Move to window") + .size(12) + .color(text_color.scale_alpha(0.7)), + ) + .width(Length::Fill) + .height(DROP_HEADER_HEIGHT) + .align_y(Alignment::Center) + .padding([0, 8]); + + let panel = container(column![header, rows].spacing(DROP_ROW_GAP)) + .width(rect.width) + .padding(DROP_PANEL_PADDING) + .style(move |_| container::Style { + background: Some(background.into()), + border: Border { + color: outline, + width: 1.0, + radius: 8.0.into(), + }, + shadow: Shadow { + color: Color::BLACK.scale_alpha(0.35), + offset: Vector::new(0.0, 6.0), + blur_radius: 16.0, + }, + text_color: Some(text_color), + ..container::Style::default() + }); + + Some( + container(panel) + .width(Length::Fill) + .height(Length::Fill) + .align_x(Alignment::Start) + .align_y(Alignment::Start) + .padding(Padding { + top: rect.y, + left: rect.x, + right: 0.0, + bottom: 0.0, + }) + .into(), + ) +} + /// Theme selection as a right-aligned drop list. fn theme_picker(state: &Moorly) -> Element<'_, Message> { let mut options = Vec::new(); @@ -2808,13 +3740,7 @@ fn color_swatch_row<'a>( .padding(3) .style(button::text); - let picker = iced_aw::color_picker( - open, - color, - button, - Message::CancelColorPicker, - on_submit, - ); + let picker = iced_aw::color_picker(open, color, button, Message::CancelColorPicker, on_submit); row![text(label), space::horizontal(), picker] .align_y(Alignment::Center) @@ -2828,7 +3754,10 @@ fn shortcuts_panel(state: &Moorly) -> Element<'_, Message> { ShortcutAction::Settings, state.shortcuts.get(ShortcutAction::Settings), ), - shortcut_row(ShortcutAction::Quit, state.shortcuts.get(ShortcutAction::Quit)), + shortcut_row( + ShortcutAction::Quit, + state.shortcuts.get(ShortcutAction::Quit) + ), ] .spacing(8); @@ -2843,10 +3772,7 @@ fn shortcuts_panel(state: &Moorly) -> Element<'_, Message> { } /// One read-only binding row with buttons to clear or rebind it. -fn shortcut_row( - action: ShortcutAction, - shortcut: Option<&Shortcut>, -) -> Element<'static, Message> { +fn shortcut_row(action: ShortcutAction, shortcut: Option<&Shortcut>) -> Element<'static, Message> { let value = shortcut.map(ToString::to_string).unwrap_or_default(); // No `on_input`: the field only displays the binding. @@ -2879,7 +3805,11 @@ fn shortcut_capture_panel(capture: &ShortcutCapture) -> Element<'_, Message> { .unwrap_or_else(|| "Press a key combination".to_owned()); let mut panel = column![ - text(format!("Enter a new shortcut for {}", capture.action.label())).size(12), + text(format!( + "Enter a new shortcut for {}", + capture.action.label() + )) + .size(12), container(text(preview).size(16)) .width(Length::Fill) .padding([6, 10]) @@ -3168,9 +4098,7 @@ fn directory_picker_view(picker: &DirPicker) -> Element<'_, Message> { .on_press(message) .width(Length::Fill) .padding([6, 8]) - .style(move |theme, status| { - theme::selectable_row(theme, status, selected) - }), + .style(move |theme, status| theme::selectable_row(theme, status, selected)), ); } @@ -3208,7 +4136,11 @@ fn directory_picker_view(picker: &DirPicker) -> Element<'_, Message> { .on_press(Message::CancelDirectoryPicker) .style(theme::danger_option), button("Select") - .on_press_maybe(picker.can_confirm().then_some(Message::ConfirmDirectoryPicker)) + .on_press_maybe( + picker + .can_confirm() + .then_some(Message::ConfirmDirectoryPicker) + ) .style(theme::positive_option), ] .spacing(8), @@ -3256,8 +4188,7 @@ fn profile_dialog_view<'a>( .spacing(4), column![ text("Folder").size(12), - pick_list(choices, selected_folder, Message::ProfileFolderSelected) - .width(Length::Fill), + pick_list(choices, selected_folder, Message::ProfileFolderSelected).width(Length::Fill), ] .spacing(4), row![ @@ -3339,9 +4270,7 @@ fn profile_kind_view(draft: &ProfileDraft) -> Element<'_, Message> { button("...") .on_press(Message::OpenDirectoryPicker) .padding([2, 6]) - .style(|theme, status| { - theme::selectable_row(theme, status, false) - }), + .style(|theme, status| theme::selectable_row(theme, status, false)), ) .width(Length::Fill) .height(Length::Fill) @@ -3401,13 +4330,10 @@ fn profile_kind_view(draft: &ProfileDraft) -> Element<'_, Message> { let mut auth_buttons = row![].spacing(6).width(Length::Fill); for auth in AuthMethod::ALL { let item = button( - column![ - text(auth.glyph()).size(18), - text(auth.label()).size(11), - ] - .spacing(2) - .align_x(Alignment::Center) - .width(Length::Fill), + column![text(auth.glyph()).size(18), text(auth.label()).size(11),] + .spacing(2) + .align_x(Alignment::Center) + .width(Length::Fill), ) .on_press(Message::AuthMethodSelected(auth)) .width(Length::Fill) @@ -3487,11 +4413,11 @@ fn password_field(draft: &ProfileDraft) -> Element<'_, Message> { }; let eye = container(eye_button) - .width(Length::Fill) - .height(Length::Fill) - .align_x(Alignment::End) - .align_y(Alignment::Center) - .padding(Padding::ZERO.right(6.0)); + .width(Length::Fill) + .height(Length::Fill) + .align_x(Alignment::End) + .align_y(Alignment::Center) + .padding(Padding::ZERO.right(6.0)); column![ text("Password").size(12), @@ -3518,9 +4444,7 @@ fn private_key_field(draft: &ProfileDraft) -> Element<'_, Message> { button("...") .on_press(Message::OpenPrivateKeyPicker) .padding([2, 6]) - .style(|theme, status| { - theme::selectable_row(theme, status, false) - }), + .style(|theme, status| theme::selectable_row(theme, status, false)), ) .width(Length::Fill) .height(Length::Fill) @@ -3605,9 +4529,7 @@ fn profile_folder_row( }) .width(Length::Fill) .padding([4, 26]) - .style(move |theme, status| { - theme::selectable_row(theme, status, profile_selected) - }), + .style(move |theme, status| theme::selectable_row(theme, status, profile_selected)), ); } } @@ -3616,14 +4538,14 @@ fn profile_folder_row( } /// Landing tab: the profile listing with a shortcut to the Settings page. -fn start_page(state: &Moorly) -> Element<'_, Message> { +fn start_page(state: &Moorly, window: window::Id) -> Element<'_, Message> { responsive(move |size| { // Half the window and 60% of its height, with sensible minimums. let width = (size.width * 0.5).max(400.0); let list_height = (size.height * 0.6).max(300.0); let settings = button(text("Settings")) - .on_press(Message::SelectTab(Tab::Settings)) + .on_press(Message::SelectTab(window, Tab::Settings)) .padding([6, 12]) .style(theme::outlined_option); @@ -3705,20 +4627,17 @@ fn settings_page(state: &Moorly) -> Element<'_, Message> { .padding([6, 10]); if section == state.settings_section { - item.style(move |theme, status| { - theme::settings_active(theme, status, accent) - }) + item.style(move |theme, status| theme::settings_active(theme, status, accent)) } else { - item.style(move |theme, status| { - theme::menubar_button(theme, status, text_color) - }) + item.style(move |theme, status| theme::menubar_button(theme, status, text_color)) } }; - let menu = container(column(SettingsSection::ALL.map(|section| menu_item(section).into())).spacing(2)) - .width(160) - .height(Length::Fill) - .padding(8); + let menu = + container(column(SettingsSection::ALL.map(|section| menu_item(section).into())).spacing(2)) + .width(160) + .height(Length::Fill) + .padding(8); let scrolls = state.settings_section != SettingsSection::Profiles; @@ -3786,9 +4705,7 @@ fn settings_page(state: &Moorly) -> Element<'_, Message> { content.into() }; - let frame = row![menu, content] - .width(Length::Fill) - .height(Length::Fill); + let frame = row![menu, content].width(Length::Fill).height(Length::Fill); let dirty = state.show_start_tab_draft != state.show_start_tab || state.fade_settings_draft != state.fade_settings @@ -3937,27 +4854,46 @@ fn scroll_button( delta: f32, enabled: bool, text_color: Color, + window: window::Id, ) -> iced::widget::Button<'static, Message> { button(text(symbol).size(17)) - .on_press_maybe(enabled.then_some(Message::ScrollTabsBy(delta))) + .on_press_maybe(enabled.then_some(Message::ScrollTabsBy(window, delta))) + .width(SCROLL_BUTTON_WIDTH) .padding([0, 6]) .style(move |theme, status| theme::menubar_button(theme, status, text_color)) } -/// 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) +/// Whether the tab strip can still scroll left/right. +fn tab_scroll_limits(state: &Moorly, window: window::Id) -> (bool, bool) { + let Some(window_state) = state.windows.get(&window) else { + return (false, false); + }; + + if window_state.tabs.is_empty() { + return (false, false); + } + + let metrics = tab_strip_metrics(window_state); + let max_offset = (metrics.content - metrics.viewport).max(0.0); + let offset = window_state.tab_offset.min(max_offset); + (offset > 0.5, offset < max_offset - 0.5) } -fn main_view(state: &Moorly) -> Element<'_, Message> { +fn main_view(state: &Moorly, window: window::Id) -> Element<'_, Message> { + let Some(window_state) = state.windows.get(&window) else { + return container(space::horizontal()) + .width(Length::Fill) + .height(Length::Fill) + .into(); + }; + // Tab strip: size tabs to the strip's current width so as many as // possible fit before scrolling starts. - let tabs = state.tabs.clone(); - let active_tab = state.active_tab; + let tabs = window_state.tabs.clone(); + let active_tab = window_state.active_tab; + let menu_open = window_state.menu_open; + let tabs_submenu_open = window_state.tabs_submenu_open; + let scroll_id = window_state.scroll_id.clone(); let hide_close = state.hide_tab_close; let colors = state.colors; let text_color = colors[ColorOption::Text.index()]; @@ -3987,6 +4923,7 @@ fn main_view(state: &Moorly) -> Element<'_, Message> { for &tab in &tabs { tab_row = tab_row.push(tab_view( + window, tab, active_tab == Some(tab), hide_close, @@ -4000,30 +4937,32 @@ fn main_view(state: &Moorly) -> Element<'_, Message> { .direction(scrollable::Direction::Horizontal( scrollable::Scrollbar::hidden(), )) - .id(TAB_SCROLL_ID) + .id(scroll_id.clone()) .width(Length::Fill) .height(Length::Fill) - .on_scroll(Message::TabsScrolled); + .on_scroll(move |viewport| Message::TabsScrolled(window, viewport)); // Convert vertical wheel input into horizontal tab-strip scrolling. - mouse_area(tab_strip).on_scroll(Message::ScrollTabs).into() + mouse_area(tab_strip) + .on_scroll(move |delta| Message::ScrollTabs(window, delta)) + .into() }); - let (can_scroll_left, can_scroll_right) = tab_scroll_limits(state); + let (can_scroll_left, can_scroll_right) = tab_scroll_limits(state, window); let mut bar = row![ tab_strip, - scroll_button("◀", -TAB_SCROLL_STEP, can_scroll_left, text_color), - scroll_button("▶", TAB_SCROLL_STEP, can_scroll_right, text_color), + scroll_button("◀", -TAB_SCROLL_STEP, can_scroll_left, text_color, window), + scroll_button("▶", TAB_SCROLL_STEP, can_scroll_right, text_color, window), ] .spacing(2) .align_y(Alignment::Center); - if state.menu_open { + if menu_open { // The dropdown draws the close button over this spot. bar = bar.push(space::horizontal().width(HAMBURGER_WIDTH)); } else { - bar = bar.push(hamburger(false, text_color)); + bar = bar.push(hamburger(false, text_color, window)); } let menubar = container(bar) @@ -4032,14 +4971,14 @@ fn main_view(state: &Moorly) -> Element<'_, Message> { .align_y(Alignment::Center) .padding(Padding { top: 0.0, - right: 8.0, + right: MENUBAR_RIGHT_PADDING, bottom: 0.0, - left: 5.0, + left: TAB_STRIP_LEFT, }) .style(move |theme| theme::menubar(theme, sidebar_background)); - let main_area: Element<'_, Message> = match state.active_tab { - Some(Tab::Start) => start_page(state), + let main_area: Element<'_, Message> = match active_tab { + Some(Tab::Start) => start_page(state, window), Some(Tab::Settings) => settings_page(state), _ => container(column![]) .width(Length::Fill) @@ -4057,11 +4996,26 @@ fn main_view(state: &Moorly) -> Element<'_, Message> { }); let base = column![menubar, main_area]; + let ghost = drag_ghost(state, window, colors); + let drop_bar = tab_drop_bar(state, window, colors); + let drop_panel = drop_panel(state, window, colors); - if !state.menu_open { + if !menu_open { // Keep the root a `stack` so the tab strip's scroll state survives // opening/closing the menu. - return stack![base].into(); + let mut root = stack![base]; + + if let Some(ghost) = ghost { + root = root.push(ghost); + } + if let Some(drop_bar) = drop_bar { + root = root.push(drop_bar); + } + if let Some(drop_panel) = drop_panel { + root = root.push(drop_panel); + } + + return root.into(); } let menu_items = column![].spacing(4); @@ -4078,44 +5032,42 @@ fn main_view(state: &Moorly) -> Element<'_, Message> { let mut menu_items = menu_items.push(menu_item( "Settings", settings_shortcut, - Message::SelectTab(Tab::Settings), + Message::SelectTab(window, Tab::Settings), )); if cfg!(debug_assertions) { menu_items = menu_items.push(menu_item( "temp Add Tab", Some("Ctrl+Shift+T".to_owned()), - Message::AddTab, + Message::AddTab(window), )); } let menu_items = menu_items - .push(menu_item("Tabs", None, Message::ToggleTabsSubmenu)) + .push(menu_item("Tabs", None, Message::ToggleTabsSubmenu(window))) .push(rule::horizontal(1)) .push(menu_item("Quit", quit_shortcut, 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(16), - container(rule::vertical(1)).height(12).padding([0, 6]), - ] - .align_y(Alignment::Center), - ) - .height(MENU_ITEM_HEIGHT) - .padding(Padding::ZERO.top(4.0)) - .align_y(Alignment::Start), - ], - ) + let tabs_marker = container(column![ + space::vertical().height(tabs_row_top()), + container( + row![ + text("◀").size(16), + container(rule::vertical(1)).height(12).padding([0, 6]), + ] + .align_y(Alignment::Center), + ) + .height(MENU_ITEM_HEIGHT) + .padding(Padding::ZERO.top(4.0)) + .align_y(Alignment::Start), + ]) .width(24); let menu = container( column![ - container(hamburger(true, text_color)) + container(hamburger(true, text_color, window)) .width(Length::Fill) .height(HAMBURGER_ROW_HEIGHT) .align_x(Alignment::End) @@ -4133,9 +5085,13 @@ fn main_view(state: &Moorly) -> Element<'_, Message> { menu_item( "Close Active Tab", Some("Ctrl+Shift+W".to_owned()), - Message::CloseActiveTab, + Message::CloseActiveTab(window), + ), + menu_item( + "Close all other tabs", + None, + Message::CloseOtherTabs(window), ), - menu_item("Close all other tabs", None, Message::CloseOtherTabs), ] .spacing(4), ) @@ -4144,11 +5100,11 @@ fn main_view(state: &Moorly) -> Element<'_, Message> { .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 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 { + if tabs_submenu_open { dropdown_row = dropdown_row.push(tabs_submenu); } dropdown_row = dropdown_row.push(menu); @@ -4166,17 +5122,28 @@ fn main_view(state: &Moorly) -> Element<'_, Message> { .width(Length::Fill) .height(Length::Fill), ) - .on_press(Message::CloseMenu); + .on_press(Message::CloseMenu(window)); - stack![base, backdrop, dropdown] + let mut root = stack![base, backdrop, dropdown] .width(Length::Fill) - .height(Length::Fill) - .into() + .height(Length::Fill); + + if let Some(ghost) = ghost { + root = root.push(ghost); + } + if let Some(drop_bar) = drop_bar { + root = root.push(drop_bar); + } + if let Some(drop_panel) = drop_panel { + root = root.push(drop_panel); + } + + root.into() } /// The application content with the notification stack rendered above it. -fn view(state: &Moorly) -> Element<'_, Message> { - let content = main_view(state); +fn view(state: &Moorly, window: window::Id) -> Element<'_, Message> { + let content = main_view(state, window); if state.notifications.is_empty() { return content; @@ -4203,10 +5170,30 @@ mod tests { use super::{Message, Moorly, Tab, theme, update}; use iced::keyboard; + fn test_window() -> iced::window::Id { + static WINDOW: std::sync::OnceLock = std::sync::OnceLock::new(); + + *WINDOW.get_or_init(iced::window::Id::unique) + } + + fn window_state(state: &Moorly) -> &super::WindowState { + &state.windows[&test_window()] + } + + fn window_state_mut(state: &mut Moorly) -> &mut super::WindowState { + state.windows.get_mut(&test_window()).unwrap() + } + fn state() -> Moorly { + let window = test_window(); + let window_state = super::WindowState::new(false, iced::Size::new(1024.0, 768.0)); + Moorly { - menu_open: false, - tabs_submenu_open: false, + windows: [(window, window_state)].into_iter().collect(), + window_order: vec![window], + main_window: Some(window), + focused_window: Some(window), + drag: None, theme: theme::Preference::default(), saved_theme: theme::Preference::default(), theme_choice: super::ThemeChoice::BuiltIn(theme::Preference::default()), @@ -4217,8 +5204,6 @@ mod tests { shortcuts: super::Shortcuts::default(), saved_shortcuts: super::Shortcuts::default(), shortcut_capture: None, - tabs: Vec::new(), - active_tab: None, settings_section: super::SettingsSection::default(), pending_settings_section: None, show_start_tab: true, @@ -4248,20 +5233,21 @@ mod tests { profile_dialog: None, dir_picker: None, next_blank_tab: 1, - tab_offset: 0.0, - tab_viewport_width: 0.0, - tab_content_width: 0.0, notifications: super::notifications::NotificationManager::default(), } } #[test] fn start_tab_follows_the_saved_setting() { - let state = Moorly::default(); + let (state, _) = super::boot(); + let window = state.windows.keys().next().copied().unwrap(); let expected = state.show_start_tab.then_some(Tab::Start); - assert_eq!(state.tabs, expected.into_iter().collect::>()); - assert_eq!(state.active_tab, expected); + assert_eq!( + state.windows[&window].tabs, + expected.into_iter().collect::>() + ); + assert_eq!(state.windows[&window].active_tab, expected); assert_eq!(Tab::Start.title(), "Start"); } @@ -4274,13 +5260,7 @@ mod tests { fade.go_mut(false, start); assert!(fade.interpolate(0.0, 1.0, start) > 0.99); - assert!( - fade.interpolate( - 0.0, - 1.0, - start + iced::time::Duration::from_millis(250) - ) < 0.01 - ); + assert!(fade.interpolate(0.0, 1.0, start + iced::time::Duration::from_millis(250)) < 0.01); } #[test] @@ -4297,7 +5277,11 @@ mod tests { state.pending_settings_section, Some(super::SettingsSection::Startup) ); - assert!(state.fade_animation.is_animating(iced::time::Instant::now())); + assert!( + state + .fade_animation + .is_animating(iced::time::Instant::now()) + ); let later = iced::time::Instant::now() + iced::time::Duration::from_secs(1); let _ = update(&mut state, Message::Frame(later)); @@ -4384,7 +5368,10 @@ mod tests { assert!(text.contains("[shortcuts]")); assert_eq!(parsed["general"]["fade_settings"].as_bool(), Some(false)); assert_eq!(parsed["appearance"]["theme"].as_str(), Some("dark")); - assert_eq!(parsed["appearance"]["toast"]["enabled"].as_bool(), Some(true)); + assert_eq!( + parsed["appearance"]["toast"]["enabled"].as_bool(), + Some(true) + ); assert_eq!( parsed["appearance"]["toast"]["info"].as_str(), Some("#010203") @@ -4420,7 +5407,11 @@ mod tests { Some("Ctrl+Shift+K".to_owned()) ); assert_eq!( - state.saved_shortcuts.settings.as_ref().map(ToString::to_string), + state + .saved_shortcuts + .settings + .as_ref() + .map(ToString::to_string), Some("Ctrl+,".to_owned()) ); @@ -4582,7 +5573,8 @@ mod tests { assert!(loaded.toast.enabled); assert_eq!( - loaded.toast.colors(theme::Preference::Dark)[super::ToastColorOption::Background.index()], + loaded.toast.colors(theme::Preference::Dark) + [super::ToastColorOption::Background.index()], iced::Color::from_rgb8(1, 2, 3) ); } @@ -4592,13 +5584,7 @@ mod tests { let mut state = state(); let tab = Tab::Start; - let _ = update( - &mut state, - Message::HoverTab { - tab, - hovered: true, - }, - ); + let _ = update(&mut state, Message::HoverTab { tab, hovered: true }); let later = iced::time::Instant::now() + iced::time::Duration::from_secs(1); let fade = state.tab_close_fades.get(&tab).unwrap(); @@ -4620,107 +5606,233 @@ mod tests { #[test] fn tab_scroll_buttons_follow_the_viewport() { let mut state = state(); - state.tab_viewport_width = 200.0; - state.tab_content_width = 500.0; + let window = test_window(); + { + let window_state = window_state_mut(&mut state); + // 315px window => 200px strip; five tabs overflow at the min width. + window_state.size = iced::Size::new(315.0, 768.0); + window_state.tabs = (1..=5).map(Tab::Blank).collect(); + } - state.tab_offset = 0.0; - assert_eq!(super::tab_scroll_limits(&state), (false, true)); + window_state_mut(&mut state).tab_offset = 0.0; + assert_eq!(super::tab_scroll_limits(&state, window), (false, true)); - state.tab_offset = 150.0; - assert_eq!(super::tab_scroll_limits(&state), (true, true)); + window_state_mut(&mut state).tab_offset = 150.0; + assert_eq!(super::tab_scroll_limits(&state, window), (true, true)); - state.tab_offset = 300.0; - assert_eq!(super::tab_scroll_limits(&state), (true, false)); + window_state_mut(&mut state).tab_offset = 310.0; + assert_eq!(super::tab_scroll_limits(&state, window), (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); + let window = test_window(); + let _ = update(&mut state, Message::SelectTab(window, Tab::Settings)); + let _ = update(&mut state, Message::AddTab(window)); + let _ = update(&mut state, Message::AddTab(window)); + let window_state = window_state(&state); assert_eq!( - state.tabs, + window_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"); + assert_eq!(window_state.active_tab, Some(Tab::Blank(2))); + assert_eq!(window_state.tabs[1].title(), "temp 1"); + assert_eq!(window_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 = 10.0 * super::TAB_MIN_WIDTH + 9.0 * super::TAB_SPACING; + let window = test_window(); + { + let window_state = window_state_mut(&mut state); + // 515px window => 400px strip; ten tabs overflow at the min width. + window_state.size = iced::Size::new(515.0, 768.0); + window_state.tabs = (1..=10).map(Tab::Blank).collect(); + window_state.active_tab = Some(Tab::Blank(10)); + } - state.tab_offset = 620.0; - assert_eq!(super::tab_reveal_delta(&state), None); + window_state_mut(&mut state).tab_offset = 620.0; + assert_eq!(super::tab_reveal_delta(&state, window), None); - state.tab_offset = 0.0; - assert!(super::tab_reveal_delta(&state).unwrap() > 0.0); + window_state_mut(&mut state).tab_offset = 0.0; + assert!(super::tab_reveal_delta(&state, window).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 window = test_window(); + let _ = update(&mut state, Message::SelectTab(window, Tab::Settings)); + let _ = update(&mut state, Message::AddTab(window)); + let _ = update(&mut state, Message::AddTab(window)); - let _ = update(&mut state, Message::CloseOtherTabs); - assert_eq!(state.tabs, vec![Tab::Blank(2)]); - assert_eq!(state.active_tab, Some(Tab::Blank(2))); + let _ = update(&mut state, Message::CloseOtherTabs(window)); + let window_state = window_state(&state); + assert_eq!(window_state.tabs, vec![Tab::Blank(2)]); + assert_eq!(window_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 window = test_window(); + let _ = update(&mut state, Message::SelectTab(window, Tab::Settings)); + let _ = update(&mut state, Message::AddTab(window)); - let _ = update(&mut state, Message::CloseActiveTab); - assert_eq!(state.tabs, vec![Tab::Settings]); - assert_eq!(state.active_tab, Some(Tab::Settings)); + let _ = update(&mut state, Message::CloseActiveTab(window)); + let window_state = window_state(&state); + assert_eq!(window_state.tabs, vec![Tab::Settings]); + assert_eq!(window_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 window = test_window(); + let _ = update(&mut state, Message::SelectTab(window, Tab::Settings)); + let _ = update(&mut state, Message::AddTab(window)); + let _ = update(&mut state, Message::AddTab(window)); - 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::SelectTab(window, Tab::Blank(1))); + let _ = update(&mut state, Message::CloseTab(window, Tab::Blank(1))); + assert_eq!(window_state(&state).active_tab, Some(Tab::Blank(2))); - let _ = update(&mut state, Message::CloseTab(Tab::Blank(2))); - assert_eq!(state.active_tab, Some(Tab::Settings)); + let _ = update(&mut state, Message::CloseTab(window, Tab::Blank(2))); + assert_eq!(window_state(&state).active_tab, Some(Tab::Settings)); } #[test] - fn closing_active_tab_unloads_it() { + fn closing_the_last_tab_unloads_the_window() { let mut state = state(); - let _ = update(&mut state, Message::SelectTab(Tab::Settings)); - assert_eq!(state.tabs, vec![Tab::Settings]); - assert_eq!(state.active_tab, Some(Tab::Settings)); + let window = test_window(); + let _ = update(&mut state, Message::SelectTab(window, Tab::Settings)); + assert_eq!(window_state(&state).tabs, vec![Tab::Settings]); + assert_eq!(window_state(&state).active_tab, Some(Tab::Settings)); - let _ = update(&mut state, Message::SelectSettingsSection(super::SettingsSection::Startup)); - let _ = update(&mut state, Message::CloseTab(Tab::Settings)); - assert!(state.tabs.is_empty()); - assert_eq!(state.active_tab, None); + let _ = update( + &mut state, + Message::SelectSettingsSection(super::SettingsSection::Startup), + ); + let _ = update(&mut state, Message::CloseTab(window, Tab::Settings)); + assert!(!state.windows.contains_key(&window)); + assert!(state.window_order.is_empty()); assert_eq!(state.settings_section, super::SettingsSection::General); } + #[test] + fn dragging_reorders_tabs_and_moving_the_last_tab_closes_the_window() { + let mut state = state(); + let window = test_window(); + let _ = update(&mut state, Message::SelectTab(window, Tab::Settings)); + let _ = update(&mut state, Message::AddTab(window)); + let _ = update(&mut state, Message::AddTab(window)); + + // 1024px window => 909px strip => 230px tabs with 2px gaps. + state.drag = Some(super::TabDrag { + window, + tab: Tab::Settings, + origin: iced::Point::new(10.0, 20.0), + pointer: iced::Point::new(585.0, 20.0), + moved: true, + detach: false, + }); + + // The move is pending until release. + assert_eq!( + window_state(&state).tabs, + vec![Tab::Settings, Tab::Blank(1), Tab::Blank(2)] + ); + assert_eq!(super::tab_gap_index(&state, window, 585.0), Some(3)); + + let _ = super::finish_drag(&mut state, window); + assert_eq!( + window_state(&state).tabs, + vec![Tab::Blank(1), Tab::Blank(2), Tab::Settings] + ); + + let destination = iced::window::Id::unique(); + state.windows.insert( + destination, + super::WindowState::with_tab(Tab::Blank(9), iced::Size::new(800.0, 600.0), None), + ); + state.window_order.push(destination); + + let source = window_state_mut(&mut state); + source.tabs = vec![Tab::Settings]; + source.active_tab = Some(Tab::Settings); + + super::move_tab_to_window(&mut state, window, destination, Tab::Settings); + let _ = super::close_window_if_empty(&mut state, window); + + assert!(!state.windows.contains_key(&window)); + assert_eq!(state.windows[&destination].active_tab, Some(Tab::Settings)); + assert_eq!( + super::window_title(&state, destination), + "Settings - Moorly" + ); + } + + #[test] + fn drop_panel_selects_the_window_under_the_pointer() { + let mut state = state(); + let source = test_window(); + let destination = iced::window::Id::unique(); + state.windows.insert( + destination, + super::WindowState::with_tab(Tab::Blank(9), iced::Size::new(800.0, 600.0), None), + ); + state.window_order.push(destination); + + let rect = super::drop_panel_rect(window_state(&state), 1); + let row_y = rect.y + + super::DROP_PANEL_PADDING + + super::DROP_HEADER_HEIGHT + + super::DROP_ROW_GAP + + super::DROP_ROW_HEIGHT / 2.0; + let point = iced::Point::new(rect.x + 10.0, row_y); + + assert_eq!( + super::drop_target_at(&state, source, point), + Some(destination) + ); + assert_eq!( + super::drop_target_at(&state, source, iced::Point::new(0.0, 0.0)), + None + ); + } + + #[test] + fn dragging_near_an_edge_requests_autoscroll() { + let mut state = state(); + let window = test_window(); + window_state_mut(&mut state).tabs = (1..=20).map(Tab::Blank).collect(); + + let viewport = super::tab_strip_width(1024.0); + state.drag = Some(super::TabDrag { + window, + tab: Tab::Blank(1), + origin: iced::Point::new(10.0, 20.0), + pointer: iced::Point::new(super::TAB_STRIP_LEFT + viewport - 2.0, 20.0), + moved: true, + detach: false, + }); + assert!(super::drag_scroll_delta(&state).unwrap() > 0.0); + + state.drag.as_mut().unwrap().pointer = iced::Point::new(6.0, 20.0); + assert!(super::drag_scroll_delta(&state).unwrap() < 0.0); + } + #[test] fn shortcuts_round_trip_through_text() { let shortcut = super::Shortcut::parse("ctrl+shift+k").unwrap(); assert_eq!(shortcut.to_string(), "Ctrl+Shift+K"); - assert_eq!(super::Shortcut::parse("Ctrl+,").unwrap().to_string(), "Ctrl+,"); + assert_eq!( + super::Shortcut::parse("Ctrl+,").unwrap().to_string(), + "Ctrl+," + ); assert_eq!(super::Shortcut::parse("Ctrl+"), None); assert_eq!(super::Shortcut::parse("Hyper+K"), None); } @@ -4744,7 +5856,14 @@ mod tests { ), ); assert_eq!( - state.shortcut_capture.as_ref().unwrap().candidate.as_ref().unwrap().to_string(), + state + .shortcut_capture + .as_ref() + .unwrap() + .candidate + .as_ref() + .unwrap() + .to_string(), "Ctrl+Shift+K" ); @@ -4815,7 +5934,10 @@ mod tests { ); let _ = update( &mut state, - press(keyboard::Key::Character("k".into()), keyboard::Modifiers::NONE), + press( + keyboard::Key::Character("k".into()), + keyboard::Modifiers::NONE, + ), ); assert!(state.shortcut_capture.as_ref().unwrap().candidate.is_none()); @@ -4950,9 +6072,15 @@ mod tests { let mut state = state(); let _ = update(&mut state, Message::OpenProfileDialog); let _ = update(&mut state, Message::ProfileNameChanged("Server".to_owned())); - let _ = update(&mut state, Message::ProfileHostChanged("example.com".to_owned())); + let _ = update( + &mut state, + Message::ProfileHostChanged("example.com".to_owned()), + ); let _ = update(&mut state, Message::ProfilePortChanged("2222".to_owned())); - let _ = update(&mut state, Message::ProfileUsernameChanged("root".to_owned())); + let _ = update( + &mut state, + Message::ProfileUsernameChanged("root".to_owned()), + ); let _ = update( &mut state, Message::ProfilePasswordChanged("hunter2".to_owned()), @@ -5063,11 +6191,7 @@ mod tests { let child = root.join("child"); std::fs::create_dir_all(&child).unwrap(); - let picker = super::DirPicker::open( - root.clone(), - false, - super::PickerTarget::StartPath, - ); + let picker = super::DirPicker::open(root.clone(), false, super::PickerTarget::StartPath); assert_eq!(picker.entries, vec![child]); assert!(picker.error.is_none());