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

27 files changed, 1905 insertions, 914 deletions

diff --git a/assets/layouts/default.yaml b/assets/layouts/default.yaml
index e63356917..a3987e50b 100644
--- a/assets/layouts/default.yaml
+++ b/assets/layouts/default.yaml
@@ -5,4 +5,4 @@ parts:
   - direction: Vertical
     split_size:
       Fixed: 1
-    plugin: status-bar
\ No newline at end of file
+    plugin: status-bar
diff --git a/assets/plugins/status-bar.wasm b/assets/plugins/status-bar.wasm
index 97b9be0ce..646ad3b5b 100644
--- a/assets/plugins/status-bar.wasm
+++ b/assets/plugins/status-bar.wasm
diff --git a/src/client/boundaries.rs b/src/client/boundaries.rs
index 498a37318..67733c12b 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 {
+