rework wm_info_provider stuff

2 files changed, 99 insertions, 93 deletions

diff --git a/src/wm_info_provider/ext_workspace_unstable.rs b/src/wm_info_provider/ext_workspace_unstable.rs
index 467be2b..8cb5855 100644
--- a/src/wm_info_provider/ext_workspace_unstable.rs
+++ b/src/wm_info_provider/ext_workspace_unstable.rs
@@ -10,7 +10,6 @@ pub struct ExtWorkspaceUnstable {
     manager: ZextWorkspaceManagerV1,
     groups: Vec<Group>,
     known_outputs: Vec<WlOutput>,
-    callback: WmInfoCallback,
 }
 
 #[derive(Debug)]
@@ -29,37 +28,62 @@ struct Workspace {
 }
 
 impl ExtWorkspaceUnstable {
-    pub fn bind(
-        conn: &mut Connection<State>,
-        globals: &Globals,
-        callback: WmInfoCallback,
-    ) -> Option<Self> {
+    pub fn bind(conn: &mut Connection<State>, globals: &Globals) -> Option<Self> {
         Some(Self {
             manager: globals.bind_with_cb(conn, 1..=1, manager_cb).ok()?,
             groups: Vec::new(),
             known_outputs: Vec::new(),
-            callback,
         })
     }
 }
 
-impl ExtWorkspaceUnstable {
-    pub fn new_ouput(&mut self, _: &mut Connection<State>, output: WlOutput) {
+impl WmInfoProvider for ExtWorkspaceUnstable {
+    fn new_ouput(&mut self, _conn: &mut Connection<State>, output: WlOutput) {
         self.known_outputs.push(output);
     }
 
-    pub fn output_removed(&mut self, _: &mut Connection<State>, output: WlOutput) {
+    fn output_removed(&mut self, _conn: &mut Connection<State>, output: WlOutput) {
         self.known_outputs.retain(|&o| o != output);
         for group in &mut self.groups {
             group.outputs.retain(|&id| id != output.id());
         }
     }
 
-    pub fn click_on_tag(
+    fn get_tags(&self, output: WlOutput) -> Vec<Tag> {
+        let Some(group) = self
+            .groups
+            .iter()
+            .find(|g| g.outputs.contains(&output.id()))
+        else {
+            return Vec::new();
+        };
+
+        let mut tags: Vec<_> = group
+            .workspaces
+            .iter()
+            .flat_map(|w| {
+                let name = w.name.clone()?;
+                Some(Tag {
+                    name,
+                    is_focused: w.is_focused,
+                    is_active: true,
+                    is_urgent: w.is_urgent,
+                })
+            })
+            .collect();
+        tags.sort_unstable_by(|a, b| a.name.cmp(&b.name));
+        tags
+    }
+
+    fn get_layout_name(&self, _output: WlOutput) -> Option<String> {
+        None
+    }
+
+    fn click_on_tag(
         &mut self,
         conn: &mut Connection<State>,
-        _: WlOutput,
-        _: WlSeat,
+        _output: WlOutput,
+        _seat: WlSeat,
         tag: &str,
         btn: PointerBtn,
     ) {
@@ -78,62 +102,30 @@ impl ExtWorkspaceUnstable {
         ws.workspace_handle.activate(conn);
         self.manager.commit(conn);
     }
+
+    fn as_any(&mut self) -> &mut dyn Any {
+        self
+    }
 }
 
 fn manager_cb(
     conn: &mut Connection<State>,
-    s: &mut State,
+    state: &mut State,
     _: ZextWorkspaceManagerV1,
     event: zext_workspace_manager_v1::Event,
 ) {
-    let WmInfoProvider::Ewu(state) = &mut s.shared_state.wm_info_provider else {
-        unreachable!()
-    };
+    let ewu = state.shared_state.get_ewu().unwrap();
 
     match event {
         zext_workspace_manager_v1::Event::WorkspaceGroup(group_handle) => {
             conn.set_callback_for(group_handle, group_cb);
-            state.groups.push(Group {
+            ewu.groups.push(Group {
                 group_handle,
                 workspaces: Vec::new(),
                 outputs: Vec::new(),
             });
         }
-        zext_workspace_manager_v1::Event::Done => {
-            let mut events = Vec::new();
-            for &output in &state.known_outputs {
-                if let Some(group) = state
-                    .groups
-                    .iter()
-                    .find(|g| g.outputs.contains(&output.id()))
-                {
-                    let mut tags: Vec<_> = group
-                        .workspaces
-                        .iter()
-                        .flat_map(|w| {
-                            let name = w.name.clone()?;
-                            Some(Tag {
-                                name,
-                                is_focused: w.is_focused,
-                                is_active: true,
-                                is_urgent: w.is_urgent,
-                            })
-                        })
-                        .collect();
-                    tags.sort_unstable_by(|a, b| a.name.cmp(&b.name));
-                    events.push((output, tags));
-                }
-            }
-
-            let cb = state.callback;
-            for (output, tags) in events {
-                let info = WmInfo {
-                    layout_name: None,
-                    tags,
-                };
-                (cb)(conn, s, output, info);
-            }
-        }
+        zext_workspace_manager_v1::Event::Done => state.tags_updated(conn, None),
         zext_workspace_manager_v1::Event::Finished => unreachable!(),
     }
 }
@@ -144,10 +136,8 @@ fn group_cb(
     group_handle: ZextWorkspaceGroupHandleV1,
     event: zext_workspace_group_handle_v1::Event,
 ) {
-    let WmInfoProvider::Ewu(state) = &mut state.shared_state.wm_info_provider else {
-        unreachable!()
-    };
-    let group = state
+    let ewu = state.shared_state.get_ewu().unwrap();
+    let group = ewu
         .groups
         .iter_mut()
         .find(|g| g.group_handle == group_handle)
@@ -179,10 +169,8 @@ fn workspace_cb(
     workspace_handle: ZextWorkspaceHandleV1,
     event: zext_workspace_handle_v1::Event,
 ) {
-    let WmInfoProvider::Ewu(state) = &mut state.shared_state.wm_info_provider else {
-        unreachable!()
-    };
-    let group = state
+    let ewu = state.shared_state.get_ewu().unwrap();
+    let group = ewu
         .groups
         .iter_mut()
         .find(|g| {
diff --git a/src/wm_info_provider/river.rs b/src/wm_info_provider/river.rs
index b5683ab..c9778bc 100644
--- a/src/wm_info_provider/river.rs
+++ b/src/wm_info_provider/river.rs
@@ -10,7 +10,7 @@ pub struct RiverInfoProvider {
     status_manager: ZriverStatusManagerV1,
     control: ZriverControlV1,
     output_statuses: Vec<OutputStatus>,
-    callback: WmInfoCallback,
+    max_tag: u8,
 }
 
 struct OutputStatus {
@@ -26,19 +26,19 @@ impl RiverInfoProvider {
     pub fn bind(
         conn: &mut Connection<State>,
         globals: &Globals,
-        callback: WmInfoCallback,
+        config: &WmConfig,
     ) -> Option<Self> {
         Some(Self {
             status_manager: globals.bind(conn, 1..=4).ok()?,
             control: globals.bind(conn, 1..=1).ok()?,
             output_statuses: Vec::new(),
-            callback,
+            max_tag: config.river.max_tag,
         })
     }
 }
 
-impl RiverInfoProvider {
-    pub fn new_output(&mut self, conn: &mut Connection<State>, output: WlOutput) {
+impl WmInfoProvider for RiverInfoProvider {
+    fn new_ouput(&mut self, conn: &mut Connection<State>, output: WlOutput) {
         let status =
             self.status_manager
                 .get_river_output_status_with_cb(conn, output, output_status_cb);
@@ -52,7 +52,7 @@ impl RiverInfoProvider {
         });
     }
 
-    pub fn output_removed(&mut self, conn: &mut Connection<State>, output: WlOutput) {
+    fn output_removed(&mut self, conn: &mut Connection<State>, output: WlOutput) {
         let index = self
             .output_statuses
             .iter()
@@ -62,10 +62,29 @@ impl RiverInfoProvider {
         output_status.status.destroy(conn);
     }
 
-    pub fn click_on_tag(
+    fn get_tags(&self, output: WlOutput) -> Vec<Tag> {
+        let Some(status) = self.output_statuses.iter().find(|s| s.output == output) else {
+            return Vec::new();
+        };
+        (1..=self.max_tag)
+            .map(|tag| Tag {
+                name: tag.to_string(),
+                is_focused: status.focused_tags & (1 << (tag - 1)) != 0,
+                is_active: status.active_tags & (1 << (tag - 1)) != 0,
+                is_urgent: status.urgent_tags & (1 << (tag - 1)) != 0,
+            })
+            .collect()
+    }
+
+    fn get_layout_name(&self, output: WlOutput) -> Option<String> {
+        let status = self.output_statuses.iter().find(|s| s.output == output)?;
+        status.layout_name.clone()
+    }
+
+    fn click_on_tag(
         &mut self,
         conn: &mut Connection<State>,
-        _: WlOutput,
+        _output: WlOutput,
         seat: WlSeat,
         tag: &str,
         btn: PointerBtn,
@@ -82,6 +101,10 @@ impl RiverInfoProvider {
         self.control
             .run_command_with_cb(conn, seat, river_command_cb);
     }
+
+    fn as_any(&mut self) -> &mut dyn Any {
+        self
+    }
 }
 
 fn output_status_cb(
@@ -90,45 +113,40 @@ fn output_status_cb(
     output_status: ZriverOutputStatusV1,
     event: zriver_output_status_v1::Event,
 ) {
-    let WmInfoProvider::River(river) = &mut state.shared_state.wm_info_provider else {
-        unreachable!()
-    };
-    let max_tag = state.shared_state.config.wm.river.max_tag.min(32);
-
+    let river = state.shared_state.get_river().unwrap();
     let status = river
         .output_statuses
         .iter_mut()
         .find(|s| s.status == output_status)
         .unwrap();
+    let output = status.output;
 
     use zriver_output_status_v1::Event;
     match event {
-        Event::FocusedTags(tags) => status.focused_tags = tags,
+        Event::FocusedTags(tags) => {
+            status.focused_tags = tags;
+            state.tags_updated(conn, Some(output));
+        }
         Event::ViewTags(tags) => {
             status.active_tags = tags
                 .chunks_exact(4)
                 .map(|bytes| u32::from_ne_bytes(bytes.try_into().unwrap()))
                 .fold(0, |a, b| a | b);
+            state.tags_updated(conn, Some(output));
+        }
+        Event::UrgentTags(tags) => {
+            status.urgent_tags = tags;
+            state.tags_updated(conn, Some(output));
+        }
+        Event::LayoutName(ln) => {
+            status.layout_name = Some(ln.to_string_lossy().into());
+            state.layout_name_updated(conn, Some(output));
+        }
+        Event::LayoutNameClear => {
+            status.layout_name = None;
+            state.layout_name_updated(conn, Some(output));
         }
-        Event::UrgentTags(tags) => status.urgent_tags = tags,
-        Event::LayoutName(ln) => status.layout_name = Some(ln.to_string_lossy().into()),
-        Event::LayoutNameClear => status.layout_name = None,
     }
-
-    let info = WmInfo {
-        layout_name: status.layout_name.clone(),
-        tags: (1..=max_tag)
-            .map(|tag| Tag {
-                name: tag.to_string(),
-                is_focused: status.focused_tags & (1 << (tag - 1)) != 0,
-                is_active: status.active_tags & (1 << (tag - 1)) != 0,
-                is_urgent: status.urgent_tags & (1 << (tag - 1)) != 0,
-            })
-            .collect(),
-    };
-
-    let output = status.output;
-    (river.callback)(conn, state, output, info);
 }
 
 fn river_command_cb(