fix(ui): stabilize bar monitor hotplug recovery

Signed-off-by: Maika Namuo <httpworldview@gmail.com>

Author: httpsworldview

src/persistence/schema.rs

@@ -109,6 +109,7 @@ impl UiSettings {
             if let Some(value) = map.remove("bar") {
                 out.bar = lossy::settings(value, "bar", BarSettings::default(), |map, out| {
                     lossy::fields!(map, out, "bar"; enabled, alignment, height, monitor);
+                    out.monitor = out.monitor.take().filter(|name| !name.is_empty());
                 });
             }
             lossy::fields!(map, out, "settings";
@@ -248,6 +249,8 @@ mod tests {
         assert_eq!(settings.bar.alignment, BarAlignment::Bottom);
         assert_eq!(settings.bar.height, BAR_DEFAULT_HEIGHT);
         assert_eq!(settings.bar.monitor.as_deref(), Some("HDMI-A-1"));
+        let empty_monitor = UiSettings::from_json_lossy(r#"{"bar":{"monitor":""}}"#).unwrap();
+        assert!(empty_monitor.bar.monitor.is_none());
 
         assert_eq!(settings.visuals.order, vec![VisualKind::Spectrum]);
         assert_eq!(settings.visuals.width_basis.len(), 1);

src/ui/app.rs

@@ -36,6 +36,7 @@ use windowing::{
 };
 
 const TOAST_DISPLAY_DURATION: Duration = Duration::from_secs(2);
+const BAR_RETRY_WINDOW: Duration = Duration::from_secs(5);
 const MAINTENANCE_INTERVAL: Duration = Duration::from_millis(100);
 const BAR_RESIZE_HANDLE_THICKNESS: f32 = 6.0;
 
@@ -117,7 +118,9 @@ struct UiApp {
     main_window_size: Size,
     last_base_window_size: Size,
     main_window_is_layer: bool,
-    opened_main_layer_window: Option<window::Id>,
+    main_layer_opened: bool,
+    main_layer_ready: bool,
+    last_bar_retry: Option<Instant>,
     use_layershell: bool,
     settings_window: Option<(window::Id, ActiveSettings)>,
     settings_scroll: ScrollGlow,
@@ -189,7 +192,9 @@ impl UiApp {
             main_window_size: main_size,
             last_base_window_size: base_size,
             main_window_is_layer: main_is_layer,
-            opened_main_layer_window: None,
+            main_layer_opened: false,
+            main_layer_ready: false,
+            last_bar_retry: None,
             use_layershell,
             settings_window: None,
             settings_scroll: ScrollGlow::default(),

src/ui/app/message.rs

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 // Copyright (C) 2026 Maika Namuo
 
-use super::{TOAST_DISPLAY_DURATION, UiApp, windowing::AppWindow};
-use crate::ui::config::{BarChange, BarOutputEvent, ConfigEffect, ConfigMessage};
+use super::{BAR_RETRY_WINDOW, TOAST_DISPLAY_DURATION, UiApp, windowing::AppWindow};
+use crate::ui::config::{BarOutputChange, BarOutputEvent, ConfigEffect, ConfigMessage};
 use crate::ui::settings::SettingsMessage;
 use crate::ui::visuals::VisualsMessage;
 use crate::ui::widgets::{fill, page, scroll_glow::ScrollGlow};
@@ -50,16 +50,12 @@ pub(super) fn layershell_open(settings: NewLayerShellSettings) -> (window::Id, T
 }
 
 pub(super) fn shell_event(event: ShellEvent) -> Option<Message> {
+    use BarOutputEvent as Change;
+
     Some(match event {
-        ShellEvent::OutputAdded(output) => {
-            Message::BarOutput(output.id, output.name, BarOutputEvent::Added)
-        }
-        ShellEvent::OutputUpdated(output) => {
-            Message::BarOutput(output.id, output.name, BarOutputEvent::Updated)
-        }
-        ShellEvent::OutputRemoved(output) => {
-            Message::BarOutput(output.id, output.name, BarOutputEvent::Removed)
-        }
+        ShellEvent::OutputAdded(o) => Message::BarOutput(o.id, o.name, Change::Added),
+        ShellEvent::OutputUpdated(o) => Message::BarOutput(o.id, o.name, Change::Updated),
+        ShellEvent::OutputRemoved(o) => Message::BarOutput(o.id, o.name, Change::Removed),
         ShellEvent::WindowOutputChanged { window, output } => {
             Message::BarWindowOutput(window, output.map(|output| output.id))
         }
@@ -113,11 +109,22 @@ pub(super) fn app_event(
     }
 }
 
+fn retry_bar(app: &mut UiApp, closed: bool) -> Task<Message> {
+    if app
+        .last_bar_retry
+        .is_some_and(|retry| retry.elapsed() < BAR_RETRY_WINDOW)
+    {
+        return if closed { exit() } else { Task::none() };
+    }
+    app.last_bar_retry = Some(Instant::now());
+    app.recreate_main_window(!closed)
+}
+
 fn close_main_layer(app: &mut UiApp, window: window::Id) -> Task<Message> {
-    if app.config_page.retry_bar_after_close() {
-        app.handle_bar_config_change(BarChange::Monitor)
-    } else {
+    if app.main_layer_ready {
         app.on_window_closed(window)
+    } else {
+        retry_bar(app, true)
     }
 }
 
@@ -141,11 +148,11 @@ pub(super) fn update(app: &mut UiApp, msg: Message) -> Task<Message> {
                 app.frames.borrow_mut().set_rate(rate);
                 Task::none()
             }
-            Some(ConfigEffect::DecorationsChanged(enabled)) if app.main_window_is_layer => {
-                app.recreate_popout_windows(enabled)
+            Some(ConfigEffect::DecorationsChanged) => app.recreate_visual_windows(),
+            Some(ConfigEffect::BarChanged(change)) => {
+                app.last_bar_retry = None;
+                app.handle_bar_config_change(change)
             }
-            Some(ConfigEffect::DecorationsChanged(enabled)) => app.recreate_windows(enabled),
-            Some(ConfigEffect::BarChanged(change)) => app.handle_bar_config_change(change),
             Some(ConfigEffect::ThemeChanged) => {
                 if let Some((_, panel)) = app.settings_window.as_mut() {
                     *panel = super::ActiveSettings::new(panel.kind(), &app.visual_manager);
@@ -154,9 +161,7 @@ pub(super) fn update(app: &mut UiApp, msg: Message) -> Task<Message> {
             }
             None => Task::none(),
         },
-        Message::Visuals(VisualsMessage::SettingsRequested(kind)) => {
-            app.open_settings_window(kind, false)
-        }
+        Message::Visuals(VisualsMessage::SettingsRequested(kind)) => app.open_settings_window(kind),
         Message::Visuals(visuals_msg) => app.visuals_page.update(visuals_msg).map(Message::Visuals),
         Message::ToggleConfig => app.toggle_config_window(),
         Message::TogglePause => {
@@ -189,23 +194,31 @@ pub(super) fn update(app: &mut UiApp, msg: Message) -> Task<Message> {
             Task::none()
         }
         Message::BarOutput(id, name, event) => {
-            if app.config_page.sync_bar_output(id, name, event) {
-                app.handle_bar_config_change(BarChange::Monitor)
+            let change = app.config_page.sync_bar_output(id, name, event);
+            if app.main_window_is_layer && change != BarOutputChange::Unchanged {
+                app.last_bar_retry = None;
+            }
+            if app.main_window_is_layer && change == BarOutputChange::CurrentRemoved {
+                app.main_layer_ready = false;
+            }
+            if app.main_window_is_layer && change == BarOutputChange::Retarget {
+                retry_bar(app, false)
             } else {
                 Task::none()
             }
         }
-        Message::BarWindowOutput(window, output) => {
-            if app.main_window_is_layer
-                && window == app.main_window_id
-                && app.config_page.sync_current_bar_output(output)
-            {
-                app.handle_bar_config_change(BarChange::Monitor)
+        Message::BarWindowOutput(window, output)
+            if app.main_window_is_layer && window == app.main_window_id =>
+        {
+            app.main_layer_ready = true;
+            if app.config_page.sync_current_bar_output(output) {
+                retry_bar(app, false)
             } else {
                 Task::none()
             }
         }
-        // Shell close events are ordered after output changes in the same stream.
+        Message::BarWindowOutput(_, _) => Task::none(),
+        // Output changes and shell closes share one ordered event stream.
         Message::ShellWindowClosed(window)
             if app.main_window_is_layer && window == app.main_window_id =>
         {
@@ -214,15 +227,15 @@ pub(super) fn update(app: &mut UiApp, msg: Message) -> Task<Message> {
         Message::ShellWindowClosed(_) => Task::none(),
         Message::WindowOpened(window) => {
             if app.main_window_is_layer && window == app.main_window_id {
-                app.opened_main_layer_window = Some(window);
+                app.main_layer_opened = true;
             }
             Task::none()
         }
         // After Opened, the ordered shell close is authoritative for the main layer.
         Message::WindowClosed(window)
             if app.main_window_is_layer && window == app.main_window_id =>
         {
-            if app.opened_main_layer_window == Some(window) {
+            if app.main_layer_opened {
                 Task::none()
             } else {
                 close_main_layer(app, window)

src/ui/app/windowing.rs

@@ -186,29 +186,23 @@ impl UiApp {
         }
     }
 
-    pub(super) fn open_settings_window(
-        &mut self,
-        kind: VisualKind,
-        force_new: bool,
-    ) -> Task<Message> {
-        let new_panel = ActiveSettings::new(kind, &self.visual_manager);
+    pub(super) fn open_settings_window(&mut self, kind: VisualKind) -> Task<Message> {
+        let panel = ActiveSettings::new(kind, &self.visual_manager);
         let previous = self.settings_window.take();
-        let same_kind = previous
+        if previous
             .as_ref()
-            .is_some_and(|(_, panel)| panel.kind() == kind);
-        if same_kind && !force_new {
-            self.settings_window = previous.map(|(id, _)| (id, new_panel));
+            .is_some_and(|(_, current)| current.kind() == kind)
+        {
+            self.settings_window = previous.map(|(id, _)| (id, panel));
             return Task::none();
         }
-        let (new_id, open_task) = open_tool_base_window(self.use_layershell);
-        if !same_kind {
-            self.settings_scroll = ScrollGlow::default();
-        }
-        self.settings_window = Some((new_id, new_panel));
+
+        let (id, open) = open_tool_base_window(self.use_layershell);
+        self.settings_scroll = ScrollGlow::default();
+        self.settings_window = Some((id, panel));
         match previous {
-            Some((old_id, _)) if force_new => Task::batch([open_task, window::close(old_id)]),
-            Some((old_id, _)) => Task::batch([window::close(old_id), open_task]),
-            None => open_task,
+            Some((old, _)) => Task::batch([window::close(old), open]),
+            None => open,
         }
     }
 
@@ -476,73 +470,65 @@ impl UiApp {
         Task::none()
     }
 
-    pub(super) fn recreate_main_window(
-        &mut self,
-        bar_settings: BarSettings,
-        use_decorations: bool,
-    ) -> Task<Message> {
+    pub(super) fn recreate_main_window(&mut self, close_old: bool) -> Task<Message> {
         let old_main_id = self.main_window_id;
+        let (bar, decorations) = {
+            let settings = &self.settings_handle.borrow().data;
+            (settings.bar.clone(), settings.decorations)
+        };
+        self.config_page.sync_current_bar_output(None);
+        self.main_layer_opened = false;
+        self.main_layer_ready = false;
         let (new_main_id, open_main, main_is_layer, main_size) = open_main_window(
             self.use_layershell,
-            bar_settings,
+            bar,
             self.last_base_window_size,
-            use_decorations,
+            decorations,
         );
         self.main_window_id = new_main_id;
         self.main_window_size = main_size;
         self.main_window_is_layer = main_is_layer;
-        Task::batch([open_main, window::close(old_main_id)])
+        if close_old {
+            Task::batch([open_main, window::close(old_main_id)])
+        } else {
+            open_main
+        }
     }
 
     pub(super) fn handle_bar_config_change(&mut self, change: BarChange) -> Task<Message> {
         if !self.use_layershell {
             return Task::none();
         }
-        let (bar, decorations) = {
-            let settings = &self.settings_handle.borrow().data;
-            (settings.bar.clone(), settings.decorations)
-        };
+        let bar = self.settings_handle.borrow().data.bar.clone();
         match change {
             BarChange::Mode if bar.enabled != self.main_window_is_layer => {
-                self.recreate_main_window(bar, decorations)
-            }
-            BarChange::Monitor if self.main_window_is_layer => {
-                self.recreate_main_window(bar, decorations)
+                self.recreate_main_window(true)
             }
+            BarChange::Monitor if self.main_window_is_layer => self.recreate_main_window(true),
             BarChange::Mode | BarChange::Layout if self.main_window_is_layer => {
                 self.apply_bar_layout(bar.alignment, bar.height)
             }
             BarChange::Mode | BarChange::Layout | BarChange::Monitor => Task::none(),
         }
     }
 
-    pub(super) fn recreate_popout_windows(&mut self, use_decorations: bool) -> Task<Message> {
+    pub(super) fn recreate_visual_windows(&mut self) -> Task<Message> {
+        let decorations = self.settings_handle.borrow().data.decorations;
         let old_popouts = std::mem::take(&mut self.popout_windows);
-        let mut tasks = Vec::with_capacity(old_popouts.len() * 2);
-        for (old_id, popout) in old_popouts {
-            let (new_id, open_task) =
-                open_base_window(self.use_layershell, popout.size, use_decorations);
-            self.popout_windows.insert(new_id, popout);
-            tasks.push(open_task);
-            tasks.push(window::close(old_id));
+        let mut tasks = Vec::with_capacity(old_popouts.len() * 2 + 2);
+
+        if !self.main_window_is_layer {
+            let old = self.main_window_id;
+            let (id, open) =
+                open_base_window(self.use_layershell, self.main_window_size, decorations);
+            self.main_window_id = id;
+            tasks.extend([open, window::close(old)]);
+        }
+        for (old, popout) in old_popouts {
+            let (id, open) = open_base_window(self.use_layershell, popout.size, decorations);
+            self.popout_windows.insert(id, popout);
+            tasks.extend([open, window::close(old)]);
         }
         Task::batch(tasks)
     }
-
-    pub(super) fn recreate_windows(&mut self, use_decorations: bool) -> Task<Message> {
-        let old_main_id = self.main_window_id;
-        let (new_main_id, open_main) =
-            open_base_window(self.use_layershell, self.main_window_size, use_decorations);
-        self.main_window_id = new_main_id;
-        self.main_window_is_layer = false;
-        let settings_kind = self.settings_window.as_ref().map(|(_, panel)| panel.kind());
-        let settings_task =
-            settings_kind.map_or_else(Task::none, |kind| self.open_settings_window(kind, true));
-        Task::batch([
-            open_main,
-            window::close(old_main_id),
-            settings_task,
-            self.recreate_popout_windows(use_decorations),
-        ])
-    }
 }