Support 3 kinds of alert messages

Author: andornaut

src/app/config/default_config.rs

@@ -18,7 +18,7 @@ open_selected_file_template = "pcmanfm %s"
 
 [theme]
 alert_bg = "#373424"
-alert_fg = "#CCC8B0"
+alert_fg = "#9f8800"
 
 alert_error_bg = "#373424"
 alert_error_fg = "#DC322F"
@@ -35,7 +35,7 @@ header_bg = "#373424"
 header_fg = "#CCC8B0"
 
 help_bg = "#373424"
-help_fg = "#CCC8B0"
+help_fg = "#9C9977"
 
 notice_clipboard_bg = "#70C0B1"
 notice_clipboard_fg = "#1D1F21"

src/file_system.rs

@@ -16,7 +16,7 @@ use crate::{
 };
 
 pub struct FileSystem {
-    directory: PathInfo,
+    directory: Option<PathInfo>,
     open_current_directory_template: Option<String>,
     open_new_window_template: Option<String>,
     open_selected_file_template: Option<String>,
@@ -27,7 +27,7 @@ pub struct FileSystem {
 impl FileSystem {
     pub fn new(config: &Config) -> Self {
         Self {
-            directory: PathInfo::default(),
+            directory: None,
             open_current_directory_template: config.open_current_directory_template.clone(),
             open_new_window_template: config.open_new_window_template.clone(),
             open_selected_file_template: config.open_selected_file_template.clone(),
@@ -58,31 +58,22 @@ impl FileSystem {
     }
 
     fn back(&mut self) -> CommandResult {
-        match self.directory.parent() {
+        let directory = self.directory.as_ref().unwrap();
+        match directory.parent() {
             Some(parent) => self.cd(parent),
             None => CommandResult::none(),
         }
     }
-
     fn cd(&mut self, directory: PathInfo) -> CommandResult {
-        // Unwatch the current directory if we're watching it
-        if let Some(watcher) = &mut self.watcher {
-            if let Err(e) = watcher.unwatch_directory(PathBuf::from(&self.directory.path)) {
-                error!("Failed to unwatch directory: {}", e);
-            }
-        }
+        let watcher = self.watcher.as_mut().expect("Watcher not initialized");
 
         (match sync::cd(&directory) {
             Ok(children) => {
-                self.directory = directory.clone();
+                self.directory = Some(directory.clone());
 
-                // Watch the new directory
-                if let Some(watcher) = &mut self.watcher {
-                    if let Err(e) = watcher.watch_directory(PathBuf::from(&directory.path)) {
-                        error!("Failed to watch directory: {}", e);
-                    }
+                if let Err(e) = watcher.watch_directory(PathBuf::from(&directory.path)) {
+                    error!("Failed to watch directory: {}", e);
                 }
-
                 Command::SetDirectory(directory, children)
             }
             Err(error) => anyhow!("Failed to change to directory {directory:?}: {error}").into(),
@@ -111,9 +102,10 @@ impl FileSystem {
     }
 
     fn open_current_directory(&self) -> CommandResult {
+        let directory = self.directory.as_ref().unwrap();
         open_in(
             self.open_current_directory_template.clone(),
-            &self.directory.path,
+            &directory.path,
         )
         .map_or_else(|error| error.into(), |_| CommandResult::none())
     }
@@ -124,7 +116,8 @@ impl FileSystem {
     }
 
     fn open_new_window(&self) -> CommandResult {
-        open_in(self.open_new_window_template.clone(), &self.directory.path)
+        let directory = self.directory.as_ref().unwrap();
+        open_in(self.open_new_window_template.clone(), &directory.path)
             .map_or_else(|error| error.into(), |_| CommandResult::none())
     }
 
@@ -138,6 +131,7 @@ impl FileSystem {
     }
 
     fn refresh(&mut self) -> CommandResult {
-        self.cd(self.directory.clone())
+        let directory = self.directory.as_ref().unwrap();
+        self.cd(directory.clone())
     }
 }

src/file_system/watcher.rs

@@ -12,6 +12,7 @@ use crate::command::Command;
 
 pub struct DirectoryWatcher {
     watcher: RecommendedWatcher,
+    currently_watched: Option<PathBuf>,
 }
 
 impl DirectoryWatcher {
@@ -21,17 +22,22 @@ impl DirectoryWatcher {
         let watcher = recommended_watcher(tx)?;
 
         thread::spawn(move || background_watcher(command_tx, rx));
-        Ok(Self { watcher })
+        Ok(Self {
+            watcher,
+            currently_watched: None,
+        })
     }
 
     pub fn watch_directory(&mut self, path: PathBuf) -> Result<()> {
+        if let Some(old_path) = &self.currently_watched {
+            if let Err(e) = self.watcher.unwatch(old_path.as_path()) {
+                error!("Failed to unwatch directory: {}", e);
+            }
+        }
+
         self.watcher
             .watch(path.as_path(), notify::RecursiveMode::NonRecursive)?;
-        Ok(())
-    }
-
-    pub fn unwatch_directory(&mut self, path: PathBuf) -> Result<()> {
-        self.watcher.unwatch(path.as_path())?;
+        self.currently_watched = Some(path);
         Ok(())
     }
 }
@@ -53,8 +59,10 @@ fn background_watcher(
                 _ => {}
             },
             Err(e) => {
-                let error_command =
-                    Command::AlertError(format!("Failed to watch directory: {}", e));
+                let error_command = Command::AlertError(format!(
+                    "Failed to run the directory watcher in the background: {}",
+                    e
+                ));
                 if let Err(e) = command_tx.send(error_command) {
                     error!("Failed to send error command: {}", e);
                 }

src/views/alerts.rs

@@ -16,6 +16,7 @@ use crate::{
 };
 
 const MAX_NUMBER_ALERTS: usize = 5;
+const MIN_HEIGHT: u16 = 2;
 
 #[derive(Clone, Debug, Eq, PartialEq)]
 enum AlertKind {
@@ -24,29 +25,28 @@ enum AlertKind {
     Error,
 }
 
+impl AlertKind {
+    fn to_style(&self, theme: &Theme) -> Style {
+        match self {
+            AlertKind::Info => theme.alert_info(),
+            AlertKind::Warn => theme.alert_warning(),
+            AlertKind::Error => theme.alert_error(),
+        }
+    }
+}
+
 #[derive(Default)]
 pub(super) struct AlertsView {
     alerts: VecDeque<(AlertKind, String)>,
     area: Rect,
 }
 
 impl AlertsView {
-    pub(super) fn height(&self, width: u16) -> u16 {
-        if self.should_show() {
-            // TODO cache `self.list_items()` result for use in render()
-            let width = width.saturating_sub(2); // -2 for horizontal borders
-            let items = self.list_items(width);
-            items.len() as u16 + 2 // +2 for vertical borders
-        } else {
-            0
-        }
-    }
-
     fn add_alert(&mut self, kind: AlertKind, message: String) -> CommandResult {
         if self.alerts.len() == MAX_NUMBER_ALERTS {
-            self.alerts.pop_front();
+            self.alerts.pop_back();
         }
-        self.alerts.push_back((kind, message));
+        self.alerts.push_front((kind, message));
         CommandResult::none()
     }
 
@@ -55,32 +55,35 @@ impl AlertsView {
         CommandResult::none()
     }
 
-    fn list_items(&self, width: u16) -> Vec<(Line<'_>, AlertKind)> {
+    fn height(&self, area: &Rect) -> u16 {
+        if !self.should_show(area) {
+            return 0;
+        }
+        // First subtract borders from the outer area
+        let inner_width = area.width.saturating_sub(2);
+        let items = self.alerts(inner_width);
+        items.len() as u16 + 2 // +2 for vertical borders
+    }
+
+    fn alerts(&self, width_without_borders: u16) -> Vec<(AlertKind, Line<'_>)> {
+        let width_without_prefix = width_without_borders.saturating_sub(2);
+
         self.alerts
             .iter()
-            .rev() // Newest alert messages near the top
             .flat_map(|(kind, message)| {
-                split_with_ellipsis(message, width.saturating_sub(2))
+                split_with_ellipsis(message, width_without_prefix)
                     .into_iter()
                     .enumerate()
                     .map(|(i, line)| {
                         let prefix = if i == 0 { "•" } else { " " };
-                        (Line::from(format!("{prefix} {line}")), kind.clone())
+                        (kind.clone(), Line::from(format!("{prefix} {line}")))
                     })
             })
             .collect()
     }
 
-    fn should_show(&self) -> bool {
-        !self.alerts.is_empty()
-    }
-
-    fn get_style(&self, kind: &AlertKind, theme: &Theme) -> Style {
-        match kind {
-            AlertKind::Info => theme.alert_info(),
-            AlertKind::Warn => theme.alert_warning(),
-            AlertKind::Error => theme.alert_error(),
-        }
+    fn should_show(&self, area: &Rect) -> bool {
+        !self.alerts.is_empty() && area.height >= MIN_HEIGHT
     }
 }
 
@@ -103,7 +106,6 @@ impl CommandHandler for AlertsView {
     fn handle_mouse(&mut self, event: &MouseEvent) -> CommandResult {
         match event.kind {
             MouseEventKind::Down(MouseButton::Left) => {
-                // `self.should_receive_mouse()` guards this method to ensure that the click intersects with this view.
                 self.clear_alerts();
                 CommandResult::none()
             }
@@ -118,25 +120,27 @@ impl CommandHandler for AlertsView {
 
 impl View for AlertsView {
     fn constraint(&self, area: Rect, _: &InputMode) -> Constraint {
-        Constraint::Length(self.height(area.width))
+        Constraint::Length(self.height(&area))
     }
 
     fn render(&mut self, area: Rect, buf: &mut Buffer, _: &InputMode, theme: &Theme) {
-        self.area = area;
-        if !self.should_show() {
+        if !self.should_show(&area) {
             return;
         }
-
-        let bordered_area = bordered(buf, area, theme.alert(), Some("Alerts".into()));
-        let items = self.list_items(bordered_area.width);
-        let mut text: Text<'_> = Text::default();
-
-        for (line, kind) in items {
-            let style = self.get_style(&kind, theme);
-            text.lines.push(Line::from(line.spans).style(style));
-        }
-
-        let widget = Paragraph::new(text);
+        self.area = area;
+        let bordered_area = bordered(
+            buf,
+            area,
+            theme.alert(),
+            Some("Alerts (Press \"a\" to clear)".into()),
+        );
+        let text = Text::from(
+            self.alerts(bordered_area.width)
+                .into_iter()
+                .map(|(kind, line)| line.style(kind.to_style(theme)))
+                .collect::<Vec<_>>(),
+        );
+        let widget = Paragraph::new(text).style(theme.alert());
         widget.render(bordered_area, buf);
     }
 }

src/views/help.rs

@@ -1,4 +1,4 @@
-use ratatui::crossterm::event::{KeyCode, KeyModifiers};
+use ratatui::crossterm::event::{KeyCode, KeyModifiers, MouseButton, MouseEvent, MouseEventKind};
 use ratatui::{
     buffer::Buffer,
     layout::{Constraint, Rect},
@@ -13,33 +13,50 @@ use crate::{
     command::{handler::CommandHandler, mode::InputMode, result::CommandResult},
 };
 
+const MIN_HEIGHT: u16 = 2;
+
 #[derive(Default)]
 pub(super) struct HelpView {
-    should_show: bool,
+    area: Rect,
+    is_visible: bool,
 }
 
 impl HelpView {
     pub(super) fn height(&self) -> u16 {
-        if self.should_show {
-            4 // 2 + 2 for borders
+        if self.is_visible {
+            4 // 2 lines of text + 2 borders
         } else {
             0
         }
     }
 
-    fn toggle_show_help(&mut self) -> CommandResult {
-        self.should_show = !self.should_show;
+    fn toggle_visibility(&mut self) -> CommandResult {
+        self.is_visible = !self.is_visible;
         CommandResult::none()
     }
 }
 
 impl CommandHandler for HelpView {
     fn handle_key(&mut self, code: &KeyCode, modifiers: &KeyModifiers) -> CommandResult {
         match (*code, *modifiers) {
-            (KeyCode::Char('?'), KeyModifiers::NONE) => self.toggle_show_help(),
+            (KeyCode::Char('?'), KeyModifiers::NONE) => self.toggle_visibility(),
             (_, _) => CommandResult::NotHandled,
         }
     }
+
+    fn handle_mouse(&mut self, event: &MouseEvent) -> CommandResult {
+        match event.kind {
+            MouseEventKind::Down(MouseButton::Left) => {
+                self.is_visible = false;
+                CommandResult::none()
+            }
+            _ => CommandResult::none(),
+        }
+    }
+
+    fn should_receive_mouse(&self, x: u16, y: u16) -> bool {
+        self.is_visible && self.area.intersects(Rect::new(x, y, 1, 1))
+    }
 }
 
 impl View for HelpView {
@@ -48,11 +65,13 @@ impl View for HelpView {
     }
 
     fn render(&mut self, area: Rect, buf: &mut Buffer, mode: &InputMode, theme: &Theme) {
-        if !self.should_show {
+        if !self.is_visible || area.height < MIN_HEIGHT {
             return;
         }
+        self.area = area;
+
         let style = theme.help();
-        let bordered_rect = bordered(buf, area, style, Some("Help".into()));
+        let bordered_rect = bordered(buf, area, style, Some("Help (Press \"?\" to close)".into()));
         let spans = match *mode {
             InputMode::Prompt => prompt_help(),
             _ => content_help(),

src/views/notices.rs

@@ -56,11 +56,6 @@ impl NoticesView {
         CommandResult::none()
     }
 
-    pub(super) fn clear_filter(&mut self) -> CommandResult {
-        self.filter.clear();
-        CommandResult::none()
-    }
-
     pub(super) fn set_clipboard(
         &mut self,
         path: PathInfo,