Added tab handling, tab scroll, wheel scrolling for tabs
This commit is contained in:
1 parent
143f43a407
commit
1f5da251dc
1 file changed
+430
-51
+430
-51
@@ -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)
|
||||
.align_y(Alignment::Center);
|
||||
.on_scroll(Message::TabsScrolled);
|
||||
|
||||
// Convert vertical wheel input into horizontal tab-strip scrolling.
|
||||
let tab_strip = mouse_area(tab_strip).on_scroll(Message::ScrollTabs);
|
||||
|
||||
let (can_scroll_left, can_scroll_right) = tab_scroll_limits(state);
|
||||
|
||||
let mut bar = row![
|
||||
tab_strip,
|
||||
scroll_button("◀", -TAB_SCROLL_STEP, can_scroll_left),
|
||||
scroll_button("▶", TAB_SCROLL_STEP, can_scroll_right),
|
||||
]
|
||||
.spacing(2)
|
||||
.align_y(Alignment::Center);
|
||||
|
||||
let mut bar = row![tabs].align_y(Alignment::Center);
|
||||
if state.menu_open {
|
||||
// The dropdown draws the close button over this spot.
|
||||
bar = bar.push(space::horizontal().width(HAMBURGER_WIDTH));
|
||||
@@ -291,7 +518,7 @@ fn view(state: &Moorly) -> Element<'_, Message> {
|
||||
|
||||
let main_area: Element<'_, Message> = match state.active_tab {
|
||||
Some(Tab::Settings) => settings_page(state),
|
||||
None => container(column![])
|
||||
_ => container(column![])
|
||||
.width(Length::Fill)
|
||||
.height(Length::Fill)
|
||||
.into(),
|
||||
@@ -300,54 +527,116 @@ fn view(state: &Moorly) -> Element<'_, Message> {
|
||||
let base = column![menubar, main_area];
|
||||
|
||||
if !state.menu_open {
|
||||
return base.into();
|
||||
// Keep the root a `stack` so the tab strip's scroll state survives
|
||||
// opening/closing the menu.
|
||||
return stack![base].into();
|
||||
}
|
||||
|
||||
let theme_field = stack![
|
||||
container(
|
||||
pick_list(
|
||||
theme::Preference::ALL,
|
||||
Some(state.theme),
|
||||
Message::SetTheme
|
||||
let theme_field = container(
|
||||
stack![
|
||||
container(
|
||||
pick_list(
|
||||
theme::Preference::ALL,
|
||||
Some(state.theme),
|
||||
Message::SetTheme
|
||||
)
|
||||
.width(Length::Fill),
|
||||
)
|
||||
.width(Length::Fill),
|
||||
)
|
||||
.width(Length::Fill)
|
||||
.padding(Padding::ZERO.top(6.0)),
|
||||
container(
|
||||
container(text("Theme").size(11))
|
||||
.padding([0, 4])
|
||||
.style(theme::field_label),
|
||||
)
|
||||
.padding(Padding::ZERO.left(8.0)),
|
||||
]
|
||||
.width(Length::Fill);
|
||||
.width(Length::Fill)
|
||||
.padding(Padding::ZERO.top(6.0)),
|
||||
container(
|
||||
container(text("Theme").size(11))
|
||||
.padding([0, 4])
|
||||
.style(theme::field_label),
|
||||
)
|
||||
.padding(Padding::ZERO.left(8.0)),
|
||||
]
|
||||
.width(Length::Fill),
|
||||
)
|
||||
.width(Length::Fill)
|
||||
.height(THEME_FIELD_HEIGHT)
|
||||
.align_y(Alignment::Center);
|
||||
|
||||
let menu_items = column![theme_field].spacing(4);
|
||||
|
||||
let mut menu_items = menu_items.push(menu_item(
|
||||
"Settings",
|
||||
Some("Ctrl+,"),
|
||||
Message::SelectTab(Tab::Settings),
|
||||
));
|
||||
|
||||
if cfg!(debug_assertions) {
|
||||
menu_items = menu_items.push(menu_item(
|
||||
"temp Add Tab",
|
||||
Some("Ctrl+Shift+T"),
|
||||
Message::AddTab,
|
||||
));
|
||||
}
|
||||
|
||||
let menu_items = menu_items
|
||||
.push(menu_item(
|
||||
"Settings",
|
||||
Some("Ctrl+,"),
|
||||
Message::SelectTab(Tab::Settings),
|
||||
))
|
||||
.push(menu_item("Tabs", None, Message::ToggleTabsSubmenu))
|
||||
.push(rule::horizontal(1))
|
||||
.push(menu_item("Quit", None, Message::Quit));
|
||||
.push(menu_item("Quit", None, Message::Quit))
|
||||
.width(Length::Fill);
|
||||
|
||||
// The `< |` marker owns its own column; menu rows start to its right.
|
||||
let tabs_marker = container(
|
||||
column![
|
||||
space::vertical().height(tabs_row_top()),
|
||||
container(
|
||||
row![
|
||||
text("<").size(12),
|
||||
container(rule::vertical(1)).height(12).padding([0, 6]),
|
||||
]
|
||||
.align_y(Alignment::Center),
|
||||
)
|
||||
.height(MENU_ITEM_HEIGHT)
|
||||
.align_y(Alignment::Center),
|
||||
],
|
||||
)
|
||||
.width(24);
|
||||
|
||||
let menu = container(
|
||||
column![
|
||||
container(hamburger(true))
|
||||
.width(Length::Fill)
|
||||
.align_x(Alignment::End),
|
||||
menu_items,
|
||||
.height(HAMBURGER_ROW_HEIGHT)
|
||||
.align_x(Alignment::End)
|
||||
.align_y(Alignment::Center),
|
||||
row![tabs_marker, menu_items].align_y(Alignment::Start),
|
||||
]
|
||||
.spacing(2),
|
||||
)
|
||||
.width(200)
|
||||
.padding(4)
|
||||
.width(220)
|
||||
.padding(MENU_PADDING)
|
||||
.style(theme::menu);
|
||||
|
||||
let dropdown = container(menu)
|
||||
let tabs_submenu = container(
|
||||
column![
|
||||
menu_item(
|
||||
"Close Active Tab",
|
||||
Some("Ctrl+Shift+W"),
|
||||
Message::CloseActiveTab,
|
||||
),
|
||||
menu_item("Close all other tabs", None, Message::CloseOtherTabs),
|
||||
]
|
||||
.spacing(4),
|
||||
)
|
||||
.width(220)
|
||||
.padding(MENU_PADDING)
|
||||
.style(theme::menu);
|
||||
|
||||
// Push the submenu down so its first row starts level with the Tabs row.
|
||||
let tabs_submenu = container(tabs_submenu)
|
||||
.padding(Padding::ZERO.top(tabs_submenu_top() - MENU_PADDING));
|
||||
|
||||
let mut dropdown_row = row![].spacing(0).align_y(Alignment::Start);
|
||||
if state.tabs_submenu_open {
|
||||
dropdown_row = dropdown_row.push(tabs_submenu);
|
||||
}
|
||||
dropdown_row = dropdown_row.push(menu);
|
||||
|
||||
let dropdown = container(dropdown_row)
|
||||
.width(Length::Fill)
|
||||
.height(Length::Fill)
|
||||
.align_x(Alignment::End)
|
||||
@@ -375,10 +664,15 @@ mod tests {
|
||||
fn state() -> Moorly {
|
||||
Moorly {
|
||||
menu_open: false,
|
||||
tabs_submenu_open: false,
|
||||
theme: theme::Preference::default(),
|
||||
tabs: Vec::new(),
|
||||
active_tab: None,
|
||||
settings_section: super::SettingsSection::default(),
|
||||
next_blank_tab: 1,
|
||||
tab_offset: 0.0,
|
||||
tab_viewport_width: 0.0,
|
||||
tab_content_width: 0.0,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -392,6 +686,91 @@ mod tests {
|
||||
assert_eq!(fitted.chars().count(), 20);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tab_scroll_buttons_follow_the_viewport() {
|
||||
let mut state = state();
|
||||
state.tab_viewport_width = 200.0;
|
||||
state.tab_content_width = 500.0;
|
||||
|
||||
state.tab_offset = 0.0;
|
||||
assert_eq!(super::tab_scroll_limits(&state), (false, true));
|
||||
|
||||
state.tab_offset = 150.0;
|
||||
assert_eq!(super::tab_scroll_limits(&state), (true, true));
|
||||
|
||||
state.tab_offset = 300.0;
|
||||
assert_eq!(super::tab_scroll_limits(&state), (true, false));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn add_tab_appends_a_new_blank_tab() {
|
||||
let mut state = state();
|
||||
let _ = update(&mut state, Message::SelectTab(Tab::Settings));
|
||||
let _ = update(&mut state, Message::AddTab);
|
||||
let _ = update(&mut state, Message::AddTab);
|
||||
|
||||
assert_eq!(
|
||||
state.tabs,
|
||||
vec![Tab::Settings, Tab::Blank(1), Tab::Blank(2)]
|
||||
);
|
||||
assert_eq!(state.active_tab, Some(Tab::Blank(2)));
|
||||
assert_eq!(state.tabs[1].title(), "temp 1");
|
||||
assert_eq!(state.tabs[2].title(), "temp 2");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn revealing_active_tab_only_scrolls_when_needed() {
|
||||
let mut state = state();
|
||||
state.tabs = (1..=10).map(Tab::Blank).collect();
|
||||
state.active_tab = Some(Tab::Blank(10));
|
||||
state.tab_viewport_width = 400.0;
|
||||
state.tab_content_width = 1000.0;
|
||||
|
||||
state.tab_offset = 600.0;
|
||||
assert_eq!(super::tab_reveal_delta(&state), None);
|
||||
|
||||
state.tab_offset = 0.0;
|
||||
assert!(super::tab_reveal_delta(&state).unwrap() > 0.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn close_other_tabs_keeps_only_the_active_one() {
|
||||
let mut state = state();
|
||||
let _ = update(&mut state, Message::SelectTab(Tab::Settings));
|
||||
let _ = update(&mut state, Message::AddTab);
|
||||
let _ = update(&mut state, Message::AddTab);
|
||||
|
||||
let _ = update(&mut state, Message::CloseOtherTabs);
|
||||
assert_eq!(state.tabs, vec![Tab::Blank(2)]);
|
||||
assert_eq!(state.active_tab, Some(Tab::Blank(2)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn close_active_tab_shortcut_closes_selected_tab() {
|
||||
let mut state = state();
|
||||
let _ = update(&mut state, Message::SelectTab(Tab::Settings));
|
||||
let _ = update(&mut state, Message::AddTab);
|
||||
|
||||
let _ = update(&mut state, Message::CloseActiveTab);
|
||||
assert_eq!(state.tabs, vec![Tab::Settings]);
|
||||
assert_eq!(state.active_tab, Some(Tab::Settings));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn closing_selects_the_next_tab_then_the_last() {
|
||||
let mut state = state();
|
||||
let _ = update(&mut state, Message::SelectTab(Tab::Settings));
|
||||
let _ = update(&mut state, Message::AddTab);
|
||||
let _ = update(&mut state, Message::AddTab);
|
||||
|
||||
let _ = update(&mut state, Message::SelectTab(Tab::Blank(1)));
|
||||
let _ = update(&mut state, Message::CloseTab(Tab::Blank(1)));
|
||||
assert_eq!(state.active_tab, Some(Tab::Blank(2)));
|
||||
|
||||
let _ = update(&mut state, Message::CloseTab(Tab::Blank(2)));
|
||||
assert_eq!(state.active_tab, Some(Tab::Settings));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn closing_active_tab_unloads_it() {
|
||||
let mut state = state();
|
||||
|
||||
Reference in new issue
Block a user