use cosmic::{ cosmic_theme, iced::{ alignment::{Horizontal, Vertical}, futures::SinkExt, keyboard::Modifiers, subscription::{self, Subscription}, //TODO: export in cosmic::widget widget::{ horizontal_rule, scrollable::{AbsoluteOffset, Viewport}, }, Alignment, Color, ContentFit, Length, Point, Rectangle, Size, }, theme, widget, Element, }; use mime_guess::MimeGuess; use once_cell::sync::Lazy; use std::{ cell::Cell, cmp::Ordering, collections::HashMap, fmt, fs::{self, Metadata}, path::PathBuf, time::{Duration, Instant}, }; use crate::{ app::Action, config::{IconSizes, TabConfig}, dialog::DialogKind, fl, key_bind::KeyBind, menu, mime_icon::mime_icon, mouse_area, }; const DOUBLE_CLICK_DURATION: Duration = Duration::from_millis(500); const GRID_ITEM_HEIGHT: usize = 116; const GRID_ITEM_WIDTH: usize = 96; //TODO: adjust for locales? const TIME_FORMAT: &'static str = "%a %-d %b %-Y %r"; static SPECIAL_DIRS: Lazy> = Lazy::new(|| { let mut special_dirs = HashMap::new(); if let Some(dir) = dirs::document_dir() { special_dirs.insert(dir, "folder-documents"); } if let Some(dir) = dirs::download_dir() { special_dirs.insert(dir, "folder-download"); } if let Some(dir) = dirs::audio_dir() { special_dirs.insert(dir, "folder-music"); } if let Some(dir) = dirs::picture_dir() { special_dirs.insert(dir, "folder-pictures"); } if let Some(dir) = dirs::public_dir() { special_dirs.insert(dir, "folder-publicshare"); } if let Some(dir) = dirs::template_dir() { special_dirs.insert(dir, "folder-templates"); } if let Some(dir) = dirs::video_dir() { special_dirs.insert(dir, "folder-videos"); } if let Some(dir) = dirs::desktop_dir() { special_dirs.insert(dir, "user-desktop"); } if let Some(dir) = dirs::home_dir() { special_dirs.insert(dir, "user-home"); } special_dirs }); fn button_appearance( theme: &theme::Theme, selected: bool, focused: bool, accent: bool, ) -> widget::button::Appearance { let cosmic = theme.cosmic(); let mut appearance = widget::button::Appearance::new(); if selected { if accent { appearance.background = Some(Color::from(cosmic.accent_color()).into()); appearance.icon_color = Some(Color::from(cosmic.on_accent_color())); appearance.text_color = Some(Color::from(cosmic.on_accent_color())); } else { appearance.background = Some(Color::from(cosmic.bg_component_color()).into()); } } if focused && accent { appearance.outline_width = 1.0; appearance.outline_color = Color::from(cosmic.accent_color()); appearance.border_width = 2.0; appearance.border_color = Color::TRANSPARENT; } appearance.border_radius = cosmic.radius_s().into(); appearance } fn button_style(selected: bool, accent: bool) -> theme::Button { //TODO: move to libcosmic? theme::Button::Custom { active: Box::new(move |focused, theme| button_appearance(theme, selected, focused, accent)), disabled: Box::new(move |theme| button_appearance(theme, selected, false, accent)), hovered: Box::new(move |focused, theme| { button_appearance(theme, selected, focused, accent) }), pressed: Box::new(move |focused, theme| { button_appearance(theme, selected, focused, accent) }), } } pub fn folder_icon(path: &PathBuf, icon_size: u16) -> widget::icon::Handle { widget::icon::from_name(SPECIAL_DIRS.get(path).map_or("folder", |x| *x)) .size(icon_size) .handle() } pub fn folder_icon_symbolic(path: &PathBuf, icon_size: u16) -> widget::icon::Handle { widget::icon::from_name(format!( "{}-symbolic", SPECIAL_DIRS.get(path).map_or("folder", |x| *x) )) .size(icon_size) .handle() } pub fn trash_icon_symbolic(icon_size: u16) -> widget::icon::Handle { let full = match trash::os_limited::list() { Ok(entries) => !entries.is_empty(), Err(_err) => false, }; widget::icon::from_name(if full { "user-trash-full-symbolic" } else { "user-trash-symbolic" }) .size(icon_size) .handle() } //TODO: translate, add more levels? fn format_size(size: u64) -> String { const KB: u64 = 1000; const MB: u64 = 1000 * KB; const GB: u64 = 1000 * MB; const TB: u64 = 1000 * GB; if size >= TB { format!("{:.1} TB", size as f64 / TB as f64) } else if size >= GB { format!("{:.1} GB", size as f64 / GB as f64) } else if size >= MB { format!("{:.1} MB", size as f64 / MB as f64) } else if size >= KB { format!("{:.1} KB", size as f64 / KB as f64) } else { format!("{} B", size) } } #[cfg(not(target_os = "windows"))] fn hidden_attribute(_metadata: &Metadata) -> bool { false } #[cfg(target_os = "windows")] fn hidden_attribute(metadata: &Metadata) -> bool { use std::os::windows::fs::MetadataExt; // https://learn.microsoft.com/en-us/windows/win32/fileio/file-attribute-constants const FILE_ATTRIBUTE_HIDDEN: u32 = 2; metadata.file_attributes() & FILE_ATTRIBUTE_HIDDEN == FILE_ATTRIBUTE_HIDDEN } pub fn scan_path(tab_path: &PathBuf, sizes: IconSizes) -> Vec { let mut items = Vec::new(); match fs::read_dir(tab_path) { Ok(entries) => { for entry_res in entries { let entry = match entry_res { Ok(ok) => ok, Err(err) => { log::warn!("failed to read entry in {:?}: {}", tab_path, err); continue; } }; let name = match entry.file_name().into_string() { Ok(ok) => ok, Err(name_os) => { log::warn!( "failed to parse entry in {:?}: {:?} is not valid UTF-8", tab_path, name_os, ); continue; } }; let metadata = match entry.metadata() { Ok(ok) => ok, Err(err) => { log::warn!( "failed to read metadata for entry in {:?}: {}", tab_path, err ); continue; } }; let hidden = name.starts_with(".") || hidden_attribute(&metadata); let path = entry.path(); let mime_guess = MimeGuess::from_path(&path); let (icon_handle_grid, icon_handle_list) = if metadata.is_dir() { ( folder_icon(&path, sizes.grid()), folder_icon(&path, sizes.list()), ) } else { ( mime_icon(&path, sizes.grid()), mime_icon(&path, sizes.list()), ) }; let children = if metadata.is_dir() { //TODO: calculate children in the background (and make it cancellable?) match fs::read_dir(&path) { Ok(entries) => entries.count(), Err(err) => { log::warn!("failed to read directory {:?}: {}", path, err); 0 } } } else { 0 }; items.push(Item { name, metadata: ItemMetadata::Path { metadata, children }, hidden, path, mime_guess, icon_handle_grid, icon_handle_list, thumbnail_res_opt: match mime_guess.first() { Some(mime) if mime.type_() == "image" => None, _ => Some(Err(())), }, button_id: widget::Id::unique(), pos_opt: Cell::new(None), rect_opt: Cell::new(None), selected: false, click_time: None, }); } } Err(err) => { log::warn!("failed to read directory {:?}: {}", tab_path, err); } } items.sort_by(|a, b| match (a.metadata.is_dir(), b.metadata.is_dir()) { (true, false) => Ordering::Less, (false, true) => Ordering::Greater, _ => lexical_sort::natural_lexical_cmp(&a.name, &b.name), }); items } // This config statement is from trash::os_limited, inverted #[cfg(not(any( target_os = "windows", all( unix, not(target_os = "macos"), not(target_os = "ios"), not(target_os = "android") ) )))] pub fn scan_trash() -> Vec { log::warn!("viewing trash not supported on this platform"); Vec::new() } // This config statement is from trash::os_limited #[cfg(any( target_os = "windows", all( unix, not(target_os = "macos"), not(target_os = "ios"), not(target_os = "android") ) ))] pub fn scan_trash(sizes: IconSizes) -> Vec { let mut items: Vec = Vec::new(); match trash::os_limited::list() { Ok(entries) => { for entry in entries { let metadata = match trash::os_limited::metadata(&entry) { Ok(ok) => ok, Err(err) => { log::warn!("failed to get metadata for trash item {:?}: {}", entry, err); continue; } }; let path = entry.original_path(); let name = entry.name.clone(); let mime_guess = MimeGuess::from_path(&path); let (icon_handle_grid, icon_handle_list) = match metadata.size { trash::TrashItemSize::Entries(_) => ( folder_icon(&path, sizes.grid()), folder_icon(&path, sizes.list()), ), trash::TrashItemSize::Bytes(_) => ( mime_icon(&path, sizes.grid()), mime_icon(&path, sizes.list()), ), }; items.push(Item { name, metadata: ItemMetadata::Trash { metadata, entry }, hidden: false, path, mime_guess, icon_handle_grid, icon_handle_list, thumbnail_res_opt: Some(Err(())), button_id: widget::Id::unique(), pos_opt: Cell::new(None), rect_opt: Cell::new(None), selected: false, click_time: None, }); } } Err(err) => { log::warn!("failed to read trash items: {}", err); } } items.sort_by(|a, b| match (a.metadata.is_dir(), b.metadata.is_dir()) { (true, false) => Ordering::Less, (false, true) => Ordering::Greater, _ => lexical_sort::natural_lexical_cmp(&a.name, &b.name), }); items } #[derive(Clone, Debug, Eq, PartialEq)] pub enum Location { Path(PathBuf), Trash, } impl Location { pub fn scan(&self, sizes: IconSizes) -> Vec { match self { Self::Path(path) => scan_path(path, sizes), Self::Trash => scan_trash(sizes), } } } #[derive(Clone, Debug)] pub enum Command { Action(Action), ChangeLocation(String, Location), FocusButton(widget::Id), FocusTextInput(widget::Id), OpenFile(PathBuf), Scroll(widget::Id, AbsoluteOffset), } #[derive(Clone, Debug)] pub enum Message { Click(Option), Config(TabConfig), ContextAction(Action), ContextMenu(Option), Drag(Option), EditLocation(Option), GoNext, GoPrevious, ItemDown, ItemLeft, ItemRight, ItemUp, Location(Location), LocationUp, Open, Resize(Size), RightClick(usize), Scroll(Viewport), Thumbnail(PathBuf, Result), ToggleShowHidden, View(View), ToggleSort(HeadingOptions), } #[derive(Clone, Debug)] pub enum ItemMetadata { Path { metadata: Metadata, children: usize, }, Trash { metadata: trash::TrashItemMetadata, entry: trash::TrashItem, }, } impl ItemMetadata { pub fn is_dir(&self) -> bool { match self { Self::Path { metadata, .. } => metadata.is_dir(), Self::Trash { metadata, .. } => match metadata.size { trash::TrashItemSize::Entries(_) => true, trash::TrashItemSize::Bytes(_) => false, }, } } } #[derive(Clone)] pub struct Item { pub name: String, pub metadata: ItemMetadata, pub hidden: bool, pub path: PathBuf, pub mime_guess: MimeGuess, pub icon_handle_grid: widget::icon::Handle, pub icon_handle_list: widget::icon::Handle, pub thumbnail_res_opt: Option>, pub button_id: widget::Id, pub pos_opt: Cell>, pub rect_opt: Cell>, pub selected: bool, pub click_time: Option, } impl Item { pub fn property_view(&self, sizes: IconSizes) -> Element { let cosmic_theme::Spacing { space_xxxs, .. } = theme::active().cosmic().spacing; let mut column = widget::column().spacing(space_xxxs); let is_image = if let Some(mime) = self.mime_guess.first() { mime.type_() == "image" && self.path.is_file() } else { false }; column = column.push(widget::row::with_children(vec![ widget::horizontal_space(Length::Fill).into(), if is_image { widget::image::viewer(widget::image::Handle::from_path(&self.path)) .min_scale(1.0) .into() } else { widget::icon::icon(self.icon_handle_grid.clone()) .content_fit(ContentFit::Contain) .size(sizes.grid()) .into() }, widget::horizontal_space(Length::Fill).into(), ])); column = column.push(widget::text::heading(self.name.clone())); if let Some(mime) = self.mime_guess.first() { column = column.push(widget::text(format!("Type: {}", mime))); } //TODO: translate! //TODO: correct display of folder size? match &self.metadata { ItemMetadata::Path { metadata, children } => { if metadata.is_dir() { column = column.push(widget::text(format!("Items: {}", children))); } else { column = column.push(widget::text(format!( "Size: {}", format_size(metadata.len()) ))); } if let Ok(time) = metadata.created() { column = column.push(widget::text(format!( "Created: {}", chrono::DateTime::::from(time).format(TIME_FORMAT) ))); } if let Ok(time) = metadata.modified() { column = column.push(widget::text(format!( "Modified: {}", chrono::DateTime::::from(time).format(TIME_FORMAT) ))); } if let Ok(time) = metadata.accessed() { column = column.push(widget::text(format!( "Accessed: {}", chrono::DateTime::::from(time).format(TIME_FORMAT) ))); } } ItemMetadata::Trash { .. } => { //TODO: trash metadata } } column.into() } } impl fmt::Debug for Item { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_struct("Item") .field("name", &self.name) .field("metadata", &self.metadata) .field("hidden", &self.hidden) .field("path", &self.path) .field("mime_guess", &self.mime_guess) // icon_handles // thumbnail_res_opt .field("button_id", &self.button_id) .field("pos_opt", &self.pos_opt) .field("rect_opt", &self.rect_opt) .field("selected", &self.selected) .field("click_time", &self.click_time) .finish() } } #[derive(Clone, Copy, Debug)] pub enum View { Grid, List, } #[derive(Clone, Copy, Debug, Hash, PartialEq, PartialOrd, Ord, Eq)] pub enum HeadingOptions { Name, Modified, Size, } #[derive(Clone, Debug)] pub struct Tab { //TODO: make more items private pub location: Location, pub context_menu: Option, pub view: View, pub dialog: Option, pub scroll_opt: Option, pub size_opt: Option, pub edit_location: Option, pub edit_location_id: widget::Id, pub history_i: usize, pub history: Vec, pub config: TabConfig, items_opt: Option>, scrollable_id: widget::Id, select_focus: Option, select_shift: Option, sort_name: HeadingOptions, sort_direction: bool, } impl Tab { pub fn new(location: Location, config: TabConfig) -> Self { let history = vec![location.clone()]; let sort_name = HeadingOptions::Name; let sort_direction = true; Self { location, context_menu: None, view: View::Grid, dialog: None, scroll_opt: None, size_opt: None, edit_location: None, edit_location_id: widget::Id::unique(), history_i: 0, history, config, items_opt: None, scrollable_id: widget::Id::unique(), select_focus: None, select_shift: None, sort_name, sort_direction, } } pub fn title(&self) -> String { //TODO: better title match &self.location { Location::Path(path) => { format!("{}", path.display()) } Location::Trash => { fl!("trash") } } } pub fn items_opt(&self) -> Option<&Vec> { self.items_opt.as_ref() } pub fn set_items(&mut self, items: Vec) { self.items_opt = Some(items); self.select_focus = None; } pub fn select_all(&mut self) { self.select_focus = None; if let Some(ref mut items) = self.items_opt { for item in items.iter_mut() { if !self.config.show_hidden && item.hidden { item.selected = false; continue; } item.selected = true; item.click_time = None; } } } pub fn select_none(&mut self) -> bool { self.select_focus = None; let mut had_selection = false; if let Some(ref mut items) = self.items_opt { for item in items.iter_mut() { if item.selected { item.selected = false; had_selection = true; } } } had_selection } pub fn select_name(&mut self, name: &str) { self.select_focus = None; if let Some(ref mut items) = self.items_opt { for (i, item) in items.iter_mut().enumerate() { if item.name == name { self.select_focus = Some(i); item.selected = true; } else { item.selected = false; } } } } fn select_position(&mut self, row: usize, col: usize, mod_shift: bool) -> bool { let mut start = (row, col); let mut end = (row, col); if mod_shift { if self.select_focus.is_none() || self.select_shift.is_none() { // Set select shift to initial state if necessary self.select_shift = self.select_focus; } if let Some(pos) = self.select_shift_pos_opt() { if pos.0 < row || (pos.0 == row && pos.1 < col) { start = pos; } else { end = pos; } } } else { // Clear select shift if the modifier is not set self.select_shift = None; }; let mut found = false; if let Some(ref mut items) = self.items_opt { for (i, item) in items.iter_mut().enumerate() { item.selected = false; let pos = match item.pos_opt.get() { Some(some) => some, None => continue, }; if pos.0 < start.0 || (pos.0 == start.0 && pos.1 < start.1) { // Before start continue; } if pos.0 > end.0 || (pos.0 == end.0 && pos.1 > end.1) { // After end continue; } if pos == (row, col) { // Update focus if this is what we wanted to select self.select_focus = Some(i); } item.selected = true; found = true; } } found } pub fn select_rect(&mut self, rect: Rectangle) { self.select_focus = None; if let Some(ref mut items) = self.items_opt { for (_i, item) in items.iter_mut().enumerate() { //TODO: modifiers item.selected = match item.rect_opt.get() { Some(item_rect) => item_rect.intersects(&rect), None => false, }; } } } fn select_focus_id(&self) -> Option { let items = self.items_opt.as_ref()?; let item = items.get(self.select_focus?)?; Some(item.button_id.clone()) } fn select_focus_pos_opt(&self) -> Option<(usize, usize)> { let items = self.items_opt.as_ref()?; let item = items.get(self.select_focus?)?; item.pos_opt.get() } fn select_focus_scroll(&mut self) -> Option { let items = self.items_opt.as_ref()?; let item = items.get(self.select_focus?)?; let rect = item.rect_opt.get()?; //TODO: move to function let visible_rect = { let point = match self.scroll_opt { Some(offset) => Point::new(0.0, offset.y), None => Point::new(0.0, 0.0), }; let size = self.size_opt.unwrap_or_else(|| Size::new(0.0, 0.0)); Rectangle::new(point, size) }; if rect.y < visible_rect.y { // Scroll up to rect self.scroll_opt = Some(AbsoluteOffset { x: 0.0, y: rect.y }); self.scroll_opt } else if (rect.y + rect.height) > (visible_rect.y + visible_rect.height) { // Scroll down to rect self.scroll_opt = Some(AbsoluteOffset { x: 0.0, y: rect.y + rect.height - visible_rect.height, }); self.scroll_opt } else { // Do not scroll None } } fn select_shift_pos_opt(&self) -> Option<(usize, usize)> { let items = self.items_opt.as_ref()?; let item = items.get(self.select_shift?)?; item.pos_opt.get() } pub fn update(&mut self, message: Message, modifiers: Modifiers) -> Vec { let mut commands = Vec::new(); let mut cd = None; let mut history_i_opt = None; let mod_ctrl = modifiers.contains(Modifiers::CTRL) && self.dialog.as_ref().map_or(true, |x| x.multiple()); let mod_shift = modifiers.contains(Modifiers::SHIFT) && self.dialog.as_ref().map_or(true, |x| x.multiple()); match message { Message::Click(click_i_opt) => { self.select_focus = None; if let Some(ref mut items) = self.items_opt { for (i, item) in items.iter_mut().enumerate() { if Some(i) == click_i_opt { // Filter out selection if it does not match dialog kind if let Some(dialog) = &self.dialog { let item_is_dir = item.path.is_dir(); if item_is_dir != dialog.is_dir() { // Allow selecting folder if dialog is for files to make it // possible to double click //TODO: clear any other selection when selecting a folder if !item_is_dir { continue; } } } self.select_focus = Some(i); item.selected = true; if let Some(click_time) = item.click_time { if click_time.elapsed() < DOUBLE_CLICK_DURATION { match self.location { Location::Path(_) => { if item.path.is_dir() { //TODO: allow opening multiple tabs? cd = Some(Location::Path(item.path.clone())); } else { commands.push(Command::OpenFile(item.path.clone())); } } Location::Trash => { //TODO: open properties? } } } } //TODO: prevent triple-click and beyond from opening file? item.click_time = Some(Instant::now()); } else if mod_ctrl { // Holding control allows multiple selection item.click_time = None; } else { item.selected = false; item.click_time = None; } } } self.context_menu = None; } Message::Config(config) => { self.config = config; } Message::ContextAction(action) => { // Close context menu self.context_menu = None; commands.push(Command::Action(action)); } Message::ContextMenu(point_opt) => { self.context_menu = point_opt; } Message::Drag(rect_opt) => match rect_opt { Some(rect) => { self.select_rect(rect); } None => {} }, Message::EditLocation(edit_location) => { if self.edit_location.is_none() && edit_location.is_some() { commands.push(Command::FocusTextInput(self.edit_location_id.clone())); } self.edit_location = edit_location; } Message::GoNext => { if let Some(history_i) = self.history_i.checked_add(1) { if let Some(location) = self.history.get(history_i) { cd = Some(location.clone()); history_i_opt = Some(history_i); } } } Message::GoPrevious => { if let Some(history_i) = self.history_i.checked_sub(1) { if let Some(location) = self.history.get(history_i) { cd = Some(location.clone()); history_i_opt = Some(history_i); } } } Message::ItemDown => { if let Some((row, col)) = self.select_focus_pos_opt() { //TODO: Shift modifier should select items in between // Try to select item in next row if !self.select_position(row + 1, col, mod_shift) { // Ensure current item is still selected if there are no other items self.select_position(row, col, mod_shift); } } else { // Select first item //TODO: select first in scroll self.select_position(0, 0, mod_shift); } if let Some(offset) = self.select_focus_scroll() { commands.push(Command::Scroll(self.scrollable_id.clone(), offset)); } if let Some(id) = self.select_focus_id() { commands.push(Command::FocusButton(id)); } } Message::ItemLeft => { if let Some((row, col)) = self.select_focus_pos_opt() { // Try to select previous item in current row if !col .checked_sub(1) .map_or(false, |col| self.select_position(row, col, mod_shift)) { // Try to select last item in previous row if !row.checked_sub(1).map_or(false, |row| { let mut col = 0; if let Some(ref items) = self.items_opt { for item in items.iter() { match item.pos_opt.get() { Some((item_row, item_col)) if item_row == row => { col = col.max(item_col); } _ => continue, } } } self.select_position(row, col, mod_shift) }) { // Ensure current item is still selected if there are no other items self.select_position(row, col, mod_shift); } } } else { // Select first item //TODO: select first in scroll self.select_position(0, 0, mod_shift); } if let Some(offset) = self.select_focus_scroll() { commands.push(Command::Scroll(self.scrollable_id.clone(), offset)); } if let Some(id) = self.select_focus_id() { commands.push(Command::FocusButton(id)); } } Message::ItemRight => { if let Some((row, col)) = self.select_focus_pos_opt() { // Try to select next item in current row if !self.select_position(row, col + 1, mod_shift) { // Try to select first item in next row if !self.select_position(row + 1, 0, mod_shift) { // Ensure current item is still selected if there are no other items self.select_position(row, col, mod_shift); } } } else { // Select first item //TODO: select first in scroll self.select_position(0, 0, mod_shift); } if let Some(offset) = self.select_focus_scroll() { commands.push(Command::Scroll(self.scrollable_id.clone(), offset)); } if let Some(id) = self.select_focus_id() { commands.push(Command::FocusButton(id)); } } Message::ItemUp => { if let Some((row, col)) = self.select_focus_pos_opt() { //TODO: Shift modifier should select items in between // Try to select item in last row if !row .checked_sub(1) .map_or(false, |row| self.select_position(row, col, mod_shift)) { // Ensure current item is still selected if there are no other items self.select_position(row, col, mod_shift); } } else { // Select first item //TODO: select first in scroll self.select_position(0, 0, mod_shift); } if let Some(offset) = self.select_focus_scroll() { commands.push(Command::Scroll(self.scrollable_id.clone(), offset)); } if let Some(id) = self.select_focus_id() { commands.push(Command::FocusButton(id)); } } Message::Location(location) => { cd = Some(location); } Message::LocationUp => { // Sets location to the path's parent // Does nothing if path is root or location is Trash if let Location::Path(ref path) = self.location { if let Some(parent) = path.parent() { cd = Some(Location::Path(parent.to_owned())); } } } Message::Open => { if let Some(ref mut items) = self.items_opt { for item in items.iter() { if item.selected { match self.location { Location::Path(_) => { if item.path.is_dir() { //TODO: allow opening multiple tabs? cd = Some(Location::Path(item.path.clone())); } else { commands.push(Command::OpenFile(item.path.clone())); } } Location::Trash => { //TODO: open properties? } } } } } } Message::Resize(size) => { self.size_opt = Some(size); } Message::RightClick(click_i) => { if let Some(ref mut items) = self.items_opt { if !items.get(click_i).map_or(false, |x| x.selected) { // If item not selected, clear selection on other items for (i, item) in items.iter_mut().enumerate() { if i == click_i { item.selected = true; } else if mod_ctrl { // Holding control allows multiple selection } else { item.selected = false; } item.click_time = None; } } } } Message::Scroll(viewport) => { self.scroll_opt = Some(viewport.absolute_offset()); } Message::Thumbnail(path, thumbnail_res) => { if let Some(ref mut items) = self.items_opt { for item in items.iter_mut() { if item.path == path { if let Ok(thumbnail) = &thumbnail_res { //TODO: pass handles already generated to avoid blocking main thread let handle = widget::icon::from_raster_pixels( thumbnail.width(), thumbnail.height(), thumbnail.as_raw().clone(), ); item.icon_handle_grid = handle.clone(); item.icon_handle_list = handle; } item.thumbnail_res_opt = Some(thumbnail_res); break; } } } } Message::ToggleShowHidden => self.config.show_hidden = !self.config.show_hidden, Message::View(view) => { self.view = view; } Message::ToggleSort(heading_option) => { let heading_sort = if self.sort_name == heading_option { !self.sort_direction } else { true }; self.sort_direction = heading_sort; self.sort_name = heading_option; } } if let Some(location) = cd { if location != self.location { self.location = location.clone(); self.items_opt = None; self.select_focus = None; self.edit_location = None; if let Some(history_i) = history_i_opt { // Navigating in history self.history_i = history_i; } else { // Truncate history to remove next entries self.history.truncate(self.history_i + 1); // Push to the front of history self.history_i = self.history.len(); self.history.push(location.clone()); } commands.push(Command::ChangeLocation(self.title(), location)); } } commands } fn column_sort(&self) -> Option> { let check_reverse = |ord: Ordering, sort: bool| { if sort { ord } else { ord.reverse() } }; let mut items: Vec<&Item> = self.items_opt.as_ref()?.iter().collect(); let heading_sort = self.sort_direction; match self.sort_name { HeadingOptions::Size => { items.sort_by(|a, b| { // entries take precedence over size let get_size = |x: &Item| match &x.metadata { ItemMetadata::Path { metadata, children } => { if metadata.is_dir() { (true, *children as u64) } else { (false, metadata.len()) } } ItemMetadata::Trash { metadata, .. } => match metadata.size { trash::TrashItemSize::Entries(entries) => (true, entries as u64), trash::TrashItemSize::Bytes(bytes) => (false, bytes), }, }; let (a_is_entry, a_size) = get_size(a); let (b_is_entry, b_size) = get_size(b); let ord = match (a_is_entry, b_is_entry) { (true, false) => Ordering::Less, (false, true) => Ordering::Greater, _ => a_size.cmp(&b_size), }; check_reverse(ord, heading_sort) }) } HeadingOptions::Name => items.sort_by(|a, b| { let ord = match (a.path.is_dir(), b.path.is_dir()) { (true, false) => Ordering::Less, (false, true) => Ordering::Greater, _ => lexical_sort::natural_lexical_cmp(&a.name, &b.name), }; check_reverse(ord, heading_sort) }), HeadingOptions::Modified => { items.sort_by(|a, b| { let get_modified = |x: &Item| match &x.metadata { ItemMetadata::Path { metadata, .. } => metadata.modified().ok(), ItemMetadata::Trash { .. } => None, }; let a = get_modified(a); let b = get_modified(b); check_reverse(a.cmp(&b), heading_sort) }); } } Some(items) } pub fn location_view(&self) -> Element { let cosmic_theme::Spacing { space_xxxs, space_xxs, space_s, .. } = theme::active().cosmic().spacing; let mut row = widget::row::with_capacity(5).align_items(Alignment::Center); let mut prev_button = widget::button(widget::icon::from_name("go-previous-symbolic").size(16)) .padding(space_xxs) .style(theme::Button::Icon); if self.history_i > 0 && !self.history.is_empty() { prev_button = prev_button.on_press(Message::GoPrevious); } row = row.push(prev_button); let mut next_button = widget::button(widget::icon::from_name("go-next-symbolic").size(16)) .padding(space_xxs) .style(theme::Button::Icon); if self.history_i + 1 < self.history.len() { next_button = next_button.on_press(Message::GoNext); } row = row.push(next_button); row = row.push(widget::horizontal_space(Length::Fixed(space_s.into()))); if let Some(location) = &self.edit_location { match location { Location::Path(path) => { row = row.push( widget::button(widget::icon::from_name("window-close-symbolic").size(16)) .on_press(Message::EditLocation(None)) .padding(space_xxs) .style(theme::Button::Icon), ); row = row.push( widget::text_input("", path.to_string_lossy()) .id(self.edit_location_id.clone()) .on_input(|input| { Message::EditLocation(Some(Location::Path(PathBuf::from(input)))) }) .on_submit(Message::Location(location.clone())), ); return row.into(); } _ => { //TODO: allow editing other locations } } } else if let Location::Path(_) = &self.location { row = row.push( widget::button(widget::icon::from_name("edit-symbolic").size(16)) .on_press(Message::EditLocation(Some(self.location.clone()))) .padding(space_xxs) .style(theme::Button::Icon), ); } let mut children: Vec> = Vec::new(); match &self.location { Location::Path(path) => { let home_dir = crate::home_dir(); for ancestor in path.ancestors() { let ancestor = ancestor.to_path_buf(); let mut found_home = false; let mut row = widget::row::with_capacity(2) .align_items(Alignment::Center) .spacing(space_xxxs); let name = match ancestor.file_name() { Some(name) => { if ancestor == home_dir { row = row.push( widget::icon::icon(folder_icon_symbolic(&ancestor, 16)) .size(16), ); found_home = true; fl!("home") } else { name.to_string_lossy().to_string() } } None => { row = row.push( widget::icon::from_name("drive-harddisk-system-symbolic") .size(16) .icon(), ); fl!("filesystem") } }; if children.is_empty() { row = row.push(widget::text::heading(name)); } else { children.push( widget::icon::from_name("go-next-symbolic") .size(16) .icon() .into(), ); row = row.push(widget::text(name)); } children.push( widget::button(row) .padding(space_xxxs) .on_press(Message::Location(Location::Path(ancestor))) .style(theme::Button::Link) .into(), ); if found_home { break; } } children.reverse(); } Location::Trash => { let mut row = widget::row::with_capacity(2) .align_items(Alignment::Center) .spacing(space_xxxs); row = row.push(widget::icon::icon(trash_icon_symbolic(16)).size(16)); row = row.push(widget::text::heading(fl!("trash"))); children.push( widget::button(row) .padding(space_xxxs) .on_press(Message::Location(Location::Trash)) .style(theme::Button::Text) .into(), ); } } for child in children { row = row.push(child); } row.into() } pub fn empty_view(&self, has_hidden: bool) -> Element { let cosmic_theme::Spacing { space_xxs, .. } = theme::active().cosmic().spacing; widget::column::with_children(vec![widget::container( widget::column::with_children(vec![ widget::icon::from_name("folder-symbolic") .size(64) .icon() .into(), widget::text(if has_hidden { fl!("empty-folder-hidden") } else { fl!("empty-folder") }) .into(), ]) .align_items(Alignment::Center) .spacing(space_xxs), ) .align_x(Horizontal::Center) .align_y(Vertical::Center) .width(Length::Fill) .height(Length::Fill) .into()]) .into() } pub fn grid_view(&self) -> Element { let cosmic_theme::Spacing { space_m, space_xxs, space_xxxs, .. } = theme::active().cosmic().spacing; let TabConfig { show_hidden, icon_sizes, } = self.config; let (width, height) = match self.size_opt { Some(size) => ( (size.width.floor() as usize) .checked_sub(2 * (space_m as usize)) .unwrap_or(0) .max(GRID_ITEM_WIDTH), (size.height.floor() as usize).max(GRID_ITEM_HEIGHT), ), None => (GRID_ITEM_WIDTH, GRID_ITEM_HEIGHT), }; let (cols, column_spacing) = { let width_m1 = width.checked_sub(GRID_ITEM_WIDTH).unwrap_or(0); let cols_m1 = width_m1 / (GRID_ITEM_WIDTH + space_xxs as usize); let cols = cols_m1 + 1; let spacing = width_m1 .checked_div(cols_m1) .unwrap_or(0) .checked_sub(GRID_ITEM_WIDTH) .unwrap_or(0); (cols, spacing as u16) }; let mut grid = widget::grid() .column_spacing(column_spacing) .row_spacing(space_xxs) .padding([0, space_m].into()); if let Some(ref items) = self.items_opt { let mut count = 0; let mut col = 0; let mut row = 0; let mut hidden = 0; for (i, item) in items.iter().enumerate() { if !show_hidden && item.hidden { item.pos_opt.set(None); item.rect_opt.set(None); hidden += 1; continue; } item.pos_opt.set(Some((row, col))); item.rect_opt.set(Some(Rectangle::new( Point::new( (col * (GRID_ITEM_WIDTH + column_spacing as usize) + space_m as usize) as f32, (row * (GRID_ITEM_HEIGHT + space_xxs as usize)) as f32, ), Size::new(GRID_ITEM_WIDTH as f32, GRID_ITEM_HEIGHT as f32), ))); //TODO: one focus group per grid item (needs custom widget) let buttons = vec![ widget::button( widget::icon::icon(item.icon_handle_grid.clone()) .content_fit(ContentFit::Contain) .size(icon_sizes.grid()), ) .on_press(Message::Click(Some(i))) .padding(space_xxxs) .style(button_style(item.selected, false)), widget::button(widget::text(item.name.clone())) .id(item.button_id.clone()) .on_press(Message::Click(Some(i))) .padding([0, space_xxs]) .style(button_style(item.selected, true)), ]; let mut column = widget::column::with_capacity(buttons.len()) .align_items(Alignment::Center) .height(Length::Fixed(GRID_ITEM_HEIGHT as f32)) .width(Length::Fixed(GRID_ITEM_WIDTH as f32)); for button in buttons { if self.context_menu.is_some() { column = column.push(button) } else { column = column.push( mouse_area::MouseArea::new(button).on_right_press_no_capture( move |_point_opt| Message::RightClick(i), ), ); } } grid = grid.push(column); count += 1; col += 1; if col >= cols { col = 0; row += 1; grid = grid.insert_row(); } } if count == 0 { return self.empty_view(hidden > 0); } //TODO: HACK If we don't reach the bottom of the view, go ahead and add a spacer to do that { let mut max_bottom = 0; for item in items.iter() { if let Some(rect) = item.rect_opt.get() { let bottom = (rect.y + rect.height).ceil() as usize; if bottom > max_bottom { max_bottom = bottom; } } } let spacer_height = height .checked_sub(max_bottom + 2 * (space_xxs as usize)) .unwrap_or(0); if spacer_height > 0 { if col != 0 { grid = grid.insert_row(); } grid = grid.push(widget::vertical_space(Length::Fixed(spacer_height as f32))); } } } widget::scrollable( mouse_area::MouseArea::new(grid) .on_drag(Message::Drag) .show_drag_rect(true), ) .id(self.scrollable_id.clone()) .on_scroll(Message::Scroll) .width(Length::Fill) .into() } pub fn list_view(&self) -> Element { let cosmic_theme::Spacing { space_m, space_xxs, .. } = theme::active().cosmic().spacing; //TODO: make adaptive? let size = self.size_opt.unwrap_or_else(|| Size::new(0.0, 0.0)); let row_height = 40; let modified_width = Length::Fixed(200.0); let size_width = Length::Fixed(100.0); macro_rules! heading_item { ($name: literal, $width: expr, $msg: expr) => { widget::row::with_children(vec![ widget::text::heading(fl!($name)).into(), widget::button(widget::icon::from_name( match (self.sort_name == $msg, self.sort_direction) { (true, true) => "go-down-symbolic", (true, false) => "go-up-symbolic", _ => "list-remove-symbolic", }, )) .on_press(Message::ToggleSort($msg)) .style(cosmic::style::Button::Icon) .into(), ]) .spacing(space_xxs) .width($width) .align_items(Alignment::Center) .into() }; } let mut children: Vec> = Vec::new(); children.push( widget::row::with_children(vec![ heading_item!("name", Length::Fill, HeadingOptions::Name), //TODO: do not show modified column when in the trash heading_item!("modified", modified_width, HeadingOptions::Modified), heading_item!("size", size_width, HeadingOptions::Size), ]) .align_items(Alignment::Center) .height(Length::Fixed(row_height as f32)) .padding(space_xxs) .spacing(space_xxs) .into(), ); let mut y = row_height; children.push(horizontal_rule(1).into()); y += 1; if let Some(ref items) = self.column_sort() { let mut count = 0; let mut hidden = 0; let TabConfig { show_hidden, icon_sizes, } = self.config; for (i, item) in items.iter().enumerate() { if !show_hidden && item.hidden { item.pos_opt.set(None); item.rect_opt.set(None); hidden += 1; continue; } item.pos_opt.set(Some((count, 0))); item.rect_opt.set(Some(Rectangle::new( Point::new(space_m as f32, y as f32), Size::new(size.width - (2 * space_m) as f32, row_height as f32), ))); if count > 0 { children.push(horizontal_rule(1).into()); y += 1; } let modified_text = match &item.metadata { ItemMetadata::Path { metadata, .. } => match metadata.modified() { Ok(time) => chrono::DateTime::::from(time) .format(TIME_FORMAT) .to_string(), Err(_) => String::new(), }, ItemMetadata::Trash { .. } => String::new(), }; let size_text = match &item.metadata { ItemMetadata::Path { metadata, children } => { if metadata.is_dir() { format!("{} items", children) } else { format_size(metadata.len()) } } ItemMetadata::Trash { metadata, .. } => match metadata.size { trash::TrashItemSize::Entries(entries) => { //TODO: translate if entries == 1 { format!("{} item", entries) } else { format!("{} items", entries) } } trash::TrashItemSize::Bytes(bytes) => format_size(bytes), }, }; //TODO: align columns let button = widget::button( widget::row::with_children(vec![ widget::icon::icon(item.icon_handle_list.clone()) .content_fit(ContentFit::Contain) .size(icon_sizes.list()) .into(), widget::text(item.name.clone()).width(Length::Fill).into(), widget::text(modified_text).width(modified_width).into(), widget::text(size_text).width(size_width).into(), ]) .align_items(Alignment::Center) .spacing(space_xxs), ) .height(Length::Fixed(row_height as f32)) .id(item.button_id.clone()) .padding(space_xxs) .style(button_style(item.selected, true)) .on_press(Message::Click(Some(i))); if self.context_menu.is_some() { children.push(button.into()); } else { children.push( mouse_area::MouseArea::new(button) .on_right_press_no_capture(move |_point_opt| Message::RightClick(i)) .into(), ); } count += 1; y += row_height; } if count == 0 { return self.empty_view(hidden > 0); } } widget::scrollable(widget::column::with_children(children).padding([0, space_m])) .id(self.scrollable_id.clone()) .on_scroll(Message::Scroll) .width(Length::Fill) .into() } pub fn view(&self, key_binds: &HashMap) -> Element { let location_view = self.location_view(); let item_view = match self.view { View::Grid => self.grid_view(), View::List => self.list_view(), }; let mut mouse_area = mouse_area::MouseArea::new(widget::container(item_view).height(Length::Fill)) .on_press(move |_point_opt| Message::Click(None)) .on_back_press(move |_point_opt| Message::GoPrevious) .on_forward_press(move |_point_opt| Message::GoNext) .on_resize(Message::Resize); if self.context_menu.is_some() { mouse_area = mouse_area.on_right_press(move |_point_opt| Message::ContextMenu(None)); } else { mouse_area = mouse_area.on_right_press(move |point_opt| Message::ContextMenu(point_opt)); } let mut popover = widget::popover(mouse_area); if let Some(point) = self.context_menu { popover = popover .popup(menu::context_menu(&self, &key_binds)) .position(widget::popover::Position::Point(point)); } widget::container(widget::column::with_children(vec![ location_view, popover.into(), ])) .height(Length::Fill) .width(Length::Fill) .into() } pub fn subscription(&self) -> Subscription { if let Some(items) = &self.items_opt { //TODO: how many thumbnail loads should be in flight at once? let jobs = 8; let mut subscriptions = Vec::with_capacity(jobs); //TODO: move to function let visible_rect = { let point = match self.scroll_opt { Some(offset) => Point::new(0.0, offset.y), None => Point::new(0.0, 0.0), }; let size = self.size_opt.unwrap_or_else(|| Size::new(0.0, 0.0)); Rectangle::new(point, size) }; //TODO: HACK to ensure positions are up to date since subscription runs before view let _ = match self.view { View::Grid => self.grid_view(), View::List => self.list_view(), }; for item in items.iter() { if item.thumbnail_res_opt.is_some() { // Skip items that already have a thumbnail continue; } match item.rect_opt.get() { Some(rect) => { if !rect.intersects(&visible_rect) { // Skip items that are not visible continue; } } None => { // Skip items with no determined rect (this should include hidden items) continue; } } let path = item.path.clone(); subscriptions.push(subscription::channel( path.clone(), 1, |mut output| async move { let (path, thumbnail_res) = tokio::task::spawn_blocking(move || { let start = std::time::Instant::now(); let thumbnail_res = match image::io::Reader::open(&path) { Ok(reader) => match reader.decode() { Ok(image) => { //TODO: configurable thumbnail size let thumbnail = image.thumbnail(64, 64); Ok(thumbnail.to_rgba8()) } Err(err) => { log::warn!("failed to decode {:?}: {}", path, err); Err(()) } }, Err(err) => { log::warn!("failed to read {:?}: {}", path, err); Err(()) } }; log::info!("thumbnailed {:?} in {:?}", path, start.elapsed()); (path, thumbnail_res) }) .await .unwrap(); match output .send(Message::Thumbnail(path.clone(), thumbnail_res)) .await { Ok(()) => {} Err(err) => { log::warn!("failed to send thumbnail for {:?}: {}", path, err); } } //TODO: how to properly kill this task? loop { tokio::time::sleep(std::time::Duration::new(1, 0)).await; } }, )); if subscriptions.len() >= jobs { break; } } Subscription::batch(subscriptions) } else { Subscription::none() } } } #[cfg(test)] mod tests { use std::{io, path::PathBuf}; use cosmic::iced_runtime::keyboard::Modifiers; use log::{debug, trace}; use tempfile::TempDir; use test_log::test; use super::{scan_path, Location, Message, Tab}; use crate::{ app::test_utils::{ assert_eq_tab_path, empty_fs, eq_path_item, filter_dirs, read_dir_sorted, simple_fs, tab_click_new, NAME_LEN, NUM_DIRS, NUM_FILES, NUM_HIDDEN, NUM_NESTED, }, config::{IconSizes, TabConfig}, }; // Boilerplate for tab tests. Checks if simulated clicks selected items. fn tab_selects_item( clicks: &[usize], modifiers: Modifiers, expected_selected: &[bool], ) -> io::Result<()> { let (_fs, mut tab) = tab_click_new(NUM_FILES, NUM_NESTED, NUM_DIRS, NUM_NESTED, NAME_LEN)?; // Simulate clicks by triggering Message::Click for &click in clicks { debug!("Emitting Message::Click(Some({click})) with modifiers: {modifiers:?}"); tab.update(Message::Click(Some(click)), modifiers); } let items = tab .items_opt .as_deref() .expect("tab should be populated with items"); for (i, (&expected, actual)) in expected_selected.into_iter().zip(items).enumerate() { assert_eq!( expected, actual.selected, "expected index {i} to be {}", if expected { "selected but it was deselected" } else { "deselected but it was selected" } ); } Ok(()) } fn tab_history() -> io::Result<(TempDir, Tab, Vec)> { let fs = simple_fs(NUM_FILES, NUM_NESTED, NUM_DIRS, NUM_NESTED, NAME_LEN)?; let path = fs.path(); let mut tab = Tab::new(Location::Path(path.into()), TabConfig::default()); // All directories (simple_fs only produces one nested layer) let dirs: Vec = filter_dirs(path)? .flat_map(|dir| { filter_dirs(&dir).map(|nested_dirs| std::iter::once(dir).chain(nested_dirs)) }) .flatten() .collect(); assert!( dirs.len() == NUM_DIRS + NUM_DIRS * NUM_NESTED, "Sanity check: Have {} dirs instead of {}", dirs.len(), NUM_DIRS + NUM_DIRS * NUM_NESTED ); debug!("Building history by emitting Message::Location"); for dir in &dirs { debug!( "Emitting Message::Location(Location::Path(\"{}\"))", dir.display() ); tab.update( Message::Location(Location::Path(dir.clone())), Modifiers::empty(), ); } trace!("Tab history: {:?}", tab.history); Ok((fs, tab, dirs)) } #[test] fn scan_path_succeeds_on_valid_path() -> io::Result<()> { let fs = simple_fs(NUM_FILES, NUM_HIDDEN, NUM_DIRS, NUM_NESTED, NAME_LEN)?; let path = fs.path(); // Read directory entries and sort as cosmic-files does let entries = read_dir_sorted(path)?; debug!("Calling scan_path(\"{}\")", path.display()); let actual = scan_path(&path.to_owned(), IconSizes::default()); // scan_path shouldn't skip any entries assert_eq!(entries.len(), actual.len()); // Correct files should be scanned assert!(entries .into_iter() .zip(actual.into_iter()) .all(|(path, item)| eq_path_item(&path, &item))); Ok(()) } #[test] fn scan_path_returns_empty_vec_for_invalid_path() -> io::Result<()> { let fs = simple_fs(NUM_FILES, NUM_NESTED, NUM_DIRS, NUM_NESTED, NAME_LEN)?; let path = fs.path(); // A nonexisting path within the temp dir let invalid_path = path.join("ferris"); assert!(!invalid_path.exists()); debug!("Calling scan_path(\"{}\")", invalid_path.display()); let actual = scan_path(&invalid_path, IconSizes::default()); assert!(actual.is_empty()); Ok(()) } #[test] fn scan_path_empty_dir_returns_empty_vec() -> io::Result<()> { let fs = empty_fs()?; let path = fs.path(); debug!("Calling scan_path(\"{}\")", path.display()); let actual = scan_path(&path.to_owned(), IconSizes::default()); assert_eq!(0, path.read_dir()?.count()); assert!(actual.is_empty()); Ok(()) } #[test] fn tab_location_changes_location() -> io::Result<()> { let fs = simple_fs(NUM_FILES, NUM_NESTED, NUM_DIRS, NUM_NESTED, NAME_LEN)?; let path = fs.path(); // Next directory in temp directory // This does not have to be sorted let next_dir = filter_dirs(path)? .next() .expect("temp directory should have at least one directory"); let mut tab = Tab::new(Location::Path(path.to_owned()), TabConfig::default()); debug!( "Emitting Message::Location(Location::Path(\"{}\"))", next_dir.display() ); tab.update( Message::Location(Location::Path(next_dir.clone())), Modifiers::empty(), ); // Validate that the tab's path updated // NOTE: `items_opt` is set to None with Message::Location so this ONLY checks for equal paths // If item contents are NOT None then this needs to be reevaluated for correctness assert_eq_tab_path(&tab, &next_dir); assert!( tab.items_opt.is_none(), "Tab's `items` is not None which means this test needs to be updated" ); Ok(()) } #[test] fn tab_click_single_selects_item() -> io::Result<()> { // Select the second directory with no keys held down tab_selects_item(&[1], Modifiers::empty(), &[false, true]) } #[test] fn tab_click_double_opens_folder() -> io::Result<()> { let (fs, mut tab) = tab_click_new(NUM_FILES, NUM_NESTED, NUM_DIRS, NUM_NESTED, NAME_LEN)?; let path = fs.path(); // Simulate double clicking second directory debug!("Emitting first Message::Click(Some(1))"); tab.update(Message::Click(Some(1)), Modifiers::empty()); debug!("Emitting second Message::Click(Some(1))"); tab.update(Message::Click(Some(1)), Modifiers::empty()); // Path to second directory let second_dir = read_dir_sorted(path)? .into_iter() .filter(|p| p.is_dir()) .nth(1) .expect("should be at least two directories"); // Location should have changed to second_dir assert_eq_tab_path(&tab, &second_dir); Ok(()) } #[test] fn tab_click_ctrl_selects_multiple() -> io::Result<()> { // Select the first and second directory by holding down ctrl tab_selects_item(&[0, 1], Modifiers::CTRL, &[true, true]) } #[test] fn tab_gonext_moves_forward_in_history() -> io::Result<()> { let (fs, mut tab, dirs) = tab_history()?; let path = fs.path(); // Rewind to the start for _ in 0..dirs.len() { debug!("Emitting Message::GoPrevious to rewind to the start",); tab.update(Message::GoPrevious, Modifiers::empty()); } assert_eq_tab_path(&tab, path); // Back to the future. Directories should be in the order they were opened. for dir in dirs { debug!("Emitting Message::GoNext",); tab.update(Message::GoNext, Modifiers::empty()); assert_eq_tab_path(&tab, &dir); } Ok(()) } #[test] fn tab_goprev_moves_backward_in_history() -> io::Result<()> { let (fs, mut tab, dirs) = tab_history()?; let path = fs.path(); for dir in dirs.into_iter().rev() { assert_eq_tab_path(&tab, &dir); debug!("Emitting Message::GoPrevious",); tab.update(Message::GoPrevious, Modifiers::empty()); } assert_eq_tab_path(&tab, path); Ok(()) } #[test] fn tab_empty_history_does_nothing_on_prev_next() -> io::Result<()> { let fs = simple_fs(0, NUM_NESTED, NUM_DIRS, 0, NAME_LEN)?; let path = fs.path(); let mut tab = Tab::new(Location::Path(path.into()), TabConfig::default()); // Tab's location shouldn't change if GoPrev or GoNext is triggered debug!("Emitting Message::GoPrevious",); tab.update(Message::GoPrevious, Modifiers::empty()); assert_eq_tab_path(&tab, path); debug!("Emitting Message::GoNext",); tab.update(Message::GoNext, Modifiers::empty()); assert_eq_tab_path(&tab, path); Ok(()) } #[test] fn tab_locationup_moves_up_hierarchy() -> io::Result<()> { let fs = simple_fs(0, NUM_NESTED, NUM_DIRS, 0, NAME_LEN)?; let path = fs.path(); let mut next_dir = filter_dirs(path)? .next() .expect("should be at least one directory"); let mut tab = Tab::new(Location::Path(next_dir.clone()), TabConfig::default()); // This will eventually yield false once root is hit while next_dir.pop() { debug!("Emitting Message::LocationUp",); tab.update(Message::LocationUp, Modifiers::empty()); assert_eq_tab_path(&tab, &next_dir); } Ok(()) } }