pub(crate) mod wl_display {
pub(crate) trait EvHandler {
fn error(
&mut self,
sender_id: crate::types::ObjectId,
object_id: crate::types::ObjectId,
code: u32,
message: &str,
);
fn delete_id(&mut self, sender_id: crate::types::ObjectId, id: u32);
}
pub(crate) fn event<T: EvHandler>(
state: &mut T,
wire_msg: &mut crate::wire::Messages<'_>,
) -> Result<(), crate::wire::Error> {
match wire_msg.op() {
0u16 => {
let object_id = wire_msg
.next_object()
.ok_or(crate::wire::Error::NullObjectId)?;
let code = wire_msg.next_u32();
let message = wire_msg.next_string()?;
state.error(wire_msg.sender_id(), object_id, code, message);
Ok(())
}
1u16 => {
let id = wire_msg.next_u32();
state.delete_id(wire_msg.sender_id(), id);
Ok(())
}
otherwise => Err(crate::wire::Error::UnrecognizedEventOpCode((
"wl_display",
otherwise,
))),
}
}
pub(crate) mod req {
pub(crate) const SYNC: u16 = 0u16;
pub(crate) fn sync(
backend: &mut crate::Waybackend,
sender_id: crate::types::ObjectId,
callback: crate::types::ObjectId,
) -> Result<(), crate::wire::Error> {
let crate::Waybackend {
wire_msg_builder,
wayland_fd,
..
} = backend;
wire_msg_builder.add_header(wayland_fd, sender_id, SYNC)?;
wire_msg_builder.add_new_specified_id(wayland_fd, callback)?;
wire_msg_builder.finish();
Ok(())
}
pub(crate) const GET_REGISTRY: u16 = 1u16;
pub(crate) fn get_registry(
backend: &mut crate::Waybackend,
sender_id: crate::types::ObjectId,
registry: crate::types::ObjectId,
) -> Result<(), crate::wire::Error> {
let crate::Waybackend {
wire_msg_builder,
wayland_fd,
..
} = backend;
wire_msg_builder.add_header(wayland_fd, sender_id, GET_REGISTRY)?;
wire_msg_builder.add_new_specified_id(wayland_fd, registry)?;
wire_msg_builder.finish();
Ok(())
}
}
#[allow(non_camel_case_types)]
#[repr(u32)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub(crate) enum Error {
invalid_object = 0u32,
invalid_method = 1u32,
no_memory = 2u32,
implementation = 3u32,
}
impl core::convert::TryFrom<u32> for Error {
type Error = crate::wire::Error;
#[allow(non_upper_case_globals)]
fn try_from(value: u32) -> Result<Self, Self::Error> {
const invalid_object: u32 = Error::invalid_object as u32;
const invalid_method: u32 = Error::invalid_method as u32;
const no_memory: u32 = Error::no_memory as u32;
const implementation: u32 = Error::implementation as u32;
match value {
invalid_object => Ok(Self::invalid_object),
invalid_method => Ok(Self::invalid_method),
no_memory => Ok(Self::no_memory),
implementation => Ok(Self::implementation),
otherwise => Err(crate::wire::Error::InvalidEnumDiscriminant((
"Error", otherwise,
))),
}
}
}
impl core::convert::From<Error> for u32 {
fn from(value: Error) -> u32 {
value as u32
}
}
}
pub(crate) mod wl_registry {
pub(crate) trait EvHandler {
fn global(
&mut self,
sender_id: crate::types::ObjectId,
name: u32,
interface: &str,
version: u32,
);
fn global_remove(&mut self, sender_id: crate::types::ObjectId, name: u32);
}
pub(crate) fn event<T: EvHandler>(
state: &mut T,
wire_msg: &mut crate::wire::Messages<'_>,
) -> Result<(), crate::wire::Error> {
match wire_msg.op() {
0u16 => {
let name = wire_msg.next_u32();
let interface = wire_msg.next_string()?;
let version = wire_msg.next_u32();
state.global(wire_msg.sender_id(), name, interface, version);
Ok(())
}
1u16 => {
let name = wire_msg.next_u32();
state.global_remove(wire_msg.sender_id(), name);
Ok(())
}
otherwise => Err(crate::wire::Error::UnrecognizedEventOpCode((
"wl_registry",
otherwise,
))),
}
}
pub(crate) mod req {
pub(crate) const BIND: u16 = 0u16;
pub(crate) fn bind(
backend: &mut crate::Waybackend,
sender_id: crate::types::ObjectId,
name: u32,
id: crate::types::ObjectId,
interface: &str,
version: u32,
) -> Result<(), crate::wire::Error> {
let crate::Waybackend {
wire_msg_builder,
wayland_fd,
..
} = backend;
wire_msg_builder.add_header(wayland_fd, sender_id, BIND)?;
wire_msg_builder.add_u32(wayland_fd, name)?;
wire_msg_builder.add_new_unspecified_id(wayland_fd, id, interface, version)?;
wire_msg_builder.finish();
Ok(())
}
}
}
pub(crate) mod wl_callback {
pub(crate) trait EvHandler {
fn done(&mut self, sender_id: crate::types::ObjectId, callback_data: u32);
}
pub(crate) fn event<T: EvHandler>(
state: &mut T,
wire_msg: &mut crate::wire::Messages<'_>,
) -> Result<(), crate::wire::Error> {
match wire_msg.op() {
0u16 => {
let callback_data = wire_msg.next_u32();
state.done(wire_msg.sender_id(), callback_data);
Ok(())
}
otherwise => Err(crate::wire::Error::UnrecognizedEventOpCode((
"wl_callback",
otherwise,
))),
}
}
pub(crate) mod req {}
}