add the :stage_all_files internal

Default mapping: ctrl-a

5 files changed, 32 insertions, 25 deletions

diff --git a/src/app/app.rs b/src/app/app.rs
index bd5cf68..73bbc6d 100644
--- a/src/app/app.rs
+++ b/src/app/app.rs
@@ -86,7 +86,6 @@ impl App {
                     con,
                     &Dam::unlimited(),
                 )?
-                .expect("Failed to create BrowserState"),
             ),
             Areas::create(&mut Vec::new(), 0, screen, false),
             con,
@@ -384,7 +383,7 @@ impl App {
                             }
                             if let Some(selected_path) = self.state().selected_path() {
                                 let dir = closest_dir(selected_path);
-                                if let Ok(Some(new_state)) = BrowserState::new(
+                                if let Ok(new_state) = BrowserState::new(
                                     dir,
                                     self.state().tree_options().without_pattern(),
                                     self.screen,
@@ -594,8 +593,11 @@ impl App {
         con: &AppContext,
     ) -> Result<(), ProgramError> {
         while self.has_pending_task() && !dam.has_event() {
-            if self.do_pending_task(app_state, con, dam) {
-                self.update_preview(con); // the selection may have changed
+            let error = self.do_pending_task(app_state, con, dam).err();
+            self.update_preview(con); // the selection may have changed
+            if let Some(error) = &error {
+                self.mut_panel().set_error(error.to_string());
+            } else {
                 let app_cmd_context = AppCmdContext {
                     panel_skin: &skin.focused,
                     preview_panel: self.preview_panel,
@@ -604,39 +606,38 @@ impl App {
                     con,
                 };
                 self.mut_panel().refresh_input_status(app_state, &app_cmd_context);
-                self.display_panels(w, skin, app_state, con)?;
-            } else {
-                warn!("unexpected lack of update on do_pending_task");
-                return Ok(());
+            }
+            self.display_panels(w, skin, app_state, con)?;
+            if error.is_some() {
+                return Ok(()); // breaking pending tasks chain on first error/interruption
             }
         }
         Ok(())
     }
 
-    /// do the next pending task
+    /// Do the next pending task
     fn do_pending_task(
         &mut self,
-        app_state: &AppState,
+        app_state: &mut AppState,
         con: &AppContext,
         dam: &mut Dam,
-    ) -> bool {
+    ) -> Result<(), ProgramError> {
         let screen = self.screen;
         // we start with the focused panel
         if self.panel().has_pending_task() {
-            self.mut_panel().do_pending_task(&app_state.stage, screen, con, dam);
-            return true;
+            return self.mut_panel().do_pending_task(app_state, screen, con, dam);
         }
         // then the other ones
         for idx in 0..self.panels.len().get() {
             if idx != self.active_panel_idx {
                 let panel = &mut self.panels[idx];
                 if panel.has_pending_task() {
-                    panel.do_pending_task(&app_state.stage, screen, con, dam);
-                    return true;
+                    return panel.do_pending_task(app_state, screen, con, dam);
                 }
             }
         }
-        false
+        warn!("unexpected lack of pending task");
+        Ok(())
     }
 
     fn has_pending_task(&mut self) -> bool {
diff --git a/src/app/app_context.rs b/src/app/app_context.rs
index 542b422..518bafa 100644
--- a/src/app/app_context.rs
+++ b/src/app/app_context.rs
@@ -75,6 +75,9 @@ pub struct AppContext {
     /// number of threads used by file_sum (count, size, date)
     /// computation
     pub file_sum_threads_count: usize,
+
+    /// number of files which may be staged in one staging operation
+    pub max_staged_count: usize,
 }
 
 impl AppContext {
@@ -116,6 +119,9 @@ impl AppContext {
             (_, Some(b)) => !b,
             _ => true,
         };
+        let max_staged_count = config.max_staged_count
+            .unwrap_or(10_000)
+            .clamp(10, 100_000);
         Ok(Self {
             config_paths,
             launch_args,
@@ -133,6 +139,7 @@ impl AppContext {
             max_panels_count,
             quit_on_last_cancel: config.quit_on_last_cancel.unwrap_or(false),
             file_sum_threads_count,
+            max_staged_count,
         })
     }
 }
diff --git a/src/app/cmd_result.rs b/src/app/cmd_result.rs
index 74a5dde..465feff 100644
--- a/src/app/cmd_result.rs
+++ b/src/app/cmd_result.rs
@@ -62,11 +62,11 @@ impl CmdResult {
         CmdResult::DisplayError(format!("verb not found: {:?}", &text))
     }
     pub fn from_optional_state(
-        os: Result<Option<BrowserState>, TreeBuildError>,
+        os: Result<BrowserState, TreeBuildError>,
         in_new_panel: bool,
     ) -> CmdResult {
         match os {
-            Ok(Some(os)) => {
+            Ok(os) => {
                 if in_new_panel {
                     CmdResult::NewPanel {
                         state: Box::new(os),
@@ -77,7 +77,7 @@ impl CmdResult {
                     CmdResult::NewState(Box::new(os))
                 }
             }
-            Ok(None) => CmdResult::Keep,
+            Err(TreeBuildError::Interrupted) => CmdResult::Keep,
             Err(e) => CmdResult::error(e.to_string()),
         }
     }
diff --git a/src/app/panel.rs b/src/app/panel.rs
index 0411e49..9a2757d 100644
--- a/src/app/panel.rs
+++ b/src/app/panel.rs
@@ -13,7 +13,6 @@ use {
         errors::ProgramError,
         keys::KEY_FORMAT,
         skin::PanelSkin,
-        stage::*,
         task_sync::Dam,
         verb::*,
     },
@@ -109,12 +108,12 @@ impl Panel {
     /// in the dam
     pub fn do_pending_task(
         &mut self,
-        stage: &Stage,
+        app_state: &mut AppState,
         screen: Screen,
         con: &AppContext,
         dam: &mut Dam,
-    ) {
-        self.mut_state().do_pending_task(stage, screen, con, dam)
+    ) -> Result<(), ProgramError> {
+        self.mut_state().do_pending_task(app_state, screen, con, dam)
     }
 
     pub fn has_pending_task(&self) -> bool {
diff --git a/src/app/panel_state.rs b/src/app/panel_state.rs
index 01b2129..743579b 100644
--- a/src/app/panel_state.rs
+++ b/src/app/panel_state.rs
@@ -699,11 +699,11 @@ pub trait PanelState {
 
     fn do_pending_task(
         &mut self,
-        _stage: &Stage,
+        _app_state: &mut AppState,
         _screen: Screen,
         _con: &AppContext,
         _dam: &mut Dam,
-    ) {
+    ) -> Result<(), ProgramError> {
         // no pending task in default impl
         unreachable!();
     }