Default mode 368

* Parsing Implemented

* Adds option to specify a default mode
  either through a flag `--options default-mode [MODE]`,
  or a configuration option `default_mode: [MODE]`

closes #368

src/client/mod.rs

@@ -20,6 +20,7 @@ use crate::common::{
     thread_bus::{SenderType, SenderWithContext, SyncChannelWithContext},
 };
 use crate::server::ServerInstruction;
+use zellij_tile::data::InputMode;
 
 /// Instructions related to the client-side application and sent from server to client
 #[derive(Serialize, Deserialize, Debug, Clone)]
@@ -54,7 +55,7 @@ pub fn start_client(mut os_input: Box<dyn ClientOsApi>, opts: CliArgs, config: C
     os_input.send_to_server(ServerInstruction::NewClient(
         full_screen_ws,
         opts,
-        config_options,
+        config_options.clone(),
     ));
     os_input.set_raw_mode(0);
     let _ = os_input
@@ -83,12 +84,14 @@ pub fn start_client(mut os_input: Box<dyn ClientOsApi>, opts: CliArgs, config: C
             let send_client_instructions = send_client_instructions.clone();
             let command_is_executing = command_is_executing.clone();
             let os_input = os_input.clone();
+            let default_mode = config_options.default_mode.unwrap_or(InputMode::Normal);
             move || {
                 input_loop(
                     os_input,
                     config,
                     command_is_executing,
                     send_client_instructions,
+                    default_mode,
                 )
             }
         });

src/common/input/handler.rs

@@ -33,9 +33,10 @@ impl InputHandler {
         command_is_executing: CommandIsExecuting,
         config: Config,
         send_client_instructions: SenderWithContext<ClientInstruction>,
+        mode: InputMode,
     ) -> Self {
         InputHandler {
-            mode: InputMode::Normal,
+            mode,
             os_input,
             config,
             command_is_executing,
@@ -225,12 +226,14 @@ pub fn input_loop(
     config: Config,
     command_is_executing: CommandIsExecuting,
     send_client_instructions: SenderWithContext<ClientInstruction>,
+    default_mode: InputMode,
 ) {
     let _handler = InputHandler::new(
         os_input,
         command_is_executing,
         config,
         send_client_instructions,
+        default_mode,
     )
     .handle_input();
 }

src/common/input/options.rs

@@ -2,6 +2,7 @@
 use crate::cli::ConfigCli;
 use serde::{Deserialize, Serialize};
 use structopt::StructOpt;
+use zellij_tile::data::InputMode;
 
 #[derive(Clone, Default, Debug, PartialEq, Deserialize, Serialize, StructOpt)]
 /// Options that can be set either through the config file,
@@ -11,6 +12,9 @@ pub struct Options {
     /// that is compatible with more fonts
     #[structopt(long)]
     pub simplified_ui: bool,
+    /// Allows to specify the default mode
+    #[structopt(long)]
+    pub default_mode: Option<InputMode>,
 }
 
 impl Options {
@@ -32,7 +36,15 @@ impl Options {
             self.simplified_ui
         };
 
-        Options { simplified_ui }
+        let default_mode = match other.default_mode {
+            None => self.default_mode,
+            other => other,
+        };
+
+        Options {
+            simplified_ui,
+            default_mode,
+        }
     }
 
     pub fn from_cli(&self, other: Option<ConfigCli>) -> Options {

src/common/screen.rs

@@ -333,6 +333,7 @@ pub fn screen_thread_main(
 ) {
     let colors = bus.os_input.as_ref().unwrap().load_palette();
     let capabilities = config_options.simplified_ui;
+    let default_mode = config_options.default_mode.unwrap_or_default();
 
     let mut screen = Screen::new(
         bus,
@@ -343,9 +344,10 @@ pub fn screen_thread_main(
             capabilities: PluginCapabilities {
                 arrow_fonts: capabilities,
             },
+            mode: default_mode,
             ..ModeInfo::default()
         },
-        InputMode::Normal,
+        default_mode,
         colors,
     );
     loop {

zellij-tile/src/data.rs

@@ -1,4 +1,5 @@
 use serde::{Deserialize, Serialize};
+use std::str::FromStr;
 use strum_macros::{EnumDiscriminants, EnumIter, EnumString, ToString};
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
@@ -89,6 +90,23 @@ impl Default for PaletteColor {
     }
 }
 
+impl FromStr for InputMode {
+    type Err = Box<dyn std::error::Error>;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "normal" => Ok(InputMode::Normal),
+            "resize" => Ok(InputMode::Resize),
+            "locked" => Ok(InputMode::Locked),
+            "pane" => Ok(InputMode::Pane),
+            "tab" => Ok(InputMode::Tab),
+            "scroll" => Ok(InputMode::Scroll),
+            "renametab" => Ok(InputMode::RenameTab),
+            e => Err(e.to_string().into()),
+        }
+    }
+}
+
 #[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq, Hash)]
 pub enum PaletteSource {
     Default,