Add Option for Simplified Layout

* the simplified layout omits the Nerdfonts characters that are not
  found in every Fontset

* add an optional config option to opt into the simplified ui
  `simplified_ui: bool`

* add a config flag that allows opting into the simplified ui
  `zellij options --simplified-ui`

* move the `clean` flag to the `setup` subcommand

8 files changed, 69 insertions, 19 deletions

diff --git a/src/cli.rs b/src/cli.rs
index 91b0ed39..870af1d1 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -10,6 +10,10 @@ pub struct CliArgs {
     #[structopt(long)]
     pub max_panes: Option<usize>,
 
+    /// Speficy, if a simplified layout should be used that is compatible with more fonts
+    #[structopt(long)]
+    pub simplified: bool,
+
     /// Change where zellij looks for layouts and plugins
     #[structopt(long)]
     pub data_dir: Option<PathBuf>,
@@ -36,11 +40,11 @@ pub struct CliArgs {
 #[derive(Debug, StructOpt, Clone, Serialize, Deserialize)]
 pub enum ConfigCli {
     /// Change the behaviour of zellij
-    #[structopt(name = "option")]
-    Config {
-        /// Disables loading of configuration file at default location
+    #[structopt(name = "options")]
+    Options {
         #[structopt(long)]
-        clean: bool,
+        /// Allow plugins to use a more compatible font type
+        simplified_ui: bool,
     },
 
     #[structopt(name = "generate-completion")]
@@ -48,9 +52,12 @@ pub enum ConfigCli {
 
     #[structopt(name = "setup")]
     Setup {
-        /// Disables loading of configuration file at default location
         /// Dump the default configuration file to stdout
         #[structopt(long)]
         dump_config: bool,
+        /// Disables loading of configuration file at default location,
+        /// loads the defaults that zellij ships with
+        #[structopt(long)]
+        clean: bool,
     },
 }
diff --git a/src/client/mod.rs b/src/client/mod.rs
index 8a5834f0..5ebf8cec 100644
--- a/src/client/mod.rs
+++ b/src/client/mod.rs
@@ -42,7 +42,11 @@ pub fn start_client(mut os_input: Box<dyn ClientOsApi>, opts: CliArgs, config: C
 
     let full_screen_ws = os_input.get_terminal_size_using_fd(0);
     os_input.connect_to_server();
-    os_input.send_to_server(ServerInstruction::NewClient(full_screen_ws, opts));
+    os_input.send_to_server(ServerInstruction::NewClient(
+        full_screen_ws,
+        opts,
+        config.options.clone(),
+    ));
     os_input.set_raw_mode(0);
 
     let (send_client_instructions, receive_client_instructions): SyncChannelWithContext<
diff --git a/src/common/input/config.rs b/src/common/input/config.rs
index 3263b571..019d1c4c 100644
--- a/src/common/input/config.rs
+++ b/src/common/input/config.rs
@@ -6,10 +6,11 @@ use std::io::{self, Read};
 use std::path::{Path, PathBuf};
 
 use super::keybinds::{Keybinds, KeybindsFromYaml};
+use super::options::Options;
 use crate::cli::{CliArgs, ConfigCli};
 use crate::common::setup;
 
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 use std::convert::TryFrom;
 
 const DEFAULT_CONFIG_FILE_NAME: &str = "config.yaml";
@@ -19,13 +20,16 @@ type ConfigResult = Result<Config, ConfigError>;
 /// Intermediate deserialization config struct
 #[derive(Debug, Deserialize)]
 pub struct ConfigFromYaml {
+    #[serde(flatten)]
+    pub options: Option<Options>,
     pub keybinds: Option<KeybindsFromYaml>,
 }
 
 /// Main configuration.
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
 pub struct Config {
     pub keybinds: Keybinds,
+    pub options: Options,
 }
 
 #[derive(Debug)]
@@ -43,7 +47,8 @@ pub enum ConfigError {
 impl Default for Config {
     fn default() -> Self {
         let keybinds = Keybinds::default();
-        Config { keybinds }
+        let options = Options::default();
+        Config { keybinds, options }
     }
 }
 
@@ -55,7 +60,7 @@ impl TryFrom<&CliArgs> for Config {
             return Config::new(&path);
         }
 
-        if let Some(ConfigCli::Config { clean, .. }) = opts.option {
+        if let Some(ConfigCli::Setup { clean, .. }) = opts.option {
             if clean {
                 return Config::from_default_assets();
             }
@@ -84,7 +89,8 @@ impl Config {
     pub fn from_yaml(yaml_config: &str) -> ConfigResult {
         let config_from_yaml: ConfigFromYaml = serde_yaml::from_str(&yaml_config)?;
         let keybinds = Keybinds::get_default_keybinds_with_config(config_from_yaml.keybinds);
-        Ok(Config { keybinds })
+        let options = Options::from_yaml(config_from_yaml.options);
+        Ok(Config { keybinds, options })
     }
 
     /// Deserializes from given path.
diff --git a/src/common/input/handler.rs b/src/common/input/handler.rs
index a4293220..6238a3ee 100644
--- a/src/common/input/handler.rs
+++ b/src/common/input/handler.rs
@@ -11,7 +11,7 @@ use crate::server::ServerInstruction;
 use crate::CommandIsExecuting;
 
 use termion::input::{TermRead, TermReadEventsAndRaw};
-use zellij_tile::data::{InputMode, Key, ModeInfo, Palette};
+use zellij_tile::data::{InputMode, Key, ModeInfo, Palette, PluginCapabilities};
 
 /// Handles the dispatching of [`Action`]s according to the current
 /// [`InputMode`], and keep tracks of the current [`InputMode`].
@@ -148,6 +148,7 @@ impl InputHandler {
 // TODO this should probably be automatically generated in some way
 pub fn get_mode_info(mode: InputMode, palette: Palette) -> ModeInfo {
     let mut keybinds: Vec<(String, String)> = vec![];
+    let capabilities = PluginCapabilities { arrow_fonts: true };
     match mode {
         InputMode::Normal | InputMode::Locked => {}
         InputMode::Resize => {
@@ -181,6 +182,7 @@ pub fn get_mode_info(mode: InputMode, palette: Palette) -> ModeInfo {
         mode,
         keybinds,
         palette,
+        capabilities,
     }
 }
 
diff --git a/src/common/input/keybinds.rs b/src/common/input/keybinds.rs
index 823ca264..8bef47fd 100644
--- a/src/common/input/keybinds.rs
+++ b/src/common/input/keybinds.rs
@@ -4,14 +4,14 @@ use std::collections::HashMap;
 use super::actions::Action;
 use super::config;
 
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 use strum::IntoEnumIterator;
 use zellij_tile::data::*;
 
 /// Used in the config struct
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
 pub struct Keybinds(HashMap<InputMode, ModeKeybinds>);
-#[derive(Clone, Debug, Default, PartialEq)]
+#[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
 pub struct ModeKeybinds(HashMap<Key, Vec<Action>>);
 
 /// Intermediate struct used for deserialisation
diff --git a/src/common/input/mod.rs b/src/common/input/mod.rs
index 6589cac2..f30ccf23 100644
--- a/src/common/input/mod.rs
+++ b/src/common/input/mod.rs
@@ -4,3 +4,4 @@ pub mod actions;
 pub mod config;
 pub mod handler;
 pub mod keybinds;
+pub mod options;
diff --git a/src/common/input/options.rs b/src/common/input/options.rs
new file mode 100644
index 00000000..4c2dd861
--- /dev/null
+++ b/src/common/input/options.rs
@@ -0,0 +1,19 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Default, Debug, PartialEq, Deserialize, Serialize)]
+/// Options that can be set either through the config file,
+/// or cli flags
+pub struct Options {
+    /// Allow plugins to use a more compatible font type
+    pub simplified_ui: bool,
+}
+
+impl Options {
+    pub fn from_yaml(from_yaml: Option<Options>) -> Options {
+        if let Some(opts) = from_yaml {
+            opts
+        } else {
+            Options::default()
+        }
+    }
+}
diff --git a/src/server/mod.rs b/src/server/mod.rs
index a90831d9..6b9c52b5 100644
--- a/src/server/mod.rs
+++ b/src/server/mod.rs
@@ -11,13 +11,14 @@ use std::{
 };
 use wasmer::{ChainableNamedResolver, Instance, Module, Store, Value};
 use wasmer_wasi::{Pipe, WasiState};
-use zellij_tile::data::{Event, EventType, InputMode, ModeInfo};
+use zellij_tile::data::{Event, EventType, InputMode, ModeInfo, PluginCapabilities};
 
-use crate::cli::CliArgs;
+use crate::cli::{CliArgs, ConfigCli};
 use crate::client::ClientInstruction;
 use crate::common::{
     errors::{ContextType, PluginContext, PtyContext, ScreenContext, ServerContext},
     input::actions::{Action, Direction},
+    input::options::Options,
     input::handler::get_mode_info,
     os_input_output::{set_permissions, ServerOsApi},
     pty_bus::{PtyBus, PtyInstruction},
@@ -36,7 +37,7 @@ use crate::panes::PositionAndSize;
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub enum ServerInstruction {
     TerminalResize(PositionAndSize),
-    NewClient(PositionAndSize, CliArgs),
+    NewClient(PositionAndSize, CliArgs, Options),
     Action(Action),
     Render(Option<String>),
     UnblockInputThread,
@@ -112,10 +113,11 @@ pub fn start_server(os_input: Box<dyn ServerOsApi>) -> thread::JoinHandle<()> {
                 let (instruction, mut err_ctx) = receive_server_instructions.recv().unwrap();
                 err_ctx.add_call(ContextType::IPCServer(ServerContext::from(&instruction)));
                 match instruction {
-                    ServerInstruction::NewClient(full_screen_ws, opts) => {
+                    ServerInstruction::NewClient(full_screen_ws, opts, config_options) => {
                         let session_data = init_session(
                             os_input.clone(),
                             opts,
+                            config_options,
                             send_server_instructions.clone(),
                             full_screen_ws,
                         );
@@ -190,6 +192,7 @@ fn handle_client(
 fn init_session(
     os_input: Box<dyn ServerOsApi>,
     opts: CliArgs,
+    config_options: Options,
     send_server_instructions: SenderWithContext<ServerInstruction>,
     full_screen_ws: PositionAndSize,
 ) -> SessionMetaData {
@@ -303,6 +306,11 @@ fn init_session(
             let send_pty_instructions = send_pty_instructions.clone();
             let send_server_instructions = send_server_instructions;
             let max_panes = opts.max_panes;
+            let capabilities = if let Some(ConfigCli::Options { simplified_ui }) = opts.option {
+                simplified_ui
+            } else {
+                config_options.simplified_ui
+            };
             let colors = os_input.load_palette();
 
             move || {
@@ -316,6 +324,9 @@ fn init_session(
                     max_panes,
                     ModeInfo {
                         palette: colors,
+                        capabilities: PluginCapabilities {
+                            arrow_fonts: capabilities,
+                        },
                         ..ModeInfo::default()
                     },
                     InputMode::Normal,