feat(config): dynamic hot reloading

At long last, config hot reloading! This introduces a config diffing system that tries to minimise the amount of reloading that needs to take place, according to the following rules:

- Monitors switching from single <--> multiple bars will need a full reload of all bars
- Bars with non-module configuration changes, or a change to the number of modules are fully reloaded
- Changes at a module level replace just that module.

This means that you can add, remove and change entire monitor configurations, individual bars, and modules and Ironbar will do its best to minimise the impact.

Hot-reloading does not currently support top-level config options other than `bar` and `monitors`. Some of these are likely to never be supported but this still requires exploration.

This also adds a new top-level `hot_reload` option, which takes two formats:

- `hot_reload: <true/false>` - enables/disables for both config and styles.
- `hot_reload.config` and `hot_reload.style` which can be used to toggle each system separately.

Author: JakeStanger

docs/Configuration guide.md

@@ -300,6 +300,9 @@ The following table lists each of the top-level bar config options:
 | `icon_theme`        | `string`                                | `null`  | Name of the GTK icon theme to use. Leave blank to use default.                                                                 |
 | `icon_overrides`    | `Map<string, string>`                   | `{}`    | Map of image inputs to override names. Usually used for app IDs (or classes) to icon names, overriding the app's default icon. |
 | `double_click_time` | `integer` or `"gtk"`                    | `250`   | Time in milliseconds to wait for a double-click. Set to `"gtk"` to use GTK's setting.                                          |
+| `hot_reload`        | `boolean` or `HotReload`                | `true`  | Whether to hot-reload config and style changes. Can also take object format to toggle separately.                              |
+| `hot_reload.config` | `boolean`                               | `true`  | Whether to hot-reload config changes.                                                                                          |
+| `hot_reload.style`  | `boolean`                               | `true`  | Whether to hot-reload style changes.                                                                                           |
 
 > [!TIP]
 > `monitors` is only required if you are following **2b** or **2c** (ie not the same bar across all monitors).

docs/Development guide.md

@@ -235,7 +235,7 @@ When the `extras` feature is enabled, it must also derive `schemars::JsonSchema`
 An extract of the Clock module is shown below as an example:
 
 ```rust
-#[derive(Debug, Deserialize, Clone)]
+#[derive(Debug, Deserialize, Clone, PartialEq)]
 #[cfg_attr(feature = "extras", derive(schemars::JsonSchema))]
 #[serde(default)]
 pub struct ClockModule {

src/bar.rs

@@ -1,3 +1,4 @@
+use crate::config::diff::BarDiffDetails;
 use crate::config::{BarConfig, BarPosition, MarginConfig, ModuleConfig};
 use crate::modules::{BarModuleFactory, ModuleInfo, ModuleLocation, ModuleRef};
 use crate::popup::Popup;
@@ -19,6 +20,7 @@ enum Inner {
     Loaded {
         module_refs: Vec<ModuleRef>,
         popup: Rc<Popup>,
+        instance: Rc<Bar>,
     },
 }
 
@@ -145,7 +147,7 @@ impl Bar {
         let margin = config.margin;
 
         let instance = Rc::new(self.clone());
-        let load_result = self.load_modules(instance, config, monitor);
+        let load_result = self.load_modules(&instance, config, monitor);
 
         let autohide_state = if let Some(autohide) = autohide {
             let hotspot_window = Window::new();
@@ -177,6 +179,7 @@ impl Bar {
         self.inner = Inner::Loaded {
             popup: load_result.popup,
             module_refs: load_result.module_refs,
+            instance,
         };
 
         self
@@ -188,6 +191,144 @@ impl Bar {
         self.window.destroy();
     }
 
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+
+    /// The name of the output the bar is displayed on.
+    pub fn monitor_name(&self) -> &str {
+        &self.monitor_name
+    }
+
+    pub fn popup(&self) -> Rc<Popup> {
+        match &self.inner {
+            Inner::New { .. } => {
+                panic!("Attempted to get popup of uninitialized bar. This is a serious bug!")
+            }
+            Inner::Loaded { popup, .. } => popup.clone(),
+        }
+    }
+
+    pub fn visible(&self) -> bool {
+        self.window.is_visible()
+    }
+
+    /// Sets the window visibility status
+    pub fn set_visible(&self, visible: bool) {
+        self.window.set_visible(visible);
+    }
+
+    pub fn set_exclusive(&self, exclusive: bool) {
+        if exclusive {
+            self.window.auto_exclusive_zone_enable();
+        } else {
+            self.window.set_exclusive_zone(0);
+        }
+    }
+
+    pub fn set_locked(&self, locked: bool) {
+        let mut autohide_state = self.autohide_state.borrow_mut();
+        let Some(autohide_state) = autohide_state.as_mut() else {
+            return;
+        };
+
+        if locked {
+            autohide_state.lock_state = LockState::Locked;
+        } else if autohide_state.lock_state == LockState::LockedPendingClose {
+            self.window.set_visible(false);
+            autohide_state.hotspot_window.set_visible(true);
+            autohide_state.lock_state = LockState::Unlocked;
+        }
+    }
+
+    pub fn modules(&self) -> &[ModuleRef] {
+        match &self.inner {
+            Inner::New { .. } => {
+                panic!("Attempted to get modules of uninitialized bar. This is a serious bug!")
+            }
+            Inner::Loaded { module_refs, .. } => module_refs,
+        }
+    }
+
+    pub fn apply_diff(&mut self, diff: BarDiffDetails, config: BarConfig, monitor: &Monitor) {
+        let module_factory =
+            BarModuleFactory::new(self.ironbar.clone(), self.instance(), self.popup()).into();
+        let app = &self.window.application().expect("to exist");
+
+        macro_rules! info {
+            ($location:expr) => {
+                ModuleInfo {
+                    app,
+                    bar_position: config.position,
+                    monitor,
+                    output_name: &self.monitor_name,
+                    location: $location,
+                }
+            };
+        }
+
+        let module_refs = match &mut self.inner {
+            Inner::New { .. } => {
+                panic!("Attempted to get modules of uninitialized bar. This is a serious bug!")
+            }
+            Inner::Loaded { module_refs, .. } => module_refs,
+        };
+
+        let mut load_modules = |mut modules: Vec<ModuleConfig>,
+                                diffs: Vec<usize>,
+                                container: &gtk::Box,
+                                location: ModuleLocation| {
+            for i in diffs.into_iter().rev() {
+                let Some(existing_module) = module_refs
+                    .iter_mut()
+                    .filter(|m| m.location == location)
+                    .nth(i)
+                else {
+                    error!("failed to find existing module to replace");
+                    return;
+                };
+
+                // avoid potential panic if all modules are disabled, but...
+                if modules.is_empty() {
+                    return;
+                }
+
+                #[allow(unreachable_code)] // ...above check doesn't satisfy rustc
+                let module = modules.remove(i);
+
+                match module.create(&module_factory, container, &info!(location)) {
+                    Ok(module) => {
+                        let existing_wrapper = existing_module
+                            .root_widget
+                            .parent()
+                            .expect("root should have revealer parent");
+                        let new_wrapper = module
+                            .root_widget
+                            .parent()
+                            .expect("root should have revealer parent");
+
+                        container.reorder_child_after(&new_wrapper, Some(&existing_wrapper));
+                        container.remove(&existing_wrapper);
+                        let _ = std::mem::replace(existing_module, module);
+                    }
+                    Err(err) => error!("{err:?}"),
+                }
+            }
+        };
+
+        if let Some(modules) = config.start {
+            load_modules(modules, diff.start, &self.start, ModuleLocation::Start);
+        }
+
+        if let Some(modules) = config.center {
+            load_modules(modules, diff.center, &self.center, ModuleLocation::Center);
+        }
+
+        if let Some(modules) = config.end {
+            load_modules(modules, diff.end, &self.end, ModuleLocation::End);
+        }
+    }
+
     /// Sets up GTK layer shell for a provided application window.
     fn setup_layer_shell(
         &self,
@@ -360,7 +501,7 @@ impl Bar {
     /// Loads the configured modules onto a bar.
     fn load_modules(
         &self,
-        instance: Rc<Bar>,
+        instance: &Rc<Bar>,
         config: BarConfig,
         monitor: &Monitor,
     ) -> BarLoadResult {
@@ -380,7 +521,7 @@ impl Bar {
 
         // popup ignores module location so can bodge this for now
         let popup = Popup::new(
-            &info!(ModuleLocation::Left),
+            &info!(ModuleLocation::Start),
             config.popup_gap,
             config.popup_autohide,
         );
@@ -391,13 +532,13 @@ impl Bar {
         if let Some(modules) = config.start {
             self.content.set_start_widget(Some(&self.start));
 
-            let info = info!(ModuleLocation::Left);
+            let info = info!(ModuleLocation::Start);
             refs.extend(add_modules(
                 &self.start,
                 modules,
                 &info,
                 &self.ironbar,
-                &instance,
+                instance,
                 &popup,
             ));
         }
@@ -411,21 +552,21 @@ impl Bar {
                 modules,
                 &info,
                 &self.ironbar,
-                &instance,
+                instance,
                 &popup,
             ));
         }
 
         if let Some(modules) = config.end {
             self.content.set_end_widget(Some(&self.end));
 
-            let info = info!(ModuleLocation::Right);
+            let info = info!(ModuleLocation::End);
             refs.extend(add_modules(
                 &self.end,
                 modules,
                 &info,
                 &self.ironbar,
-                &instance,
+                instance,
                 &popup,
             ));
         }
@@ -451,62 +592,12 @@ impl Bar {
         }
     }
 
-    pub fn name(&self) -> &str {
-        &self.name
-    }
-
-    /// The name of the output the bar is displayed on.
-    pub fn monitor_name(&self) -> &str {
-        &self.monitor_name
-    }
-
-    pub fn popup(&self) -> Rc<Popup> {
-        match &self.inner {
-            Inner::New { .. } => {
-                panic!("Attempted to get popup of uninitialized bar. This is a serious bug!")
-            }
-            Inner::Loaded { popup, .. } => popup.clone(),
-        }
-    }
-
-    pub fn visible(&self) -> bool {
-        self.window.is_visible()
-    }
-
-    /// Sets the window visibility status
-    pub fn set_visible(&self, visible: bool) {
-        self.window.set_visible(visible);
-    }
-
-    pub fn set_exclusive(&self, exclusive: bool) {
-        if exclusive {
-            self.window.auto_exclusive_zone_enable();
-        } else {
-            self.window.set_exclusive_zone(0);
-        }
-    }
-
-    pub fn set_locked(&self, locked: bool) {
-        let mut autohide_state = self.autohide_state.borrow_mut();
-        let Some(autohide_state) = autohide_state.as_mut() else {
-            return;
-        };
-
-        if locked {
-            autohide_state.lock_state = LockState::Locked;
-        } else if autohide_state.lock_state == LockState::LockedPendingClose {
-            self.window.set_visible(false);
-            autohide_state.hotspot_window.set_visible(true);
-            autohide_state.lock_state = LockState::Unlocked;
-        }
-    }
-
-    pub fn modules(&self) -> &[ModuleRef] {
+    fn instance(&self) -> Rc<Bar> {
         match &self.inner {
             Inner::New { .. } => {
                 panic!("Attempted to get modules of uninitialized bar. This is a serious bug!")
             }
-            Inner::Loaded { module_refs, .. } => module_refs,
+            Inner::Loaded { instance, .. } => instance.clone(),
         }
     }
 }

src/clients/outputs.rs

@@ -75,14 +75,14 @@ impl MonitorProxy {
                 tx.send_expect(MonitorEvent {
                     connector: self.connector.clone(),
                     state: MonitorState::Disconnected,
-                })
+                });
             }
             InternalMonitorState::BothConnected(wl_output, gdk_output) => {
                 info!("Monitor {} connected", self.connector);
                 tx.send_expect(MonitorEvent {
                     connector: self.connector.clone(),
                     state: MonitorState::Connected(wl_output.clone(), gdk_output.clone()),
-                })
+                });
             }
             _ => {}
         }
@@ -112,7 +112,7 @@ impl Client {
         }
     }
 
-    pub(crate) fn start(&self, ironbar: &Rc<Ironbar>) {
+    pub(crate) fn start(&self, ironbar: Rc<Ironbar>) {
         let mut rx_wl_outputs = ironbar.clients.borrow_mut().wayland().subscribe_outputs();
 
         let monitors = arc_mut!(HashMap::new());
@@ -133,13 +133,13 @@ impl Client {
                         });
                         match event.event_type {
                             wayland::OutputEventType::New => {
-                                entry.connect_wayland(&event.output).maybe_send(&output_tx)
+                                entry.connect_wayland(&event.output).maybe_send(&output_tx);
                             }
                             wayland::OutputEventType::Destroyed => {
-                                entry.disconnect().maybe_send(&output_tx)
+                                entry.disconnect().maybe_send(&output_tx);
                             }
                             wayland::OutputEventType::Update => {}
-                        };
+                        }
                     }
                 }
             });

src/config/common.rs

@@ -19,7 +19,7 @@ use tracing::trace;
 /// For information on the Script type, and embedding scripts in strings,
 /// see [here](script).
 /// For information on styling, please see the [styling guide](styling-guide).
-#[derive(Debug, Default, Deserialize, Clone)]
+#[derive(Debug, Default, Deserialize, Clone, PartialEq)]
 #[cfg_attr(feature = "extras", derive(schemars::JsonSchema))]
 pub struct CommonConfig {
     /// Sets the unique widget name,
@@ -208,7 +208,7 @@ pub struct CommonConfig {
     pub disable_popup: bool,
 }
 
-#[derive(Debug, Deserialize, Clone)]
+#[derive(Debug, Deserialize, Clone, PartialEq, Eq)]
 #[serde(rename_all = "snake_case")]
 #[cfg_attr(feature = "extras", derive(schemars::JsonSchema))]
 pub enum TransitionType {
@@ -218,7 +218,7 @@ pub enum TransitionType {
     SlideEnd,
 }
 
-#[derive(Debug, Default, Deserialize, Clone, Copy)]
+#[derive(Debug, Default, Deserialize, Clone, Copy, PartialEq, Eq)]
 #[serde(rename_all = "snake_case")]
 #[cfg_attr(feature = "extras", derive(schemars::JsonSchema))]
 pub enum ModuleOrientation {
@@ -247,7 +247,7 @@ impl From<ModuleOrientation> for Orientation {
     }
 }
 
-#[derive(Debug, Default, Deserialize, Clone, Copy)]
+#[derive(Debug, Default, Deserialize, Clone, Copy, PartialEq, Eq)]
 #[serde(rename_all = "snake_case")]
 #[cfg_attr(feature = "extras", derive(schemars::JsonSchema))]
 pub enum ModuleJustification {