Make tick rate configurable

src/config.rs

@@ -45,6 +45,7 @@ pub struct Config {
     pub print_empty_columns: bool,
     pub due: usize,
     pub rule_precedence_color: Vec<String>,
+    pub uda_tick_rate: u64,
     pub uda_task_detail_prefetch: usize,
     pub uda_task_report_show_info: bool,
     pub uda_task_report_looping: bool,
@@ -74,6 +75,7 @@ impl Config {
         let data_location = Self::get_data_location();
         let due = Self::get_due();
         let rule_precedence_color = Self::get_rule_precedence_color();
+        let uda_tick_rate = Self::get_uda_tick_rate();
         let uda_task_detail_prefetch = Self::get_uda_task_detail_prefetch();
         let uda_task_report_show_info = Self::get_uda_task_report_show_info();
         let uda_task_report_looping = Self::get_uda_task_report_looping();
@@ -95,6 +97,7 @@ impl Config {
             data_location,
             due,
             rule_precedence_color,
+            uda_tick_rate,
             uda_task_detail_prefetch,
             uda_task_report_show_info,
             uda_task_report_looping,
@@ -116,6 +119,7 @@ impl Config {
                 data_location,
                 due,
                 rule_precedence_color,
+                uda_tick_rate,
                 uda_task_detail_prefetch,
                 uda_task_report_show_info,
                 uda_task_report_looping,
@@ -146,6 +150,7 @@ impl Config {
             print_empty_columns,
             due,
             rule_precedence_color,
+            uda_tick_rate,
             uda_task_detail_prefetch,
             uda_task_report_show_info,
             uda_task_report_looping,
@@ -423,6 +428,14 @@ impl Config {
             .unwrap()
     }
 
+    async fn get_uda_tick_rate() -> u64 {
+        Self::get_config("uda.taskwarrior-tui.tick-rate")
+            .await
+            .unwrap_or_default()
+            .parse::<u64>()
+            .unwrap_or(250)
+    }
+
     async fn get_uda_task_detail_prefetch() -> usize {
         Self::get_config("uda.taskwarrior-tui.task-report.task-detail-prefetch")
             .await

src/main.rs

@@ -53,63 +53,62 @@ fn main() -> Result<()> {
 }
 
 async fn tui_main(_config: &str) -> Result<()> {
-    // Terminal initialization
-    let terminal = setup_terminal();
-
     panic::set_hook(Box::new(|panic_info| {
         destruct_terminal();
         better_panic::Settings::auto().create_panic_handler()(panic_info);
     }));
 
+    let maybeapp = TaskwarriorTuiApp::new();
+    if maybeapp.is_err() {
+        destruct_terminal();
+        return Err(maybeapp.err().unwrap());
+    }
+
+    let app = Arc::new(Mutex::new(maybeapp.unwrap()));
+    let terminal = Arc::new(Mutex::new(setup_terminal()));
+
+    {
+        let mut terminal = terminal.lock().await;
+        app.lock().await.render(&mut terminal).unwrap();
+    }
+
     // Setup event handlers
     let events = Events::with_config(EventConfig {
-        tick_rate: Duration::from_millis(250),
+        tick_rate: Duration::from_millis(app.lock().await.config.uda_tick_rate),
     });
 
-    let maybeapp = TaskwarriorTuiApp::new();
-    match maybeapp {
-        Ok(app) => {
-            let app = Arc::new(Mutex::new(app));
-            let terminal = Arc::new(Mutex::new(terminal));
-            loop {
-                let handle = {
-                    let app = app.clone();
-                    let terminal = terminal.clone();
-                    task::spawn_local(async move {
-                        let mut t = terminal.lock().await;
-                        app.lock().await.render(&mut t).unwrap();
-                    })
-                };
-                // Handle input
-                match events.next().await? {
-                    Event::Input(input) => {
-                        let mut t = terminal.lock().await;
-                        let r = app.lock().await.handle_input(input, &mut t, &events);
-                        if r.is_err() {
-                            destruct_terminal();
-                            return r;
-                        }
-                    }
-                    Event::Tick => {
-                        let r = app.lock().await.update(false);
-                        if r.is_err() {
-                            destruct_terminal();
-                            return r;
-                        }
-                    }
-                }
-
-                if app.lock().await.should_quit {
+    loop {
+        let handle = {
+            let app = app.clone();
+            let terminal = terminal.clone();
+            task::spawn_local(async move {
+                let mut terminal = terminal.lock().await;
+                app.lock().await.render(&mut terminal).unwrap();
+            })
+        };
+        // Handle input
+        match events.next().await? {
+            Event::Input(input) => {
+                let mut t = terminal.lock().await;
+                let r = app.lock().await.handle_input(input, &mut t, &events);
+                if r.is_err() {
                     destruct_terminal();
-                    break;
+                    return r;
+                }
+            }
+            Event::Tick => {
+                let r = app.lock().await.update(false);
+                if r.is_err() {
+                    destruct_terminal();
+                    return r;
                 }
             }
-
-            Ok(())
         }
-        Err(e) => {
+
+        if app.lock().await.should_quit {
             destruct_terminal();
-            Err(e)
+            break;
         }
     }
+    Ok(())
 }

src/util.rs

@@ -88,7 +88,7 @@ impl Events {
                     continue;
                 }
 
-                let mut delay = Delay::new(Duration::from_millis(250)).fuse();
+                let mut delay = Delay::new(tick_rate).fuse();
                 let mut event = reader.next().fuse();
 
                 select! {