update river protocol & refactor

build.rs

@@ -1,22 +1,14 @@
-extern crate wayland_scanner;
+use std::env::var;
-
 use std::path::Path;
 use wayland_scanner::{generate_code, Side};
 
-pub fn main() {
+fn main() {
-    generate("river_status_unstable_v1");
+    let out_dir = var("OUT_DIR").unwrap();
-}
+    let out_dir = Path::new(&out_dir);
-
+
-fn generate(protocol_name: &str) {
+    generate_code(
-    let out_dir = Path::new(concat!(env!("CARGO_MANIFEST_DIR"), "/src/wayland/"));
+        "./protocol/river-status-unstable-v1.xml",
-
+        out_dir.join("river-status-unstable-v1.rs"),
-    let mut protocol_dir = String::from(concat!(env!("CARGO_MANIFEST_DIR"), "/protocol/"));
+        Side::Client,
-    protocol_dir.push_str(&protocol_name.replace("_", "-"));
+    );
-    protocol_dir.push_str(".xml");
-
-    let protocol = Path::new(&protocol_dir);
-    let mut protocol_file = protocol_name.to_string();
-    protocol_file.push_str(".rs");
-
-    generate_code(protocol, out_dir.join(protocol_file), Side::Client);
 }

protocol/river-status-unstable-v1.xml

@@ -16,7 +16,7 @@
     OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
   </copyright>
 
-  <interface name="zriver_status_manager_v1" version="2">
+  <interface name="zriver_status_manager_v1" version="3">
     <description summary="manage river status objects">
       A global factory for objects that receive status information specific
       to river. It could be used to implement, for example, a status bar.
@@ -85,7 +85,7 @@
     </event>
   </interface>
 
-  <interface name="zriver_seat_status_v1" version="1">
+  <interface name="zriver_seat_status_v1" version="3">
     <description summary="track seat focus">
       This interface allows clients to receive information about the current
       focus of a seat. Note that (un)focused_output events will only be sent
@@ -121,5 +121,13 @@
       </description>
       <arg name="title" type="string" summary="title of the focused view"/>
     </event>
+
+    <event name="mode" since="3">
+      <description summary="the active mode changed">
+        Sent once on binding the interface and again whenever a new mode
+        is entered (e.g. with riverctl enter-mode foobar).
+      </description>
+      <arg name="name" type="string" summary="name of the mode"/>
+    </event>
   </interface>
 </protocol>

src/main.rs

@@ -1,6 +1,6 @@
-mod wayland;
+mod river_protocols;
 
-use crate::wayland::river_status_unstable_v1::{
+use river_protocols::{
     zriver_output_status_v1, zriver_seat_status_v1, zriver_status_manager_v1::ZriverStatusManagerV1,
 };
 use serde::ser::{SerializeSeq, Serializer};

src/river_protocols.rs

@@ -0,0 +1,27 @@
+pub use generated::client::*;
+
+pub mod generated {
+    // The generated code tends to trigger a lot of warnings
+    // so we isolate it into a very permissive module
+    #![allow(dead_code, non_camel_case_types, unused_unsafe, unused_variables)]
+    #![allow(non_upper_case_globals, non_snake_case, unused_imports)]
+    #![allow(clippy::all)]
+
+    pub mod client {
+        // These imports are used by the generated code
+        use wayland_client::protocol::wl_output;
+        use wayland_client::{protocol, sys};
+        use wayland_client::{
+            AnonymousObject, Attached, Display, GlobalManager, Main, Proxy, ProxyMap,
+        };
+        use wayland_commons::map::{Object, ObjectMetadata};
+        use wayland_commons::smallvec;
+        use wayland_commons::wire::{Argument, ArgumentType, Message, MessageDesc};
+        use wayland_commons::{Interface, MessageGroup};
+        // pub(crate) use wayland_protocols::unstable::xdg_output::v1::client::zxdg_output_v1::Event;
+        // If you protocol interacts with objects from other protocols, you'll need to import
+        // their modules, like so:
+        use wayland_client::protocol::{wl_region, wl_seat, wl_surface};
+        include!(concat!(env!("OUT_DIR"), "/river-status-unstable-v1.rs"));
+    }
+}

src/wayland/mod.rs

@@ -1,38 +0,0 @@
-extern crate wayland_client;
-extern crate wayland_commons;
-extern crate wayland_protocols;
-
-// Re-export only the actual code, and then only use this re-export
-// The `generated` module below is just some boilerplate to properly isolate stuff
-// and avoid exposing internal details.
-//
-// You can use all the types from my_protocol as if they went from `wayland_client::protocol`.
-pub use wayland::client as river_status_unstable_v1;
-
-pub mod wayland {
-    // The generated code tends to trigger a lot of warnings
-    // so we isolate it into a very permissive module
-    #![allow(dead_code, non_camel_case_types, unused_unsafe, unused_variables)]
-    #![allow(non_upper_case_globals, non_snake_case, unused_imports)]
-
-    pub mod client {
-        // These imports are used by the generated code
-        pub(crate) use wayland_client::protocol::wl_output;
-        pub(crate) use wayland_client::{protocol, sys};
-        pub(crate) use wayland_client::{
-            AnonymousObject, Attached, Display, GlobalManager, Main, Proxy, ProxyMap,
-        };
-        pub(crate) use wayland_commons::map::{Object, ObjectMetadata};
-        pub(crate) use wayland_commons::smallvec;
-        pub(crate) use wayland_commons::wire::{Argument, ArgumentType, Message, MessageDesc};
-        pub(crate) use wayland_commons::{Interface, MessageGroup};
-        // pub(crate) use wayland_protocols::unstable::xdg_output::v1::client::zxdg_output_v1::Event;
-        // If you protocol interacts with objects from other protocols, you'll need to import
-        // their modules, like so:
-        pub(crate) use wayland_client::protocol::{wl_region, wl_seat, wl_surface};
-        include!(concat!(
-            env!("CARGO_MANIFEST_DIR"),
-            "/src/wayland/river_status_unstable_v1.rs"
-        ));
-    }
-}

src/wayland/river_status_unstable_v1.rs

@@ -1,906 +0,0 @@
-use std::os::raw::{c_char, c_void};
-const NULLPTR: *const c_void = 0 as *const c_void;
-static mut types_null: [*const sys::common::wl_interface; 1] =
-    [NULLPTR as *const sys::common::wl_interface];
-#[doc = "manage river status objects\n\nA global factory for objects that receive status information specific\nto river. It could be used to implement, for example, a status bar."]
-pub mod zriver_status_manager_v1 {
-    use super::sys::client::*;
-    use super::sys::common::{wl_argument, wl_array, wl_interface, wl_message};
-    use super::{
-        smallvec, types_null, AnonymousObject, Argument, ArgumentType, Interface, Main, Message,
-        MessageDesc, MessageGroup, Object, ObjectMetadata, Proxy, NULLPTR,
-    };
-    use std::os::raw::c_char;
-    #[derive(Debug)]
-    #[non_exhaustive]
-    pub enum Request {
-        #[doc = "destroy the river_status_manager object\n\nThis request indicates that the client will not use the\nriver_status_manager object any more. Objects that have been created\nthrough this instance are not affected.\n\nThis is a destructor, once sent this object cannot be used any longer."]
-        Destroy,
-        #[doc = "create an output status object\n\nThis creates a new river_output_status object for the given wl_output."]
-        GetRiverOutputStatus { output: super::wl_output::WlOutput },
-        #[doc = "create a seat status object\n\nThis creates a new river_seat_status object for the given wl_seat."]
-        GetRiverSeatStatus { seat: super::wl_seat::WlSeat },
-    }
-    impl super::MessageGroup for Request {
-        const MESSAGES: &'static [super::MessageDesc] = &[
-            super::MessageDesc {
-                name: "destroy",
-                since: 1,
-                signature: &[],
-                destructor: true,
-            },
-            super::MessageDesc {
-                name: "get_river_output_status",
-                since: 1,
-                signature: &[super::ArgumentType::NewId, super::ArgumentType::Object],
-                destructor: false,
-            },
-            super::MessageDesc {
-                name: "get_river_seat_status",
-                since: 1,
-                signature: &[super::ArgumentType::NewId, super::ArgumentType::Object],
-                destructor: false,
-            },
-        ];
-        type Map = super::ProxyMap;
-        fn is_destructor(&self) -> bool {
-            match *self {
-                Request::Destroy => true,
-                _ => false,
-            }
-        }
-        fn opcode(&self) -> u16 {
-            match *self {
-                Request::Destroy => 0,
-                Request::GetRiverOutputStatus { .. } => 1,
-                Request::GetRiverSeatStatus { .. } => 2,
-            }
-        }
-        fn since(&self) -> u32 {
-            match *self {
-                Request::Destroy => 1,
-                Request::GetRiverOutputStatus { .. } => 1,
-                Request::GetRiverSeatStatus { .. } => 1,
-            }
-        }
-        fn child<Meta: ObjectMetadata>(
-            opcode: u16,
-            version: u32,
-            meta: &Meta,
-        ) -> Option<Object<Meta>> {
-            match opcode {
-                1 => Some(Object::from_interface::<
-                    super::zriver_output_status_v1::ZriverOutputStatusV1,
-                >(version, meta.child())),
-                2 => Some(Object::from_interface::<
-                    super::zriver_seat_status_v1::ZriverSeatStatusV1,
-                >(version, meta.child())),
-                _ => None,
-            }
-        }
-        fn from_raw(msg: Message, map: &mut Self::Map) -> Result<Self, ()> {
-            panic!("Request::from_raw can not be used Client-side.")
-        }
-        fn into_raw(self, sender_id: u32) -> Message {
-            match self {
-                Request::Destroy => Message {
-                    sender_id: sender_id,
-                    opcode: 0,
-                    args: smallvec![],
-                },
-                Request::GetRiverOutputStatus { output } => Message {
-                    sender_id: sender_id,
-                    opcode: 1,
-                    args: smallvec![Argument::NewId(0), Argument::Object(output.as_ref().id()),],
-                },
-                Request::GetRiverSeatStatus { seat } => Message {
-                    sender_id: sender_id,
-                    opcode: 2,
-                    args: smallvec![Argument::NewId(0), Argument::Object(seat.as_ref().id()),],
-                },
-            }
-        }
-        unsafe fn from_raw_c(
-            obj: *mut ::std::os::raw::c_void,
-            opcode: u32,
-            args: *const wl_argument,
-        ) -> Result<Request, ()> {
-            panic!("Request::from_raw_c can not be used Client-side.")
-        }
-        fn as_raw_c_in<F, T>(self, f: F) -> T
-        where
-            F: FnOnce(u32, &mut [wl_argument]) -> T,
-        {
-            match self {
-                Request::Destroy => {
-                    let mut _args_array: [wl_argument; 0] = unsafe { ::std::mem::zeroed() };
-                    f(0, &mut _args_array)
-                }
-                Request::GetRiverOutputStatus { output } => {
-                    let mut _args_array: [wl_argument; 2] = unsafe { ::std::mem::zeroed() };
-                    _args_array[0].o = ::std::ptr::null_mut() as *mut _;
-                    _args_array[1].o = output.as_ref().c_ptr() as *mut _;
-                    f(1, &mut _args_array)
-                }
-                Request::GetRiverSeatStatus { seat } => {
-                    let mut _args_array: [wl_argument; 2] = unsafe { ::std::mem::zeroed() };
-                    _args_array[0].o = ::std::ptr::null_mut() as *mut _;
-                    _args_array[1].o = seat.as_ref().c_ptr() as *mut _;
-                    f(2, &mut _args_array)
-                }
-            }
-        }
-    }
-    #[derive(Debug)]
-    #[non_exhaustive]
-    pub enum Event {}
-    impl super::MessageGroup for Event {
-        const MESSAGES: &'static [super::MessageDesc] = &[];
-        type Map = super::ProxyMap;
-        fn is_destructor(&self) -> bool {
-            match *self {}
-        }
-        fn opcode(&self) -> u16 {
-            match *self {}
-        }
-        fn since(&self) -> u32 {
-            match *self {}
-        }
-        fn child<Meta: ObjectMetadata>(
-            opcode: u16,
-            version: u32,
-            meta: &Meta,
-        ) -> Option<Object<Meta>> {
-            match opcode {
-                _ => None,
-            }
-        }
-        fn from_raw(msg: Message, map: &mut Self::Map) -> Result<Self, ()> {
-            match msg.opcode {
-                _ => Err(()),
-            }
-        }
-        fn into_raw(self, sender_id: u32) -> Message {
-            panic!("Event::into_raw can not be used Client-side.")
-        }
-        unsafe fn from_raw_c(
-            obj: *mut ::std::os::raw::c_void,
-            opcode: u32,
-            args: *const wl_argument,
-        ) -> Result<Event, ()> {
-            match opcode {
-                _ => return Err(()),
-            }
-        }
-        fn as_raw_c_in<F, T>(self, f: F) -> T
-        where
-            F: FnOnce(u32, &mut [wl_argument]) -> T,
-        {
-            panic!("Event::as_raw_c_in can not be used Client-side.")
-        }
-    }
-    #[derive(Clone, Eq, PartialEq)]
-    pub struct ZriverStatusManagerV1(Proxy<ZriverStatusManagerV1>);
-    impl AsRef<Proxy<ZriverStatusManagerV1>> for ZriverStatusManagerV1 {
-        #[inline]
-        fn as_ref(&self) -> &Proxy<Self> {
-            &self.0
-        }
-    }
-    impl From<Proxy<ZriverStatusManagerV1>> for ZriverStatusManagerV1 {
-        #[inline]
-        fn from(value: Proxy<Self>) -> Self {
-            ZriverStatusManagerV1(value)
-        }
-    }
-    impl From<ZriverStatusManagerV1> for Proxy<ZriverStatusManagerV1> {
-        #[inline]
-        fn from(value: ZriverStatusManagerV1) -> Self {
-            value.0
-        }
-    }
-    impl std::fmt::Debug for ZriverStatusManagerV1 {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            f.write_fmt(format_args!("{:?}", self.0))
-        }
-    }
-    impl Interface for ZriverStatusManagerV1 {
-        type Request = Request;
-        type Event = Event;
-        const NAME: &'static str = "zriver_status_manager_v1";
-        const VERSION: u32 = 2;
-        fn c_interface() -> *const wl_interface {
-            unsafe { &zriver_status_manager_v1_interface }
-        }
-    }
-    impl ZriverStatusManagerV1 {
-        #[doc = "destroy the river_status_manager object\n\nThis request indicates that the client will not use the\nriver_status_manager object any more. Objects that have been created\nthrough this instance are not affected.\n\nThis is a destructor, you cannot send requests to this object any longer once this method is called."]
-        pub fn destroy(&self) -> () {
-            let msg = Request::Destroy;
-            self.0.send::<AnonymousObject>(msg, None);
-        }
-        #[doc = "create an output status object\n\nThis creates a new river_output_status object for the given wl_output."]
-        pub fn get_river_output_status(
-            &self,
-            output: &super::wl_output::WlOutput,
-        ) -> Main<super::zriver_output_status_v1::ZriverOutputStatusV1> {
-            let msg = Request::GetRiverOutputStatus {
-                output: output.clone(),
-            };
-            self.0.send(msg, None).unwrap()
-        }
-        #[doc = "create a seat status object\n\nThis creates a new river_seat_status object for the given wl_seat."]
-        pub fn get_river_seat_status(
-            &self,
-            seat: &super::wl_seat::WlSeat,
-        ) -> Main<super::zriver_seat_status_v1::ZriverSeatStatusV1> {
-            let msg = Request::GetRiverSeatStatus { seat: seat.clone() };
-            self.0.send(msg, None).unwrap()
-        }
-    }
-    #[doc = r" The minimal object version supporting this request"]
-    pub const REQ_DESTROY_SINCE: u32 = 1u32;
-    #[doc = r" The minimal object version supporting this request"]
-    pub const REQ_GET_RIVER_OUTPUT_STATUS_SINCE: u32 = 1u32;
-    #[doc = r" The minimal object version supporting this request"]
-    pub const REQ_GET_RIVER_SEAT_STATUS_SINCE: u32 = 1u32;
-    static mut zriver_status_manager_v1_requests_get_river_output_status_types:
-        [*const wl_interface; 2] = [
-        unsafe {
-            &super::zriver_output_status_v1::zriver_output_status_v1_interface
-                as *const wl_interface
-        },
-        unsafe { &super::wl_output::wl_output_interface as *const wl_interface },
-    ];
-    static mut zriver_status_manager_v1_requests_get_river_seat_status_types:
-        [*const wl_interface; 2] = [
-        unsafe {
-            &super::zriver_seat_status_v1::zriver_seat_status_v1_interface as *const wl_interface
-        },
-        unsafe { &super::wl_seat::wl_seat_interface as *const wl_interface },
-    ];
-    #[doc = r" C-representation of the messages of this interface, for interop"]
-    pub static mut zriver_status_manager_v1_requests: [wl_message; 3] = [
-        wl_message {
-            name: b"destroy\0" as *const u8 as *const c_char,
-            signature: b"\0" as *const u8 as *const c_char,
-            types: unsafe { &types_null as *const _ },
-        },
-        wl_message {
-            name: b"get_river_output_status\0" as *const u8 as *const c_char,
-            signature: b"no\0" as *const u8 as *const c_char,
-            types: unsafe {
-                &zriver_status_manager_v1_requests_get_river_output_status_types as *const _
-            },
-        },
-        wl_message {
-            name: b"get_river_seat_status\0" as *const u8 as *const c_char,
-            signature: b"no\0" as *const u8 as *const c_char,
-            types: unsafe {
-                &zriver_status_manager_v1_requests_get_river_seat_status_types as *const _
-            },
-        },
-    ];
-    #[doc = r" C representation of this interface, for interop"]
-    pub static mut zriver_status_manager_v1_interface: wl_interface = wl_interface {
-        name: b"zriver_status_manager_v1\0" as *const u8 as *const c_char,
-        version: 2,
-        request_count: 3,
-        requests: unsafe { &zriver_status_manager_v1_requests as *const _ },
-        event_count: 0,
-        events: NULLPTR as *const wl_message,
-    };
-}
-#[doc = "track output tags and focus\n\nThis interface allows clients to receive information about the current\nwindowing state of an output."]
-pub mod zriver_output_status_v1 {
-    use super::sys::client::*;
-    use super::sys::common::{wl_argument, wl_array, wl_interface, wl_message};
-    use super::{
-        smallvec, types_null, AnonymousObject, Argument, ArgumentType, Interface, Main, Message,
-        MessageDesc, MessageGroup, Object, ObjectMetadata, Proxy, NULLPTR,
-    };
-    use std::os::raw::c_char;
-    #[derive(Debug)]
-    #[non_exhaustive]
-    pub enum Request {
-        #[doc = "destroy the river_output_status object\n\nThis request indicates that the client will not use the\nriver_output_status object any more.\n\nThis is a destructor, once sent this object cannot be used any longer."]
-        Destroy,
-    }
-    impl super::MessageGroup for Request {
-        const MESSAGES: &'static [super::MessageDesc] = &[super::MessageDesc {
-            name: "destroy",
-            since: 1,
-            signature: &[],
-            destructor: true,
-        }];
-        type Map = super::ProxyMap;
-        fn is_destructor(&self) -> bool {
-            match *self {
-                Request::Destroy => true,
-            }
-        }
-        fn opcode(&self) -> u16 {
-            match *self {
-                Request::Destroy => 0,
-            }
-        }
-        fn since(&self) -> u32 {
-            match *self {
-                Request::Destroy => 1,
-            }
-        }
-        fn child<Meta: ObjectMetadata>(
-            opcode: u16,
-            version: u32,
-            meta: &Meta,
-        ) -> Option<Object<Meta>> {
-            match opcode {
-                _ => None,
-            }
-        }
-        fn from_raw(msg: Message, map: &mut Self::Map) -> Result<Self, ()> {
-            panic!("Request::from_raw can not be used Client-side.")
-        }
-        fn into_raw(self, sender_id: u32) -> Message {
-            match self {
-                Request::Destroy => Message {
-                    sender_id: sender_id,
-                    opcode: 0,
-                    args: smallvec![],
-                },
-            }
-        }
-        unsafe fn from_raw_c(
-            obj: *mut ::std::os::raw::c_void,
-            opcode: u32,
-            args: *const wl_argument,
-        ) -> Result<Request, ()> {
-            panic!("Request::from_raw_c can not be used Client-side.")
-        }
-        fn as_raw_c_in<F, T>(self, f: F) -> T
-        where
-            F: FnOnce(u32, &mut [wl_argument]) -> T,
-        {
-            match self {
-                Request::Destroy => {
-                    let mut _args_array: [wl_argument; 0] = unsafe { ::std::mem::zeroed() };
-                    f(0, &mut _args_array)
-                }
-            }
-        }
-    }
-    #[derive(Debug)]
-    #[non_exhaustive]
-    pub enum Event {
-        #[doc = "focused tags of the output\n\nSent once binding the interface and again whenever the tag focus of\nthe output changes."]
-        FocusedTags { tags: u32 },
-        #[doc = "tag state of an output's views\n\nSent once on binding the interface and again whenever the tag state\nof the output changes."]
-        ViewTags { tags: Vec<u8> },
-        #[doc = "tags of the output with an urgent view\n\nSent once on binding the interface and again whenever the set of\ntags with at least one urgent view changes.\n\nOnly available since version 2 of the interface"]
-        UrgentTags { tags: u32 },
-    }
-    impl super::MessageGroup for Event {
-        const MESSAGES: &'static [super::MessageDesc] = &[
-            super::MessageDesc {
-                name: "focused_tags",
-                since: 1,
-                signature: &[super::ArgumentType::Uint],
-                destructor: false,
-            },
-            super::MessageDesc {
-                name: "view_tags",
-                since: 1,
-                signature: &[super::ArgumentType::Array],
-                destructor: false,
-            },
-            super::MessageDesc {
-                name: "urgent_tags",
-                since: 2,
-                signature: &[super::ArgumentType::Uint],
-                destructor: false,
-            },
-        ];
-        type Map = super::ProxyMap;
-        fn is_destructor(&self) -> bool {
-            match *self {
-                _ => false,
-            }
-        }
-        fn opcode(&self) -> u16 {
-            match *self {
-                Event::FocusedTags { .. } => 0,
-                Event::ViewTags { .. } => 1,
-                Event::UrgentTags { .. } => 2,
-            }
-        }
-        fn since(&self) -> u32 {
-            match *self {
-                Event::FocusedTags { .. } => 1,
-                Event::ViewTags { .. } => 1,
-                Event::UrgentTags { .. } => 2,
-            }
-        }
-        fn child<Meta: ObjectMetadata>(
-            opcode: u16,
-            version: u32,
-            meta: &Meta,
-        ) -> Option<Object<Meta>> {
-            match opcode {
-                _ => None,
-            }
-        }
-        fn from_raw(msg: Message, map: &mut Self::Map) -> Result<Self, ()> {
-            match msg.opcode {
-                0 => {
-                    let mut args = msg.args.into_iter();
-                    Ok(Event::FocusedTags {
-                        tags: {
-                            if let Some(Argument::Uint(val)) = args.next() {
-                                val
-                            } else {
-                                return Err(());
-                            }
-                        },
-                    })
-                }
-                1 => {
-                    let mut args = msg.args.into_iter();
-                    Ok(Event::ViewTags {
-                        tags: {
-                            if let Some(Argument::Array(val)) = args.next() {
-                                *val
-                            } else {
-                                return Err(());
-                            }
-                        },
-                    })
-                }
-                2 => {
-                    let mut args = msg.args.into_iter();
-                    Ok(Event::UrgentTags {
-                        tags: {
-                            if let Some(Argument::Uint(val)) = args.next() {
-                                val
-                            } else {
-                                return Err(());
-                            }
-                        },
-                    })
-                }
-                _ => Err(()),
-            }
-        }
-        fn into_raw(self, sender_id: u32) -> Message {
-            panic!("Event::into_raw can not be used Client-side.")
-        }
-        unsafe fn from_raw_c(
-            obj: *mut ::std::os::raw::c_void,
-            opcode: u32,
-            args: *const wl_argument,
-        ) -> Result<Event, ()> {
-            match opcode {
-                0 => {
-                    let _args = ::std::slice::from_raw_parts(args, 1);
-                    Ok(Event::FocusedTags { tags: _args[0].u })
-                }
-                1 => {
-                    let _args = ::std::slice::from_raw_parts(args, 1);
-                    Ok(Event::ViewTags {
-                        tags: {
-                            let array = &*_args[0].a;
-                            ::std::slice::from_raw_parts(array.data as *const u8, array.size)
-                                .to_owned()
-                        },
-                    })
-                }
-                2 => {
-                    let _args = ::std::slice::from_raw_parts(args, 1);
-                    Ok(Event::UrgentTags { tags: _args[0].u })
-                }
-                _ => return Err(()),
-            }
-        }
-        fn as_raw_c_in<F, T>(self, f: F) -> T
-        where
-            F: FnOnce(u32, &mut [wl_argument]) -> T,
-        {
-            panic!("Event::as_raw_c_in can not be used Client-side.")
-        }
-    }
-    #[derive(Clone, Eq, PartialEq)]
-    pub struct ZriverOutputStatusV1(Proxy<ZriverOutputStatusV1>);
-    impl AsRef<Proxy<ZriverOutputStatusV1>> for ZriverOutputStatusV1 {
-        #[inline]
-        fn as_ref(&self) -> &Proxy<Self> {
-            &self.0
-        }
-    }
-    impl From<Proxy<ZriverOutputStatusV1>> for ZriverOutputStatusV1 {
-        #[inline]
-        fn from(value: Proxy<Self>) -> Self {
-            ZriverOutputStatusV1(value)
-        }
-    }
-    impl From<ZriverOutputStatusV1> for Proxy<ZriverOutputStatusV1> {
-        #[inline]
-        fn from(value: ZriverOutputStatusV1) -> Self {
-            value.0
-        }
-    }
-    impl std::fmt::Debug for ZriverOutputStatusV1 {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            f.write_fmt(format_args!("{:?}", self.0))
-        }
-    }
-    impl Interface for ZriverOutputStatusV1 {
-        type Request = Request;
-        type Event = Event;
-        const NAME: &'static str = "zriver_output_status_v1";
-        const VERSION: u32 = 2;
-        fn c_interface() -> *const wl_interface {
-            unsafe { &zriver_output_status_v1_interface }
-        }
-    }
-    impl ZriverOutputStatusV1 {
-        #[doc = "destroy the river_output_status object\n\nThis request indicates that the client will not use the\nriver_output_status object any more.\n\nThis is a destructor, you cannot send requests to this object any longer once this method is called."]
-        pub fn destroy(&self) -> () {
-            let msg = Request::Destroy;
-            self.0.send::<AnonymousObject>(msg, None);
-        }
-    }
-    #[doc = r" The minimal object version supporting this request"]
-    pub const REQ_DESTROY_SINCE: u32 = 1u32;
-    #[doc = r" The minimal object version supporting this event"]
-    pub const EVT_FOCUSED_TAGS_SINCE: u32 = 1u32;
-    #[doc = r" The minimal object version supporting this event"]
-    pub const EVT_VIEW_TAGS_SINCE: u32 = 1u32;
-    #[doc = r" The minimal object version supporting this event"]
-    pub const EVT_URGENT_TAGS_SINCE: u32 = 2u32;
-    #[doc = r" C-representation of the messages of this interface, for interop"]
-    pub static mut zriver_output_status_v1_requests: [wl_message; 1] = [wl_message {
-        name: b"destroy\0" as *const u8 as *const c_char,
-        signature: b"\0" as *const u8 as *const c_char,
-        types: unsafe { &types_null as *const _ },
-    }];
-    #[doc = r" C-representation of the messages of this interface, for interop"]
-    pub static mut zriver_output_status_v1_events: [wl_message; 3] = [
-        wl_message {
-            name: b"focused_tags\0" as *const u8 as *const c_char,
-            signature: b"u\0" as *const u8 as *const c_char,
-            types: unsafe { &types_null as *const _ },
-        },
-        wl_message {
-            name: b"view_tags\0" as *const u8 as *const c_char,
-            signature: b"a\0" as *const u8 as *const c_char,
-            types: unsafe { &types_null as *const _ },
-        },
-        wl_message {
-            name: b"urgent_tags\0" as *const u8 as *const c_char,
-            signature: b"2u\0" as *const u8 as *const c_char,
-            types: unsafe { &types_null as *const _ },
-        },
-    ];
-    #[doc = r" C representation of this interface, for interop"]
-    pub static mut zriver_output_status_v1_interface: wl_interface = wl_interface {
-        name: b"zriver_output_status_v1\0" as *const u8 as *const c_char,
-        version: 2,
-        request_count: 1,
-        requests: unsafe { &zriver_output_status_v1_requests as *const _ },
-        event_count: 3,
-        events: unsafe { &zriver_output_status_v1_events as *const _ },
-    };
-}
-#[doc = "track seat focus\n\nThis interface allows clients to receive information about the current\nfocus of a seat. Note that (un)focused_output events will only be sent\nif the client has bound the relevant wl_output globals."]
-pub mod zriver_seat_status_v1 {
-    use super::sys::client::*;
-    use super::sys::common::{wl_argument, wl_array, wl_interface, wl_message};
-    use super::{
-        smallvec, types_null, AnonymousObject, Argument, ArgumentType, Interface, Main, Message,
-        MessageDesc, MessageGroup, Object, ObjectMetadata, Proxy, NULLPTR,
-    };
-    use std::os::raw::c_char;
-    #[derive(Debug)]
-    #[non_exhaustive]
-    pub enum Request {
-        #[doc = "destroy the river_seat_status object\n\nThis request indicates that the client will not use the\nriver_seat_status object any more.\n\nThis is a destructor, once sent this object cannot be used any longer."]
-        Destroy,
-    }
-    impl super::MessageGroup for Request {
-        const MESSAGES: &'static [super::MessageDesc] = &[super::MessageDesc {
-            name: "destroy",
-            since: 1,
-            signature: &[],
-            destructor: true,
-        }];
-        type Map = super::ProxyMap;
-        fn is_destructor(&self) -> bool {
-            match *self {
-                Request::Destroy => true,
-            }
-        }
-        fn opcode(&self) -> u16 {
-            match *self {
-                Request::Destroy => 0,
-            }
-        }
-        fn since(&self) -> u32 {
-            match *self {
-                Request::Destroy => 1,
-            }
-        }
-        fn child<Meta: ObjectMetadata>(
-            opcode: u16,
-            version: u32,
-            meta: &Meta,
-        ) -> Option<Object<Meta>> {
-            match opcode {
-                _ => None,
-            }
-        }
-        fn from_raw(msg: Message, map: &mut Self::Map) -> Result<Self, ()> {
-            panic!("Request::from_raw can not be used Client-side.")
-        }
-        fn into_raw(self, sender_id: u32) -> Message {
-            match self {
-                Request::Destroy => Message {
-                    sender_id: sender_id,
-                    opcode: 0,
-                    args: smallvec![],
-                },
-            }
-        }
-        unsafe fn from_raw_c(
-            obj: *mut ::std::os::raw::c_void,
-            opcode: u32,
-            args: *const wl_argument,
-        ) -> Result<Request, ()> {
-            panic!("Request::from_raw_c can not be used Client-side.")
-        }
-        fn as_raw_c_in<F, T>(self, f: F) -> T
-        where
-            F: FnOnce(u32, &mut [wl_argument]) -> T,
-        {
-            match self {
-                Request::Destroy => {
-                    let mut _args_array: [wl_argument; 0] = unsafe { ::std::mem::zeroed() };
-                    f(0, &mut _args_array)
-                }
-            }
-        }
-    }
-    #[derive(Debug)]
-    #[non_exhaustive]
-    pub enum Event {
-        #[doc = "the seat focused an output\n\nSent on binding the interface and again whenever an output gains focus."]
-        FocusedOutput { output: super::wl_output::WlOutput },
-        #[doc = "the seat unfocused an output\n\nSent whenever an output loses focus."]
-        UnfocusedOutput { output: super::wl_output::WlOutput },
-        #[doc = "information on the focused view\n\nSent once on binding the interface and again whenever the focused\nview or a property thereof changes. The title may be an empty string\nif no view is focused or the focused view did not set a title."]
-        FocusedView { title: String },
-    }
-    impl super::MessageGroup for Event {
-        const MESSAGES: &'static [super::MessageDesc] = &[
-            super::MessageDesc {
-                name: "focused_output",
-                since: 1,
-                signature: &[super::ArgumentType::Object],
-                destructor: false,
-            },
-            super::MessageDesc {
-                name: "unfocused_output",
-                since: 1,
-                signature: &[super::ArgumentType::Object],
-                destructor: false,
-            },
-            super::MessageDesc {
-                name: "focused_view",
-                since: 1,
-                signature: &[super::ArgumentType::Str],
-                destructor: false,
-            },
-        ];
-        type Map = super::ProxyMap;
-        fn is_destructor(&self) -> bool {
-            match *self {
-                _ => false,
-            }
-        }
-        fn opcode(&self) -> u16 {
-            match *self {
-                Event::FocusedOutput { .. } => 0,
-                Event::UnfocusedOutput { .. } => 1,
-                Event::FocusedView { .. } => 2,
-            }
-        }
-        fn since(&self) -> u32 {
-            match *self {
-                Event::FocusedOutput { .. } => 1,
-                Event::UnfocusedOutput { .. } => 1,
-                Event::FocusedView { .. } => 1,
-            }
-        }
-        fn child<Meta: ObjectMetadata>(
-            opcode: u16,
-            version: u32,
-            meta: &Meta,
-        ) -> Option<Object<Meta>> {
-            match opcode {
-                _ => None,
-            }
-        }
-        fn from_raw(msg: Message, map: &mut Self::Map) -> Result<Self, ()> {
-            match msg.opcode {
-                0 => {
-                    let mut args = msg.args.into_iter();
-                    Ok(Event::FocusedOutput {
-                        output: {
-                            if let Some(Argument::Object(val)) = args.next() {
-                                map.get_or_dead(val).into()
-                            } else {
-                                return Err(());
-                            }
-                        },
-                    })
-                }
-                1 => {
-                    let mut args = msg.args.into_iter();
-                    Ok(Event::UnfocusedOutput {
-                        output: {
-                            if let Some(Argument::Object(val)) = args.next() {
-                                map.get_or_dead(val).into()
-                            } else {
-                                return Err(());
-                            }
-                        },
-                    })
-                }
-                2 => {
-                    let mut args = msg.args.into_iter();
-                    Ok(Event::FocusedView {
-                        title: {
-                            if let Some(Argument::Str(val)) = args.next() {
-                                let s = String::from_utf8(val.into_bytes()).unwrap_or_else(|e| {
-                                    String::from_utf8_lossy(&e.into_bytes()).into()
-                                });
-                                s
-                            } else {
-                                return Err(());
-                            }
-                        },
-                    })
-                }
-                _ => Err(()),
-            }
-        }
-        fn into_raw(self, sender_id: u32) -> Message {
-            panic!("Event::into_raw can not be used Client-side.")
-        }
-        unsafe fn from_raw_c(
-            obj: *mut ::std::os::raw::c_void,
-            opcode: u32,
-            args: *const wl_argument,
-        ) -> Result<Event, ()> {
-            match opcode {
-                0 => {
-                    let _args = ::std::slice::from_raw_parts(args, 1);
-                    Ok(Event::FocusedOutput {
-                        output: Proxy::<super::wl_output::WlOutput>::from_c_ptr(
-                            _args[0].o as *mut _,
-                        )
-                        .into(),
-                    })
-                }
-                1 => {
-                    let _args = ::std::slice::from_raw_parts(args, 1);
-                    Ok(Event::UnfocusedOutput {
-                        output: Proxy::<super::wl_output::WlOutput>::from_c_ptr(
-                            _args[0].o as *mut _,
-                        )
-                        .into(),
-                    })
-                }
-                2 => {
-                    let _args = ::std::slice::from_raw_parts(args, 1);
-                    Ok(Event::FocusedView {
-                        title: ::std::ffi::CStr::from_ptr(_args[0].s)
-                            .to_string_lossy()
-                            .into_owned(),
-                    })
-                }
-                _ => return Err(()),
-            }
-        }
-        fn as_raw_c_in<F, T>(self, f: F) -> T
-        where
-            F: FnOnce(u32, &mut [wl_argument]) -> T,
-        {
-            panic!("Event::as_raw_c_in can not be used Client-side.")
-        }
-    }
-    #[derive(Clone, Eq, PartialEq)]
-    pub struct ZriverSeatStatusV1(Proxy<ZriverSeatStatusV1>);
-    impl AsRef<Proxy<ZriverSeatStatusV1>> for ZriverSeatStatusV1 {
-        #[inline]
-        fn as_ref(&self) -> &Proxy<Self> {
-            &self.0
-        }
-    }
-    impl From<Proxy<ZriverSeatStatusV1>> for ZriverSeatStatusV1 {
-        #[inline]
-        fn from(value: Proxy<Self>) -> Self {
-            ZriverSeatStatusV1(value)
-        }
-    }
-    impl From<ZriverSeatStatusV1> for Proxy<ZriverSeatStatusV1> {
-        #[inline]
-        fn from(value: ZriverSeatStatusV1) -> Self {
-            value.0
-        }
-    }
-    impl std::fmt::Debug for ZriverSeatStatusV1 {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            f.write_fmt(format_args!("{:?}", self.0))
-        }
-    }
-    impl Interface for ZriverSeatStatusV1 {
-        type Request = Request;
-        type Event = Event;
-        const NAME: &'static str = "zriver_seat_status_v1";
-        const VERSION: u32 = 1;
-        fn c_interface() -> *const wl_interface {
-            unsafe { &zriver_seat_status_v1_interface }
-        }
-    }
-    impl ZriverSeatStatusV1 {
-        #[doc = "destroy the river_seat_status object\n\nThis request indicates that the client will not use the\nriver_seat_status object any more.\n\nThis is a destructor, you cannot send requests to this object any longer once this method is called."]
-        pub fn destroy(&self) -> () {
-            let msg = Request::Destroy;
-            self.0.send::<AnonymousObject>(msg, None);
-        }
-    }
-    #[doc = r" The minimal object version supporting this request"]
-    pub const REQ_DESTROY_SINCE: u32 = 1u32;
-    #[doc = r" The minimal object version supporting this event"]
-    pub const EVT_FOCUSED_OUTPUT_SINCE: u32 = 1u32;
-    #[doc = r" The minimal object version supporting this event"]
-    pub const EVT_UNFOCUSED_OUTPUT_SINCE: u32 = 1u32;
-    #[doc = r" The minimal object version supporting this event"]
-    pub const EVT_FOCUSED_VIEW_SINCE: u32 = 1u32;
-    #[doc = r" C-representation of the messages of this interface, for interop"]
-    pub static mut zriver_seat_status_v1_requests: [wl_message; 1] = [wl_message {
-        name: b"destroy\0" as *const u8 as *const c_char,
-        signature: b"\0" as *const u8 as *const c_char,
-        types: unsafe { &types_null as *const _ },
-    }];
-    static mut zriver_seat_status_v1_events_focused_output_types: [*const wl_interface; 1] =
-        [unsafe { &super::wl_output::wl_output_interface as *const wl_interface }];
-    static mut zriver_seat_status_v1_events_unfocused_output_types: [*const wl_interface; 1] =
-        [unsafe { &super::wl_output::wl_output_interface as *const wl_interface }];
-    #[doc = r" C-representation of the messages of this interface, for interop"]
-    pub static mut zriver_seat_status_v1_events: [wl_message; 3] = [
-        wl_message {
-            name: b"focused_output\0" as *const u8 as *const c_char,
-            signature: b"o\0" as *const u8 as *const c_char,
-            types: unsafe { &zriver_seat_status_v1_events_focused_output_types as *const _ },
-        },
-        wl_message {
-            name: b"unfocused_output\0" as *const u8 as *const c_char,
-            signature: b"o\0" as *const u8 as *const c_char,
-            types: unsafe { &zriver_seat_status_v1_events_unfocused_output_types as *const _ },
-        },
-        wl_message {
-            name: b"focused_view\0" as *const u8 as *const c_char,
-            signature: b"s\0" as *const u8 as *const c_char,
-            types: unsafe { &types_null as *const _ },
-        },
-    ];
-    #[doc = r" C representation of this interface, for interop"]
-    pub static mut zriver_seat_status_v1_interface: wl_interface = wl_interface {
-        name: b"zriver_seat_status_v1\0" as *const u8 as *const c_char,
-        version: 1,
-        request_count: 1,
-        requests: unsafe { &zriver_seat_status_v1_requests as *const _ },
-        event_count: 3,
-        events: unsafe { &zriver_seat_status_v1_events as *const _ },
-    };
-}