feat: transfer transferQueue instead of the old many

src/ui/activities/filetransfer/actions/copy.rs

@@ -18,14 +18,15 @@ impl FileTransferActivity {
                 self.local_copy_file(&entry, dest_path.as_path());
             }
             SelectedFile::Many(entries) => {
-                // Try to copy each file to Input/{FILE_NAME}
-                let base_path: PathBuf = PathBuf::from(input);
                 // Iter files
-                for entry in entries.iter() {
+                for (entry, mut dest_path) in entries.into_iter() {
-                    let mut dest_path: PathBuf = base_path.clone();
                     dest_path.push(entry.name());
-                    self.local_copy_file(entry, dest_path.as_path());
+                    self.local_copy_file(&entry, dest_path.as_path());
                 }
+
+                // clear selection
+                self.host_bridge_mut().clear_queue();
+                self.reload_host_bridge_filelist();
             }
             SelectedFile::None => {}
         }
@@ -39,14 +40,15 @@ impl FileTransferActivity {
                 self.remote_copy_file(entry, dest_path.as_path());
             }
             SelectedFile::Many(entries) => {
-                // Try to copy each file to Input/{FILE_NAME}
-                let base_path: PathBuf = PathBuf::from(input);
                 // Iter files
-                for entry in entries.into_iter() {
+                for (entry, mut dest_path) in entries.into_iter() {
-                    let mut dest_path: PathBuf = base_path.clone();
                     dest_path.push(entry.name());
                     self.remote_copy_file(entry, dest_path.as_path());
                 }
+
+                // clear selection
+                self.remote_mut().clear_queue();
+                self.reload_remote_filelist();
             }
             SelectedFile::None => {}
         }

src/ui/activities/filetransfer/actions/delete.rs

@@ -16,10 +16,14 @@ impl FileTransferActivity {
             }
             SelectedFile::Many(entries) => {
                 // Iter files
-                for entry in entries.iter() {
+                for (entry, _) in entries.iter() {
                     // Delete file
                     self.local_remove_file(entry);
                 }
+
+                // clear selection
+                self.host_bridge_mut().clear_queue();
+                self.reload_host_bridge_filelist();
             }
             SelectedFile::None => {}
         }
@@ -33,10 +37,14 @@ impl FileTransferActivity {
             }
             SelectedFile::Many(entries) => {
                 // Iter files
-                for entry in entries.iter() {
+                for (entry, _) in entries.iter() {
                     // Delete file
                     self.remote_remove_file(entry);
                 }
+
+                // clear selection
+                self.remote_mut().clear_queue();
+                self.reload_remote_filelist();
             }
             SelectedFile::None => {}
         }

src/ui/activities/filetransfer/actions/edit.rs

@@ -16,7 +16,7 @@ impl FileTransferActivity {
     pub(crate) fn action_edit_local_file(&mut self) {
         let entries: Vec<File> = match self.get_local_selected_entries() {
             SelectedFile::One(entry) => vec![entry],
-            SelectedFile::Many(entries) => entries,
+            SelectedFile::Many(entries) => entries.into_iter().map(|(f, _)| f).collect(),
             SelectedFile::None => vec![],
         };
         // Edit all entries
@@ -38,12 +38,16 @@ impl FileTransferActivity {
                 }
             }
         }
+
+        // clear selection
+        self.host_bridge_mut().clear_queue();
+        self.reload_host_bridge_filelist();
     }
 
     pub(crate) fn action_edit_remote_file(&mut self) {
         let entries: Vec<File> = match self.get_remote_selected_entries() {
             SelectedFile::One(entry) => vec![entry],
-            SelectedFile::Many(entries) => entries,
+            SelectedFile::Many(entries) => entries.into_iter().map(|(f, _)| f).collect(),
             SelectedFile::None => vec![],
         };
         // Edit all entries
@@ -60,6 +64,10 @@ impl FileTransferActivity {
                 }
             }
         }
+
+        // clear selection
+        self.remote_mut().clear_queue();
+        self.reload_remote_filelist();
     }
 
     /// Edit a file on localhost

src/ui/activities/filetransfer/actions/find.rs

@@ -11,7 +11,7 @@ use super::{File, FileTransferActivity, LogLevel, SelectedFile, TransferOpts, Tr
 impl FileTransferActivity {
     pub(crate) fn action_find_changedir(&mut self) {
         // Match entry
-        if let SelectedFile::One(entry) = self.get_found_selected_entries() {
+        if let Some(entry) = self.get_found_selected_file() {
             debug!("Changedir to: {}", entry.name());
             // Get path: if a directory, use directory path; if it is a File, get parent path
             let path = if entry.is_dir() {
@@ -103,11 +103,12 @@ impl FileTransferActivity {
                             // Check which file would be replaced
                             let existing_files: Vec<&File> = entries
                                 .iter()
-                                .filter(|x| {
+                                .filter(|(x, dest_path)| {
                                     self.remote_file_exists(
                                         Self::file_to_check_many(x, dest_path.as_path()).as_path(),
                                     )
                                 })
+                                .map(|(x, _)| x)
                                 .collect();
                             // Check whether to replace files
                             if !existing_files.is_empty()
@@ -117,7 +118,7 @@ impl FileTransferActivity {
                             }
                         }
                         if let Err(err) = self.filetransfer_send(
-                            TransferPayload::Many(entries),
+                            TransferPayload::TransferQueue(entries),
                             dest_path.as_path(),
                             None,
                         ) {
@@ -134,11 +135,12 @@ impl FileTransferActivity {
                             // Check which file would be replaced
                             let existing_files: Vec<&File> = entries
                                 .iter()
-                                .filter(|x| {
+                                .filter(|(x, dest_path)| {
                                     self.host_bridge_file_exists(
                                         Self::file_to_check_many(x, dest_path.as_path()).as_path(),
                                     )
                                 })
+                                .map(|(x, _)| x)
                                 .collect();
                             // Check whether to replace files
                             if !existing_files.is_empty()
@@ -148,7 +150,7 @@ impl FileTransferActivity {
                             }
                         }
                         if let Err(err) = self.filetransfer_recv(
-                            TransferPayload::Many(entries),
+                            TransferPayload::TransferQueue(entries),
                             dest_path.as_path(),
                             None,
                         ) {
@@ -157,6 +159,12 @@ impl FileTransferActivity {
                                 format!("Could not download file: {err}"),
                             );
                         }
+
+                        // clear selection
+                        if let Some(f) = self.found_mut() {
+                            f.clear_queue();
+                            self.update_find_list();
+                        }
                     }
                 }
             }
@@ -172,10 +180,16 @@ impl FileTransferActivity {
             }
             SelectedFile::Many(entries) => {
                 // Iter files
-                for entry in entries.iter() {
+                for (entry, _) in entries.iter() {
                     // Delete file
                     self.remove_found_file(entry);
                 }
+
+                // clear selection
+                if let Some(f) = self.found_mut() {
+                    f.clear_queue();
+                    self.update_find_list();
+                }
             }
             SelectedFile::None => {}
         }
@@ -200,10 +214,15 @@ impl FileTransferActivity {
             }
             SelectedFile::Many(entries) => {
                 // Iter files
-                for entry in entries.iter() {
+                for (entry, _) in entries.iter() {
                     // Open file
                     self.open_found_file(entry, None);
                 }
+                // clear selection
+                if let Some(f) = self.found_mut() {
+                    f.clear_queue();
+                    self.update_find_list();
+                }
             }
             SelectedFile::None => {}
         }
@@ -217,10 +236,15 @@ impl FileTransferActivity {
             }
             SelectedFile::Many(entries) => {
                 // Iter files
-                for entry in entries.iter() {
+                for (entry, _) in entries.iter() {
                     // Open file
                     self.open_found_file(entry, Some(with));
                 }
+                // clear selection
+                if let Some(f) = self.found_mut() {
+                    f.clear_queue();
+                    self.update_find_list();
+                }
             }
             SelectedFile::None => {}
         }

src/ui/activities/filetransfer/actions/mod.rs

@@ -2,15 +2,19 @@
 //!
 //! `filetransfer_activiy` is the module which implements the Filetransfer activity, which is the main activity afterall
 
+use std::path::{Path, PathBuf};
+
 use remotefs::File;
 use remotefs::fs::UnixPex;
 use tuirealm::{State, StateValue};
 
 use super::browser::FileExplorerTab;
+use super::lib::browser::FoundExplorerTab;
 use super::{
     FileTransferActivity, Id, LogLevel, Msg, PendingActionMsg, TransferMsg, TransferOpts,
     TransferPayload, UiMsg,
 };
+use crate::explorer::FileExplorer;
 
 // actions
 pub(crate) mod change_dir;
@@ -37,7 +41,8 @@ pub(crate) mod watcher;
 #[derive(Debug)]
 pub(crate) enum SelectedFile {
     One(File),
-    Many(Vec<File>),
+    /// List of file with their destination path
+    Many(Vec<(File, PathBuf)>),
     None,
 }
 
@@ -46,7 +51,10 @@ impl SelectedFile {
     /// In case is `Many` the first item mode is returned
     pub fn unix_pex(&self) -> Option<UnixPex> {
         match self {
-            Self::Many(files) => files.iter().next().and_then(|file| file.metadata().mode),
+            Self::Many(files) => files
+                .iter()
+                .next()
+                .and_then(|(file, _)| file.metadata().mode),
             Self::One(file) => file.metadata().mode,
             Self::None => None,
         }
@@ -56,7 +64,7 @@ impl SelectedFile {
     pub fn get_files(self) -> Vec<File> {
         match self {
             Self::One(file) => vec![file],
-            Self::Many(files) => files,
+            Self::Many(files) => files.into_iter().map(|(f, _)| f).collect(),
             Self::None => vec![],
         }
     }
@@ -65,7 +73,6 @@ impl SelectedFile {
 #[derive(Debug)]
 enum SelectedFileIndex {
     One(usize),
-    Many(Vec<usize>), // TODO: remove
     None,
 }
 
@@ -78,68 +85,42 @@ impl From<Option<&File>> for SelectedFile {
     }
 }
 
-impl From<Vec<&File>> for SelectedFile {
-    fn from(files: Vec<&File>) -> Self {
-        SelectedFile::Many(files.into_iter().cloned().collect())
-    }
-}
-
 impl FileTransferActivity {
     /// Get local file entry
-    pub(crate) fn get_local_selected_entries(&self) -> SelectedFile {
+    pub(crate) fn get_local_selected_entries(&mut self) -> SelectedFile {
-        match self.get_selected_index(&Id::ExplorerHostBridge) {
+        self.get_selected_files(&Id::ExplorerHostBridge)
-            SelectedFileIndex::One(idx) => SelectedFile::from(self.host_bridge().get(idx)),
+    }
-            SelectedFileIndex::Many(files) => {
+
-                let files: Vec<&File> = files
+    pub(crate) fn get_local_selected_file(&self) -> Option<File> {
-                    .iter()
+        self.get_selected_file(&Id::ExplorerHostBridge)
-                    .filter_map(|x| self.host_bridge().get(*x)) // Usize to Option<File>
-                    .collect();
-                SelectedFile::from(files)
-            }
-            SelectedFileIndex::None => SelectedFile::None,
-        }
     }
 
     /// Get remote file entry
-    pub(crate) fn get_remote_selected_entries(&self) -> SelectedFile {
+    pub(crate) fn get_remote_selected_entries(&mut self) -> SelectedFile {
-        match self.get_selected_index(&Id::ExplorerRemote) {
+        self.get_selected_files(&Id::ExplorerRemote)
-            SelectedFileIndex::One(idx) => SelectedFile::from(self.remote().get(idx)),
+    }
-            SelectedFileIndex::Many(files) => {
+
-                let files: Vec<&File> = files
+    pub(crate) fn get_remote_selected_file(&self) -> Option<File> {
-                    .iter()
+        self.get_selected_file(&Id::ExplorerRemote)
-                    .filter_map(|x| self.remote().get(*x)) // Usize to Option<File>
-                    .collect();
-                SelectedFile::from(files)
-            }
-            SelectedFileIndex::None => SelectedFile::None,
-        }
     }
 
     /// Returns whether only one entry is selected on local host
-    pub(crate) fn is_local_selected_one(&self) -> bool {
+    pub(crate) fn is_local_selected_one(&mut self) -> bool {
         matches!(self.get_local_selected_entries(), SelectedFile::One(_))
     }
 
     /// Returns whether only one entry is selected on remote host
-    pub(crate) fn is_remote_selected_one(&self) -> bool {
+    pub(crate) fn is_remote_selected_one(&mut self) -> bool {
         matches!(self.get_remote_selected_entries(), SelectedFile::One(_))
     }
 
     /// Get remote file entry
-    pub(crate) fn get_found_selected_entries(&self) -> SelectedFile {
+    pub(crate) fn get_found_selected_entries(&mut self) -> SelectedFile {
-        match self.get_selected_index(&Id::ExplorerFind) {
+        self.get_selected_files(&Id::ExplorerFind)
-            SelectedFileIndex::One(idx) => {
+    }
-                SelectedFile::from(self.found().as_ref().unwrap().get(idx))
+
-            }
+    pub(crate) fn get_found_selected_file(&self) -> Option<File> {
-            SelectedFileIndex::Many(files) => {
+        self.get_selected_file(&Id::ExplorerFind)
-                let files: Vec<&File> = files
-                    .iter()
-                    .filter_map(|x| self.found().as_ref().unwrap().get(*x)) // Usize to Option<File>
-                    .collect();
-                SelectedFile::from(files)
-            }
-            SelectedFileIndex::None => SelectedFile::None,
-        }
     }
 
     // -- private
@@ -147,17 +128,74 @@ impl FileTransferActivity {
     fn get_selected_index(&self, id: &Id) -> SelectedFileIndex {
         match self.app.state(id) {
             Ok(State::One(StateValue::Usize(idx))) => SelectedFileIndex::One(idx),
-            Ok(State::Vec(files)) => {
-                let list: Vec<usize> = files
-                    .iter()
-                    .map(|x| match x {
-                        StateValue::Usize(v) => *v,
-                        _ => 0,
-                    })
-                    .collect();
-                SelectedFileIndex::Many(list)
-            }
             _ => SelectedFileIndex::None,
         }
     }
+
+    fn get_selected_files(&mut self, id: &Id) -> SelectedFile {
+        let browser = self.browser_by_id(id);
+        // if transfer queue is not empty, return that
+        let transfer_queue = browser.enqueued().clone();
+        if !transfer_queue.is_empty() {
+            return SelectedFile::Many(
+                transfer_queue
+                    .iter()
+                    .filter_map(|(src, dest)| {
+                        let src_file = self.get_file_from_path(id, src)?;
+                        Some((src_file, dest.clone()))
+                    })
+                    .collect(),
+            );
+        }
+
+        let browser = self.browser_by_id(id);
+        // if no transfer queue, return selected files
+        match self.get_selected_index(id) {
+            SelectedFileIndex::One(idx) => {
+                let Some(f) = browser.get(idx) else {
+                    return SelectedFile::None;
+                };
+                SelectedFile::One(f.clone())
+            }
+            SelectedFileIndex::None => SelectedFile::None,
+        }
+    }
+
+    fn get_file_from_path(&mut self, id: &Id, path: &Path) -> Option<File> {
+        match id {
+            &Id::ExplorerHostBridge => self.host_bridge.stat(path).ok(),
+            &Id::ExplorerRemote => self.client.stat(path).ok(),
+            &Id::ExplorerFind => {
+                let found = self.browser.found_tab().unwrap();
+                match found {
+                    FoundExplorerTab::Local => self.host_bridge.stat(path).ok(),
+                    FoundExplorerTab::Remote => self.client.stat(path).ok(),
+                }
+            }
+            _ => None,
+        }
+    }
+
+    fn browser_by_id(&self, id: &Id) -> &FileExplorer {
+        match id {
+            &Id::ExplorerHostBridge => self.host_bridge(),
+            &Id::ExplorerRemote => self.remote(),
+            &Id::ExplorerFind => self.found().as_ref().unwrap(),
+            _ => unreachable!(),
+        }
+    }
+
+    fn get_selected_file(&self, id: &Id) -> Option<File> {
+        let browser = self.browser_by_id(id);
+        // if no transfer queue, return selected files
+        match self.get_selected_index(id) {
+            SelectedFileIndex::One(idx) => {
+                let Some(f) = browser.get(idx) else {
+                    return None;
+                };
+                Some(f.clone())
+            }
+            SelectedFileIndex::None => None,
+        }
+    }
 }

src/ui/activities/filetransfer/actions/open.rs

@@ -13,24 +13,32 @@ impl FileTransferActivity {
     pub(crate) fn action_open_local(&mut self) {
         let entries: Vec<File> = match self.get_local_selected_entries() {
             SelectedFile::One(entry) => vec![entry],
-            SelectedFile::Many(entries) => entries,
+            SelectedFile::Many(entries) => entries.into_iter().map(|(f, _)| f).collect(),
             SelectedFile::None => vec![],
         };
         entries
             .iter()
             .for_each(|x| self.action_open_local_file(x, None));
+
+        // clear selection
+        self.host_bridge_mut().clear_queue();
+        self.reload_host_bridge_filelist();
     }
 
     /// Open local file
     pub(crate) fn action_open_remote(&mut self) {
         let entries: Vec<File> = match self.get_remote_selected_entries() {
             SelectedFile::One(entry) => vec![entry],
-            SelectedFile::Many(entries) => entries,
+            SelectedFile::Many(entries) => entries.into_iter().map(|(f, _)| f).collect(),
             SelectedFile::None => vec![],
         };
         entries
             .iter()
             .for_each(|x| self.action_open_remote_file(x, None));
+
+        // clear selection
+        self.remote_mut().clear_queue();
+        self.reload_remote_filelist();
     }
 
     /// Perform open lopcal file
@@ -86,26 +94,33 @@ impl FileTransferActivity {
     pub(crate) fn action_local_open_with(&mut self, with: &str) {
         let entries: Vec<File> = match self.get_local_selected_entries() {
             SelectedFile::One(entry) => vec![entry],
-            SelectedFile::Many(entries) => entries,
+            SelectedFile::Many(entries) => entries.into_iter().map(|(f, _)| f).collect(),
             SelectedFile::None => vec![],
         };
         // Open all entries
         entries
             .iter()
             .for_each(|x| self.action_open_local_file(x, Some(with)));
+
+        // clear selection
+        self.host_bridge_mut().clear_queue();
     }
 
     /// Open selected file with provided application
     pub(crate) fn action_remote_open_with(&mut self, with: &str) {
         let entries: Vec<File> = match self.get_remote_selected_entries() {
             SelectedFile::One(entry) => vec![entry],
-            SelectedFile::Many(entries) => entries,
+            SelectedFile::Many(entries) => entries.into_iter().map(|(f, _)| f).collect(),
             SelectedFile::None => vec![],
         };
         // Open all entries
         entries
             .iter()
             .for_each(|x| self.action_open_remote_file(x, Some(with)));
+
+        // clear selection
+        self.remote_mut().clear_queue();
+        self.reload_remote_filelist();
     }
 
     fn open_bridged_file(&mut self, entry: &File, open_with: Option<&str>) {

src/ui/activities/filetransfer/actions/rename.rs

@@ -18,13 +18,15 @@ impl FileTransferActivity {
             }
             SelectedFile::Many(entries) => {
                 // Try to copy each file to Input/{FILE_NAME}
-                let base_path: PathBuf = PathBuf::from(input);
                 // Iter files
-                for entry in entries.iter() {
+                for (entry, mut dest_path) in entries.into_iter() {
-                    let mut dest_path: PathBuf = base_path.clone();
                     dest_path.push(entry.name());
-                    self.local_rename_file(entry, dest_path.as_path());
+                    self.local_rename_file(&entry, dest_path.as_path());
                 }
+
+                // clear selection
+                self.host_bridge_mut().clear_queue();
+                self.reload_host_bridge_filelist();
             }
             SelectedFile::None => {}
         }
@@ -38,13 +40,16 @@ impl FileTransferActivity {
             }
             SelectedFile::Many(entries) => {
                 // Try to copy each file to Input/{FILE_NAME}
-                let base_path: PathBuf = PathBuf::from(input);
                 // Iter files
-                for entry in entries.iter() {
+                for (entry, mut dest_path) in entries.into_iter() {
-                    let mut dest_path: PathBuf = base_path.clone();
                     dest_path.push(entry.name());
-                    self.remote_rename_file(entry, dest_path.as_path());
+                    self.remote_rename_file(&entry, dest_path.as_path());
                 }
+
+                // clear selection
+                self.remote_mut().clear_queue();
+                // reload remote
+                self.reload_remote_filelist();
             }
             SelectedFile::None => {}
         }

src/ui/activities/filetransfer/actions/save.rs

@@ -64,11 +64,12 @@ impl FileTransferActivity {
                     // Check which file would be replaced
                     let existing_files: Vec<&File> = entries
                         .iter()
-                        .filter(|x| {
+                        .filter(|(x, dest_path)| {
                             self.remote_file_exists(
                                 Self::file_to_check_many(x, dest_path.as_path()).as_path(),
                             )
                         })
+                        .map(|(x, _)| x)
                         .collect();
                     // Check whether to replace files
                     if !existing_files.is_empty() && !self.should_replace_files(existing_files) {
@@ -76,7 +77,7 @@ impl FileTransferActivity {
                     }
                 }
                 if let Err(err) = self.filetransfer_send(
-                    TransferPayload::Many(entries),
+                    TransferPayload::TransferQueue(entries),
                     dest_path.as_path(),
                     None,
                 ) {
@@ -86,6 +87,10 @@ impl FileTransferActivity {
                             format!("Could not upload file: {err}"),
                         );
                     }
+                } else {
+                    // clear selection
+                    self.host_bridge_mut().clear_queue();
+                    self.reload_host_bridge_filelist();
                 }
             }
             SelectedFile::None => {}
@@ -128,11 +133,12 @@ impl FileTransferActivity {
                     // Check which file would be replaced
                     let existing_files: Vec<&File> = entries
                         .iter()
-                        .filter(|x| {
+                        .filter(|(x, dest_path)| {
                             self.host_bridge_file_exists(
                                 Self::file_to_check_many(x, dest_path.as_path()).as_path(),
                             )
                         })
+                        .map(|(x, _)| x)
                         .collect();
                     // Check whether to replace files
                     if !existing_files.is_empty() && !self.should_replace_files(existing_files) {
@@ -140,7 +146,7 @@ impl FileTransferActivity {
                     }
                 }
                 if let Err(err) = self.filetransfer_recv(
-                    TransferPayload::Many(entries),
+                    TransferPayload::TransferQueue(entries),
                     dest_path.as_path(),
                     None,
                 ) {
@@ -150,6 +156,11 @@ impl FileTransferActivity {
                             format!("Could not download file: {err}"),
                         );
                     }
+                } else {
+                    // clear selection
+                    self.remote_mut().clear_queue();
+                    // reload remote
+                    self.reload_remote_filelist();
                 }
             }
             SelectedFile::None => {}

src/ui/activities/filetransfer/actions/symlink.rs

@@ -5,12 +5,12 @@
 // locals
 use std::path::PathBuf;
 
-use super::{FileTransferActivity, LogLevel, SelectedFile};
+use super::{FileTransferActivity, LogLevel};
 
 impl FileTransferActivity {
     /// Create symlink on localhost
     pub(crate) fn action_local_symlink(&mut self, name: String) {
-        if let SelectedFile::One(entry) = self.get_local_selected_entries() {
+        if let Some(entry) = self.get_local_selected_file() {
             match self
                 .host_bridge
                 .symlink(PathBuf::from(name.as_str()).as_path(), entry.path())
@@ -34,7 +34,7 @@ impl FileTransferActivity {
 
     /// Copy file on remote
     pub(crate) fn action_remote_symlink(&mut self, name: String) {
-        if let SelectedFile::One(entry) = self.get_remote_selected_entries() {
+        if let Some(entry) = self.get_remote_selected_file() {
             match self
                 .client
                 .symlink(PathBuf::from(name.as_str()).as_path(), entry.path())

src/ui/activities/filetransfer/lib/browser.rs

@@ -60,18 +60,6 @@ impl Browser {
         }
     }
 
-    pub fn other_explorer(&self) -> &FileExplorer {
-        let found_set = self.found.is_some();
-        match (self.tab, found_set) {
-            (FileExplorerTab::HostBridge, false) => &self.remote,
-            (FileExplorerTab::Remote, false) => &self.host_bridge,
-            (FileExplorerTab::HostBridge, true) => &self.found.as_ref().unwrap().explorer,
-            (FileExplorerTab::Remote, true) => &self.found.as_ref().unwrap().explorer,
-            (FileExplorerTab::FindHostBridge, _) => &self.remote,
-            (FileExplorerTab::FindRemote, _) => &self.host_bridge,
-        }
-    }
-
     pub fn other_explorer_no_found(&self) -> &FileExplorer {
         match self.tab {
             FileExplorerTab::HostBridge | FileExplorerTab::FindHostBridge => &self.remote,

src/ui/activities/filetransfer/misc.rs

@@ -228,7 +228,7 @@ impl FileTransferActivity {
                     transfer_stats
                 )
             }
-            TransferPayload::Many(entries) => {
+            TransferPayload::TransferQueue(entries) => {
                 format!(
                     "{} files has been successfully transferred ({})",
                     entries.len(),
@@ -485,7 +485,14 @@ impl FileTransferActivity {
             .found()
             .unwrap()
             .iter_files()
-            .map(|x| vec![TextSpan::from(self.found().unwrap().fmt_file(x))])
+            .map(|x| {
+                let mut span = TextSpan::from(self.found().unwrap().fmt_file(x));
+                if self.found().unwrap().enqueued().contains_key(x.path()) {
+                    span.modifiers |=
+                        TextModifiers::REVERSED | TextModifiers::UNDERLINED | TextModifiers::ITALIC;
+                }
+                vec![span]
+            })
             .collect();
         assert!(
             self.app

src/ui/activities/filetransfer/session.rs

@@ -41,7 +41,8 @@ enum TransferErrorReason {
 pub(super) enum TransferPayload {
     File(File),
     Any(File),
-    Many(Vec<File>),
+    /// List of file with their destination name
+    TransferQueue(Vec<(File, PathBuf)>),
 }
 
 impl FileTransferActivity {
@@ -264,8 +265,8 @@ impl FileTransferActivity {
             TransferPayload::File(ref file) => {
                 self.filetransfer_send_file(file, curr_remote_path, dst_name)
             }
-            TransferPayload::Many(ref entries) => {
+            TransferPayload::TransferQueue(ref entries) => {
-                self.filetransfer_send_many(entries, curr_remote_path)
+                self.filetransfer_send_transfer_queue(entries)
             }
         };
         // Notify
@@ -331,18 +332,17 @@ impl FileTransferActivity {
         result
     }
 
-    /// Send many entries to remote
+    /// Send transfer queue entries to remote
-    fn filetransfer_send_many(
+    fn filetransfer_send_transfer_queue(
         &mut self,
-        entries: &[File],
+        entries: &[(File, PathBuf)],
-        curr_remote_path: &Path,
     ) -> Result<(), String> {
         // Reset states
         self.transfer.reset();
         // Calculate total size of transfer
         let total_transfer_size: usize = entries
             .iter()
-            .map(|x| self.get_total_transfer_size_host(x))
+            .map(|(x, _)| self.get_total_transfer_size_host(x))
             .sum();
         self.transfer.full.init(total_transfer_size);
         // Mount progress bar
@@ -350,7 +350,7 @@ impl FileTransferActivity {
         // Send recurse
         let result = entries
             .iter()
-            .map(|x| self.filetransfer_send_recurse(x, curr_remote_path, None))
+            .map(|(x, remote)| self.filetransfer_send_recurse(x, &remote, None))
             .find(|x| x.is_err())
             .unwrap_or(Ok(()));
         // Umount progress bar
@@ -704,8 +704,8 @@ impl FileTransferActivity {
                 self.filetransfer_recv_any(entry, host_bridge_path, dst_name)
             }
             TransferPayload::File(ref file) => self.filetransfer_recv_file(file, host_bridge_path),
-            TransferPayload::Many(ref entries) => {
+            TransferPayload::TransferQueue(ref entries) => {
-                self.filetransfer_recv_many(entries, host_bridge_path)
+                self.filetransfer_recv_transfer_queue(entries)
             }
         };
         // Notify
@@ -764,18 +764,17 @@ impl FileTransferActivity {
         result.map_err(|x| x.to_string())
     }
 
-    /// Send many entries to remote
+    /// Receive transfer queue from remote
-    fn filetransfer_recv_many(
+    fn filetransfer_recv_transfer_queue(
         &mut self,
-        entries: &[File],
+        entries: &[(File, PathBuf)],
-        curr_remote_path: &Path,
     ) -> Result<(), String> {
         // Reset states
         self.transfer.reset();
         // Calculate total size of transfer
         let total_transfer_size: usize = entries
             .iter()
-            .map(|x| self.get_total_transfer_size_remote(x))
+            .map(|(x, _)| self.get_total_transfer_size_remote(x))
             .sum();
         self.transfer.full.init(total_transfer_size);
         // Mount progress bar
@@ -783,7 +782,7 @@ impl FileTransferActivity {
         // Send recurse
         let result = entries
             .iter()
-            .map(|x| self.filetransfer_recv_recurse(x, curr_remote_path, None))
+            .map(|(x, path)| self.filetransfer_recv_recurse(x, &path, None))
             .find(|x| x.is_err())
             .unwrap_or(Ok(()));
         // Umount progress bar

src/ui/activities/filetransfer/update.rs

@@ -113,7 +113,7 @@ impl FileTransferActivity {
                 }
             }
             TransferMsg::EnterDirectory if self.browser.tab() == FileExplorerTab::HostBridge => {
-                if let SelectedFile::One(entry) = self.get_local_selected_entries() {
+                if let Some(entry) = self.get_local_selected_file() {
                     self.action_submit_local(entry);
                     // Update file list if sync
                     if self.browser.sync_browsing && self.browser.found().is_none() {
@@ -123,7 +123,7 @@ impl FileTransferActivity {
                 }
             }
             TransferMsg::EnterDirectory if self.browser.tab() == FileExplorerTab::Remote => {
-                if let SelectedFile::One(entry) = self.get_remote_selected_entries() {
+                if let Some(entry) = self.get_remote_selected_file() {
                     self.action_submit_remote(entry);
                     // Update file list if sync
                     if self.browser.sync_browsing && self.browser.found().is_none() {