move view struct out of Context and pass in as a separate argument

 - rename static variables to all caps
 - change index to be Option<usize> rather than i32 where -1 means
   the directory is empty

28 files changed, 439 insertions, 377 deletions

diff --git a/src/commands/change_directory.rs b/src/commands/change_directory.rs
index 0b96145..ae77964 100644
--- a/src/commands/change_directory.rs
+++ b/src/commands/change_directory.rs
@@ -4,6 +4,7 @@ use crate::commands::{JoshutoCommand, JoshutoRunnable};
 use crate::context::JoshutoContext;
 use crate::preview;
 use crate::ui;
+use crate::window::JoshutoView;
 
 #[derive(Clone, Debug)]
 pub struct ChangeDirectory {
@@ -18,9 +19,13 @@ impl ChangeDirectory {
         "cd"
     }
 
-    pub fn change_directory(path: &path::PathBuf, context: &mut JoshutoContext) {
+    pub fn change_directory(
+        path: &path::PathBuf,
+        context: &mut JoshutoContext,
+        view: &JoshutoView,
+    ) {
         if !path.exists() {
-            ui::wprint_err(&context.views.bot_win, "Error: No such file or directory");
+            ui::wprint_err(&view.bot_win, "Error: No such file or directory");
             return;
         }
         let curr_tab = &mut context.tabs[context.curr_tab_index];
@@ -30,7 +35,7 @@ impl ChangeDirectory {
                 curr_tab.curr_path = path.clone();
             }
             Err(e) => {
-                ui::wprint_err(&context.views.bot_win, e.to_string().as_str());
+                ui::wprint_err(&view.bot_win, e.to_string().as_str());
                 return;
             }
         }
@@ -50,7 +55,7 @@ impl ChangeDirectory {
         {
             Ok(s) => Some(s),
             Err(e) => {
-                ui::wprint_err(&context.views.bot_win, e.to_string().as_str());
+                ui::wprint_err(&view.bot_win, e.to_string().as_str());
                 None
             }
         };
@@ -62,14 +67,14 @@ impl ChangeDirectory {
             {
                 Ok(s) => Some(s),
                 Err(e) => {
-                    ui::wprint_err(&context.views.bot_win, e.to_string().as_str());
+                    ui::wprint_err(&view.bot_win, e.to_string().as_str());
                     None
                 }
             };
         }
 
         curr_tab.refresh(
-            &context.views,
+            view,
             &context.config_t,
             &context.username,
             &context.hostname,
@@ -86,11 +91,11 @@ impl std::fmt::Display for ChangeDirectory {
 }
 
 impl JoshutoRunnable for ChangeDirectory {
-    fn execute(&self, context: &mut JoshutoContext) {
-        Self::change_directory(&self.path, context);
+    fn execute(&self, context: &mut JoshutoContext, view: &JoshutoView) {
+        Self::change_directory(&self.path, context, view);
         preview::preview_file(
             &mut context.tabs[context.curr_tab_index],
-            &context.views,
+            &view,
             &context.config_t,
         );
         ncurses::doupdate();
diff --git a/src/commands/cursor_move.rs b/src/commands/cursor_move.rs
index c59fde6..4bc16c7 100644
--- a/src/commands/cursor_move.rs
+++ b/src/commands/cursor_move.rs
@@ -1,78 +1,119 @@
 use crate::commands::{JoshutoCommand, JoshutoRunnable};
 use crate::context::JoshutoContext;
-use crate::preview;
+use crate::window::JoshutoView;
+
+pub mod CursorMove {
+    use crate::context::JoshutoContext;
+    use crate::preview;
+    use crate::window::JoshutoView;
+
+    pub fn cursor_move(mut new_index: usize, context: &mut JoshutoContext, view: &JoshutoView) {
+        let curr_tab = &mut context.tabs[context.curr_tab_index];
+
+        if let Some(curr_list) = curr_tab.curr_list.as_mut() {
+            match curr_list.index {
+                None => {}
+                Some(index) => {
+                    let dir_len = curr_list.contents.len();
+                    if new_index >= dir_len {
+                        new_index = dir_len - 1;
+                        if index == dir_len - 1 {
+                            return;
+                        }
+                    }
+                    curr_list.index = Some(new_index);
+                }
+            }
+        }
+        curr_tab.refresh_curr(&view.mid_win, context.config_t.scroll_offset);
+        curr_tab.refresh_file_status(&view.bot_win);
+        curr_tab.refresh_path_status(
+            &view.top_win,
+            &context.username,
+            &context.hostname,
+            context.config_t.tilde_in_titlebar,
+        );
+        preview::preview_file(curr_tab, &view, &context.config_t);
+        ncurses::doupdate();
+    }
+}
 
 #[derive(Clone, Debug)]
-pub struct CursorMove {
-    movement: i32,
+pub struct CursorMoveInc {
+    movement: usize,
 }
 
-impl CursorMove {
-    pub fn new(movement: i32) -> Self {
-        CursorMove { movement }
+impl CursorMoveInc {
+    pub fn new(movement: usize) -> Self {
+        CursorMoveInc { movement }
     }
     pub const fn command() -> &'static str {
-        "cursor_move"
+        "cursor_move_increment"
     }
+}
 
-    pub fn cursor_move(new_index: i32, context: &mut JoshutoContext) {
-        {
-            let curr_tab = &mut context.tabs[context.curr_tab_index];
-
-            if let Some(ref mut curr_list) = curr_tab.curr_list {
-                let curr_index = curr_list.index;
-                let dir_len = curr_list.contents.len() as i32;
+impl JoshutoCommand for CursorMoveInc {}
 
-                let mut new_index = new_index;
-                if new_index <= 0 {
-                    new_index = 0;
-                    if curr_index <= 0 {
-                        return;
-                    }
-                } else if new_index >= dir_len {
-                    new_index = dir_len - 1;
-                    if curr_index == dir_len - 1 {
-                        return;
-                    }
-                }
+impl std::fmt::Display for CursorMoveInc {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{} {}", Self::command(), self.movement)
+    }
+}
 
-                curr_list.index = new_index;
+impl JoshutoRunnable for CursorMoveInc {
+    fn execute(&self, context: &mut JoshutoContext, view: &JoshutoView) {
+        let mut movement: Option<usize> = None;
+        {
+            let curr_tab = context.curr_tab_mut();
+            if let Some(curr_list) = curr_tab.curr_list.as_ref() {
+                movement = curr_list.index.map(|x| x + self.movement);
             }
-            curr_tab.refresh_curr(&context.views.mid_win, context.config_t.scroll_offset);
-            curr_tab.refresh_file_status(&context.views.bot_win);
-            curr_tab.refresh_path_status(
-                &context.views.top_win,
-                &context.username,
-                &context.hostname,
-                context.config_t.tilde_in_titlebar,
-            );
-            preview::preview_file(curr_tab, &context.views, &context.config_t);
         }
-        ncurses::doupdate();
+        if let Some(s) = movement {
+            CursorMove::cursor_move(s, context, view);
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct CursorMoveDec {
+    movement: usize,
+}
+
+impl CursorMoveDec {
+    pub fn new(movement: usize) -> Self {
+        CursorMoveDec { movement }
+    }
+    pub const fn command() -> &'static str {
+        "cursor_move_increment"
     }
 }
 
-impl JoshutoCommand for CursorMove {}
+impl JoshutoCommand for CursorMoveDec {}
 
-impl std::fmt::Display for CursorMove {
+impl std::fmt::Display for CursorMoveDec {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(f, "{} {}", Self::command(), self.movement)
     }
 }
 
-impl JoshutoRunnable for CursorMove {
-    fn execute(&self, context: &mut JoshutoContext) {
-        let mut movement: Option<i32> = None;
-
+impl JoshutoRunnable for CursorMoveDec {
+    fn execute(&self, context: &mut JoshutoContext, view: &JoshutoView) {
+        let mut movement: Option<usize> = None;
         {
-            let curr_tab = &mut context.tabs[context.curr_tab_index];
+            let curr_tab = context.curr_tab_mut();
             if let Some(curr_list) = curr_tab.curr_list.as_ref() {
-                let curr_index = curr_list.index;
-                movement = Some(curr_index + self.movement);
+                movement = curr_list.index.map(|x| {
+                    if x > self.movement {
+                        x - self.movement
+                    } else {
+                        0
+                    }
+                });
             }
         }
         if let Some(s) = movement {
-            CursorMove::cursor_move(s, context);
+            CursorMove::cursor_move(s, context, view);
         }
     }
 }
@@ -98,23 +139,21 @@ impl std::fmt::Display for CursorMovePageUp {
 }
 
 impl JoshutoRunnable for CursorMovePageUp {
-    fn execute(&self, context: &mut JoshutoContext) {
-        let mut movement: Option<i32> = None;
-
-        {
-            let curr_tab = &mut context.tabs[context.curr_tab_index];
+    fn execute(&self, context: &mut JoshutoContext, view: &JoshutoView) {
+        let movement: Option<usize> = {
+            let curr_tab = context.curr_tab_mut();
             if let Some(curr_list) = curr_tab.curr_list.as_ref() {
-                let curr_index = curr_list.index;
-                if curr_index <= 0 {
-                    return;
-                }
-
-                let half_page = context.views.mid_win.cols / 2;
-                movement = Some(curr_index - half_page);
+                let half_page = view.mid_win.cols as usize / 2;
+                curr_list
+                    .index
+                    .map(|x| if x > half_page { x - half_page } else { 0 })
+            } else {
+                None
             }
-        }
+        };
+
         if let Some(s) = movement {
-            CursorMove::cursor_move(s, context);
+            CursorMove::cursor_move(s, context, view);
         }
     }
 }
@@ -140,24 +179,26 @@ impl std::fmt::Display for CursorMovePageDown {
 }
 
 impl JoshutoRunnable for CursorMovePageDown {
-    fn execute(&self, context: &mut JoshutoContext) {
-        let mut movement: Option<i32> = None;
-
-        {
+    fn execute(&self, context: &mut JoshutoContext, view: &JoshutoView) {
+        let movement: Option<usize> = {
             let curr_tab = &mut context.tabs[context.curr_tab_index];
             if let Some(curr_list) = curr_tab.curr_list.as_ref() {
-                let curr_index = curr_list.index;
                 let dir_len = curr_list.contents.len();
-                if curr_index >= dir_len as i32 - 1 {
-                    return;
-                }
-
-                let half_page = context.views.mid_win.cols / 2;
-                movement = Some(curr_index + half_page);
+                let half_page = view.mid_win.cols as usize / 2;
+                curr_list.index.map(|x| {
+                    if x + half_page > dir_len - 1 {
+                        dir_len - 1
+                    } else {
+                        x + half_page
+                    }
+                })
+            } else {
+                None
             }
-        }
+        };
+
         if let Some(s) = movement {
-            CursorMove::cursor_move(s, context);
+            CursorMove::cursor_move(s, context, view);
         }
     }
 }
@@ -183,21 +224,22 @@ impl std::fmt::Display for CursorMoveHome {
 }
 
 impl JoshutoRunnable for CursorMoveHome {
-    fn execute(&self, context: &mut JoshutoContext) {
-        let mut movement: Option<i32> = None;
-
-        {
-            let curr_tab = &mut context.tabs[context.curr_tab_index];
+    fn execute(&self, context: &mut JoshutoContext, view: &JoshutoView) {
+        let movement: Option<usize> = {
+            let curr_tab = context.curr_tab_mut();
             if let Some(curr_list) = curr_tab.curr_list.as_ref() {
-                let curr_index = curr_list.index;
-                if curr_index <= 0 {
-                    return;
+                if curr_list.contents.len() == 0 {
+                    None
+                } else {
+                    Some(0)
                 }
-                movement = Some(0);
+            } else {
+                None
             }
-        }
+        };
+
         if let Some(s) = movement {
-            CursorMove::cursor_move(s, context);
+            CursorMove::cursor_move(s, context, view);
         }
     }
 }
@@ -223,23 +265,19 @@ impl std::fmt::Display for CursorMoveEnd {
 }
 
 impl JoshutoRunnable for CursorMoveEnd {
-    fn execute(&self, context: &mut JoshutoContext) {
-        let mut movement: Option<i32> = None;
-
-        {
-            let curr_tab = &mut context.tabs[context.curr_tab_index];
+    fn execute(&self, context: &mut JoshutoContext, view: &JoshutoView) {
+        let movement: Option<usize> = {
+            let curr_tab = context.curr_tab_mut();
             if let Some(curr_list) = curr_tab.curr_list.as_ref() {
-                let curr_index = curr_list.index;
                 let dir_len = curr_list.contents.len();
-                if curr_index >= dir_len as i32 - 1 {
-                    return;
-                }
-                movement = Some(dir_len as i32 - 1);
+                Some(dir_len - 1)
+            } else {
+                None
             }
-        }
+        };
 
         if let Some(s) = movement {
-            CursorMove::cursor_move(s, context);
+            CursorMove::cursor_move(s, context, view);
         }
     }
 }
diff --git a/src/commands/delete_files.rs b/src/commands/delete_files.rs
index 9a3caed..1875b39 100644
--- a/src/commands/delete_files.rs
+++ b/src/commands/delete_files.rs
@@ -6,6 +6,7 @@ use crate::config::keymap;
 use crate::context::JoshutoContext;
 use crate::preview;
 use crate::ui;
+use crate::window::JoshutoView;
 
 #[derive(Clone, Debug)]
 pub struct DeleteFiles;
@@ -41,8 +42,8 @@ impl std::fmt::Display for DeleteFiles {
 }
 
 impl JoshutoRunnable for DeleteFiles {
-    fn execute(&self, context: &mut JoshutoContext) {
-        ui::wprint_msg(&context.views.bot_win, "Delete selected files? (Y/n)");
+    fn execute(&self, context: &mut JoshutoContext, view: &JoshutoView) {
+        ui::wprint_msg(&view.bot_win, "Delete selected files? (Y/n)");
         ncurses::timeout(-1);
         ncurses::doupdate();
 
@@ -51,9 +52,9 @@ impl JoshutoRunnable for DeleteFiles {
             if let Some(s) = context.tabs[context.curr_tab_index].curr_list.as_ref() {
                 if let Some(paths) = commands::collect_selected_paths(s) {
                     match Self::remove_files(paths) {
-                        Ok(_) => ui::wprint_msg(&context.views.bot_win, "Deleted files"),
+                        Ok(_) => ui::wprint_msg(&view.bot_win, "Deleted files"),
                         Err(e) => {
-                            ui::wprint_err(&context.views.bot_win, e.to_string().as_str());
+                            ui::wprint_err(&view.bot_win, e.to_string().as_str());
                             ncurses::doupdate();
                             return;
                         }
@@ -64,23 +65,23 @@ impl JoshutoRunnable for DeleteFiles {
             let curr_tab = &mut context.tabs[context.curr_tab_index];
             curr_tab.reload_contents(&context.config_t.sort_type);
             curr_tab.refresh(
-                &context.views,
+                &view,
                 &context.config_t,
                 &context.username,
                 &context.hostname,
             );
         } else {
             let curr_tab = &context.tabs[context.curr_tab_index];
-            curr_tab.refresh_file_status(&context.views.bot_win);
+            curr_tab.refresh_file_status(&view.bot_win);
             curr_tab.refresh_path_status(
-                &context.views.top_win,
+                &view.top_win,
                 &context.username,
                 &context.hostname,
                 context.config_t.tilde_in_titlebar,
             );
         }
         let curr_tab = &mut context.tabs[context.curr_tab_index];
-        preview::preview_file(curr_tab, &context.views, &context.config_t);
+        preview::preview_file(curr_tab, &view, &context.config_t);
         ncurses::doupdate();
     }
 }
diff --git a/src/commands/file_operations.rs b/src/commands/file_operations.rs
index dab6b24..da602e2 100644
--- a/src/commands/file_operations.rs
+++ b/src/commands/file_operations.rs
@@ -7,11 +7,12 @@ use std::time;
 use crate::commands::{self, JoshutoCommand, JoshutoRunnable, ProgressInfo};
 use crate::context::JoshutoContext;
 use crate::structs::JoshutoDirList;
+use crate::window::JoshutoView;
 
 lazy_static! {
-    static ref selected_files: Mutex<Vec<path::PathBuf>> = Mutex::new(vec![]);
-    static ref fileop: Mutex<FileOp> = Mutex::new(FileOp::Copy);
-    static ref tab_src: atomic::AtomicUsize = atomic::AtomicUsize::new(0);
+    static ref SELECTED_FILES: Mutex<Vec<path::PathBuf>> = Mutex::new(vec![]);
+    static ref FILE_OPERATION: Mutex<FileOp> = Mutex::new(FileOp::Copy);
+    static ref TAB_SRC: atomic::AtomicUsize = atomic::AtomicUsize::new(0);
 }
 
 pub struct FileOperationThread {
@@ -31,17 +32,17 @@ impl FileOperationThread {
 }
 
 fn set_file_op(operation: FileOp) {
-    let mut data = fileop.lock().unwrap();
+    let mut data = FILE_OPERATION.lock().unwrap();
     *data = operation;
 }
 
 fn set_tab_src(tab_index: usize) {
-    tab_src.store(tab_index, atomic::Ordering::Release);
+    TAB_SRC.store(tab_index, atomic::Ordering::Release);
 }
 
 fn repopulated_selected_files(dirlist: &JoshutoDirList) -> bool {
     if let Some(contents) = commands::collect_selected_paths(dirlist) {
-        let mut data = selected_files.lock().unwrap();
+        let mut data = SELECTED_FILES.lock().unwrap();
         *data = contents;
         return true;
     }
@@ -80,7 +81,7 @@ impl std::fmt::Display for CutFiles {
 }
 
 impl JoshutoRunnable for CutFiles {
-    fn execute(&self, context: &mut JoshutoContext) {
+    fn execute(&self, context: &mut JoshutoContext, _: &JoshutoView) {
         let curr_tab = context.curr_tab_ref();
         if let Some(s) = curr_tab.curr_list.as_ref() {
             if repopulated_selected_files(s) {
@@ -112,7 +113,7 @@ impl std::fmt::Display for CopyFiles {
 }
 
 impl JoshutoRunnable for CopyFiles {
-    fn execute(&self, context: &mut JoshutoContext) {
+    fn execute(&self, context: &mut JoshutoContext, _: &JoshutoView) {
         let curr_tab = context.curr_tab_ref();
         if let Some(s) = curr_tab.curr_list.as_ref() {
             if repopulated_selected_files(s) {
@@ -140,7 +141,7 @@ impl PasteFiles {
         use std::os::linux::fs::MetadataExt;
 
         let tab_dest = context.curr_tab_index;
-        let tab_src_index = tab_src.load(atomic::Ordering::SeqCst);
+        let tab_src_index = TAB_SRC.load(atomic::Ordering::SeqCst);
 
         let options = self.options.clone();
         let mut destination = context.tabs[tab_dest].curr_path.clone();
@@ -148,7 +149,7 @@ impl PasteFiles {
         let dest_ino = destination.metadata()?.st_dev();
         let path_ino;
         {
-            let paths = selected_files.lock().unwrap();
+            let paths = SELECTED_FILES.lock().unwrap();
             if paths.len() == 0 {
                 return Err(std::io::Error::new(
                     std::io::ErrorKind::Other,
@@ -161,7 +162,7 @@ impl PasteFiles {
         let (tx, rx) = mpsc::channel();
         let handle = if dest_ino == path_ino {
             thread::spawn(move || {
-                let mut paths = selected_files.lock().unwrap();
+                let mut paths = SELECTED_FILES.lock().unwrap();
                 let mut progress_info = ProgressInfo {
                     bytes_finished: 1,
                     total_bytes: paths.len() as u64 + 1,
@@ -197,7 +198,7 @@ impl PasteFiles {
             })
         } else {
             thread::spawn(move || {
-                let mut paths = selected_files.lock().unwrap();
+                let mut paths = SELECTED_FILES.lock().unwrap();
 
                 let handle = |process_info: fs_extra::TransitProcess| {
                     let progress_info = ProgressInfo {
@@ -225,13 +226,13 @@ impl PasteFiles {
     #[cfg(not(target_os = "linux"))]
     fn cut(&self, context: &mut JoshutoContext) -> Result<FileOperationThread, std::io::Error> {
         let tab_dest = context.curr_tab_index;
-        let tab_src_index = tab_src.load(atomic::Ordering::SeqCst);
+        let tab_src_index = TAB_SRC.load(atomic::Ordering::SeqCst);
 
         let mut destination = context.tabs[tab_dest].curr_path.clone();
         let options = self.options.clone();
 
         {
-            let paths = selected_files.lock().unwrap();
+            let paths = SELECTED_FILES.lock().unwrap();
             if paths.len() == 0 {
                 return Err(std::io::Error::new(
                     std::io::ErrorKind::Other,
@@ -242,7 +243,7 @@ impl PasteFiles {
         let (tx, rx) = mpsc::channel();
 
         let handle = thread::spawn(move || {
-            let mut paths = selected_files.lock().unwrap();
+            let mut paths = SELECTED_FILES.lock().unwrap();
 
             let handle = |process_info: fs_extra::TransitProcess| {
                 let progress_info = ProgressInfo {
@@ -268,7 +269,7 @@ impl PasteFiles {
 
     fn copy(&self, context: &mut JoshutoContext) -> Result<FileOperationThread, std::io::Error> {
         let tab_dest = context.curr_tab_index;
-        let tab_src_index = tab_src.load(atomic::Ordering::SeqCst);
+        let tab_src_index = TAB_SRC.load(atomic::Ordering::SeqCst);
 
         let destination = context.tabs[tab_dest].curr_path.clone();
         let options = self.options.clone();
@@ -276,7 +277,7 @@ impl PasteFiles {
         let (tx, rx) = mpsc::channel();
 
         let handle = thread::spawn(move || {
-            let paths = selected_files.lock().unwrap();
+            let paths = SELECTED_FILES.lock().unwrap();
 
             let handle = |process_info: fs_extra::TransitProcess| {
                 let progress_info = ProgressInfo {
@@ -320,8 +321,8 @@ impl std::fmt::Debug for PasteFiles {
 }
 
 impl JoshutoRunnable for PasteFiles {
-    fn execute(&self, context: &mut JoshutoContext) {
-        let file_operation = fileop.lock().unwrap();
+    fn execute(&self, context: &mut JoshutoContext, _: &JoshutoView) {
+        let file_operation = FILE_OPERATION.lock().unwrap();
 
         let thread = match *file_operation {
             FileOp::Copy => self.copy(context),
diff --git a/src/commands/mod.rs b/src/commands/mod.rs
index 1185d93..7cfa311 100644
--- a/src/commands/mod.rs
+++ b/src/commands/mod.rs
@@ -17,7 +17,8 @@ mod tab_switch;
 
 pub use self::change_directory::ChangeDirectory;
 pub use self::cursor_move::{
-    CursorMove, CursorMoveEnd, CursorMoveHome, CursorMovePageDown, CursorMovePageUp,
+    CursorMove, CursorMoveDec, CursorMoveEnd, CursorMoveHome, CursorMoveInc, CursorMovePageDown,
+    CursorMovePageUp,
 };
 pub use self::delete_files::DeleteFiles;
 pub use self::file_operations::{CopyFiles, CutFiles, FileOperationThread, PasteFiles};
@@ -41,6 +42,7 @@ use std::path::PathBuf;
 
 use crate::context::JoshutoContext;
 use crate::structs;
+use crate::window::JoshutoView;
 
 #[derive(Debug)]
 pub enum CommandKeybind {
@@ -49,7 +51,7 @@ pub enum CommandKeybind {
 }
 
 pub trait JoshutoRunnable {
-    fn execute(&self, context: &mut JoshutoContext);
+    fn execute(&self, context: &mut JoshutoContext, view: &JoshutoView);
 }
 
 pub trait JoshutoCommand: JoshutoRunnable + std::fmt::Display + std::fmt::Debug {}
@@ -89,12 +91,27 @@ pub fn from_args(command: &str, args: Option<&Vec<String>>) -> Option<Box<Joshut
         }
         "close_tab" => Some(Box::new(self::CloseTab::new())),
         "copy_files" => Some(Box::new(self::CopyFiles::new())),
-        "cursor_move" => {
+        "cursor_move_inc" => {
             if let Some(args) = args {
                 if !args.is_empty() {
-                    match args[0].parse::<i32>() {
+                    match args[0].parse::<usize>() {
+                        Ok(s) => {
+                            return Some(Box::new(self::CursorMoveInc::new(s)));
+                        }
+                        Err(e) => {
+                            eprintln!("{}", e);
+                        }
+                    }
+                }
+            }
+            None
+        }
+        "cursor_move_dec" => {
+            if let Some(args) = args {
+                if !args.is_empty() {
+                    match args[0].parse::<usize>() {
                         Ok(s) => {
-                            return Some(Box::new(self::CursorMove::new(s)));
+                            return Some(Box::new(self::CursorMoveDec::new(s)));
                         }
                         Err(e) => {
                             eprintln!("{}", e);
@@ -218,20 +235,21 @@ pub fn from_args(command: &str, args: Option<&Vec<String>>) -> Option<Box<Joshut
 }
 
 pub fn collect_selected_paths(dirlist: &structs::JoshutoDirList) -> Option<Vec<PathBuf>> {
-    if dirlist.index < 0 {
-        return None;
-    }
-
-    let selected: Vec<PathBuf> = dirlist
-        .contents
-        .iter()
-        .filter(|entry| entry.selected)
-        .map(|entry| entry.path.clone())
-        .collect();
-    if !selected.is_empty() {
-        Some(selected)
-    } else {
-        Some(vec![dirlist.contents[dirlist.index as usize].path.clone()])
+    match dirlist.index {
+        Some(index) => {
+            let selected: Vec<PathBuf> = dirlist
+                .contents
+                .iter()
+                .filter(|entry| entry.selected)
+                .map(|entry| entry.path.clone())
+                .collect();
+            if !selected.is_empty() {
+                Some(selected)
+            } else {
+                Some(vec![dirlist.contents[index].path.clone()])
+            }
+        }
+        None => None,
     }
 }
 
diff --git a/src/commands/new_directory.rs b/src/commands/new_directory.rs
index 788d576..243cf6a 100644
--- a/src/commands/new_directory.rs
+++ b/src/commands/new_directory.rs
@@ -4,6 +4,7 @@ use crate::commands::{JoshutoCommand, JoshutoRunnable, ReloadDirList};
 use crate::context::JoshutoContext;
 use crate::textfield::JoshutoTextField;
 use crate::ui;
+use crate::window::JoshutoView;
 
 #[derive(Clone, Debug)]
 pub struct NewDirectory;
@@ -26,7 +27,7 @@ impl std::fmt::Display for NewDirectory {
 }
 
 impl JoshutoRunnable for NewDirectory {
-    fn execute(&self, context: &mut JoshutoContext) {
+    fn execute(&self, context: &mut JoshutoContext, view: &JoshutoView) {
         let (term_rows, term_cols) = ui::getmaxyx();
         const PROMPT: &str = ":mkdir ";
 
@@ -47,10 +48,10 @@ impl JoshutoRunnable for NewDirectory {
 
             match std::fs::create_dir_all(&path) {
                 Ok(_) => {
-                    ReloadDirList::reload(context);
+                    ReloadDirList::reload(context, view);
                 }
                 Err(e) => {
-                    ui::wprint_err(&context.views.bot_win, e.to_string().as_str());
+                    ui::wprint_err(&view.bot_win, e.to_string().as_str());
                 }
             }
         }
diff --git a/src/commands/open_file.rs b/src/commands/open_file.rs
index e27f588..3cbdc2c 100644
--- a/src/commands/open_file.rs
+++ b/src/commands/open_file.rs
@@ -9,8 +9,9 @@ use crate::textfield::JoshutoTextField;
 use crate::ui;
 use crate::unix;
 use crate::window;
+use crate::window::JoshutoView;
 
-use crate::mimetype_t;
+use crate::MIMETYPE_T;
 
 #[derive(Clone, Debug)]
 pub struct OpenFile;
@@ -28,7 +29,7 @@ impl OpenFile {
 
         if let Some(file_ext) = path.extension() {
             if let Some(file_ext) = file_ext.to_str() {
-                if let Some(s) = mimetype_t.extension.get(file_ext) {
+                if let Some(s) = MIMETYPE_T.extension.get(file_ext) {
                     for option in s {
                         mimetype_options.push(&option);
                     }
@@ -37,7 +38,7 @@ impl OpenFile {
         }
         let detective = mime_detective::MimeDetective::new().unwrap();
         if let Ok(mime_type) = detective.detect_filepath(path) {
-            if let Some(s) = mimetype_t.mimetype.get(mime_type.type_().as_str()) {
+            if let Some(s) = MIMETYPE_T.mimetype.get(mime_type.type_().as_str()) {
                 for option in s {
                     mimetype_options.push(&option);
                 }
@@ -46,14 +47,11 @@ impl OpenFile {
         mimetype_options
     }
 
-    fn enter_directory(path: &Path, context: &mut JoshutoContext) {
+    fn open_directory(path: &Path, context: &mut JoshutoContext, view: &JoshutoView) {
         let curr_tab = &mut context.tabs[context.curr_tab_index];
 
         if let Err