refactor: visualkind acts as visual identity

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

Author: httpsworldview

src/ui/app/message.rs

@@ -121,9 +121,7 @@ pub(super) fn update(app: &mut UiApp, msg: Message) -> Task<Message> {
                 app.sync_all_windows(),
             ])
         }
-        Message::Visuals(VisualsMessage::SettingsRequested { visual_id, kind }) => {
-            app.open_settings_window(visual_id, kind)
-        }
+        Message::Visuals(VisualsMessage::SettingsRequested(kind)) => app.open_settings_window(kind),
         Message::Visuals(VisualsMessage::WindowDragRequested) if !app.main_window_is_layer => {
             window::drag(app.main_window_id)
         }

src/ui/app/windowing.rs

@@ -7,9 +7,7 @@ use crate::persistence::settings::{BarAlignment, BarSettings, clamp_bar_height};
 use crate::ui::pages::config::ConfigMessage;
 use crate::ui::pages::visuals::{VisualsMessage, create_settings_panel};
 use crate::ui::theme;
-use crate::visuals::registry::{
-    VisualContent, VisualId, VisualKind, VisualMetadata, VisualSlotSnapshot,
-};
+use crate::visuals::registry::{VisualContent, VisualKind, VisualMetadata, VisualSlotSnapshot};
 use iced::widget::{container, mouse_area, text};
 use iced::{Element, Length, Size, Task, exit, window};
 use iced_layershell::actions::OutputSnapshotCallback;
@@ -142,7 +140,6 @@ pub(super) struct BarResizeState {
 }
 
 pub(super) struct PopoutWindow {
-    pub visual_id: VisualId,
     pub kind: VisualKind,
     pub original_index: usize,
     pub cached: Option<(VisualMetadata, VisualContent)>,
@@ -152,18 +149,15 @@ impl PopoutWindow {
     pub fn sync_from_snapshot(&mut self, snapshot: &[VisualSlotSnapshot]) {
         self.cached = snapshot
             .iter()
-            .find(|slot| slot.id == self.visual_id && slot.enabled)
+            .find(|slot| slot.kind == self.kind && slot.enabled)
             .map(|slot| (slot.metadata, slot.content.clone()));
     }
 
     pub fn view(&self) -> Element<'_, VisualsMessage> {
         let Some((_, content)) = &self.cached else {
             return fill!(text("")).into();
         };
-        let msg = VisualsMessage::SettingsRequested {
-            visual_id: self.visual_id,
-            kind: self.kind,
-        };
+        let msg = VisualsMessage::SettingsRequested(self.kind);
         mouse_area(fill!(content.render()))
             .on_right_press(msg)
             .into()
@@ -175,24 +169,15 @@ impl UiApp {
         let Some((_, panel)) = self.settings_window.as_mut() else {
             return;
         };
-        let visual_id = panel.visual_id;
-        let snapshot = self.visual_manager.snapshot();
-        let Some(kind) = snapshot.iter().find(|s| s.id == visual_id).map(|s| s.kind) else {
-            return;
-        };
-        *panel = create_settings_panel(visual_id, kind, &self.visual_manager);
+        *panel = create_settings_panel(panel.kind, &self.visual_manager);
     }
 
-    pub(super) fn open_settings_window(
-        &mut self,
-        visual_id: VisualId,
-        kind: VisualKind,
-    ) -> Task<Message> {
-        let new_panel = create_settings_panel(visual_id, kind, &self.visual_manager);
+    pub(super) fn open_settings_window(&mut self, kind: VisualKind) -> Task<Message> {
+        let new_panel = create_settings_panel(kind, &self.visual_manager);
         let previous = self.settings_window.take();
         if previous
             .as_ref()
-            .is_some_and(|(_, panel)| panel.visual_id == visual_id)
+            .is_some_and(|(_, panel)| panel.kind == kind)
         {
             self.settings_window = previous.map(|(id, _)| (id, new_panel));
             return Task::none();
@@ -206,29 +191,23 @@ impl UiApp {
         }
     }
 
-    pub(super) fn open_popout_window(
-        &mut self,
-        visual_id: VisualId,
-        kind: VisualKind,
-    ) -> Task<Message> {
+    pub(super) fn open_popout_window(&mut self, kind: VisualKind) -> Task<Message> {
         if self
             .popout_windows
             .values()
-            .any(|popout| popout.visual_id == visual_id)
+            .any(|popout| popout.kind == kind)
         {
             return Task::none();
         }
         let snapshot = self.visual_manager.snapshot();
-        let Some((index, slot)) = snapshot.iter().enumerate().find(|(_, s)| s.id == visual_id)
-        else {
+        let Some((index, slot)) = snapshot.iter().enumerate().find(|(_, s)| s.kind == kind) else {
             return Task::none();
         };
         let window_size = popout_window_size(&slot.metadata);
         let use_decorations = self.settings_handle.borrow().data.decorations;
         let (new_id, open_task) =
             open_base_window(self.use_layershell, window_size, use_decorations);
         let mut popout = PopoutWindow {
-            visual_id,
             kind,
             original_index: index,
             cached: None,
@@ -249,8 +228,8 @@ impl UiApp {
         Task::none()
     }
 
-    pub(super) fn popped_out_ids(&self) -> Vec<VisualId> {
-        self.popout_windows.values().map(|w| w.visual_id).collect()
+    pub(super) fn popped_out_kinds(&self) -> Vec<VisualKind> {
+        self.popout_windows.values().map(|w| w.kind).collect()
     }
 
     pub(super) fn sync_all_windows(&mut self) -> Task<Message> {
@@ -260,7 +239,7 @@ impl UiApp {
             .take_if(|(_, panel)| {
                 !snapshot
                     .iter()
-                    .any(|slot| slot.id == panel.visual_id && slot.enabled)
+                    .any(|slot| slot.kind == panel.kind && slot.enabled)
             })
             .map(|(id, _)| window::close::<Message>(id));
         self.popout_windows
@@ -272,7 +251,7 @@ impl UiApp {
             .map(|(id, _)| id)
             .collect();
         self.visuals_page
-            .apply_snapshot_excluding(&snapshot, &self.popped_out_ids());
+            .apply_snapshot_excluding(&snapshot, &self.popped_out_kinds());
         Task::batch(
             close_settings_task
                 .into_iter()
@@ -285,22 +264,22 @@ impl UiApp {
             return "OpenMeters".into();
         }
 
-        let (visual_id, suffix) = if let Some((_, panel)) = self
+        let (kind, suffix) = if let Some((_, panel)) = self
             .settings_window
             .as_ref()
             .filter(|(id, _)| *id == window_id)
         {
-            (panel.visual_id, " settings")
+            (panel.kind, " settings")
         } else if let Some(popout) = self.popout_windows.get(&window_id) {
-            (popout.visual_id, "")
+            (popout.kind, "")
         } else {
             return "OpenMeters".into();
         };
 
         self.visual_manager
             .snapshot()
             .iter()
-            .find(|s| s.id == visual_id)
+            .find(|s| s.kind == kind)
             .map_or_else(
                 || "OpenMeters".into(),
                 |s| format!("{}{} - OpenMeters", s.metadata.display_name, suffix),
@@ -334,7 +313,7 @@ impl UiApp {
         if let Some(popout) = self.popout_windows.remove(&source_window) {
             self.visual_manager
                 .borrow_mut()
-                .restore_position(popout.visual_id, popout.original_index);
+                .move_to(popout.kind, popout.original_index);
             self.sync_visuals_page();
             self.settings_handle.update(|settings| {
                 settings.data.visuals.order = self
@@ -346,18 +325,18 @@ impl UiApp {
             });
             return window::close(source_window);
         }
-        let Some((id, kind)) = self.visuals_page.hovered_visual() else {
+        let Some(kind) = self.visuals_page.hovered_visual() else {
             return Task::none();
         };
-        let task = self.open_popout_window(id, kind);
+        let task = self.open_popout_window(kind);
         self.sync_visuals_page();
         task
     }
 
     pub(super) fn sync_visuals_page(&mut self) {
         let snapshot = self.visual_manager.snapshot();
         self.visuals_page
-            .apply_snapshot_excluding(&snapshot, &self.popped_out_ids());
+            .apply_snapshot_excluding(&snapshot, &self.popped_out_kinds());
     }
 
     pub(super) fn apply_bar_layout(
@@ -511,15 +490,10 @@ impl UiApp {
         let Some((old_id, panel)) = self.settings_window.take() else {
             return Task::none();
         };
-        let visual_id = panel.visual_id;
-        let snapshot = self.visual_manager.snapshot();
-        let Some(slot) = snapshot.iter().find(|s| s.id == visual_id) else {
-            return window::close(old_id);
-        };
         let (new_id, open_task) = open_settings_base_window(self.use_layershell);
         self.settings_window = Some((
             new_id,
-            create_settings_panel(visual_id, slot.kind, &self.visual_manager),
+            create_settings_panel(panel.kind, &self.visual_manager),
         ));
         Task::batch([open_task, window::close(old_id)])
     }

src/ui/pages/visuals.rs

@@ -4,7 +4,7 @@
 use crate::persistence::settings::SettingsHandle;
 use crate::ui::widgets::pane_grid::{self, Content as PaneContent, Pane};
 use crate::visuals::registry::{
-    VisualContent, VisualId, VisualKind, VisualManagerHandle, VisualSlotSnapshot,
+    VisualContent, VisualKind, VisualManagerHandle, VisualSlotSnapshot,
 };
 pub mod settings;
 pub use settings::{ActiveSettings, SettingsMessage, create_panel as create_settings_panel};
@@ -18,16 +18,12 @@ pub enum VisualsMessage {
     PaneResized(pane_grid::ResizeWidths),
     PaneContextRequested(Pane),
     PaneHovered(Option<Pane>),
-    SettingsRequested {
-        visual_id: VisualId,
-        kind: VisualKind,
-    },
+    SettingsRequested(VisualKind),
     WindowDragRequested,
 }
 
 #[derive(Clone)]
 struct VisualPane {
-    id: VisualId,
     kind: VisualKind,
     content: VisualContent,
     min_width: f32,
@@ -73,7 +69,7 @@ impl VisualsPage {
                 if let Some(panes) = self.panes.as_mut()
                     && panes.move_to(pane, target)
                 {
-                    let order: Vec<_> = panes.iter().map(|(_, p)| p.id).collect();
+                    let order: Vec<_> = panes.iter().map(|(_, p)| p.kind).collect();
                     self.visual_manager.borrow_mut().reorder(&order);
                 }
             }
@@ -89,23 +85,17 @@ impl VisualsPage {
             }
             VisualsMessage::PaneContextRequested(pane) => {
                 if let Some(p) = self.panes.as_ref().and_then(|ps| ps.get(pane)) {
-                    return Task::done(VisualsMessage::SettingsRequested {
-                        visual_id: p.id,
-                        kind: p.kind,
-                    });
+                    return Task::done(VisualsMessage::SettingsRequested(p.kind));
                 }
             }
             VisualsMessage::PaneHovered(pane) => self.hovered_pane = pane,
-            VisualsMessage::SettingsRequested { .. } | VisualsMessage::WindowDragRequested => {}
+            VisualsMessage::SettingsRequested(_) | VisualsMessage::WindowDragRequested => {}
         }
         Task::none()
     }
 
-    pub fn hovered_visual(&self) -> Option<(VisualId, VisualKind)> {
-        self.panes
-            .as_ref()?
-            .get(self.hovered_pane?)
-            .map(|p| (p.id, p.kind))
+    pub fn hovered_visual(&self) -> Option<VisualKind> {
+        self.panes.as_ref()?.get(self.hovered_pane?).map(|p| p.kind)
     }
 
     pub fn view(&self, controls_visible: bool) -> Element<'_, VisualsMessage> {
@@ -142,11 +132,11 @@ impl VisualsPage {
     pub(crate) fn apply_snapshot_excluding(
         &mut self,
         snapshot: &[VisualSlotSnapshot],
-        exclude: &[VisualId],
+        exclude: &[VisualKind],
     ) {
         let slots: Vec<_> = snapshot
             .iter()
-            .filter(|s| s.enabled && !exclude.contains(&s.id))
+            .filter(|s| s.enabled && !exclude.contains(&s.kind))
             .collect();
         if slots.is_empty() {
             self.panes = None;
@@ -156,16 +146,16 @@ impl VisualsPage {
         if self.panes.as_ref().is_none_or(|panes| {
             panes
                 .iter()
-                .map(|(_, p)| p.id)
-                .ne(slots.iter().map(|s| s.id))
+                .map(|(_, p)| p.kind)
+                .ne(slots.iter().map(|s| s.kind))
         }) {
             self.panes = Some(self.build_panes(&slots));
             self.hovered_pane = None;
             return;
         }
         if let Some(panes) = self.panes.as_mut() {
             panes.for_each_mut(|_, p| {
-                if let Some(s) = slots.iter().copied().find(|s| s.id == p.id) {
+                if let Some(s) = slots.iter().copied().find(|s| s.kind == p.kind) {
                     p.content = s.content.clone();
                     p.min_width = s.metadata.min_width;
                 }
@@ -195,7 +185,6 @@ impl VisualsPage {
         let saved_width_basis = &settings.data.visuals.width_basis;
         pane_grid::State::from_iter(slots.iter().map(|&slot| {
             VisualPane {
-                id: slot.id,
                 kind: slot.kind,
                 content: slot.content.clone(),
                 min_width: slot.metadata.min_width,