feat(ui): new keybindings and status bar (#160)

* work

* feat(statusbar): new design and keybindings

* fix(ipc): add missing const

* style(fmt): rustfmt

* style(input): remove accidental comment

4 files changed, 464 insertions, 79 deletions

diff --git a/src/client/boundaries.rs b/src/client/boundaries.rs
index 498a3731..67733c12 100644
--- a/src/client/boundaries.rs
+++ b/src/client/boundaries.rs
@@ -1,6 +1,8 @@
 use crate::tab::Pane;
 use std::collections::HashMap;
 
+use std::fmt::{Display, Error, Formatter};
+
 pub mod boundary_type {
     pub const TOP_RIGHT: &str = "┐";
     pub const VERTICAL: &str = "│";
@@ -17,277 +19,579 @@ pub mod boundary_type {
 
 pub type BoundaryType = &'static str; // easy way to refer to boundary_type above
 
-fn combine_symbols(current_symbol: &str, next_symbol: &str) -> Option<&'static str> {
+#[derive(Clone, Copy, Debug)]
+pub struct BoundarySymbol {
+    boundary_type: BoundaryType,
+    invisible: bool,
+}
+
+impl BoundarySymbol {
+    pub fn new(boundary_type: BoundaryType) -> Self {
+        BoundarySymbol {
+            boundary_type,
+            invisible: false,
+        }
+    }
+    pub fn invisible(mut self) -> Self {
+        self.invisible = true;
+        self
+    }
+}
+
+impl Display for BoundarySymbol {
+    fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
+        if self.invisible {
+            write!(f, " ")
+        } else {
+            write!(f, "{}", self.boundary_type)
+        }
+    }
+}
+
+fn combine_symbols(
+    current_symbol: BoundarySymbol,
+    next_symbol: BoundarySymbol,
+) -> Option<BoundarySymbol> {
+    let invisible = current_symbol.invisible || next_symbol.invisible;
+    let current_symbol = current_symbol.boundary_type;
+    let next_symbol = next_symbol.boundary_type;
     match (current_symbol, next_symbol) {
         (boundary_type::TOP_RIGHT, boundary_type::TOP_RIGHT) => {
             // (┐, ┐) => Some(┐)
-            Some(boundary_type::TOP_RIGHT)
+            let boundary_type = boundary_type::TOP_RIGHT;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::TOP_RIGHT, boundary_type::VERTICAL) => {
             // (┐, │) => Some(┤)
-            Some(boundary_type::VERTICAL_LEFT)
+            let boundary_type = boundary_type::VERTICAL_LEFT;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::TOP_RIGHT, boundary_type::HORIZONTAL) => {
             // (┐, ─) => Some(┬)
-            Some(boundary_type::HORIZONTAL_DOWN)
+            let boundary_type = boundary_type::HORIZONTAL_DOWN;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::TOP_RIGHT, boundary_type::TOP_LEFT) => {
             // (┐, ┌) => Some(┬)
-            Some(boundary_type::HORIZONTAL_DOWN)
+            let boundary_type = boundary_type::HORIZONTAL_DOWN;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::TOP_RIGHT, boundary_type::BOTTOM_RIGHT) => {
             // (┐, ┘) => Some(┤)
-            Some(boundary_type::VERTICAL_LEFT)
+            let boundary_type = boundary_type::VERTICAL_LEFT;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::TOP_RIGHT, boundary_type::BOTTOM_LEFT) => {
             // (┐, └) => Some(┼)
-            Some(boundary_type::CROSS)
+            let boundary_type = boundary_type::CROSS;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::TOP_RIGHT, boundary_type::VERTICAL_LEFT) => {
             // (┐, ┤) => Some(┤)
-            Some(boundary_type::VERTICAL_LEFT)
+            let boundary_type = boundary_type::VERTICAL_LEFT;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::TOP_RIGHT, boundary_type::VERTICAL_RIGHT) => {
             // (┐, ├) => Some(┼)
-            Some(boundary_type::CROSS)
+            let boundary_type = boundary_type::CROSS;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::TOP_RIGHT, boundary_type::HORIZONTAL_DOWN) => {
             // (┐, ┬) => Some(┬)
-            Some(boundary_type::HORIZONTAL_DOWN)
+            let boundary_type = boundary_type::HORIZONTAL_DOWN;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::TOP_RIGHT, boundary_type::HORIZONTAL_UP) => {
             // (┐, ┴) => Some(┼)
-            Some(boundary_type::CROSS)
+            let boundary_type = boundary_type::CROSS;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::TOP_RIGHT, boundary_type::CROSS) => {
             // (┐, ┼) => Some(┼)
-            Some(boundary_type::CROSS)
+            let boundary_type = boundary_type::CROSS;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::HORIZONTAL, boundary_type::HORIZONTAL) => {
             // (─, ─) => Some(─)
-            Some(boundary_type::HORIZONTAL)
+            let boundary_type = boundary_type::HORIZONTAL;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::HORIZONTAL, boundary_type::VERTICAL) => {
             // (─, │) => Some(┼)
-            Some(boundary_type::CROSS)
+            let boundary_type = boundary_type::CROSS;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::HORIZONTAL, boundary_type::TOP_LEFT) => {
             // (─, ┌) => Some(┬)
-            Some(boundary_type::HORIZONTAL_DOWN)
+            let boundary_type = boundary_type::HORIZONTAL_DOWN;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::HORIZONTAL, boundary_type::BOTTOM_RIGHT) => {
             // (─, ┘) => Some(┴)
-            Some(boundary_type::HORIZONTAL_UP)
+            let boundary_type = boundary_type::HORIZONTAL_UP;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::HORIZONTAL, boundary_type::BOTTOM_LEFT) => {
             // (─, └) => Some(┴)
-            Some(boundary_type::HORIZONTAL_UP)
+            let boundary_type = boundary_type::HORIZONTAL_UP;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::HORIZONTAL, boundary_type::VERTICAL_LEFT) => {
             // (─, ┤) => Some(┼)
-            Some(boundary_type::CROSS)
+            let boundary_type = boundary_type::CROSS;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::HORIZONTAL, boundary_type::VERTICAL_RIGHT) => {
             // (─, ├) => Some(┼)
-            Some(boundary_type::CROSS)
+            let boundary_type = boundary_type::CROSS;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::HORIZONTAL, boundary_type::HORIZONTAL_DOWN) => {
             // (─, ┬) => Some(┬)
-            Some(boundary_type::HORIZONTAL_DOWN)
+            let boundary_type = boundary_type::HORIZONTAL_DOWN;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::HORIZONTAL, boundary_type::HORIZONTAL_UP) => {
             // (─, ┴) => Some(┴)
-            Some(boundary_type::HORIZONTAL_UP)
+            let boundary_type = boundary_type::HORIZONTAL_UP;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::HORIZONTAL, boundary_type::CROSS) => {
             // (─, ┼) => Some(┼)
-            Some(boundary_type::CROSS)
+            let boundary_type = boundary_type::CROSS;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::VERTICAL, boundary_type::VERTICAL) => {
             // (│, │) => Some(│)
-            Some(boundary_type::VERTICAL)
+            let boundary_type = boundary_type::VERTICAL;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::VERTICAL, boundary_type::TOP_LEFT) => {
             // (│, ┌) => Some(├)
-            Some(boundary_type::VERTICAL_RIGHT)
+            let boundary_type = boundary_type::VERTICAL_RIGHT;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::VERTICAL, boundary_type::BOTTOM_RIGHT) => {
             // (│, ┘) => Some(┤)
-            Some(boundary_type::VERTICAL_LEFT)
+            let boundary_type = boundary_type::VERTICAL_LEFT;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::VERTICAL, boundary_type::BOTTOM_LEFT) => {
             // (│, └) => Some(├)
-            Some(boundary_type::VERTICAL_RIGHT)
+            let boundary_type = boundary_type::VERTICAL_RIGHT;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::VERTICAL, boundary_type::VERTICAL_LEFT) => {
             // (│, ┤) => Some(┤)
-            Some(boundary_type::VERTICAL_LEFT)
+            let boundary_type = boundary_type::VERTICAL_LEFT;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::VERTICAL, boundary_type::VERTICAL_RIGHT) => {
             // (│, ├) => Some(├)
-            Some(boundary_type::VERTICAL_RIGHT)
+            let boundary_type = boundary_type::VERTICAL_RIGHT;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::VERTICAL, boundary_type::HORIZONTAL_DOWN) => {
             // (│, ┬) => Some(┼)
-            Some(boundary_type::CROSS)
+            let boundary_type = boundary_type::CROSS;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::VERTICAL, boundary_type::HORIZONTAL_UP) => {
             // (│, ┴) => Some(┼)
-            Some(boundary_type::CROSS)
+            let boundary_type = boundary_type::CROSS;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::VERTICAL, boundary_type::CROSS) => {
             // (│, ┼) => Some(┼)
-            Some(boundary_type::CROSS)
+            let boundary_type = boundary_type::CROSS;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::TOP_LEFT, boundary_type::TOP_LEFT) => {
             // (┌, ┌) => Some(┌)
-            Some(boundary_type::TOP_LEFT)
+            let boundary_type = boundary_type::TOP_LEFT;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::TOP_LEFT, boundary_type::BOTTOM_RIGHT) => {
             // (┌, ┘) => Some(┼)
-            Some(boundary_type::CROSS)
+            let boundary_type = boundary_type::CROSS;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::TOP_LEFT, boundary_type::BOTTOM_LEFT) => {
             // (┌, └) => Some(├)
-            Some(boundary_type::VERTICAL_RIGHT)
+            let boundary_type = boundary_type::VERTICAL_RIGHT;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::TOP_LEFT, boundary_type::VERTICAL_LEFT) => {
             // (┌, ┤) => Some(┼)
-            Some(boundary_type::CROSS)
+            let boundary_type = boundary_type::CROSS;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::TOP_LEFT, boundary_type::VERTICAL_RIGHT) => {
             // (┌, ├) => Some(├)
-            Some(boundary_type::VERTICAL_RIGHT)
+            let boundary_type = boundary_type::VERTICAL_RIGHT;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::TOP_LEFT, boundary_type::HORIZONTAL_DOWN) => {
             // (┌, ┬) => Some(┬)
-            Some(boundary_type::HORIZONTAL_DOWN)
+            let boundary_type = boundary_type::HORIZONTAL_DOWN;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::TOP_LEFT, boundary_type::HORIZONTAL_UP) => {
             // (┌, ┴) => Some(┼)
-            Some(boundary_type::CROSS)
+            let boundary_type = boundary_type::CROSS;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::TOP_LEFT, boundary_type::CROSS) => {
             // (┌, ┼) => Some(┼)
-            Some(boundary_type::CROSS)
+            let boundary_type = boundary_type::CROSS;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::BOTTOM_RIGHT, boundary_type::BOTTOM_RIGHT) => {
             // (┘, ┘) => Some(┘)
-            Some(boundary_type::BOTTOM_RIGHT)
+            let boundary_type = boundary_type::BOTTOM_RIGHT;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::BOTTOM_RIGHT, boundary_type::BOTTOM_LEFT) => {
             // (┘, └) => Some(┴)
-            Some(boundary_type::HORIZONTAL_UP)
+            let boundary_type = boundary_type::HORIZONTAL_UP;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::BOTTOM_RIGHT, boundary_type::VERTICAL_LEFT) => {
             // (┘, ┤) => Some(┤)
-            Some(boundary_type::VERTICAL_LEFT)
+            let boundary_type = boundary_type::VERTICAL_LEFT;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::BOTTOM_RIGHT, boundary_type::VERTICAL_RIGHT) => {
             // (┘, ├) => Some(┼)
-            Some(boundary_type::CROSS)
+            let boundary_type = boundary_type::CROSS;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::BOTTOM_RIGHT, boundary_type::HORIZONTAL_DOWN) => {
             // (┘, ┬) => Some(┼)
-            Some(boundary_type::CROSS)
+            let boundary_type = boundary_type::CROSS;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::BOTTOM_RIGHT, boundary_type::HORIZONTAL_UP) => {
             // (┘, ┴) => Some(┴)
-            Some(boundary_type::HORIZONTAL_UP)
+            let boundary_type = boundary_type::HORIZONTAL_UP;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::BOTTOM_RIGHT, boundary_type::CROSS) => {
             // (┘, ┼) => Some(┼)
-            Some(boundary_type::CROSS)
+            let boundary_type = boundary_type::CROSS;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::BOTTOM_LEFT, boundary_type::BOTTOM_LEFT) => {
             // (└, └) => Some(└)
-            Some(boundary_type::BOTTOM_LEFT)
+            let boundary_type = boundary_type::BOTTOM_LEFT;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::BOTTOM_LEFT, boundary_type::VERTICAL_LEFT) => {
             // (└, ┤) => Some(┼)
-            Some(boundary_type::CROSS)
+            let boundary_type = boundary_type::CROSS;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::BOTTOM_LEFT, boundary_type::VERTICAL_RIGHT) => {
             // (└, ├) => Some(├)
-            Some(boundary_type::VERTICAL_RIGHT)
+            let boundary_type = boundary_type::VERTICAL_RIGHT;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::BOTTOM_LEFT, boundary_type::HORIZONTAL_DOWN) => {
             // (└, ┬) => Some(┼)
-            Some(boundary_type::CROSS)
+            let boundary_type = boundary_type::CROSS;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::BOTTOM_LEFT, boundary_type::HORIZONTAL_UP) => {
             // (└, ┴) => Some(┴)
-            Some(boundary_type::HORIZONTAL_UP)
+            let boundary_type = boundary_type::HORIZONTAL_UP;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::BOTTOM_LEFT, boundary_type::CROSS) => {
             // (└, ┼) => Some(┼)
-            Some(boundary_type::CROSS)
+            let boundary_type = boundary_type::CROSS;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::VERTICAL_LEFT, boundary_type::VERTICAL_LEFT) => {
             // (┤, ┤) => Some(┤)
-            Some(boundary_type::VERTICAL_LEFT)
+            let boundary_type = boundary_type::VERTICAL_LEFT;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::VERTICAL_LEFT, boundary_type::VERTICAL_RIGHT) => {
             // (┤, ├) => Some(┼)
-            Some(boundary_type::CROSS)
+            let boundary_type = boundary_type::CROSS;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::VERTICAL_LEFT, boundary_type::HORIZONTAL_DOWN) => {
             // (┤, ┬) => Some(┼)
-            Some(boundary_type::CROSS)
+            let boundary_type = boundary_type::CROSS;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::VERTICAL_LEFT, boundary_type::HORIZONTAL_UP) => {
             // (┤, ┴) => Some(┼)
-            Some(boundary_type::HORIZONTAL_UP)
+            let boundary_type = boundary_type::HORIZONTAL_UP;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::VERTICAL_LEFT, boundary_type::CROSS) => {
             // (┤, ┼) => Some(┼)
-            Some(boundary_type::CROSS)
+            let boundary_type = boundary_type::CROSS;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::VERTICAL_RIGHT, boundary_type::VERTICAL_RIGHT) => {
             // (├, ├) => Some(├)
-            Some(boundary_type::VERTICAL_RIGHT)
+            let boundary_type = boundary_type::VERTICAL_RIGHT;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::VERTICAL_RIGHT, boundary_type::HORIZONTAL_DOWN) => {
             // (├, ┬) => Some(┼)
-            Some(boundary_type::CROSS)
+            let boundary_type = boundary_type::CROSS;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::VERTICAL_RIGHT, boundary_type::HORIZONTAL_UP) => {
             // (├, ┴) => Some(┼)
-            Some(boundary_type::CROSS)
+            let boundary_type = boundary_type::CROSS;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::VERTICAL_RIGHT, boundary_type::CROSS) => {
             // (├, ┼) => Some(┼)
-            Some(boundary_type::CROSS)
+            let boundary_type = boundary_type::CROSS;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::HORIZONTAL_DOWN, boundary_type::HORIZONTAL_DOWN) => {
             // (┬, ┬) => Some(┬)
-            Some(boundary_type::HORIZONTAL_DOWN)
+            let boundary_type = boundary_type::HORIZONTAL_DOWN;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::HORIZONTAL_DOWN, boundary_type::HORIZONTAL_UP) => {
             // (┬, ┴) => Some(┼)
-            Some(boundary_type::CROSS)
+            let boundary_type = boundary_type::CROSS;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::HORIZONTAL_DOWN, boundary_type::CROSS) => {
             // (┬, ┼) => Some(┼)
-            Some(boundary_type::CROSS)
+            let boundary_type = boundary_type::CROSS;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::HORIZONTAL_UP, boundary_type::HORIZONTAL_UP) => {
             // (┴, ┴) => Some(┴)
-            Some(boundary_type::HORIZONTAL_UP)
+            let boundary_type = boundary_type::HORIZONTAL_UP;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::HORIZONTAL_UP, boundary_type::CROSS) => {
             // (┴, ┼) => Some(┼)
-            Some(boundary_type::CROSS)
+            let boundary_type = boundary_type::CROSS;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (boundary_type::CROSS, boundary_type::CROSS) => {
             // (┼, ┼) => Some(┼)
-            Some(boundary_type::CROSS)
+            let boundary_type = boundary_type::CROSS;
+            Some(BoundarySymbol {
+                boundary_type,
+                invisible,
+            })
         }
         (_, _) => None,
     }
 }
 
-fn find_next_symbol(first_symbol: &str, second_symbol: &str) -> Option<&'static str> {
+fn find_next_symbol(
+    first_symbol: BoundarySymbol,
+    second_symbol: BoundarySymbol,
+) -> Option<BoundarySymbol> {
     if let Some(symbol) = combine_symbols(first_symbol, second_symbol) {
         Some(symbol)
     } else {
@@ -359,7 +663,8 @@ pub trait Rect {
 pub struct Boundaries {
     columns: usize,
     rows: usize,
-    boundary_characters: HashMap<Coordinates, BoundaryType>,
+    // boundary_characters: HashMap<Coordinates, BoundaryType>,
+    boundary_characters: HashMap<Coordinates, BoundarySymbol>,
 }
 
 impl Boundaries {
@@ -373,6 +678,54 @@ impl Boundaries {
         }
     }
     pub fn add_rect(&mut self, rect: &dyn Pane) {
+        if rect.x() > 0 {
+            let boundary_x_coords = rect.x() - 1;
+            let first_row_coordinates = self.rect_right_boundary_row_start(rect);
+            let last_row_coordinates = self.rect_right_boundary_row_end(rect);
+            for row in first_row_coordinates..last_row_coordinates {
+                let coordinates = Coordinates::new(boundary_x_coords, row);
+                let mut symbol_to_add = if row == first_row_coordinates && row != 0 {
+                    BoundarySymbol::new(boundary_type::TOP_LEFT)
+                } else if row == last_row_coordinates - 1 && row != self.rows - 1 {
+                    BoundarySymbol::new(boundary_type::BOTTOM_LEFT)
+                } else {
+                    BoundarySymbol::new(boundary_type::VERTICAL)
+                };
+                if rect.invisible_borders() {
+                    symbol_to_add = symbol_to_add.invisible();
+                }
+                let next_symbol = self
+                    .boundary_characters
+                    .remove(&coordinates)
+                    .and_then(|current_symbol| find_next_symbol(current_symbol, symbol_to_add))
+                    .unwrap_or(symbol_to_add);
+                self.boundary_characters.insert(coordinates, next_symbol);
+            }
+        }
+        if rect.y() > 0 {
+            let boundary_y_coords = rect.y() - 1;
+            let first_col_coordinates = self.rect_bottom_boundary_col_start(rect);
+            let last_col_coordinates = self.rect_bottom_boundary_col_end(rect);
+            for col in first_col_coordinates..last_col_coordinates {
+                let coordinates = Coordinates::new(col, boundary_y_coords);
+                let mut symbol_to_add = if col == first_col_coordinates && col != 0 {
+                    BoundarySymbol::new(boundary_type::TOP_LEFT)
+                } else if col == last_col_coordinates - 1 && col != self.columns - 1 {
+                    BoundarySymbol::new(boundary_type::TOP_RIGHT)
+                } else {
+                    BoundarySymbol::new(boundary_type::HORIZONTAL)
+                };
+                if rect.invisible_borders() {
+                    symbol_to_add = symbol_to_add.invisible();
+                }
+                let next_symbol = self
+                    .boundary_characters
+                    .remove(&coordinates)
+                    .and_then(|current_symbol| find_next_symbol(current_symbol, symbol_to_add))
+                    .unwrap_or(symbol_to_add);
+                self.boundary_characters.insert(coordinates, next_symbol);
+            }
+        }
         if self.rect_right_boundary_is_before_screen_edge(rect) {
             // let boundary_x_coords = self.rect_right_boundary_x_coords(rect);
             let boundary_x_coords = rect.right_boundary_x_coords();
@@ -380,16 +733,19 @@ impl Boundaries {
             let last_row_coordinates = self.rect_right_boundary_row_end(rect);
             for row in first_row_coordinates..last_row_coordinates {
                 let coordinates = Coordinates::new(boundary_x_coords, row);
-                let symbol_to_add = if row == first_row_coordinates && row != 0 {
-                    boundary_type::TOP_RIGHT
+                let mut symbol_to_add = if row == first_row_coordinates && row != 0 {
+                    BoundarySymbol::new(boundary_type::TOP_RIGHT)
                 } else if row == last_row_coordinates - 1 && row != self.rows - 1 {
-                    boundary_type::BOTTOM_RIGHT
+                    BoundarySymbol::new(boundary_type::BOTTOM_RIGHT)
                 } else {
-                    boundary_type::VERTICAL
+                    BoundarySymbol::new(boundary_type::VERTICAL)
                 };
+                if rect.invisible_borders() {
+                    symbol_to_add = symbol_to_add.invisible();
+                }
                 let next_symbol = self
                     .boundary_characters
-                    .get(&coordinates)
+                    .remove(&coordinates)
                     .and_then(|current_symbol| find_next_symbol(current_symbol, symbol_to_add))
                     .unwrap_or(symbol_to_add);
                 self.boundary_characters.insert(coordinates, next_symbol);
@@ -401,16 +757,19 @@ impl Boundaries {
             let last_col_coordinates = self.rect_bottom_boundary_col_end(rect);
             for col in first_col_coordinates..last_col_coordinates {
                 let coordinates = Coordinates::new(col, boundary_y_coords);
-                let symbol_to_add = if col == first_col_coordinates && col != 0 {
-                    boundary_type::BOTTOM_LEFT
+                let mut symbol_to_add = if col == first_col_coordinates && col != 0 {
+                    BoundarySymbol::new(boundary_type::BOTTOM_LEFT)
                 } else if col == last_col_coordinates - 1 && col != self.columns - 1 {
-                    boundary_type::BOTTOM_RIGHT
+                    BoundarySymbol::new(boundary_type::BOTTOM_RIGHT)
                 } else {
-                    boundary_type::HORIZONTAL
+                    BoundarySymbol::new(boundary_type::HORIZONTAL)
                 };
+                if rect.invisible_borders() {
+                    symbol_to_add = symbol_to_add.invisible();
+                }
                 let next_symbol = self
                     .boundary_characters
-                    .get(&coordinates)
+                    .remove(&coordinates)
                     .and_then(|current_symbol| find_next_symbol(current_symbol, symbol_to_add))
                     .unwrap_or(symbol_to_add);
                 self.boundary_characters.insert(coordinates, next_symbol);
diff --git a/src/client/panes/plugin_pane.rs b/src/client/panes/plugin_pane.rs
index ff173d18..588cffd6 100644
--- a/src/client/panes/plugin_pane.rs
+++ b/src/client/panes/plugin_pane.rs
@@ -10,6 +10,7 @@ pub struct PluginPane {
     pub pid: u32,
     pub should_render: bool,
     pub selectable: bool,
+    pub invisible_borders: bool,
     pub position_and_size: PositionAndSize,
     pub position_and_size_override: Option<PositionAndSize>,
     pub send_plugin_instructions: SenderWithContext<PluginInstruction>,
@@ -26,6 +27,7 @@ impl PluginPane {
             pid,
             should_render: true,
             selectable: true,
+            invisible_borders: false,
             position_and_size,
             position_and_size_override: None,
             send_plugin_instructions,
@@ -102,6 +104,9 @@ impl Pane for PluginPane {
     fn set_selectable(&mut self, selectable: bool) {
         self.selectable = selectable;
     }
+    fn set_invisible_borders(&mut self, invisible_borders: bool) {
+        self.invisible_borders = invisible_borders;
+    }
     fn set_max_height(&mut self, max_height: usize) {
         self.max_height = Some(max_height);
     }
@@ -180,4 +185,7 @@ impl Pane for PluginPane {
     fn max_height(&self) -> Option<usize> {
         self.max_height
     }
+    fn invisible_borders(&self) -> bool {
+        self.invisible_borders
+    }
 }
diff --git a/src/client/panes/terminal_pane.rs b/src/client/panes/terminal_pane.rs
index fe7fb585..21244fab 100644
--- a/src/client/panes/terminal_pane.rs
+++ b/src/client/panes/terminal_pane.rs
@@ -181,6 +181,9 @@ impl Pane for TerminalPane {
     fn set_max_height(&mut self, max_height: usize) {
         self.max_height = Some(max_height);
     }
+    fn set_invisible_borders(&mut self, _invisible_borders: bool) {
+        unimplemented!();
+    }
     fn max_height(&self) -> Option<usize> {
         self.max_height
     }
diff --git a/src/client/tab.rs b/src/client/tab.rs
index 3b49a1c4..b7f0e5c2 100644
--- a/src/client/tab.rs
+++ b/src/client/tab.rs
@@ -11,6 +11,8 @@ use std::{
 };
 use std::{io::Write, sync::mpsc::channel};
 
+use crate::utils::logging::debug_log_to_file;
+
 /*
  * Tab
  *
@@ -86,6 +88,7 @@ pub trait Pane {
     fn set_should_render(&mut self, should_render: bool);
     fn selectable(&self) -> bool;
     fn set_selectable(&mut self, selectable: bool);
+    fn set_invisible_borders(&mut self, invisible_borders: bool);
     fn set_max_height(&mut self, max_height: usize);
     fn render(&mut self) -> Option<String>;
     fn pid(&self) -> PaneId;
@@ -155,6 +158,9 @@ pub trait Pane {
     fn max_height(&self) -> Option<usize> {
         None
     }
+    fn invisible_borders(&self) -> bool {
+        false
+    }
 }
 
 impl Tab {
@@ -1895,6 +1901,15 @@ impl Tab {
             }
         }
     }
+    pub fn set_pane_invisible_borders(&mut self, id: PaneId, invisible_borders: bool) {
+        debug_log_to_file(format!(
+            "set_pane_invisible_borders: {:?}",
+            invisible_borders
+        ));
+        if let Some(pane) = self.panes.get_mut(&id) {
+            pane.set_invisible_borders(invisible_borders);
+        }
+    }
     pub fn set_pane_max_height(&mut self, id: PaneId, max_height: usize) {
         if let Some(pane) = self.panes.get_mut(&id) {
             pane.set_max_height(max_height);