update wayrs

2 files changed, 38 insertions, 73 deletions

diff --git a/src/wm_info_provider/ext_workspace_unstable.rs b/src/wm_info_provider/ext_workspace_unstable.rs
index 203cba9..c1d7b98 100644
--- a/src/wm_info_provider/ext_workspace_unstable.rs
+++ b/src/wm_info_provider/ext_workspace_unstable.rs
@@ -1,7 +1,7 @@
-use wayrs_client::global::*;
 use wayrs_client::object::ObjectId;
 use wayrs_client::proxy::Proxy;
 use wayrs_client::Connection;
+use wayrs_client::{global::*, EventCtx};
 
 use super::*;
 use crate::state::State;
@@ -30,7 +30,7 @@ struct Workspace {
 impl ExtWorkspaceUnstable {
     pub fn bind(conn: &mut Connection<State>, globals: &Globals) -> Option<Self> {
         Some(Self {
-            manager: globals.bind_with_cb(conn, 1..=1, manager_cb).ok()?,
+            manager: globals.bind_with_cb(conn, 1, manager_cb).ok()?,
             groups: Vec::new(),
             known_outputs: Vec::new(),
         })
@@ -112,48 +112,38 @@ impl WmInfoProvider for ExtWorkspaceUnstable {
     }
 }
 
-fn manager_cb(
-    conn: &mut Connection<State>,
-    state: &mut State,
-    _: ZextWorkspaceManagerV1,
-    event: zext_workspace_manager_v1::Event,
-) {
-    let ewu = state.shared_state.get_ewu().unwrap();
+fn manager_cb(ctx: EventCtx<State, ZextWorkspaceManagerV1>) {
+    let ewu = ctx.state.shared_state.get_ewu().unwrap();
 
-    match event {
+    match ctx.event {
         zext_workspace_manager_v1::Event::WorkspaceGroup(group_handle) => {
-            conn.set_callback_for(group_handle, group_cb);
+            ctx.conn.set_callback_for(group_handle, group_cb);
             ewu.groups.push(Group {
                 group_handle,
                 workspaces: Vec::new(),
                 outputs: Vec::new(),
             });
         }
-        zext_workspace_manager_v1::Event::Done => state.tags_updated(conn, None),
+        zext_workspace_manager_v1::Event::Done => ctx.state.tags_updated(ctx.conn, None),
         zext_workspace_manager_v1::Event::Finished => unreachable!(),
     }
 }
 
-fn group_cb(
-    conn: &mut Connection<State>,
-    state: &mut State,
-    group_handle: ZextWorkspaceGroupHandleV1,
-    event: zext_workspace_group_handle_v1::Event,
-) {
-    let ewu = state.shared_state.get_ewu().unwrap();
+fn group_cb(ctx: EventCtx<State, ZextWorkspaceGroupHandleV1>) {
+    let ewu = ctx.state.shared_state.get_ewu().unwrap();
     let group = ewu
         .groups
         .iter_mut()
-        .find(|g| g.group_handle == group_handle)
+        .find(|g| g.group_handle == ctx.proxy)
         .unwrap();
 
-    match event {
+    match ctx.event {
         zext_workspace_group_handle_v1::Event::OutputEnter(output) => {
             group.outputs.push(output);
         }
         zext_workspace_group_handle_v1::Event::OutputLeave(_) => todo!(),
         zext_workspace_group_handle_v1::Event::Workspace(workspace_handle) => {
-            conn.set_callback_for(workspace_handle, workspace_cb);
+            ctx.conn.set_callback_for(workspace_handle, workspace_cb);
             group.workspaces.push(Workspace {
                 workspace_handle,
                 name: None,
@@ -167,29 +157,21 @@ fn group_cb(
     }
 }
 
-fn workspace_cb(
-    conn: &mut Connection<State>,
-    state: &mut State,
-    workspace_handle: ZextWorkspaceHandleV1,
-    event: zext_workspace_handle_v1::Event,
-) {
-    let ewu = state.shared_state.get_ewu().unwrap();
+fn workspace_cb(ctx: EventCtx<State, ZextWorkspaceHandleV1>) {
+    let ewu = ctx.state.shared_state.get_ewu().unwrap();
+
     let group = ewu
         .groups
         .iter_mut()
-        .find(|g| {
-            g.workspaces
-                .iter()
-                .any(|w| w.workspace_handle == workspace_handle)
-        })
+        .find(|g| g.workspaces.iter().any(|w| w.workspace_handle == ctx.proxy))
         .unwrap();
     let workspace = group
         .workspaces
         .iter_mut()
-        .find(|w| w.workspace_handle == workspace_handle)
+        .find(|w| w.workspace_handle == ctx.proxy)
         .unwrap();
 
-    match event {
+    match ctx.event {
         zext_workspace_handle_v1::Event::Name(name) => {
             workspace.name = Some(name.to_string_lossy().into_owned());
         }
@@ -206,10 +188,8 @@ fn workspace_cb(
             }
         }
         zext_workspace_handle_v1::Event::Remove => {
-            group
-                .workspaces
-                .retain(|w| w.workspace_handle != workspace_handle);
-            workspace_handle.destroy(conn);
+            group.workspaces.retain(|w| w.workspace_handle != ctx.proxy);
+            ctx.proxy.destroy(ctx.conn);
         }
     }
 }
diff --git a/src/wm_info_provider/river.rs b/src/wm_info_provider/river.rs
index e9904bd..90c6cd1 100644
--- a/src/wm_info_provider/river.rs
+++ b/src/wm_info_provider/river.rs
@@ -1,7 +1,7 @@
 use std::ffi::CString;
 
-use wayrs_client::global::*;
 use wayrs_client::{cstr, Connection};
+use wayrs_client::{global::*, EventCtx};
 
 use super::*;
 use crate::state::State;
@@ -38,7 +38,7 @@ impl RiverInfoProvider {
         let wl_seat: WlSeat = globals.bind(conn, ..).ok()?; // river supports just one seat
         Some(Self {
             status_manager,
-            control: globals.bind(conn, 1..=1).ok()?,
+            control: globals.bind(conn, 1).ok()?,
             output_statuses: Vec::new(),
             max_tag: config.river.max_tag,
             seat_status: SeatStatus {
@@ -127,69 +127,54 @@ impl WmInfoProvider for RiverInfoProvider {
     }
 }
 
-fn output_status_cb(
-    conn: &mut Connection<State>,
-    state: &mut State,
-    output_status: ZriverOutputStatusV1,
-    event: zriver_output_status_v1::Event,
-) {
-    let river = state.shared_state.get_river().unwrap();
+fn output_status_cb(ctx: EventCtx<State, ZriverOutputStatusV1>) {
+    let river = ctx.state.shared_state.get_river().unwrap();
     let status = river
         .output_statuses
         .iter_mut()
-        .find(|s| s.status == output_status)
+        .find(|s| s.status == ctx.proxy)
         .unwrap();
     let output = status.output;
 
     use zriver_output_status_v1::Event;
-    match event {
+    match ctx.event {
         Event::FocusedTags(tags) => {
             status.focused_tags = tags;
-            state.tags_updated(conn, Some(output));
+            ctx.state.tags_updated(ctx.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));
+            ctx.state.tags_updated(ctx.conn, Some(output));
         }
         Event::UrgentTags(tags) => {
             status.urgent_tags = tags;
-            state.tags_updated(conn, Some(output));
+            ctx.state.tags_updated(ctx.conn, Some(output));
         }
         Event::LayoutName(ln) => {
             status.layout_name = Some(ln.to_string_lossy().into());
-            state.layout_name_updated(conn, Some(output));
+            ctx.state.layout_name_updated(ctx.conn, Some(output));
         }
         Event::LayoutNameClear => {
             status.layout_name = None;
-            state.layout_name_updated(conn, Some(output));
+            ctx.state.layout_name_updated(ctx.conn, Some(output));
         }
     }
 }
 
-fn seat_status_cb(
-    conn: &mut Connection<State>,
-    state: &mut State,
-    _: ZriverSeatStatusV1,
-    event: zriver_seat_status_v1::Event,
-) {
-    if let zriver_seat_status_v1::Event::Mode(mode) = event {
-        let river = state.shared_state.get_river().unwrap();
+fn seat_status_cb(ctx: EventCtx<State, ZriverSeatStatusV1>) {
+    if let zriver_seat_status_v1::Event::Mode(mode) = ctx.event {
+        let river = ctx.state.shared_state.get_river().unwrap();
         let mode = mode.to_string_lossy().into_owned();
         river.seat_status.mode = (mode != "normal").then_some(mode);
-        state.mode_name_updated(conn, None);
+        ctx.state.mode_name_updated(ctx.conn, None);
     }
 }
 
-fn river_command_cb(
-    conn: &mut Connection<State>,
-    state: &mut State,
-    _: ZriverCommandCallbackV1,
-    event: zriver_command_callback_v1::Event,
-) {
-    if let zriver_command_callback_v1::Event::Failure(msg) = event {
-        state.set_error(conn, msg.to_string_lossy())
+fn river_command_cb(ctx: EventCtx<State, ZriverCommandCallbackV1>) {
+    if let zriver_command_callback_v1::Event::Failure(msg) = ctx.event {
+        ctx.state.set_error(ctx.conn, msg.to_string_lossy())
     }
 }