remove load bar panel and draw loading bar in bottom panel instead

 - revert command parsing back to original logic
 - add support for manual refresh of currently viewing directories

6 files changed, 169 insertions, 121 deletions

diff --git a/src/joshuto.rs b/src/joshuto.rs
index 3d99184..61b6295 100644
--- a/src/joshuto.rs
+++ b/src/joshuto.rs
@@ -254,7 +254,7 @@ pub fn run(config_t: config::JoshutoConfig,
         }
 
         if tabs[index].threads.len() > 0 {
-            ncurses::timeout(2);
+            ncurses::timeout(0);
         } else {
             ncurses::timeout(-1);
         }
@@ -269,15 +269,16 @@ pub fn run(config_t: config::JoshutoConfig,
                     if progress_info.bytes_finished == progress_info.total_bytes {
                         let (_, chandle) = tabs[index].threads.remove(i);
                         chandle.join().unwrap();
-                        ncurses::werase(tabs[index].views.load_bar.win);
-                        ncurses::wnoutrefresh(tabs[index].views.load_bar.win);
+                        ui::redraw_status(&tabs[index].views, tabs[index].curr_list.as_ref(),
+                                &tabs[index].curr_path,
+                                &tabs[index].config_t.username, &tabs[index].config_t.hostname);
                         ncurses::doupdate();
                         something_finished = true;
                     } else {
                         let percent = (progress_info.bytes_finished as f64 /
                                 progress_info.total_bytes as f64) as f32;
-                        ui::draw_loading_bar(&tabs[index].views.load_bar, percent);
-                        ncurses::wnoutrefresh(tabs[index].views.load_bar.win);
+                        ui::draw_loading_bar(&tabs[index].views.bot_win, percent);
+                        ncurses::wnoutrefresh(tabs[index].views.bot_win.win);
                         ncurses::doupdate();
                     }
                 }
@@ -326,5 +327,4 @@ pub fn run(config_t: config::JoshutoConfig,
         }
         keycommand.execute(&mut tabs[index]);
     }
-    ncurses::endwin();
 }
diff --git a/src/joshuto/command.rs b/src/joshuto/command.rs
index 65b0695..f082185 100644
--- a/src/joshuto/command.rs
+++ b/src/joshuto/command.rs
@@ -20,6 +20,8 @@ pub use self::open_file::OpenFileWith;
 
 mod change_directory;
 pub use self::change_directory::ChangeDirectory;
+mod reload_dir;
+pub use self::reload_dir::ReloadDirList;
 
 mod cursor_move;
 pub use self::cursor_move::CursorMove;
@@ -108,127 +110,129 @@ pub fn split_shell_style(line: &String) -> Vec<&str>
 
 pub fn from_args(command: &str, args: Option<&Vec<String>>) -> Option<Box<dyn JoshutoCommand>>
 {
-    match args {
-        None => {
-            match command {
-                "quit" => Some(Box::new(self::Quit::new())),
-                "open_file" => Some(Box::new(self::OpenFile::new())),
-                "open_file_with" => Some(Box::new(self::OpenFileWith::new())),
-                "parent_directory" => Some(Box::new(self::ParentDirectory::new())),
-                "cursor_move_home" => Some(Box::new(self::CursorMoveHome::new())),
-                "cursor_move_end" => Some(Box::new(self::CursorMoveEnd::new())),
-                "cursor_move_page_up" => Some(Box::new(self::CursorMovePageUp::new())),
-                "cursor_move_page_down" => Some(Box::new(self::CursorMovePageDown::new())),
-
-                "toggle_hidden" => Some(Box::new(self::ToggleHiddenFiles::new())),
-
-                "cut_files" => Some(Box::new(self::CutFiles::new())),
-                "copy_files" => Some(Box::new(self::CopyFiles::new())),
-                "delete_files" => Some(Box::new(self::DeleteFiles::new())),
-                "rename_file" => Some(Box::new(self::RenameFile::new(self::RenameFileMethod::Append))),
-
-                "mkdir" => Some(Box::new(self::NewDirectory::new())),
-                "search" => Some(Box::new(self::Search::new())),
-                _ => None,
+    match command {
+        "cd" => {
+            if let Some(args) = args {
+                if args.len() > 0 {
+                    let path = path::PathBuf::from(args[0].as_str());
+                    Some(Box::new(self::ChangeDirectory::new(path)))
+                } else {
+                    None
+                }
+            } else {
+                None
             }
         },
-        Some(args) => {
-            let args_len = args.len();
-
-            match command {
-                "cd" => {
-                    if args_len > 0 {
-                        let path = path::PathBuf::from(args[0].as_str());
-                        Some(Box::new(self::ChangeDirectory::new(path)))
-                    } else {
-                        None
+        "copy_files" => Some(Box::new(self::CopyFiles::new())),
+        "cursor_move" => {
+            if let Some(args) = args {
+                if args.len() > 0 {
+                    match args[0].parse::<i32>() {
+                        Ok(s) => {
+                            Some(Box::new(self::CursorMove::new(s)))
+                        },
+                        Err(e) => {
+                            eprintln!("{}", e);
+                            None
+                        },
                     }
-                },
-                "cursor_move" => {
-                    if args_len > 0 {
-                        match args[0].parse::<i32>() {
-                            Ok(s) => {
-                                Some(Box::new(self::CursorMove::new(s)))
+                } else {
+                    None
+                }
+            } else {
+                None
+            }
+        },
+        "cursor_move_home" => Some(Box::new(self::CursorMoveHome::new())),
+        "cursor_move_end" => Some(Box::new(self::CursorMoveEnd::new())),
+        "cursor_move_page_up" => Some(Box::new(self::CursorMovePageUp::new())),
+        "cursor_move_page_down" => Some(Box::new(self::CursorMovePageDown::new())),
+        "cut_files" => Some(Box::new(self::CutFiles::new())),
+        "delete_files" => Some(Box::new(self::DeleteFiles::new())),
+        "mkdir" => Some(Box::new(self::NewDirectory::new())),
+        "open_file" => Some(Box::new(self::OpenFile::new())),
+        "open_file_with" => Some(Box::new(self::OpenFileWith::new())),
+        "parent_directory" => Some(Box::new(self::ParentDirectory::new())),
+        "paste_files" => {
+            let mut options = fs_extra::dir::CopyOptions::new();
+            if let Some(args) = args {
+                for arg in args {
+                    let splitarg: Vec<&str> = arg.split('=').collect();
+                    if splitarg.len() == 2 {
+                        match splitarg[0] {
+                            "overwrite" => {
+                                if let Ok(s) = splitarg[1].parse::<bool>() {
+                                    options.overwrite = s;
+                                } else {
+                                    eprintln!("Failed to parse: {}", arg);
+                                }
                             },
-                            Err(e) => {
-                                eprintln!("{}", e);
-                                None
+                            "skip_exist" => {
+                                if let Ok(s) = splitarg[1].parse::<bool>() {
+                                    options.skip_exist = s;
+                                } else {
+                                    eprintln!("Failed to parse: {}", arg);
+                                }
                             },
+                            _ => {},
                         }
-                    } else {
-                        None
-                    }
-                },
-                "paste_files" => {
-                    let mut options = fs_extra::dir::CopyOptions::new();
-                    for arg in args {
-                        let splitarg: Vec<&str> = arg.split('=').collect();
-                        if splitarg.len() == 2 {
-                            match splitarg[0] {
-                                "overwrite" => {
-                                    if let Ok(s) = splitarg[1].parse::<bool>() {
-                                        options.overwrite = s;
-                                    } else {
-                                        eprintln!("Failed to parse: {}", arg);
-                                    }
-                                },
-                                "skip_exist" => {
-                                    if let Ok(s) = splitarg[1].parse::<bool>() {
-                                        options.skip_exist = s;
-                                    } else {
-                                        eprintln!("Failed to parse: {}", arg);
-                                    }
-                                },
-                                _ => {},
-                            }
-                        }
-                    }
-                    let paste = self::PasteFiles::new(options);
-                    Some(Box::new(paste))
-                },
-                "rename_file" => {
-                    let method: self::file_operation::RenameFileMethod;
-                    if args_len > 0 {
-                        method = match args[0].as_str() {
-                            "prepend" => self::RenameFileMethod::Prepend,
-                            "overwrite" => self::RenameFileMethod::Overwrite,
-                            "append" => self::RenameFileMethod::Append,
-                            _ => self::RenameFileMethod::Append,
-                        };
-                        Some(Box::new(self::RenameFile::new(method)))
-                    } else {
-                        None
                     }
                 }
-                "select_files" => {
-                    let mut toggle = false;
-                    let mut all = false;
-                    for arg in args {
-                        let splitarg: Vec<&str> = arg.split('=').collect();
-                        if splitarg.len() == 2 {
-                            match splitarg[0] {
-                                "toggle" => {
-                                    if let Ok(s) = splitarg[1].parse::<bool>() {
-                                        toggle = s;
-                                    } else {
-                                        eprintln!("Failed to parse: {}", arg);
-                                    }
-                                },
-                                "all" => {
-                                    if let Ok(s) = splitarg[1].parse::<bool>() {
-                                        all = s;
-                                    } else {
-                                        eprintln!("Failed to parse: {}", arg);
-                                    }
-                                },
-                                _ => {},
-                            }
+            }
+            let paste = self::PasteFiles::new(options);
+            Some(Box::new(paste))
+        },
+        "quit" => Some(Box::new(self::Quit::new())),
+        "reload_dir_list" => Some(Box::new(self::ReloadDirList::new())),
+        "rename_file" => {
+            let method: self::file_operation::RenameFileMethod;
+            if let Some(args) = args {
+                if args.len() > 0 {
+                    method = match args[0].as_str() {
+                        "prepend" => self::RenameFileMethod::Prepend,
+                        "overwrite" => self::RenameFileMethod::Overwrite,
+                        "append" => self::RenameFileMethod::Append,
+                        _ => self::RenameFileMethod::Append,
+                    };
+                } else {
+                    method = self::RenameFileMethod::Append;
+                }
+            } else {
+                method = self::RenameFileMethod::Append;
+            }
+            Some(Box::new(self::RenameFile::new(method)))
+        }
+        "search" => Some(Box::new(self::Search::new())),
+        "select_files" => {
+            let mut toggle = false;
+            let mut all = false;
+            if let Some(args) = args {
+                for arg in args {
+                    let splitarg: Vec<&str> = arg.split('=').collect();
+                    if splitarg.len() == 2 {
+                        match splitarg[0] {
+                            "toggle" => {
+                                if let Ok(s) = splitarg[1].parse::<bool>() {
+                                    toggle = s;
+                                } else {
+                                    eprintln!("Failed to parse: {}", arg);
+                                }
+                            },
+                            "all" => {
+                                if let Ok(s) = splitarg[1].parse::<bool>() {
+                                    all = s;
+                                } else {
+                                    eprintln!("Failed to parse: {}", arg);
+                                }
+                            },
+                            _ => {},
                         }
                     }
-                    Some(Box::new(self::SelectFiles::new(toggle, all)))
-                },
-                _ => None,
+                }
             }
+            Some(Box::new(self::SelectFiles::new(toggle, all)))
         },
+        "toggle_hidden" => Some(Box::new(self::ToggleHiddenFiles::new())),
+        _ => None,
     }
 }
diff --git a/src/joshuto/command/reload_dir.rs b/src/joshuto/command/reload_dir.rs
new file mode 100644
index 0000000..6a401e7
--- /dev/null
+++ b/src/joshuto/command/reload_dir.rs
@@ -0,0 +1,44 @@
+extern crate fs_extra;
+extern crate ncurses;
+
+use std;
+
+use std::fmt;
+
+use joshuto;
+use joshuto::ui;
+use joshuto::command;
+
+#[derive(Debug)]
+pub struct ReloadDirList;
+
+impl ReloadDirList {
+    pub fn new() -> Self { ReloadDirList }
+    pub fn command() -> &'static str { "reload_dir_list" }
+}
+
+impl command::JoshutoCommand for ReloadDirList {}
+
+impl std::fmt::Display for ReloadDirList {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result
+    {
+        write!(f, "{}", Self::command())
+    }
+}
+
+impl command::Runnable for ReloadDirList {
+    fn execute(&self, context: &mut joshuto::JoshutoContext)
+    {
+        context.reload_dirlists();
+
+        ui::redraw_view(&context.views.left_win, context.parent_list.as_ref());
+        ui::redraw_view(&context.views.mid_win, context.curr_list.as_ref());
+        ui::redraw_view(&context.views.right_win, context.preview_list.as_ref());
+
+        ui::redraw_status(&context.views, context.curr_list.as_ref(),
+                &context.curr_path,
+                &context.config_t.username, &context.config_t.hostname);
+
+        ncurses::doupdate();
+    }
+}
diff --git a/src/joshuto/keymap.rs b/src/joshuto/keymap.rs
index dec5ab5..96357da 100644
--- a/src/joshuto/keymap.rs
+++ b/src/joshuto/keymap.rs
@@ -4,8 +4,6 @@ extern crate xdg;
 
 use std::collections::HashMap;
 use std::fs;
-use std::io;
-use std::io::BufRead;
 use std::process;
 
 use joshuto::command;
diff --git a/src/joshuto/ui.rs b/src/joshuto/ui.rs
index a6b021a..679a2d5 100644
--- a/src/joshuto/ui.rs
+++ b/src/joshuto/ui.rs
@@ -301,7 +301,7 @@ pub fn redraw_status(joshuto_view : &window::JoshutoView,
 pub fn draw_loading_bar(win: &window::JoshutoPanel, percentage: f32)
 {
     let cols: i32 = (win.cols as f32 * percentage) as i32;
-    ncurses::mvwchgat(win.win, 0, 0, cols, ncurses::A_STANDOUT(), 0);
+    ncurses::mvwchgat(win.win, 0, 0, cols, ncurses::A_STANDOUT(), SELECT_COLOR);
 }
 
 pub fn display_contents(win: &window::JoshutoPanel,
diff --git a/src/joshuto/window.rs b/src/joshuto/window.rs
index 025a818..eeb08f3 100644
--- a/src/joshuto/window.rs
+++ b/src/joshuto/window.rs
@@ -78,7 +78,6 @@ pub struct JoshutoView {
     pub mid_win: JoshutoPanel,
     pub right_win: JoshutoPanel,
     pub bot_win: JoshutoPanel,
-    pub load_bar: JoshutoPanel,
     pub win_ratio: (usize, usize, usize),
 }
 
@@ -112,8 +111,10 @@ impl JoshutoView {
         let win_coord: (usize, usize) = (term_rows as usize - 1, 0);
         let bot_win = JoshutoPanel::new(win_xy.0, win_xy.1, win_coord);
 
+/*
         let load_bar = JoshutoPanel::new(win_xy.0, win_xy.1, win_coord);
         load_bar.move_to_bottom();
+*/
 
         ncurses::refresh();
 
@@ -123,7 +124,6 @@ impl JoshutoView {
             mid_win,
             right_win,
             bot_win,
-            load_bar,
             win_ratio,
         }
     }
@@ -157,7 +157,9 @@ impl JoshutoView {
         let win_coord: (usize, usize) = (term_rows as usize - 1, 0);
         self.bot_win.redraw(win_xy.0, win_xy.1, win_coord);
 
+/*
         self.load_bar.redraw(win_xy.0, win_xy.1, win_coord);
         self.load_bar.move_to_bottom();
+*/
     }
 }