added runtime changes to the overlay-config using inotify, fixes #11

Author: l-const

Cargo.lock

@@ -35,6 +35,7 @@ fontdb = "0.7"
 
 # Directory utilities
 dirs = "5.0"
+notify = "8.2.0"
 
 [package.metadata.deb]
 maintainer = "Your Name <your.email@example.com>"

Cargo.toml

@@ -57,14 +57,20 @@ fn main() -> Result<()> {
 
     log::info!("Loaded overlay config: {:?}", overlay_config);
 
-    let _state = State::new(
+    let state = Arc::new(State::new(
         Arc::new(Mutex::new(overlay_config.clone())),
         Arc::new(Mutex::new(shortcuts.clone())),
-    );
-    // watcher code
+    ));
 
+    // watcher code
+    let state_clone = Arc::clone(&state);
+    let handle = std::thread::spawn(|| {
+        watcher::watch_overlay_config(state_clone).unwrap();
+    });
     // start
-    overlay::start(shortcuts, overlay_config)?;
+    overlay::start(state)?;
+
+    handle.join().unwrap();
 
     Ok(())
 }

src/main.rs

@@ -1,6 +1,7 @@
 use crate::blur::box_blur_multi_pass;
 use crate::config::OverlayConfig;
 use crate::input_listener::{start_alt_listener, AltState};
+use crate::state::State;
 use anyhow::{Context, Result};
 use smithay_client_toolkit::{
     compositor::{CompositorHandler, CompositorState},
@@ -914,7 +915,7 @@ fn run_single_overlay(
     Ok(())
 }
 
-pub fn start(shortcuts: Vec<KeyBinding>, config: OverlayConfig) -> Result<()> {
+pub fn start(state: Arc<State>) -> Result<()> {
     let ctrl_receiver = match start_alt_listener() {
         Ok(rx) => {
             log::info!("Successfully started libinput Alt key listener");
@@ -936,10 +937,10 @@ pub fn start(shortcuts: Vec<KeyBinding>, config: OverlayConfig) -> Result<()> {
             Ok(AltState::Pressed) => {
                 log::debug!("==> Alt pressed alone - spawning new overlay thread");
 
-                let shortcuts_clone = shortcuts.clone();
+                let shortcuts_clone = state.clone_keybindings();
                 let flag = Arc::new(AtomicBool::new(false));
                 let flag_clone = Arc::clone(&flag);
-                let config_clone = config.clone();
+                let config_clone = state.clone_config();
 
                 let handle = std::thread::spawn(move || {
                     if let Err(e) = run_single_overlay(shortcuts_clone, flag_clone, config_clone) {

src/overlay.rs

@@ -19,13 +19,28 @@ impl State {
         }
     }
 
-    fn _set_config(&self, new_config: config::OverlayConfig) {
+    pub(crate) fn _set_config(&self, new_config: config::OverlayConfig) {
         let mut config = self._config.lock().unwrap();
         *config = new_config;
     }
 
-    fn _set_keybindings(&self, new_keybindings: Vec<KeyBinding>) {
+    pub(crate) fn reload_overlay_config(&self) {
+        let mut config = self._config.lock().unwrap();
+        *config = config::OverlayConfig::load().unwrap();
+    }
+
+    pub(crate) fn _set_keybindings(&self, new_keybindings: Vec<KeyBinding>) {
         let mut keybindings = self._keybindings.lock().unwrap();
         *keybindings = new_keybindings;
     }
+
+    pub(crate) fn clone_config(&self) -> config::OverlayConfig {
+        let config = self._config.lock().unwrap();
+        config.clone()
+    }
+
+    pub(crate) fn clone_keybindings(&self) -> Vec<KeyBinding> {
+        let keybindings = self._keybindings.lock().unwrap();
+        keybindings.clone()
+    }
 }

src/state.rs

@@ -1 +1,30 @@
+use crate::state::State;
+use notify::{Event, RecursiveMode, Result, Watcher};
+use std::sync::Arc;
+use std::{path::Path, sync::mpsc};
 
+const OVERLAY_CONFIG_FILE: &str = "/usr/share/shortcuts-overlay/overlay-config.toml";
+
+pub(crate) fn watch_overlay_config(state: Arc<State>) -> Result<()> {
+    let (tx, rx) = mpsc::channel::<Result<Event>>();
+
+    let mut watcher = notify::recommended_watcher(tx)?;
+
+    // Add a path to be watched. All files and directories at that path and
+    // below will be monitored for changes.
+    watcher.watch(Path::new(OVERLAY_CONFIG_FILE), RecursiveMode::Recursive)?;
+    // Block forever, printing out events as they come in
+    for res in rx {
+        match res {
+            Ok(event) => {
+                log::debug!("event: {:?}", event);
+                if event.kind.is_modify() {
+                    state.reload_overlay_config();
+                }
+            }
+            Err(e) => log::error!("watch error: {:?}", e),
+        }
+    }
+
+    Ok(())
+}