update wayland libs & readd set_cursor

4 files changed, 159 insertions, 247 deletions

diff --git a/src/river_protocols/control.rs b/src/river_protocols/control.rs
index 525a9db..7cce23d 100644
--- a/src/river_protocols/control.rs
+++ b/src/river_protocols/control.rs
@@ -1,67 +1,34 @@
-pub mod protocol {
-    use smithay_client_toolkit::reexports::client as wayland_client;
-    use smithay_client_toolkit::reexports::client::protocol::*;
-
-    pub mod __interfaces {
-        use smithay_client_toolkit::reexports::client::protocol::__interfaces::*;
-        wayland_scanner::generate_interfaces!("protocols/river-control-unstable-v1.xml");
-    }
-    use self::__interfaces::*;
-
-    wayland_scanner::generate_client_code!("protocols/river-control-unstable-v1.xml");
-}
-
-mod dispatch;
-
-use std::sync::Arc;
-
-use smithay_client_toolkit::globals::GlobalData;
+use wayland_client::globals::{BindError, GlobalList};
 use wayland_client::{protocol::wl_seat, Connection, Dispatch, QueueHandle};
 
 use protocol::{zriver_command_callback_v1, zriver_control_v1};
 
-use smithay_client_toolkit::error::GlobalError;
-use smithay_client_toolkit::registry::GlobalProxy;
-
 #[derive(Debug, Clone)]
 pub struct RiverControlState {
-    control: Arc<GlobalProxy<zriver_control_v1::ZriverControlV1>>,
+    control: zriver_control_v1::ZriverControlV1,
 }
 
 impl RiverControlState {
-    pub fn new() -> Self {
-        Self {
-            control: Arc::new(GlobalProxy::NotReady),
-        }
-    }
-
-    pub fn is_available(&self) -> bool {
-        self.control.get().is_ok()
-    }
-
-    pub fn control(&self) -> Result<&zriver_control_v1::ZriverControlV1, GlobalError> {
-        self.control.get()
+    pub fn new<D>(globals: &GlobalList, qh: &QueueHandle<D>) -> Result<Self, BindError>
+    where
+        D: Dispatch<zriver_control_v1::ZriverControlV1, (), D> + 'static,
+    {
+        let control = globals.bind(qh, 1..=1, ())?;
+        Ok(Self { control })
     }
 
-    pub fn run_command<D, Args, Arg>(
-        &self,
-        qh: &QueueHandle<D>,
-        seat: &wl_seat::WlSeat,
-        args: Args,
-    ) -> Result<(), GlobalError>
+    pub fn run_command<D, Args, Arg>(&self, qh: &QueueHandle<D>, seat: &wl_seat::WlSeat, args: Args)
     where
-        D: Dispatch<zriver_control_v1::ZriverControlV1, GlobalData>
-            + Dispatch<zriver_command_callback_v1::ZriverCommandCallbackV1, RiverCommandCallbackData>
+        D: Dispatch<zriver_command_callback_v1::ZriverCommandCallbackV1, RiverCommandCallbackData>
             + 'static,
         Args: IntoIterator<Item = Arg>,
         Arg: Into<String>,
     {
-        let control = self.control()?;
         for arg in args {
-            control.add_argument(arg.into());
+            self.control.add_argument(arg.into());
         }
-        control.run_command(seat, qh, RiverCommandCallbackData {});
-        Ok(())
+        self.control
+            .run_command(seat, qh, RiverCommandCallbackData {});
     }
 }
 
@@ -82,10 +49,64 @@ pub struct RiverCommandCallbackData {
 macro_rules! delegate_river_control {
     ($ty: ty) => {
         ::smithay_client_toolkit::reexports::client::delegate_dispatch!($ty: [
-            $crate::river_protocols::control::protocol::zriver_control_v1::ZriverControlV1: ::smithay_client_toolkit::globals::GlobalData
+            $crate::river_protocols::control::protocol::zriver_control_v1::ZriverControlV1: ()
         ] => $crate::river_protocols::control::RiverControlState);
         ::smithay_client_toolkit::reexports::client::delegate_dispatch!($ty: [
             $crate::river_protocols::control::protocol::zriver_command_callback_v1::ZriverCommandCallbackV1: $crate::river_protocols::control::RiverCommandCallbackData
         ] => $crate::river_protocols::control::RiverControlState);
     };
 }
+
+impl<D> Dispatch<zriver_control_v1::ZriverControlV1, (), D> for RiverControlState
+where
+    D: Dispatch<zriver_control_v1::ZriverControlV1, ()> + RiverControlHandler + 'static,
+{
+    fn event(
+        _: &mut D,
+        _: &zriver_control_v1::ZriverControlV1,
+        _: zriver_control_v1::Event,
+        _: &(),
+        _: &Connection,
+        _: &QueueHandle<D>,
+    ) {
+        unreachable!("zriver_control_v1 has no events")
+    }
+}
+
+impl<D> Dispatch<zriver_command_callback_v1::ZriverCommandCallbackV1, RiverCommandCallbackData, D>
+    for RiverControlState
+where
+    D: Dispatch<zriver_command_callback_v1::ZriverCommandCallbackV1, RiverCommandCallbackData>
+        + RiverControlHandler
+        + 'static,
+{
+    fn event(
+        data: &mut D,
+        _callback: &zriver_command_callback_v1::ZriverCommandCallbackV1,
+        event: zriver_command_callback_v1::Event,
+        _udata: &RiverCommandCallbackData,
+        conn: &Connection,
+        qh: &QueueHandle<D>,
+    ) {
+        use zriver_command_callback_v1::Event;
+        match event {
+            Event::Success { output } => data.command_success(conn, qh, output),
+            Event::Failure { failure_message } => data.command_success(conn, qh, failure_message),
+        }
+    }
+}
+
+pub mod protocol {
+    #![allow(non_upper_case_globals)]
+
+    use smithay_client_toolkit::reexports::client as wayland_client;
+    use smithay_client_toolkit::reexports::client::protocol::*;
+
+    pub mod __interfaces {
+        use smithay_client_toolkit::reexports::client::protocol::__interfaces::*;
+        wayland_scanner::generate_interfaces!("protocols/river-control-unstable-v1.xml");
+    }
+    use self::__interfaces::*;
+
+    wayland_scanner::generate_client_code!("protocols/river-control-unstable-v1.xml");
+}
diff --git a/src/river_protocols/control/dispatch.rs b/src/river_protocols/control/dispatch.rs
deleted file mode 100644
index 14759e7..0000000
--- a/src/river_protocols/control/dispatch.rs
+++ /dev/null
@@ -1,70 +0,0 @@
-use std::sync::Arc;
-
-use super::protocol::{zriver_command_callback_v1, zriver_control_v1};
-use wayland_client::{Connection, Dispatch, QueueHandle};
-
-use smithay_client_toolkit::{
-    error::GlobalError,
-    globals::{GlobalData, ProvidesBoundGlobal},
-    registry::{ProvidesRegistryState, RegistryHandler},
-};
-
-use super::{RiverCommandCallbackData, RiverControlHandler, RiverControlState};
-
-impl<D> RegistryHandler<D> for RiverControlState
-where
-    D: Dispatch<zriver_control_v1::ZriverControlV1, GlobalData>
-        + RiverControlHandler
-        + ProvidesRegistryState
-        + 'static,
-{
-    fn ready(data: &mut D, _conn: &Connection, qh: &QueueHandle<D>) {
-        data.river_control_state().control =
-            Arc::new(data.registry().bind_one(qh, 1..=1, GlobalData).into());
-    }
-}
-
-impl ProvidesBoundGlobal<zriver_control_v1::ZriverControlV1, 1> for RiverControlState {
-    fn bound_global(&self) -> Result<zriver_control_v1::ZriverControlV1, GlobalError> {
-        self.control.get().cloned()
-    }
-}
-
-impl<D> Dispatch<zriver_control_v1::ZriverControlV1, GlobalData, D> for RiverControlState
-where
-    D: Dispatch<zriver_control_v1::ZriverControlV1, GlobalData> + RiverControlHandler + 'static,
-{
-    fn event(
-        _: &mut D,
-        _: &zriver_control_v1::ZriverControlV1,
-        _: zriver_control_v1::Event,
-        _: &GlobalData,
-        _: &Connection,
-        _: &QueueHandle<D>,
-    ) {
-        unreachable!("zriver_control_v1 has no events")
-    }
-}
-
-impl<D> Dispatch<zriver_command_callback_v1::ZriverCommandCallbackV1, RiverCommandCallbackData, D>
-    for RiverControlState
-where
-    D: Dispatch<zriver_command_callback_v1::ZriverCommandCallbackV1, RiverCommandCallbackData>
-        + RiverControlHandler
-        + 'static,
-{
-    fn event(
-        data: &mut D,
-        _callback: &zriver_command_callback_v1::ZriverCommandCallbackV1,
-        event: zriver_command_callback_v1::Event,
-        _udata: &RiverCommandCallbackData,
-        conn: &Connection,
-        qh: &QueueHandle<D>,
-    ) {
-        use zriver_command_callback_v1::Event;
-        match event {
-            Event::Success { output } => data.command_success(conn, qh, output),
-            Event::Failure { failure_message } => data.command_success(conn, qh, failure_message),
-        }
-    }
-}
diff --git a/src/river_protocols/status.rs b/src/river_protocols/status.rs
index 079572a..1779719 100644
--- a/src/river_protocols/status.rs
+++ b/src/river_protocols/status.rs
@@ -1,46 +1,29 @@
-pub mod protocol {
-    use smithay_client_toolkit::reexports::client as wayland_client;
-    use smithay_client_toolkit::reexports::client::protocol::*;
-
-    pub mod __interfaces {
-        use smithay_client_toolkit::reexports::client::protocol::__interfaces::*;
-        wayland_scanner::generate_interfaces!("protocols/river-status-unstable-v1.xml");
-    }
-    use self::__interfaces::*;
-
-    wayland_scanner::generate_client_code!("protocols/river-status-unstable-v1.xml");
-}
-
-mod dispatch;
-
 use std::sync::{Arc, Weak};
 
-use smithay_client_toolkit::globals::GlobalData;
-use wayland_client::{protocol::wl_output, Connection, Dispatch, QueueHandle};
+use wayland_client::{
+    globals::{BindError, GlobalList},
+    protocol::wl_output,
+    Connection, Dispatch, QueueHandle,
+};
 
 use protocol::{zriver_output_status_v1, zriver_status_manager_v1};
 
-use smithay_client_toolkit::error::GlobalError;
-use smithay_client_toolkit::registry::GlobalProxy;
-
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct RiverStatusState {
-    status_manager: GlobalProxy<zriver_status_manager_v1::ZriverStatusManagerV1>,
+    status_manager: zriver_status_manager_v1::ZriverStatusManagerV1,
     output_statuses: Vec<Weak<OutputStatusInner>>,
 }
 
 impl RiverStatusState {
-    pub fn new() -> Self {
-        Self {
-            status_manager: GlobalProxy::NotReady,
+    pub fn new<D>(globals: &GlobalList, qh: &QueueHandle<D>) -> Result<Self, BindError>
+    where
+        D: Dispatch<zriver_status_manager_v1::ZriverStatusManagerV1, (), D> + 'static,
+    {
+        let status_manager = globals.bind(qh, 1..=1, ())?;
+        Ok(Self {
+            status_manager,
             output_statuses: Vec::new(),
-        }
-    }
-
-    pub fn status_manager(
-        &self,
-    ) -> Result<&zriver_status_manager_v1::ZriverStatusManagerV1, GlobalError> {
-        self.status_manager.get()
+        })
     }
 
     pub fn get_output_status(
@@ -59,14 +42,15 @@ impl RiverStatusState {
         &mut self,
         qh: &QueueHandle<D>,
         output: &wl_output::WlOutput,
-    ) -> Result<RiverOutputStatus, GlobalError>
+    ) -> RiverOutputStatus
     where
-        D: Dispatch<zriver_status_manager_v1::ZriverStatusManagerV1, GlobalData>
+        D: Dispatch<zriver_status_manager_v1::ZriverStatusManagerV1, ()>
             + Dispatch<zriver_output_status_v1::ZriverOutputStatusV1, RiverStatusData>
             + 'static,
     {
-        let manager = self.status_manager()?;
-        let output_status = manager.get_river_output_status(output, qh, RiverStatusData {});
+        let output_status =
+            self.status_manager
+                .get_river_output_status(output, qh, RiverStatusData {});
 
         let output_status = RiverOutputStatus(Arc::new(OutputStatusInner {
             status: output_status,
@@ -74,7 +58,7 @@ impl RiverStatusState {
 
         self.output_statuses.push(Arc::downgrade(&output_status.0));
 
-        Ok(output_status)
+        output_status
     }
 }
 
@@ -124,7 +108,7 @@ pub struct RiverStatusData {
 macro_rules! delegate_river_status {
     ($ty: ty) => {
         ::smithay_client_toolkit::reexports::client::delegate_dispatch!($ty: [
-            $crate::river_protocols::status::protocol::zriver_status_manager_v1::ZriverStatusManagerV1: ::smithay_client_toolkit::globals::GlobalData
+            $crate::river_protocols::status::protocol::zriver_status_manager_v1::ZriverStatusManagerV1: ()
         ] => $crate::river_protocols::status::RiverStatusState);
         ::smithay_client_toolkit::reexports::client::delegate_dispatch!($ty: [
             $crate::river_protocols::status::protocol::zriver_output_status_v1::ZriverOutputStatusV1: $crate::river_protocols::status::RiverStatusData
@@ -142,3 +126,72 @@ impl Drop for OutputStatusInner {
         self.status.destroy();
     }
 }
+
+impl<D> Dispatch<zriver_status_manager_v1::ZriverStatusManagerV1, (), D> for RiverStatusState
+where
+    D: Dispatch<zriver_status_manager_v1::ZriverStatusManagerV1, ()> + RiverStatusHandler + 'static,
+{
+    fn event(
+        _: &mut D,
+        _: &zriver_status_manager_v1::ZriverStatusManagerV1,
+        _: zriver_status_manager_v1::Event,
+        _: &(),
+        _: &Connection,
+        _: &QueueHandle<D>,
+    ) {
+        unreachable!("zriver_status_manager_v1 has no events")
+    }
+}
+
+impl<D> Dispatch<zriver_output_status_v1::ZriverOutputStatusV1, RiverStatusData, D>
+    for RiverStatusState
+where
+    D: Dispatch<zriver_output_status_v1::ZriverOutputStatusV1, RiverStatusData>
+        + RiverStatusHandler
+        + 'static,
+{
+    fn event(
+        data: &mut D,
+        status: &zriver_output_status_v1::ZriverOutputStatusV1,
+        event: zriver_output_status_v1::Event,
+        _udata: &RiverStatusData,
+        conn: &Connection,
+        qh: &QueueHandle<D>,
+    ) {
+        use zriver_output_status_v1::Event;
+
+        // Remove any statuses that have been dropped
+        data.river_status_state()
+            .output_statuses
+            .retain(|status| status.upgrade().is_some());
+
+        if let Some(status) = data.river_status_state().get_output_status(status) {
+            match event {
+                Event::FocusedTags { tags } => data.focused_tags_updated(conn, qh, &status, tags),
+                Event::UrgentTags { tags } => data.urgent_tags_updated(conn, qh, &status, tags),
+                Event::ViewTags { tags } => {
+                    let tags = tags
+                        .chunks_exact(4)
+                        .map(|bytes| u32::from_ne_bytes(bytes.try_into().unwrap()))
+                        .collect();
+                    data.views_tags_updated(conn, qh, &status, tags);
+                }
+            }
+        }
+    }
+}
+
+pub mod protocol {
+    #![allow(non_upper_case_globals)]
+
+    use smithay_client_toolkit::reexports::client as wayland_client;
+    use smithay_client_toolkit::reexports::client::protocol::*;
+
+    pub mod __interfaces {
+        use smithay_client_toolkit::reexports::client::protocol::__interfaces::*;
+        wayland_scanner::generate_interfaces!("protocols/river-status-unstable-v1.xml");
+    }
+    use self::__interfaces::*;
+
+    wayland_scanner::generate_client_code!("protocols/river-status-unstable-v1.xml");
+}
diff --git a/src/river_protocols/status/dispatch.rs b/src/river_protocols/status/dispatch.rs
deleted file mode 100644
index 65d6e0c..0000000
--- a/src/river_protocols/status/dispatch.rs
+++ /dev/null
@@ -1,92 +0,0 @@
-use super::protocol::{zriver_output_status_v1, zriver_status_manager_v1};
-use wayland_client::{Connection, Dispatch, QueueHandle};
-
-use smithay_client_toolkit::{
-    error::GlobalError,
-    globals::{GlobalData, ProvidesBoundGlobal},
-    registry::{ProvidesRegistryState, RegistryHandler},
-};
-
-use super::{RiverStatusData, RiverStatusHandler, RiverStatusState};
-
-impl<D> RegistryHandler<D> for RiverStatusState
-where
-    D: Dispatch<zriver_status_manager_v1::ZriverStatusManagerV1, GlobalData>
-        + RiverStatusHandler
-        + ProvidesRegistryState
-        + 'static,
-{
-    fn ready(data: &mut D, _conn: &Connection, qh: &QueueHandle<D>) {
-        data.river_status_state().status_manager =
-            data.registry().bind_one(qh, 1..=2, GlobalData).into();
-    }
-}
-
-impl ProvidesBoundGlobal<zriver_status_manager_v1::ZriverStatusManagerV1, 1> for RiverStatusState {
-    fn bound_global(&self) -> Result<zriver_status_manager_v1::ZriverStatusManagerV1, GlobalError> {
-        self.status_manager.get().cloned()
-    }
-}
-
-impl ProvidesBoundGlobal<zriver_status_manager_v1::ZriverStatusManagerV1, 2> for RiverStatusState {
-    fn bound_global(&self) -> Result<zriver_status_manager_v1::ZriverStatusManagerV1, GlobalError> {
-        self.status_manager.get().cloned()
-    }
-}
-
-impl<D> Dispatch<zriver_status_manager_v1::ZriverStatusManagerV1, GlobalData, D>
-    for RiverStatusState
-where
-    D: Dispatch<zriver_status_manager_v1::ZriverStatusManagerV1, GlobalData>
-        + RiverStatusHandler
-        + 'static,
-{
-    fn event(
-        _: &mut D,
-        _: &zriver_status_manager_v1::ZriverStatusManagerV1,
-        _: zriver_status_manager_v1::Event,
-        _: &GlobalData,
-        _: &Connection,
-        _: &QueueHandle<D>,
-    ) {
-        unreachable!("zriver_status_manager_v1 has no events")
-    }
-}
-
-impl<D> Dispatch<zriver_output_status_v1::ZriverOutputStatusV1, RiverStatusData, D>
-    for RiverStatusState
-where
-    D: Dispatch<zriver_output_status_v1::ZriverOutputStatusV1, RiverStatusData>
-        + RiverStatusHandler
-        + 'static,
-{
-    fn event(
-        data: &mut D,
-        status: &zriver_output_status_v1::ZriverOutputStatusV1,
-        event: zriver_output_status_v1::Event,
-        _udata: &RiverStatusData,
-        conn: &Connection,
-        qh: &QueueHandle<D>,
-    ) {
-        use zriver_output_status_v1::Event;
-
-        // Remove any statuses that have been dropped
-        data.river_status_state()
-            .output_statuses
-            .retain(|status| status.upgrade().is_some());
-
-        if let Some(status) = data.river_status_state().get_output_status(status) {
-            match event {
-                Event::FocusedTags { tags } => data.focused_tags_updated(conn, qh, &status, tags),
-                Event::UrgentTags { tags } => data.urgent_tags_updated(conn, qh, &status, tags),
-                Event::ViewTags { tags } => {
-                    let tags = tags
-                        .chunks_exact(4)
-                        .map(|bytes| u32::from_ne_bytes(bytes.try_into().unwrap()))
-                        .collect();
-                    data.views_tags_updated(conn, qh, &status, tags);
-                }
-            }
-        }
-    }
-}