major refactoring in preparation for tabs support

14 files changed, 301 insertions, 246 deletions

diff --git a/src/joshuto.rs b/src/joshuto.rs
index 3ad467e..c9c954c 100644
--- a/src/joshuto.rs
+++ b/src/joshuto.rs
@@ -24,24 +24,52 @@ mod window;
 use self::command::CommandKeybind;
 use self::command::JoshutoCommand;
 
-pub struct JoshutoContext<'a> {
-    pub curr_path: path::PathBuf,
+pub struct JoshutoTab {
     pub history: history::DirHistory,
-
-    pub threads: Vec<(sync::mpsc::Receiver<command::ProgressInfo>, thread::JoinHandle<i32>)>,
-    pub views: window::JoshutoView,
+    pub curr_path: path::PathBuf,
     pub curr_list: Option<structs::JoshutoDirList>,
     pub parent_list: Option<structs::JoshutoDirList>,
     pub preview_list: Option<structs::JoshutoDirList>,
+}
+
+pub struct JoshutoContext<'a> {
+    pub username: String,
+    pub hostname: String,
+    pub threads: Vec<(sync::mpsc::Receiver<command::ProgressInfo>, thread::JoinHandle<i32>)>,
+    pub views: window::JoshutoView,
+    pub tab_index: usize,
+    pub tabs: Vec<JoshutoTab>,
 
-    pub config_t: config::JoshutoConfig,
+    pub config_t: &'a mut config::JoshutoConfig,
     pub mimetype_t: &'a config::JoshutoMimetype,
+    pub theme_t: &'a config::JoshutoTheme,
 }
 
 impl<'a> JoshutoContext<'a> {
+    pub fn new(config_t: &'a mut config::JoshutoConfig,
+        mimetype_t: &'a config::JoshutoMimetype,
+        theme_t: &'a config::JoshutoTheme) -> Self
+    {
+        let username: String = whoami::username();
+        let hostname: String = whoami::hostname();
+
+        let views: window::JoshutoView =
+            window::JoshutoView::new(config_t.column_ratio);
 
-    pub fn new(config_t: &config::JoshutoConfig,
-        mimetype_t: &'a config::JoshutoMimetype) -> Self
+        JoshutoContext {
+            username,
+            hostname,
+            threads: Vec::new(),
+            views,
+            tab_index: 0,
+            tabs: Vec::new(),
+            config_t,
+            mimetype_t,
+            theme_t
+        }
+    }
+
+    pub fn new_tab(&mut self)
     {
         let curr_path: path::PathBuf = match env::current_dir() {
             Ok(path) => { path },
@@ -53,14 +81,11 @@ impl<'a> JoshutoContext<'a> {
 
         /* keep track of where we are in directories */
         let mut history = history::DirHistory::new();
-        history.populate_to_root(&curr_path, &config_t.sort_type);
-
-        let joshuto_view: window::JoshutoView =
-            window::JoshutoView::new(config_t.column_ratio);
+        history.populate_to_root(&curr_path, &self.config_t.sort_type);
 
         /* load up directories */
         let curr_view: Option<structs::JoshutoDirList> =
-            match history.pop_or_create(&curr_path, &config_t.sort_type) {
+            match history.pop_or_create(&curr_path, &self.config_t.sort_type) {
                 Ok(s) => { Some(s) },
                 Err(e) => {
                     eprintln!("{}", e);
@@ -71,7 +96,7 @@ impl<'a> JoshutoContext<'a> {
         let parent_view: Option<structs::JoshutoDirList> =
             match curr_path.parent() {
                 Some(parent) => {
-                    match history.pop_or_create(&parent, &config_t.sort_type) {
+                    match history.pop_or_create(&parent, &self.config_t.sort_type) {
                         Ok(s) => { Some(s) },
                         Err(e) => {
                             eprintln!("{}", e);
@@ -87,7 +112,7 @@ impl<'a> JoshutoContext<'a> {
             match s.get_curr_entry() {
                 Some(dirent) => {
                     if dirent.path.is_dir() {
-                        preview_view = match history.pop_or_create(&dirent.path, &config_t.sort_type) {
+                        preview_view = match history.pop_or_create(&dirent.path, &self.config_t.sort_type) {
                             Ok(s) => { Some(s) },
                             Err(e) => {
                                 eprintln!("{}", e);
@@ -106,33 +131,35 @@ impl<'a> JoshutoContext<'a> {
             preview_view = None
         }
 
-        ui::redraw_status(&joshuto_view, curr_view.as_ref(), &curr_path,
-                &config_t.username, &config_t.hostname);
+        ui::redraw_status(&self.views, curr_view.as_ref(), &curr_path,
+                &self.username, &self.hostname);
 
-        ui::redraw_view(&joshuto_view.left_win, parent_view.as_ref());
-        ui::redraw_view(&joshuto_view.mid_win, curr_view.as_ref());
-        ui::redraw_view(&joshuto_view.right_win, preview_view.as_ref());
+        ui::redraw_view(&self.views.left_win, parent_view.as_ref());
+        ui::redraw_view(&self.views.mid_win, curr_view.as_ref());
+        ui::redraw_view(&self.views.right_win, preview_view.as_ref());
 
         ncurses::doupdate();
 
-        JoshutoContext {
-            curr_path,
-            history,
-            threads: Vec::new(),
-            views: joshuto_view,
-            curr_list: curr_view,
-            parent_list: parent_view,
-            preview_list: preview_view,
+        let tab = JoshutoTab {
+                curr_path,
+                history,
+                curr_list: curr_view,
+                parent_list: parent_view,
+                preview_list: preview_view,
+            };
 
-            config_t: config_t.clone(),
-            mimetype_t,
-        }
+        self.tabs.push(tab);
+        self.tab_index = self.tabs.len() - 1;
     }
 
     pub fn reload_dirlists(&mut self)
     {
+        if self.tab_index >= self.tabs.len() {
+            return;
+        }
+
         let mut gone = false;
-        if let Some(s) = self.curr_list.as_mut() {
+        if let Some(s) = self.tabs[self.tab_index].curr_list.as_mut() {
             if !s.path.exists() {
                 gone = true;
             } else if s.need_update() {
@@ -140,11 +167,11 @@ impl<'a> JoshutoContext<'a> {
             }
         }
         if gone {
-            self.curr_list = None;
+            self.tabs[self.tab_index].curr_list = None;
         }
 
         let mut gone = false;
-        if let Some(s) = self.parent_list.as_mut() {
+        if let Some(s) = self.tabs[self.tab_index].parent_list.as_mut() {
             if !s.path.exists() {
                 gone = true;
             } else if s.need_update() {
@@ -152,11 +179,11 @@ impl<'a> JoshutoContext<'a> {
             }
         }
         if gone {
-            self.parent_list = None;
+            self.tabs[self.tab_index].parent_list = None;
         }
 
         let mut gone = false;
-        if let Some(s) = self.preview_list.as_mut() {
+        if let Some(s) = self.tabs[self.tab_index].preview_list.as_mut() {
             if !s.path.exists() {
                 gone = true;
             } else if s.need_update() {
@@ -164,7 +191,7 @@ impl<'a> JoshutoContext<'a> {
             }
         }
         if gone {
-            self.preview_list = None;
+            self.tabs[self.tab_index].preview_list = None;
         }
     }
 }
@@ -220,83 +247,90 @@ pub fn resize_handler(context: &mut JoshutoContext)
     context.views.redraw_views();
     ncurses::refresh();
 
-    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());
+    let parent_list = context.tabs[context.tab_index].parent_list.as_ref();
+    let curr_list = context.tabs[context.tab_index].curr_list.as_ref();
+    let preview_list = context.tabs[context.tab_index].preview_list.as_ref();
+    let curr_path = &context.tabs[context.tab_index].curr_path;
 
-    ui::redraw_status(&context.views, context.curr_list.as_ref(), &context.curr_path,
-            &context.config_t.username, &context.config_t.hostname);
+    ui::redraw_view(&context.views.left_win, parent_list);
+    ui::redraw_view(&context.views.mid_win, curr_list);
+    ui::redraw_view(&context.views.right_win, preview_list);
+
+    ui::redraw_status(&context.views, curr_list, curr_path,
+            &context.username, &context.hostname);
 
     ncurses::doupdate();
 }
 
-pub fn run(config_t: config::JoshutoConfig,
+pub fn run(mut config_t: config::JoshutoConfig,
     keymap_t: config::JoshutoKeymap,
-    mimetype_t: config::JoshutoMimetype)
+    mimetype_t: config::JoshutoMimetype,
+    theme_t: config::JoshutoTheme)
 {
     ui::init_ncurses();
 
     ncurses::doupdate();
 
-    let mut tabs: Vec<JoshutoContext> = Vec::new();
-    {
-        let context = JoshutoContext::new(&config_t, &mimetype_t);
-        tabs.push(context);
-    }
+    let mut context = JoshutoContext::new(&mut config_t, &mimetype_t, &theme_t);
+
+    context.new_tab();
 
-    let index: usize = 0;
     let wait_duration: time::Duration = time::Duration::from_millis(100);
 
     loop {
         let ch: i32 = ncurses::getch();
 
         if ch == ncurses::KEY_RESIZE {
-            resize_handler(&mut tabs[index]);
+            resize_handler(&mut context);
             continue;
         }
 
-        if tabs[index].threads.len() > 0 {
+        if context.threads.len() > 0 {
             ncurses::timeout(0);
         } else {
             ncurses::timeout(-1);
         }
 
         {
-            let mut i = 0;
-
             let mut something_finished = false;
+            for i in 0..context.threads.len() {
+                if let Ok(progress_info) = &context.threads[i].0.recv_timeout(wait_duration) {
 
-            while i < tabs[index].threads.len() {
-                if let Ok(progress_info) = &tabs[index].threads[i].0.recv_timeout(wait_duration) {
                     if progress_info.bytes_finished == progress_info.total_bytes {
-                        let (_, chandle) = tabs[index].threads.remove(i);
+                        let (_, chandle) = context.threads.remove(i);
                         chandle.join().unwrap();
-                        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::werase(context.views.bot_win.win);
+                        let curr_list = context.tabs[context.tab_index].curr_list.as_ref();
+                        let curr_path = &context.tabs[context.tab_index].curr_path;
+                        ui::redraw_status(&context.views, curr_list, curr_path,
+                                &context.username, &context.hostname);
                         ncurses::doupdate();
                         something_finished = true;
+                        break;
                     } else {
                         let percent = (progress_info.bytes_finished as f64 /
                                 progress_info.total_bytes as f64) as f32;
-                        ui::draw_loading_bar(&tabs[index].views.bot_win, percent);
-                        ncurses::wnoutrefresh(tabs[index].views.bot_win.win);
+                        ui::draw_loading_bar(&context.views.bot_win, percent);
+                        ncurses::wnoutrefresh(context.views.bot_win.win);
                         ncurses::doupdate();
                     }
                 }
-                i = i + 1;
             }
 
             if something_finished {
-                tabs[index].reload_dirlists();
+                context.reload_dirlists();
+
+                let parent_list = context.tabs[context.tab_index].parent_list.as_ref();
+                let curr_list = context.tabs[context.tab_index].curr_list.as_ref();
+                let preview_list = context.tabs[context.tab_index].preview_list.as_ref();
+                let curr_path = &context.tabs[context.tab_index].curr_path;
 
-                ui::redraw_view(&tabs[index].views.left_win, tabs[index].parent_list.as_ref());
-                ui::redraw_view(&tabs[index].views.mid_win, tabs[index].curr_list.as_ref());
-                ui::redraw_view(&tabs[index].views.right_win, tabs[index].preview_list.as_ref());
+                ui::redraw_view(&context.views.left_win, parent_list);
+                ui::redraw_view(&context.views.mid_win, curr_list);
+                ui::redraw_view(&context.views.right_win, preview_list);
 
-                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);
+                ui::redraw_status(&context.views, curr_list, curr_path,
+                        &context.username, &context.hostname);
 
                 ncurses::doupdate();
             }
@@ -327,6 +361,6 @@ pub fn run(config_t: config::JoshutoConfig,
                 continue;
             }
         }
-        keycommand.execute(&mut tabs[index]);
+        keycommand.execute(&mut context);
     }
 }
diff --git a/src/joshuto/command/change_directory.rs b/src/joshuto/command/change_directory.rs
index 8f58f28..7db7da1 100644
--- a/src/joshuto/command/change_directory.rs
+++ b/src/joshuto/command/change_directory.rs
@@ -42,11 +42,11 @@ impl command::Runnable for ChangeDirectory {
             ncurses::doupdate();
             return;
         }
-
+        let curr_tab = &mut context.tabs[context.tab_index];
 
         match std::env::set_current_dir(self.path.as_path()) {
             Ok(_) => {
-                context.curr_path = self.path.clone();
+                curr_tab.curr_path = self.path.clone();
             },
             Err(e) => {
                 ui::wprint_err(&context.views.bot_win, e.to_string().as_str());
@@ -55,24 +55,24 @@ impl command::Runnable for ChangeDirectory {
         }
 
         {
-            context.history.populate_to_root(&context.curr_path, &context.config_t.sort_type);
+            curr_tab.history.populate_to_root(&curr_tab.curr_path, &context.config_t.sort_type);
 
-            let parent_list = context.parent_list.take();
-            context.history.put_back(parent_list);
+            let parent_list = curr_tab.parent_list.take();
+            curr_tab.history.put_back(parent_list);
 
-            let curr_list = context.curr_list.take();
-            context.history.put_back(curr_list);
+            let curr_list = curr_tab.curr_list.take();
+            curr_tab.history.put_back(curr_list);
 
-            let preview_list = context.preview_list.take();
-            context.history.put_back(preview_list);
+            let preview_list = curr_tab.preview_list.take();
+            curr_tab.history.put_back(preview_list);
         }
 
-        context.curr_list = match context.history.pop_or_create(&context.curr_path,
+        curr_tab.curr_list = match curr_tab.history.pop_or_create(&curr_tab.curr_path,
                     &context.config_t.sort_type) {
             Ok(s) => {
                 if let Some(dirent) = s.get_curr_entry() {
                     if dirent.path.is_dir() {
-                        context.preview_list = match context.history.pop_or_create(
+                        curr_tab.preview_list = match curr_tab.history.pop_or_create(
                                     &dirent.path, &context.config_t.sort_type) {
                             Ok(s) => {
                                 Some(s)
@@ -92,8 +92,8 @@ impl command::Runnable for ChangeDirectory {
             },
         };
 
-        if let Some(parent) = context.curr_path.parent() {
-            context.parent_list = match context.history.pop_or_create(&parent, &context.config_t.sort_type) {
+        if let Some(parent) = curr_tab.curr_path.parent() {
+            curr_tab.parent_list = match curr_tab.history.pop_or_create(&parent, &context.config_t.sort_type) {
                 Ok(s) => { Some(s) },
                 Err(e) => {
                     eprintln!("{}", e);
@@ -102,12 +102,12 @@ impl command::Runnable for ChangeDirectory {
             };
         }
 
-        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_view(&context.views.left_win, curr_tab.parent_list.as_ref());
+        ui::redraw_view(&context.views.mid_win, curr_tab.curr_list.as_ref());
+        ui::redraw_view(&context.views.right_win, curr_tab.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);
+        ui::redraw_status(&context.views, curr_tab.curr_list.as_ref(), &curr_tab.curr_path,
+                &context.username, &context.hostname);
 
         ncurses::doupdate();
     }
diff --git a/src/joshuto/command/cursor_move.rs b/src/joshuto/command/cursor_move.rs
index c4e4036..0779c94 100644
--- a/src/joshuto/command/cursor_move.rs
+++ b/src/joshuto/command/cursor_move.rs
@@ -25,7 +25,9 @@ impl CursorMove {
 
     pub fn cursor_move(new_index: i32, context: &mut joshuto::JoshutoContext)
     {
-        if let Some(ref mut curr_list) = context.curr_list {
+        let curr_tab = &mut context.tabs[context.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;
 
@@ -42,15 +44,15 @@ impl CursorMove {
                 }
             }
 
-            let dir_list = context.preview_list.take();
+            let dir_list = curr_tab.preview_list.take();
             if let Some(s) = dir_list {
-                context.history.insert(s);
+                curr_tab.history.insert(s);
             }
 
             curr_list.index = new_index;
         }
 
-        if let Some(ref curr_list) = context.curr_list {
+        if let Some(ref curr_list) = curr_tab.curr_list {
             let curr_index = curr_list.index as usize;
             let new_path = &curr_list.contents[curr_index].path;
 
@@ -58,11 +60,11 @@ impl CursorMove {
             ncurses::wnoutrefresh(context.views.mid_win.win);
 
             if new_path.is_dir() {
-                match context.history.pop_or_create(new_path.as_path(),
+                match curr_tab.history.pop_or_create(new_path.as_path(),
                         &context.config_t.sort_type) {
                     Ok(s) => {
-                        context.preview_list = Some(s);
-                        ui::redraw_view(&context.views.right_win, context.preview_list.as_ref());
+                        curr_tab.preview_list = Some(s);
+                        ui::redraw_view(&context.views.right_win, curr_tab.preview_list.as_ref());
                     },
                     Err(e) => ui::wprint_err(&context.views.right_win, e.to_string().as_str()),
                 }
@@ -71,8 +73,8 @@ impl CursorMove {
                 ncurses::wnoutrefresh(context.views.right_win.win);
             }
 
-            ui::redraw_status(&context.views, context.curr_list.as_ref(), &context.curr_path,
-                    &context.config_t.username, &context.config_t.hostname);
+            ui::redraw_status(&context.views, curr_tab.curr_list.as_ref(), &curr_tab.curr_path,
+                    &context.username, &context.hostname);
 
             ncurses::doupdate();
         }
@@ -93,9 +95,12 @@ impl command::Runnable for CursorMove {
     {
         let mut movement: Option<i32> = None;
 
-        if let Some(ref curr_list) = context.curr_list {
-            let curr_index = curr_list.index;
-            movement = Some(curr_index + self.movement);
+        {
+            let curr_tab = &mut context.tabs[context.tab_index];
+            if let Some(curr_list) = curr_tab.curr_list.as_ref() {
+                let curr_index = curr_list.index;
+                movement = Some(curr_index + self.movement);
+            }
         }
         if let Some(s) = movement {
             CursorMove::cursor_move(s, context);
@@ -125,14 +130,17 @@ impl command::Runnable for CursorMovePageUp {
     {
         let mut movement: Option<i32> = None;
 
-        if let Some(ref curr_list) = context.curr_list {
-            let curr_index = curr_list.index;
-            if curr_index <= 0 {
-                return;
-            }
+        {
+            let curr_tab = &mut context.tabs[context.tab_index];
+            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 = context.views.mid_win.cols / 2;
+                movement = Some(curr_index - half_page);
+            }
         }
         if let Some(s) = movement {
             CursorMove::cursor_move(s, context);
@@ -162,15 +170,18 @@ impl command::Runnable for CursorMovePageDown {
     {
         let mut movement: Option<i32> = None;
 
-        if let Some(ref curr_list) = context.curr_list {
-            let curr_index = curr_list.index;
-            let dir_len = curr_list.contents.len();
-            if curr_index >= dir_len as i32 - 1 {
-                return;
-            }
+        {
+            let curr_tab = &mut context.tabs[context.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 = context.views.mid_win.cols / 2;
+                movement = Some(curr_index + half_page);
+            }
         }
         if let Some(s) = movement {
             CursorMove::cursor_move(s, context);
@@ -200,12 +211,15 @@ impl command::Runnable for CursorMoveHome {
     {
         let mut movement: Option<i32> = None;
 
-        if let Some(ref curr_list) = context.curr_list {
-            let curr_index = curr_list.index;
-            if curr_index <= 0 {
-                return;
+        {
+            let curr_tab = &mut context.tabs[context.tab_index];
+            if let Some(curr_list) = curr_tab.curr_list.as_ref() {
+                let curr_index = curr_list.index;
+                if curr_index <= 0 {
+                    return;
+                }
+                movement = Some(0);
             }
-            movement = Some(0);
         }
         if let Some(s) = movement {
             CursorMove::cursor_move(s, context);
@@ -233,17 +247,20 @@ impl std::fmt::Display for CursorMoveEnd {
 impl command::Runnable for CursorMoveEnd {
     fn execute(&self, context: &mut joshuto::JoshutoContext)
     {
-
         let mut movement: Option<i32> = None;
 
-        if let Some(ref curr_list) = context.curr_list {
-            let curr_index = curr_list.index;
-            let dir_len = curr_list.contents.len();
-            if curr_index >= dir_len as i32 - 1 {
-                return;
+        {
+            let curr_tab = &mut context.tabs[context.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;
+                }
+                movement = Some(dir_len as i32 - 1);
             }
-            movement = Some(dir_len as i32 - 1);
         }
+
         if let Some(s) = movement {
             CursorMove::cursor_move(s, context);
         }
diff --git a/src/joshuto/command/file_operation.rs b/src/joshuto/command/file_operation.rs
index 7cf5144..8146bc6 100644
--- a/src/joshuto/command/file_operation.rs
+++ b/src/joshuto/command/file_operation.rs
@@ -43,14 +43,12 @@ pub fn collect_selected_paths(dirlist: &structs::JoshutoDirList)
     }
 }
 
-fn repopulated_selected_files(dirlist: &Option<structs::JoshutoDirList>) -> bool
+fn repopulated_selected_files(dirlist: &structs::JoshutoDirList) -> bool
 {
-    if let Some(s) = dirlist.as_ref() {
-        if let Some(contents) = collect_selected_paths(s) {
-            let mut data = selected_files.lock().unwrap();
-            *data = contents;
-            return true;
-        }
+    if let Some(contents) = collect_selected_paths(dirlist) {
+        let mut data = selected_files.lock().unwrap();
+        *data = contents;
+        return true;
     }
     return false;
 }
@@ -80,8 +78,11 @@ impl std::fmt::Display for CutFiles {
 impl command::Runnable for CutFiles {
     fn execute(&self, context: &mut joshuto::JoshutoContext)
     {
-        if repopulated_selected_files(&context.curr_list) {
-            set_file_op(FileOp::Cut);
+        let curr_tab = &context.tabs[context.tab_index];
+        if let Some(s) = curr_tab.curr_list.as_ref() {
+            if repopulated_selected_files(s) {
+                set_file_op(FileOp::Cut);
+            }
         }
     }
 }
@@ -106,8 +107,11 @@ impl std::fmt::Display for CopyFiles {
 impl command::Runnable for CopyFiles {
     fn execute(&self, context: &mut joshuto::JoshutoContext)
     {
-        if repopulated_selected_files(&context.curr_list) {
-            set_file_op(FileOp::Copy);
+        let curr_tab = &context.tabs[context.tab_index];
+        if let Some(s) = curr_tab.curr_list.as_ref() {
+            if repopulated_selected_files(s) {
+                set_file_op(FileOp::Copy);
+            }
         }
     }
 }
@@ -239,7 +243,7 @@ impl std::fmt::Display for PasteFiles {
 impl std::fmt::Debug for PasteFiles {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result
     {
-        write!(f, "{}", Self::command())
+        f.write_str(Self::command())
     }
 }
 
@@ -248,23 +252,22 @@ impl command::Runnable for PasteFiles {
     {
         let file_operation = fileop.lock().unwrap();
 
+        let curr_tab = &context.tabs[context.tab_index];
         let cprocess = match *file_operation {
-                FileOp::Copy => self.copy(&context.curr_path),
-                FileOp::Cut => self.cut(&context.curr_path),
+                FileOp::Copy => self.copy(&curr_tab.curr_path),
+                FileOp::Cut => self.cut(&curr_tab.curr_path),
             };
         context.threads.push(cprocess);
 
-        context.reload_dirlists();
-
         ncurses::timeout(0);
 
-        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_view(&context.views.left_win, curr_tab.parent_list.as_ref());
+        ui::redraw_view(&context.views.mid_win, curr_tab.curr_list.as_ref());
+        ui::redraw_view(&context.views.right_win, curr_tab.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);
+        ui::redraw_status(&context.views, curr_tab.curr_list.as_ref(),
+                &curr_tab.curr_path,
+                &context.username, &context.hostname);
 
         ncurses::doupdate();
     }
@@ -324,14 +327,13 @@ impl std::fmt::Display for DeleteFiles {
 impl command::Runnable for DeleteFiles {
     fn execute(&self, context: &mut joshuto::JoshutoContext)
     {
-
         ui::wprint_msg(&context.views.bot_win, "Delete selected files? (Y/n)");
         ncurses::doupdate();
         ncurses::timeout(-1);
 
         let ch = ncurses::wgetch(context.views.bot_win.win);
         if ch == 'y' as i32 || ch == keymap::ENTER as i32 {
-            if let Some(s) = context.curr_list.as_mut() {
+            if let Some(s) = context.tabs[context.tab_index].curr_list.as_ref() {
                 if let Some(paths) = collect_selected_paths(s) {
                     Self::remove_files(paths, &context.views.bot_win);
                 }
@@ -340,13 +342,15 @@ impl command::Runnable for DeleteFiles {
 
             ui::wprint_msg(&context.views.bot_win, "Deleted files");
 
-            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());
+            let curr_tab = &context.tabs[context.tab_index];
+            ui::redraw_view(&context.views.left_win, curr_tab.parent_list.as_ref());
+            ui::redraw_view(&context.views.mid_win, curr_tab.curr_list.as_ref());
+            ui::redraw_view(&context.views.right_win, curr_tab.preview_list.as_ref());
         } else {
-            ui::redraw_status(&context.views, context.curr_list.as_ref(),
-                    &context.curr_path,
-                    &context.config_t.username, &context.config_t.hostname);
+            let curr_tab = &context.tabs[context.tab_index];
+            ui::redraw_status(&context.views, curr_tab.curr_list.as_ref(),
+                    &curr_tab.curr_path,
+                    &context.username, &context.hostname);
         }
         ncurses::doupdate();
     }
@@ -402,13 +406,14 @@ impl RenameFile {
                 Ok(_) => {
                     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());
+                    let curr_tab = &context.tabs[context.tab_index];
+                    ui::redraw_view(&context.views.left_win, curr_tab.parent_list.as_ref());
+                    ui::redraw_view(&context.views.mid_win, curr_tab.curr_list.as_ref());
+                    ui::redraw_view(&context.views.right_win, curr_tab.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);
+                    ui::redraw_status(&context.views, curr_tab.curr_list.as_ref(),
+                            &curr_tab.curr_path,
+                            &context.username, &context.hostname);
                 },
                 Err(e) => {
                     ui::wprint_err(&context.views.bot_win, e.to_string().as_str());
@@ -437,7 +442,7 @@ impl command::Runnable for RenameFile {
         let mut path: Option<path::PathBuf> = None;
         let mut file_name: Option<String> = None;
 
-        if let Some(s) = context.curr_list.as_ref() {
+        if let Some(s) = context.tabs[context.tab_index].curr_list.as_ref() {
             if let Some(s) = s.get_curr_entry() {
                 path = Some(s.path.clone());
                 file_name = Some(s.file_name_as_string.clone());
diff --git a/src/joshuto/command/new_directory.rs b/src/joshuto/command/new_directory.rs
index bbc734c..7274d1a 100644
--- a/src/joshuto/command/new_directory.rs
+++ b/src/joshuto/command/new_directory.rs
@@ -46,17 +46,19 @@ impl command::Runnable for NewDirectory {
 
         if let Some(user_input) = input::get_str(&win, (0, PROMPT.len() as i32)) {
             let path = path::PathBuf::from(user_input);
+
             match std::fs::create_dir_all(&path) {
                 Ok(_) => {
                     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());
+                    let curr_tab = &context.tabs[context.tab_index];
+                    ui::redraw_view(&context.views.left_win, curr_tab.parent_list.as_ref());
+                    ui::redraw_view(&context.views.mid_win, curr_tab.curr_list.as_ref());
+                    ui::redraw_view(&context.views.right_win, curr_tab.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);
+                    ui::redraw_status(&context.views, curr_tab.curr_list.as_ref(),
+                            &curr_tab.curr_path,
+                            &context.username, &context.hostname);
                 },
                 Err(e) => {
                     ui::wprint_err(&context.views.bot_win, e.to_string().as_str());
diff --git a/src/joshuto/command/open_file.rs b/src/joshuto/command/open_file.rs
index a1c03b4..72a754c 100644
--- a/src/joshuto/command/open_file.rs
+++ b/src/joshuto/command/open_file.rs
@@ -36,9 +36,12 @@ impl std::fmt::Display for OpenFile {
 impl command::Runnable for OpenFile {
     fn execute(&self, context: &mut joshuto::JoshutoContext)
     {
+        let curr_tab = &mut context.tabs[context.tab_index];
+
         let index: usize;
         let path: path::PathBuf;
-        if let Some(s) = context.curr_list.as_ref() {
+
+        if let Some(s) = curr_tab.curr_list.as_ref() {
             if s.contents.len() == 0 {
                 return;
             } else {
@@ -89,32 +92,32 @@ impl command::Runnable for OpenFile {
             }
 
             {
-                let dir_list = context.parent_list.take();
-                context.history.put_back(dir_list);
+                let dir_list = curr_tab.parent_list.take();</