1458 lines
49 KiB
Rust
1458 lines
49 KiB
Rust
use super::*;
|
|
use hecs::CommandBuffer;
|
|
use log::{debug, error, trace, warn};
|
|
use macros::simple_event_shunt;
|
|
use std::sync::{Arc, OnceLock};
|
|
use wayland_client::globals::Global;
|
|
use wayland_protocols::{
|
|
wp::{
|
|
fractional_scale::v1::client::wp_fractional_scale_v1::WpFractionalScaleV1,
|
|
linux_dmabuf::zv1::{client as c_dmabuf, server as s_dmabuf},
|
|
pointer_constraints::zv1::{
|
|
client::zwp_confined_pointer_v1::ZwpConfinedPointerV1 as ConfinedPointerClient,
|
|
client::zwp_locked_pointer_v1::ZwpLockedPointerV1 as LockedPointerClient,
|
|
client::zwp_pointer_constraints_v1::ZwpPointerConstraintsV1 as PointerConstraintsClient,
|
|
server::{
|
|
zwp_confined_pointer_v1::{
|
|
self as cp, ZwpConfinedPointerV1 as ConfinedPointerServer,
|
|
},
|
|
zwp_locked_pointer_v1::{self as lp, ZwpLockedPointerV1 as LockedPointerServer},
|
|
zwp_pointer_constraints_v1::{
|
|
self as pc, ZwpPointerConstraintsV1 as PointerConstraintsServer,
|
|
},
|
|
},
|
|
},
|
|
relative_pointer::zv1::{
|
|
client::zwp_relative_pointer_manager_v1::ZwpRelativePointerManagerV1 as RelativePointerManClient,
|
|
client::zwp_relative_pointer_v1::ZwpRelativePointerV1 as RelativePointerClient,
|
|
server::zwp_relative_pointer_manager_v1::ZwpRelativePointerManagerV1 as RelativePointerManServer,
|
|
server::zwp_relative_pointer_v1::ZwpRelativePointerV1 as RelativePointerServer,
|
|
},
|
|
tablet::zv2::{client as c_tablet, server as s_tablet},
|
|
viewporter::client::wp_viewport::WpViewport,
|
|
},
|
|
xdg::xdg_output::zv1::{
|
|
client::zxdg_output_manager_v1::ZxdgOutputManagerV1 as OutputManClient,
|
|
client::zxdg_output_v1::ZxdgOutputV1 as XdgOutputClient,
|
|
server::{
|
|
zxdg_output_manager_v1::{
|
|
self as s_output_man, ZxdgOutputManagerV1 as OutputManServer,
|
|
},
|
|
zxdg_output_v1::{self as s_xdgo, ZxdgOutputV1 as XdgOutputServer},
|
|
},
|
|
},
|
|
xwayland::shell::v1::server::{
|
|
xwayland_shell_v1::{self, XwaylandShellV1},
|
|
xwayland_surface_v1::{self, XwaylandSurfaceV1},
|
|
},
|
|
};
|
|
use wayland_server::{
|
|
protocol::{
|
|
wl_buffer::WlBuffer,
|
|
wl_callback::WlCallback,
|
|
wl_compositor::WlCompositor,
|
|
wl_keyboard::WlKeyboard,
|
|
wl_output::WlOutput,
|
|
wl_pointer::WlPointer,
|
|
wl_region::{self, WlRegion},
|
|
wl_seat::WlSeat,
|
|
wl_shm::WlShm,
|
|
wl_shm_pool::WlShmPool,
|
|
wl_surface::WlSurface,
|
|
wl_touch::WlTouch,
|
|
},
|
|
Dispatch, DisplayHandle, GlobalDispatch, Resource,
|
|
};
|
|
|
|
// noop
|
|
impl<C: XConnection> Dispatch<WlCallback, ()> for ServerState<C> {
|
|
fn request(
|
|
_: &mut Self,
|
|
_: &wayland_server::Client,
|
|
_: &WlCallback,
|
|
_: <WlCallback as Resource>::Request,
|
|
_: &(),
|
|
_: &DisplayHandle,
|
|
_: &mut wayland_server::DataInit<'_, Self>,
|
|
) {
|
|
unreachable!();
|
|
}
|
|
}
|
|
|
|
impl<C: XConnection> Dispatch<WlSurface, Entity> for ServerState<C> {
|
|
fn request(
|
|
state: &mut Self,
|
|
_: &wayland_server::Client,
|
|
_: &WlSurface,
|
|
request: <WlSurface as Resource>::Request,
|
|
entity: &Entity,
|
|
_: &DisplayHandle,
|
|
data_init: &mut wayland_server::DataInit<'_, Self>,
|
|
) {
|
|
let data = state.world.entity(*entity).unwrap();
|
|
let mut role = data.get::<&mut SurfaceRole>();
|
|
let xdg = role.as_ref().and_then(|role| role.xdg());
|
|
let configured = xdg.is_none_or(|xdg| xdg.configured);
|
|
let client = data.get::<&client::wl_surface::WlSurface>().unwrap();
|
|
|
|
let mut cmd = CommandBuffer::new();
|
|
|
|
match request {
|
|
Request::<WlSurface>::Attach { buffer, x, y } => {
|
|
if buffer.is_none() {
|
|
trace!("xwayland attached null buffer to {client:?}");
|
|
}
|
|
let buffer = buffer.as_ref().map(|b| {
|
|
let entity: Entity = b.data().copied().unwrap();
|
|
state
|
|
.world
|
|
.get::<&client::wl_buffer::WlBuffer>(entity)
|
|
.unwrap()
|
|
});
|
|
|
|
if configured {
|
|
client.attach(buffer.as_deref(), x, y);
|
|
} else {
|
|
let buffer = buffer.as_deref().cloned();
|
|
cmd.insert(*entity, (SurfaceAttach { buffer, x, y },));
|
|
}
|
|
}
|
|
Request::<WlSurface>::DamageBuffer {
|
|
x,
|
|
y,
|
|
width,
|
|
height,
|
|
} => {
|
|
if configured {
|
|
client.damage_buffer(x, y, width, height);
|
|
}
|
|
}
|
|
Request::<WlSurface>::Frame { callback } => {
|
|
let cb = data_init.init(callback, ());
|
|
if configured {
|
|
client.frame(&state.qh, cb);
|
|
} else {
|
|
cmd.insert(*entity, (cb,));
|
|
}
|
|
}
|
|
Request::<WlSurface>::Commit => {
|
|
if configured {
|
|
client.commit();
|
|
}
|
|
}
|
|
Request::<WlSurface>::Destroy => {
|
|
if !data.has::<x::Window>() {
|
|
cmd.despawn(*entity);
|
|
}
|
|
|
|
if let Some(role) = role.as_mut() {
|
|
role.destroy();
|
|
}
|
|
client.destroy();
|
|
|
|
debug!(
|
|
"deleting (surface {:?})",
|
|
data.get::<&WlSurface>().unwrap().id().protocol_id()
|
|
);
|
|
|
|
let mut query = data.query::<(&WpViewport, Option<&WpFractionalScaleV1>)>();
|
|
let (viewport, fractional) = query.get().unwrap();
|
|
viewport.destroy();
|
|
|
|
cmd.remove::<event::SurfaceBundle>(*entity);
|
|
if let Some(f) = fractional {
|
|
f.destroy();
|
|
cmd.remove_one::<WpFractionalScaleV1>(*entity);
|
|
}
|
|
}
|
|
Request::<WlSurface>::SetBufferScale { scale } => {
|
|
client.set_buffer_scale(scale);
|
|
}
|
|
Request::<WlSurface>::SetInputRegion { region } => {
|
|
let region = region.as_ref().map(|r| r.data().unwrap());
|
|
client.set_input_region(region);
|
|
}
|
|
other => warn!("unhandled surface request: {other:?}"),
|
|
}
|
|
|
|
drop(client);
|
|
drop(role);
|
|
|
|
cmd.run_on(&mut state.world);
|
|
}
|
|
}
|
|
|
|
impl<C: XConnection> Dispatch<WlRegion, client::wl_region::WlRegion> for ServerState<C> {
|
|
fn request(
|
|
_: &mut Self,
|
|
_: &wayland_server::Client,
|
|
_: &WlRegion,
|
|
request: <WlRegion as Resource>::Request,
|
|
client: &client::wl_region::WlRegion,
|
|
_: &DisplayHandle,
|
|
_: &mut wayland_server::DataInit<'_, Self>,
|
|
) {
|
|
macros::simple_event_shunt! {
|
|
client, request: wl_region::Request => [
|
|
Add { x, y, width, height },
|
|
Subtract { x, y, width, height },
|
|
Destroy
|
|
]
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<C: XConnection>
|
|
Dispatch<WlCompositor, ClientGlobalWrapper<client::wl_compositor::WlCompositor>>
|
|
for ServerState<C>
|
|
{
|
|
fn request(
|
|
state: &mut Self,
|
|
_: &wayland_server::Client,
|
|
_: &WlCompositor,
|
|
request: <WlCompositor as wayland_server::Resource>::Request,
|
|
client: &ClientGlobalWrapper<client::wl_compositor::WlCompositor>,
|
|
_: &DisplayHandle,
|
|
data_init: &mut wayland_server::DataInit<'_, Self>,
|
|
) {
|
|
match request {
|
|
Request::<WlCompositor>::CreateSurface { id } => {
|
|
let entity = state.world.reserve_entity();
|
|
let client = client.create_surface(&state.qh, entity);
|
|
let server = data_init.init(id, entity);
|
|
debug!("new surface ({})", server.id());
|
|
let viewport = state.viewporter.get_viewport(&client, &state.qh, ());
|
|
let fractional = state
|
|
.fractional_scale
|
|
.as_ref()
|
|
.map(|f| f.get_fractional_scale(&client, &state.qh, entity));
|
|
|
|
state.world.spawn_at(
|
|
entity,
|
|
event::SurfaceBundle {
|
|
client,
|
|
server,
|
|
viewport,
|
|
scale: SurfaceScaleFactor(1.0),
|
|
},
|
|
);
|
|
if let Some(f) = fractional {
|
|
state.world.insert(entity, (f,)).unwrap();
|
|
}
|
|
}
|
|
Request::<WlCompositor>::CreateRegion { id } => {
|
|
let c_region = client.create_region(&state.qh, ());
|
|
data_init.init(id, c_region);
|
|
}
|
|
other => {
|
|
warn!("unhandled wlcompositor request: {other:?}");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<C: XConnection> Dispatch<WlBuffer, Entity> for ServerState<C> {
|
|
fn request(
|
|
state: &mut Self,
|
|
_: &wayland_server::Client,
|
|
_: &WlBuffer,
|
|
request: <WlBuffer as Resource>::Request,
|
|
entity: &Entity,
|
|
_: &DisplayHandle,
|
|
_: &mut wayland_server::DataInit<'_, Self>,
|
|
) {
|
|
assert!(matches!(request, Request::<WlBuffer>::Destroy));
|
|
|
|
state
|
|
.world
|
|
.get::<&client::wl_buffer::WlBuffer>(*entity)
|
|
.unwrap()
|
|
.destroy();
|
|
state.world.despawn(*entity).unwrap();
|
|
}
|
|
}
|
|
|
|
impl<C: XConnection> Dispatch<WlShmPool, client::wl_shm_pool::WlShmPool> for ServerState<C> {
|
|
fn request(
|
|
state: &mut Self,
|
|
_: &wayland_server::Client,
|
|
_: &WlShmPool,
|
|
request: <WlShmPool as Resource>::Request,
|
|
c_pool: &client::wl_shm_pool::WlShmPool,
|
|
_: &DisplayHandle,
|
|
data_init: &mut wayland_server::DataInit<'_, Self>,
|
|
) {
|
|
match request {
|
|
Request::<WlShmPool>::CreateBuffer {
|
|
id,
|
|
offset,
|
|
width,
|
|
height,
|
|
stride,
|
|
format,
|
|
} => {
|
|
let entity = state.world.reserve_entity();
|
|
let client = c_pool.create_buffer(
|
|
offset,
|
|
width,
|
|
height,
|
|
stride,
|
|
convert_wenum(format),
|
|
&state.qh,
|
|
entity,
|
|
);
|
|
let server = data_init.init(id, entity);
|
|
state.world.spawn_at(entity, (client, server));
|
|
}
|
|
Request::<WlShmPool>::Resize { size } => {
|
|
c_pool.resize(size);
|
|
}
|
|
Request::<WlShmPool>::Destroy => {
|
|
c_pool.destroy();
|
|
state.queue.flush().unwrap();
|
|
}
|
|
other => warn!("unhandled shmpool request: {other:?}"),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<C: XConnection> Dispatch<WlShm, ClientGlobalWrapper<client::wl_shm::WlShm>>
|
|
for ServerState<C>
|
|
{
|
|
fn request(
|
|
state: &mut Self,
|
|
_: &wayland_server::Client,
|
|
_: &WlShm,
|
|
request: <WlShm as Resource>::Request,
|
|
client: &ClientGlobalWrapper<client::wl_shm::WlShm>,
|
|
_: &DisplayHandle,
|
|
data_init: &mut wayland_server::DataInit<'_, Self>,
|
|
) {
|
|
match request {
|
|
Request::<WlShm>::CreatePool { id, fd, size } => {
|
|
let c_pool = client.create_pool(fd.as_fd(), size, &state.qh, ());
|
|
data_init.init(id, c_pool);
|
|
}
|
|
other => {
|
|
warn!("unhandled shm pool request: {other:?}");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<C: XConnection> Dispatch<WlPointer, Entity> for ServerState<C> {
|
|
fn request(
|
|
state: &mut Self,
|
|
_: &wayland_server::Client,
|
|
_: &WlPointer,
|
|
request: <WlPointer as Resource>::Request,
|
|
entity: &Entity,
|
|
_: &DisplayHandle,
|
|
_: &mut wayland_server::DataInit<'_, Self>,
|
|
) {
|
|
let c_pointer = state
|
|
.world
|
|
.get::<&client::wl_pointer::WlPointer>(*entity)
|
|
.unwrap();
|
|
|
|
match request {
|
|
Request::<WlPointer>::SetCursor {
|
|
serial,
|
|
hotspot_x,
|
|
hotspot_y,
|
|
surface,
|
|
} => {
|
|
let c_surface = surface.and_then(|s| {
|
|
let e = s.data().copied()?;
|
|
Some(
|
|
state
|
|
.world
|
|
.get::<&client::wl_surface::WlSurface>(e)
|
|
.unwrap(),
|
|
)
|
|
});
|
|
c_pointer.set_cursor(serial, c_surface.as_deref(), hotspot_x, hotspot_y);
|
|
}
|
|
Request::<WlPointer>::Release => {
|
|
c_pointer.release();
|
|
drop(c_pointer);
|
|
let _ = state.world.despawn(*entity);
|
|
}
|
|
_ => warn!("unhandled cursor request: {request:?}"),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<C: XConnection> Dispatch<WlKeyboard, Entity> for ServerState<C> {
|
|
fn request(
|
|
state: &mut Self,
|
|
_: &wayland_server::Client,
|
|
_: &WlKeyboard,
|
|
request: <WlKeyboard as Resource>::Request,
|
|
entity: &Entity,
|
|
_: &DisplayHandle,
|
|
_: &mut wayland_server::DataInit<'_, Self>,
|
|
) {
|
|
match request {
|
|
Request::<WlKeyboard>::Release => {
|
|
state
|
|
.world
|
|
.get::<&client::wl_keyboard::WlKeyboard>(*entity)
|
|
.unwrap()
|
|
.release();
|
|
state.world.despawn(*entity).unwrap();
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<C: XConnection> Dispatch<WlTouch, Entity> for ServerState<C> {
|
|
fn request(
|
|
state: &mut Self,
|
|
_: &wayland_server::Client,
|
|
_: &WlTouch,
|
|
request: <WlTouch as Resource>::Request,
|
|
entity: &Entity,
|
|
_: &DisplayHandle,
|
|
_: &mut wayland_server::DataInit<'_, Self>,
|
|
) {
|
|
match request {
|
|
Request::<WlTouch>::Release => {
|
|
state
|
|
.world
|
|
.get::<&client::wl_touch::WlTouch>(*entity)
|
|
.unwrap()
|
|
.release();
|
|
state.world.despawn(*entity).unwrap();
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<C: XConnection> Dispatch<WlSeat, Entity> for ServerState<C> {
|
|
fn request(
|
|
state: &mut Self,
|
|
_: &wayland_server::Client,
|
|
_: &WlSeat,
|
|
request: <WlSeat as Resource>::Request,
|
|
entity: &Entity,
|
|
_: &DisplayHandle,
|
|
data_init: &mut wayland_server::DataInit<'_, Self>,
|
|
) {
|
|
match request {
|
|
Request::<WlSeat>::GetPointer { id } => {
|
|
let new_entity = state.world.reserve_entity();
|
|
let client = {
|
|
state
|
|
.world
|
|
.get::<&client::wl_seat::WlSeat>(*entity)
|
|
.unwrap()
|
|
.get_pointer(&state.qh, new_entity)
|
|
};
|
|
let server = data_init.init(id, new_entity);
|
|
state.world.spawn_at(new_entity, (client, server));
|
|
}
|
|
Request::<WlSeat>::GetKeyboard { id } => {
|
|
let client = {
|
|
state
|
|
.world
|
|
.get::<&client::wl_seat::WlSeat>(*entity)
|
|
.unwrap()
|
|
.get_keyboard(&state.qh, *entity)
|
|
};
|
|
let server = data_init.init(id, *entity);
|
|
state.world.insert(*entity, (client, server)).unwrap();
|
|
}
|
|
Request::<WlSeat>::GetTouch { id } => {
|
|
let new_entity = state.world.reserve_entity();
|
|
let client = {
|
|
state
|
|
.world
|
|
.get::<&client::wl_seat::WlSeat>(*entity)
|
|
.unwrap()
|
|
.get_touch(&state.qh, new_entity)
|
|
};
|
|
let server = data_init.init(id, new_entity);
|
|
state.world.spawn_at(new_entity, (client, server));
|
|
}
|
|
other => warn!("unhandled seat request: {other:?}"),
|
|
}
|
|
}
|
|
}
|
|
|
|
macro_rules! only_destroy_request_impl {
|
|
($server:ty, $client:ty) => {
|
|
impl<C: XConnection> Dispatch<$server, Entity> for ServerState<C> {
|
|
fn request(
|
|
state: &mut Self,
|
|
_: &Client,
|
|
_: &$server,
|
|
request: <$server as Resource>::Request,
|
|
entity: &Entity,
|
|
_: &DisplayHandle,
|
|
_: &mut wayland_server::DataInit<'_, Self>,
|
|
) {
|
|
if !matches!(request, <$server as Resource>::Request::Destroy) {
|
|
warn!(
|
|
"unrecognized {} request: {:?}",
|
|
stringify!($server),
|
|
request
|
|
);
|
|
return;
|
|
}
|
|
|
|
state.world.get::<&$client>(*entity).unwrap().destroy();
|
|
state.world.despawn(*entity).unwrap();
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
only_destroy_request_impl!(RelativePointerServer, RelativePointerClient);
|
|
|
|
impl<C: XConnection>
|
|
Dispatch<RelativePointerManServer, ClientGlobalWrapper<RelativePointerManClient>>
|
|
for ServerState<C>
|
|
{
|
|
fn request(
|
|
state: &mut Self,
|
|
_: &wayland_server::Client,
|
|
_: &RelativePointerManServer,
|
|
request: <RelativePointerManServer as Resource>::Request,
|
|
client: &ClientGlobalWrapper<RelativePointerManClient>,
|
|
_: &DisplayHandle,
|
|
data_init: &mut wayland_server::DataInit<'_, Self>,
|
|
) {
|
|
match request {
|
|
Request::<RelativePointerManServer>::GetRelativePointer { id, pointer } => {
|
|
let pointer_entity: Entity = pointer.data().copied().unwrap();
|
|
let entity = state.world.reserve_entity();
|
|
let client = {
|
|
let client_pointer = state
|
|
.world
|
|
.get::<&client::wl_pointer::WlPointer>(pointer_entity)
|
|
.unwrap();
|
|
|
|
client.get_relative_pointer(&client_pointer, &state.qh, entity)
|
|
};
|
|
let server = data_init.init(id, entity);
|
|
state.world.spawn_at(entity, (server, client));
|
|
}
|
|
_ => warn!("unhandled relative pointer request: {request:?}"),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<C: XConnection> Dispatch<WlOutput, Entity> for ServerState<C> {
|
|
fn request(
|
|
state: &mut Self,
|
|
_: &wayland_server::Client,
|
|
_: &WlOutput,
|
|
request: <WlOutput as Resource>::Request,
|
|
entity: &Entity,
|
|
_: &DisplayHandle,
|
|
_: &mut wayland_server::DataInit<'_, Self>,
|
|
) {
|
|
match request {
|
|
wayland_server::protocol::wl_output::Request::Release => {
|
|
state
|
|
.world
|
|
.get::<&client::wl_output::WlOutput>(*entity)
|
|
.unwrap()
|
|
.release();
|
|
todo!("handle wloutput destruction");
|
|
}
|
|
_ => warn!("unhandled output request {request:?}"),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<C: XConnection>
|
|
Dispatch<s_dmabuf::zwp_linux_dmabuf_feedback_v1::ZwpLinuxDmabufFeedbackV1, Entity>
|
|
for ServerState<C>
|
|
{
|
|
fn request(
|
|
state: &mut Self,
|
|
_: &wayland_server::Client,
|
|
_: &s_dmabuf::zwp_linux_dmabuf_feedback_v1::ZwpLinuxDmabufFeedbackV1,
|
|
request: <s_dmabuf::zwp_linux_dmabuf_feedback_v1::ZwpLinuxDmabufFeedbackV1 as Resource>::Request,
|
|
entity: &Entity,
|
|
_: &DisplayHandle,
|
|
_: &mut wayland_server::DataInit<'_, Self>,
|
|
) {
|
|
use s_dmabuf::zwp_linux_dmabuf_feedback_v1::Request::*;
|
|
match request {
|
|
Destroy => {
|
|
state
|
|
.world
|
|
.get::<&c_dmabuf::zwp_linux_dmabuf_feedback_v1::ZwpLinuxDmabufFeedbackV1>(
|
|
*entity,
|
|
)
|
|
.unwrap()
|
|
.destroy();
|
|
state.world.despawn(*entity).unwrap();
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<C: XConnection>
|
|
Dispatch<
|
|
s_dmabuf::zwp_linux_buffer_params_v1::ZwpLinuxBufferParamsV1,
|
|
c_dmabuf::zwp_linux_buffer_params_v1::ZwpLinuxBufferParamsV1,
|
|
> for ServerState<C>
|
|
{
|
|
fn request(
|
|
state: &mut Self,
|
|
_: &wayland_server::Client,
|
|
_: &s_dmabuf::zwp_linux_buffer_params_v1::ZwpLinuxBufferParamsV1,
|
|
request: <s_dmabuf::zwp_linux_buffer_params_v1::ZwpLinuxBufferParamsV1 as Resource>::Request,
|
|
c_params: &c_dmabuf::zwp_linux_buffer_params_v1::ZwpLinuxBufferParamsV1,
|
|
_: &DisplayHandle,
|
|
data_init: &mut wayland_server::DataInit<'_, Self>,
|
|
) {
|
|
use s_dmabuf::zwp_linux_buffer_params_v1::Request::*;
|
|
match request {
|
|
// TODO: Xwayland doesn't actually seem to use the Create request, and I don't feel like implementing it...
|
|
Create { .. } => todo!(),
|
|
CreateImmed {
|
|
buffer_id,
|
|
width,
|
|
height,
|
|
format,
|
|
flags,
|
|
} => {
|
|
let entity = state.world.reserve_entity();
|
|
let client = c_params.create_immed(
|
|
width,
|
|
height,
|
|
format,
|
|
convert_wenum(flags),
|
|
&state.qh,
|
|
entity,
|
|
);
|
|
let server = data_init.init(buffer_id, entity);
|
|
state.world.spawn_at(entity, (client, server));
|
|
}
|
|
Add {
|
|
fd,
|
|
plane_idx,
|
|
offset,
|
|
stride,
|
|
modifier_hi,
|
|
modifier_lo,
|
|
} => {
|
|
c_params.add(
|
|
fd.as_fd(),
|
|
plane_idx,
|
|
offset,
|
|
stride,
|
|
modifier_hi,
|
|
modifier_lo,
|
|
);
|
|
}
|
|
Destroy => {
|
|
c_params.destroy();
|
|
}
|
|
_ => warn!("unhandled params request: {request:?}"),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<C: XConnection>
|
|
Dispatch<
|
|
s_dmabuf::zwp_linux_dmabuf_v1::ZwpLinuxDmabufV1,
|
|
ClientGlobalWrapper<c_dmabuf::zwp_linux_dmabuf_v1::ZwpLinuxDmabufV1>,
|
|
> for ServerState<C>
|
|
{
|
|
fn request(
|
|
state: &mut Self,
|
|
_: &wayland_server::Client,
|
|
_: &s_dmabuf::zwp_linux_dmabuf_v1::ZwpLinuxDmabufV1,
|
|
request: <s_dmabuf::zwp_linux_dmabuf_v1::ZwpLinuxDmabufV1 as Resource>::Request,
|
|
client: &ClientGlobalWrapper<c_dmabuf::zwp_linux_dmabuf_v1::ZwpLinuxDmabufV1>,
|
|
_: &DisplayHandle,
|
|
data_init: &mut wayland_server::DataInit<'_, Self>,
|
|
) {
|
|
use s_dmabuf::zwp_linux_dmabuf_v1::Request::*;
|
|
match request {
|
|
Destroy => {
|
|
client.destroy();
|
|
}
|
|
CreateParams { params_id } => {
|
|
let c_params = client.create_params(&state.qh, ());
|
|
data_init.init(params_id, c_params);
|
|
}
|
|
GetDefaultFeedback { id } => {
|
|
let entity = state.world.reserve_entity();
|
|
let client = client.get_default_feedback(&state.qh, entity);
|
|
let server = data_init.init(id, entity);
|
|
state.world.spawn_at(entity, (client, server));
|
|
}
|
|
GetSurfaceFeedback { id, surface } => {
|
|
let entity = state.world.reserve_entity();
|
|
let surface_entity: Entity = surface.data().copied().unwrap();
|
|
let client = {
|
|
let c_surface = state
|
|
.world
|
|
.get::<&client::wl_surface::WlSurface>(surface_entity)
|
|
.unwrap();
|
|
client.get_surface_feedback(&c_surface, &state.qh, entity)
|
|
};
|
|
let server = data_init.init(id, entity);
|
|
|
|
state.world.spawn_at(entity, (client, server));
|
|
}
|
|
_ => warn!("unhandled dmabuf request: {request:?}"),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<C: XConnection> Dispatch<WlDrmServer, Entity> for ServerState<C> {
|
|
fn request(
|
|
state: &mut Self,
|
|
_: &wayland_server::Client,
|
|
_: &WlDrmServer,
|
|
request: <WlDrmServer as Resource>::Request,
|
|
entity: &Entity,
|
|
_: &DisplayHandle,
|
|
data_init: &mut wayland_server::DataInit<'_, Self>,
|
|
) {
|
|
use wl_drm::server::wl_drm::Request::*;
|
|
|
|
type DrmFn = dyn FnOnce(
|
|
&wl_drm::client::wl_drm::WlDrm,
|
|
Entity,
|
|
&QueueHandle<MyWorld>,
|
|
) -> client::wl_buffer::WlBuffer;
|
|
|
|
let mut bufs: Option<(Box<DrmFn>, wayland_server::New<WlBuffer>)> = None;
|
|
match request {
|
|
CreateBuffer {
|
|
id,
|
|
name,
|
|
width,
|
|
height,
|
|
stride,
|
|
format,
|
|
} => {
|
|
bufs = Some((
|
|
Box::new(move |drm, key, qh| {
|
|
drm.create_buffer(name, width, height, stride, format, qh, key)
|
|
}),
|
|
id,
|
|
));
|
|
}
|
|
CreatePlanarBuffer {
|
|
id,
|
|
name,
|
|
width,
|
|
height,
|
|
format,
|
|
offset0,
|
|
stride0,
|
|
offset1,
|
|
stride1,
|
|
offset2,
|
|
stride2,
|
|
} => {
|
|
bufs = Some((
|
|
Box::new(move |drm, key, qh| {
|
|
drm.create_planar_buffer(
|
|
name, width, height, format, offset0, stride0, offset1, stride1,
|
|
offset2, stride2, qh, key,
|
|
)
|
|
}),
|
|
id,
|
|
));
|
|
}
|
|
CreatePrimeBuffer {
|
|
id,
|
|
name,
|
|
width,
|
|
height,
|
|
format,
|
|
offset0,
|
|
stride0,
|
|
offset1,
|
|
stride1,
|
|
offset2,
|
|
stride2,
|
|
} => {
|
|
bufs = Some((
|
|
Box::new(move |drm, key, qh| {
|
|
drm.create_prime_buffer(
|
|
name.as_fd(),
|
|
width,
|
|
height,
|
|
format,
|
|
offset0,
|
|
stride0,
|
|
offset1,
|
|
stride1,
|
|
offset2,
|
|
stride2,
|
|
qh,
|
|
key,
|
|
)
|
|
}),
|
|
id,
|
|
));
|
|
}
|
|
Authenticate { id } => {
|
|
state
|
|
.world
|
|
.get::<&wl_drm::client::wl_drm::WlDrm>(*entity)
|
|
.unwrap()
|
|
.authenticate(id);
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
|
|
if let Some((buf_create, id)) = bufs {
|
|
let new_entity = state.world.reserve_entity();
|
|
let client = {
|
|
let drm_client = state
|
|
.world
|
|
.get::<&wl_drm::client::wl_drm::WlDrm>(*entity)
|
|
.unwrap();
|
|
buf_create(&drm_client, new_entity, &state.qh)
|
|
};
|
|
let server = data_init.init(id, new_entity);
|
|
state.world.spawn_at(new_entity, (client, server));
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<C: XConnection> Dispatch<XdgOutputServer, Entity> for ServerState<C> {
|
|
fn request(
|
|
state: &mut Self,
|
|
_: &wayland_server::Client,
|
|
_: &XdgOutputServer,
|
|
request: <XdgOutputServer as Resource>::Request,
|
|
entity: &Entity,
|
|
_: &DisplayHandle,
|
|
_: &mut wayland_server::DataInit<'_, Self>,
|
|
) {
|
|
let s_xdgo::Request::Destroy = request else {
|
|
unreachable!();
|
|
};
|
|
|
|
let (client, _) = state
|
|
.world
|
|
.query_one_mut::<(&XdgOutputClient, &XdgOutputServer)>(*entity)
|
|
.unwrap();
|
|
client.destroy();
|
|
}
|
|
}
|
|
|
|
impl<C: XConnection> Dispatch<OutputManServer, ClientGlobalWrapper<OutputManClient>>
|
|
for ServerState<C>
|
|
{
|
|
fn request(
|
|
state: &mut Self,
|
|
_: &wayland_server::Client,
|
|
_: &OutputManServer,
|
|
request: <OutputManServer as Resource>::Request,
|
|
client: &ClientGlobalWrapper<OutputManClient>,
|
|
_: &DisplayHandle,
|
|
data_init: &mut wayland_server::DataInit<'_, Self>,
|
|
) {
|
|
match request {
|
|
s_output_man::Request::GetXdgOutput { id, output } => {
|
|
let entity: Entity = output.data().copied().unwrap();
|
|
let client = {
|
|
let c_output = state
|
|
.world
|
|
.get::<&client::wl_output::WlOutput>(entity)
|
|
.unwrap();
|
|
client.get_xdg_output(&c_output, &state.qh, entity)
|
|
};
|
|
let server = data_init.init(id, entity);
|
|
state.world.insert(entity, (client, server)).unwrap();
|
|
}
|
|
s_output_man::Request::Destroy => {}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<C: XConnection> Dispatch<ConfinedPointerServer, Entity> for ServerState<C> {
|
|
fn request(
|
|
state: &mut Self,
|
|
_: &wayland_server::Client,
|
|
_: &ConfinedPointerServer,
|
|
request: <ConfinedPointerServer as Resource>::Request,
|
|
entity: &Entity,
|
|
_: &DisplayHandle,
|
|
_: &mut wayland_server::DataInit<'_, Self>,
|
|
) {
|
|
let client = state.world.get::<&ConfinedPointerClient>(*entity).unwrap();
|
|
simple_event_shunt! {
|
|
client, request: cp::Request => [
|
|
SetRegion {
|
|
|region| region.as_ref().map(|r| r.data().unwrap())
|
|
},
|
|
Destroy
|
|
]
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<C: XConnection> Dispatch<LockedPointerServer, Entity> for ServerState<C> {
|
|
fn request(
|
|
state: &mut Self,
|
|
_: &wayland_server::Client,
|
|
_: &LockedPointerServer,
|
|
request: <LockedPointerServer as Resource>::Request,
|
|
entity: &Entity,
|
|
_: &DisplayHandle,
|
|
_: &mut wayland_server::DataInit<'_, Self>,
|
|
) {
|
|
let client = state.world.get::<&LockedPointerClient>(*entity).unwrap();
|
|
simple_event_shunt! {
|
|
client, request: lp::Request => [
|
|
SetCursorPositionHint { surface_x, surface_y },
|
|
SetRegion {
|
|
|region| region.as_ref().map(|r| r.data().unwrap())
|
|
},
|
|
Destroy
|
|
]
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<C: XConnection>
|
|
Dispatch<PointerConstraintsServer, ClientGlobalWrapper<PointerConstraintsClient>>
|
|
for ServerState<C>
|
|
{
|
|
fn request(
|
|
state: &mut Self,
|
|
_: &wayland_server::Client,
|
|
_: &PointerConstraintsServer,
|
|
request: <PointerConstraintsServer as Resource>::Request,
|
|
client: &ClientGlobalWrapper<PointerConstraintsClient>,
|
|
_: &DisplayHandle,
|
|
data_init: &mut wayland_server::DataInit<'_, Self>,
|
|
) {
|
|
use pc::Request;
|
|
|
|
match request {
|
|
Request::ConfinePointer {
|
|
id,
|
|
surface,
|
|
pointer,
|
|
region,
|
|
lifetime,
|
|
} => {
|
|
let surf_key: Entity = surface.data().copied().unwrap();
|
|
let ptr_key: Entity = pointer.data().copied().unwrap();
|
|
|
|
let entity = state.world.reserve_entity();
|
|
let client = {
|
|
let c_surface = state
|
|
.world
|
|
.get::<&client::wl_surface::WlSurface>(surf_key)
|
|
.unwrap();
|
|
let c_ptr = state
|
|
.world
|
|
.get::<&client::wl_pointer::WlPointer>(ptr_key)
|
|
.unwrap();
|
|
client.confine_pointer(
|
|
&c_surface,
|
|
&c_ptr,
|
|
region.as_ref().map(|r| r.data().unwrap()),
|
|
convert_wenum(lifetime),
|
|
&state.qh,
|
|
entity,
|
|
)
|
|
};
|
|
let server = data_init.init(id, entity);
|
|
|
|
state.world.spawn_at(entity, (client, server));
|
|
}
|
|
Request::LockPointer {
|
|
id,
|
|
surface,
|
|
pointer,
|
|
region,
|
|
lifetime,
|
|
} => {
|
|
let surf_key: Entity = surface.data().copied().unwrap();
|
|
let ptr_key: Entity = pointer.data().copied().unwrap();
|
|
|
|
let entity = state.world.reserve_entity();
|
|
let client = {
|
|
let c_surface = state
|
|
.world
|
|
.get::<&client::wl_surface::WlSurface>(surf_key)
|
|
.unwrap();
|
|
let c_ptr = state
|
|
.world
|
|
.get::<&client::wl_pointer::WlPointer>(ptr_key)
|
|
.unwrap();
|
|
client.lock_pointer(
|
|
&c_surface,
|
|
&c_ptr,
|
|
region.as_ref().map(|r| r.data().unwrap()),
|
|
convert_wenum(lifetime),
|
|
&state.qh,
|
|
entity,
|
|
)
|
|
};
|
|
let server = data_init.init(id, entity);
|
|
|
|
state.world.spawn_at(entity, (client, server));
|
|
}
|
|
Request::Destroy => {
|
|
client.destroy();
|
|
}
|
|
_ => unreachable!("unhandled pointer constraints request"),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<C: XConnection>
|
|
Dispatch<
|
|
s_tablet::zwp_tablet_manager_v2::ZwpTabletManagerV2,
|
|
ClientGlobalWrapper<c_tablet::zwp_tablet_manager_v2::ZwpTabletManagerV2>,
|
|
> for ServerState<C>
|
|
{
|
|
fn request(
|
|
state: &mut Self,
|
|
_: &wayland_server::Client,
|
|
_: &s_tablet::zwp_tablet_manager_v2::ZwpTabletManagerV2,
|
|
request: <s_tablet::zwp_tablet_manager_v2::ZwpTabletManagerV2 as Resource>::Request,
|
|
client: &ClientGlobalWrapper<c_tablet::zwp_tablet_manager_v2::ZwpTabletManagerV2>,
|
|
_: &DisplayHandle,
|
|
data_init: &mut wayland_server::DataInit<'_, Self>,
|
|
) {
|
|
use s_tablet::zwp_tablet_manager_v2::Request::*;
|
|
match request {
|
|
GetTabletSeat { tablet_seat, seat } => {
|
|
let seat_key: Entity = seat.data().copied().unwrap();
|
|
|
|
let entity = state.world.reserve_entity();
|
|
let client = {
|
|
let c_seat = state
|
|
.world
|
|
.get::<&client::wl_seat::WlSeat>(seat_key)
|
|
.unwrap();
|
|
client.get_tablet_seat(&c_seat, &state.qh, entity)
|
|
};
|
|
let server = data_init.init(tablet_seat, entity);
|
|
|
|
state.world.spawn_at(entity, (client, server));
|
|
}
|
|
other => {
|
|
warn!("unhandled tablet request: {other:?}");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
only_destroy_request_impl!(
|
|
s_tablet::zwp_tablet_seat_v2::ZwpTabletSeatV2,
|
|
c_tablet::zwp_tablet_seat_v2::ZwpTabletSeatV2
|
|
);
|
|
only_destroy_request_impl!(
|
|
s_tablet::zwp_tablet_v2::ZwpTabletV2,
|
|
c_tablet::zwp_tablet_v2::ZwpTabletV2
|
|
);
|
|
only_destroy_request_impl!(
|
|
s_tablet::zwp_tablet_pad_group_v2::ZwpTabletPadGroupV2,
|
|
c_tablet::zwp_tablet_pad_group_v2::ZwpTabletPadGroupV2
|
|
);
|
|
|
|
impl<C: XConnection> Dispatch<s_tablet::zwp_tablet_pad_v2::ZwpTabletPadV2, Entity>
|
|
for ServerState<C>
|
|
{
|
|
fn request(
|
|
state: &mut Self,
|
|
_: &Client,
|
|
_: &s_tablet::zwp_tablet_pad_v2::ZwpTabletPadV2,
|
|
request: <s_tablet::zwp_tablet_pad_v2::ZwpTabletPadV2 as Resource>::Request,
|
|
entity: &Entity,
|
|
_: &DisplayHandle,
|
|
_: &mut wayland_server::DataInit<'_, Self>,
|
|
) {
|
|
let client = state
|
|
.world
|
|
.get::<&c_tablet::zwp_tablet_pad_v2::ZwpTabletPadV2>(*entity)
|
|
.unwrap();
|
|
match request {
|
|
s_tablet::zwp_tablet_pad_v2::Request::SetFeedback {
|
|
button,
|
|
description,
|
|
serial,
|
|
} => {
|
|
client.set_feedback(button, description, serial);
|
|
}
|
|
s_tablet::zwp_tablet_pad_v2::Request::Destroy => {
|
|
client.destroy();
|
|
drop(client);
|
|
state.world.despawn(*entity).unwrap();
|
|
}
|
|
other => warn!("unhandled tablet pad request: {other:?}"),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<C: XConnection> Dispatch<s_tablet::zwp_tablet_tool_v2::ZwpTabletToolV2, Entity>
|
|
for ServerState<C>
|
|
{
|
|
fn request(
|
|
state: &mut Self,
|
|
_: &Client,
|
|
_: &s_tablet::zwp_tablet_tool_v2::ZwpTabletToolV2,
|
|
request: <s_tablet::zwp_tablet_tool_v2::ZwpTabletToolV2 as Resource>::Request,
|
|
entity: &Entity,
|
|
_: &DisplayHandle,
|
|
_: &mut wayland_server::DataInit<'_, Self>,
|
|
) {
|
|
let client = state
|
|
.world
|
|
.get::<&c_tablet::zwp_tablet_tool_v2::ZwpTabletToolV2>(*entity)
|
|
.unwrap();
|
|
match request {
|
|
s_tablet::zwp_tablet_tool_v2::Request::SetCursor {
|
|
serial,
|
|
surface,
|
|
hotspot_x,
|
|
hotspot_y,
|
|
} => {
|
|
let surf_key: Option<Entity> = surface.map(|s| s.data().copied().unwrap());
|
|
let c_surface = surf_key.map(|key| {
|
|
state
|
|
.world
|
|
.get::<&client::wl_surface::WlSurface>(key)
|
|
.unwrap()
|
|
});
|
|
client.set_cursor(serial, c_surface.as_deref(), hotspot_x, hotspot_y);
|
|
}
|
|
s_tablet::zwp_tablet_tool_v2::Request::Destroy => {
|
|
client.destroy();
|
|
drop(client);
|
|
state.world.despawn(*entity).unwrap();
|
|
}
|
|
other => warn!("unhandled tablet tool request: {other:?}"),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<C: XConnection> Dispatch<s_tablet::zwp_tablet_pad_ring_v2::ZwpTabletPadRingV2, Entity>
|
|
for ServerState<C>
|
|
{
|
|
fn request(
|
|
state: &mut Self,
|
|
_: &Client,
|
|
_: &s_tablet::zwp_tablet_pad_ring_v2::ZwpTabletPadRingV2,
|
|
request: <s_tablet::zwp_tablet_pad_ring_v2::ZwpTabletPadRingV2 as Resource>::Request,
|
|
entity: &Entity,
|
|
_: &DisplayHandle,
|
|
_: &mut wayland_server::DataInit<'_, Self>,
|
|
) {
|
|
let client = state
|
|
.world
|
|
.get::<&c_tablet::zwp_tablet_pad_ring_v2::ZwpTabletPadRingV2>(*entity)
|
|
.unwrap();
|
|
match request {
|
|
s_tablet::zwp_tablet_pad_ring_v2::Request::SetFeedback {
|
|
description,
|
|
serial,
|
|
} => {
|
|
client.set_feedback(description, serial);
|
|
}
|
|
s_tablet::zwp_tablet_pad_ring_v2::Request::Destroy => {
|
|
client.destroy();
|
|
drop(client);
|
|
state.world.despawn(*entity).unwrap();
|
|
}
|
|
other => warn!("unhandled tablet pad ring request: {other:?}"),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<C: XConnection> Dispatch<s_tablet::zwp_tablet_pad_strip_v2::ZwpTabletPadStripV2, Entity>
|
|
for ServerState<C>
|
|
{
|
|
fn request(
|
|
state: &mut Self,
|
|
_: &Client,
|
|
_: &s_tablet::zwp_tablet_pad_strip_v2::ZwpTabletPadStripV2,
|
|
request: <s_tablet::zwp_tablet_pad_strip_v2::ZwpTabletPadStripV2 as Resource>::Request,
|
|
entity: &Entity,
|
|
_: &DisplayHandle,
|
|
_: &mut wayland_server::DataInit<'_, Self>,
|
|
) {
|
|
let client = state
|
|
.world
|
|
.get::<&c_tablet::zwp_tablet_pad_strip_v2::ZwpTabletPadStripV2>(*entity)
|
|
.unwrap();
|
|
|
|
match request {
|
|
s_tablet::zwp_tablet_pad_strip_v2::Request::SetFeedback {
|
|
description,
|
|
serial,
|
|
} => {
|
|
client.set_feedback(description, serial);
|
|
}
|
|
s_tablet::zwp_tablet_pad_strip_v2::Request::Destroy => {
|
|
client.destroy();
|
|
drop(client);
|
|
state.world.despawn(*entity).unwrap();
|
|
}
|
|
other => warn!("unhandled tablet pad strip request: {other:?}"),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub(crate) struct ClientGlobalWrapper<T: Proxy>(Arc<OnceLock<T>>);
|
|
impl<T: Proxy> std::ops::Deref for ClientGlobalWrapper<T> {
|
|
type Target = T;
|
|
fn deref(&self) -> &Self::Target {
|
|
self.0.get().unwrap()
|
|
}
|
|
}
|
|
|
|
impl<T: Proxy> Default for ClientGlobalWrapper<T> {
|
|
fn default() -> Self {
|
|
Self(Arc::default())
|
|
}
|
|
}
|
|
|
|
macro_rules! global_dispatch_no_events {
|
|
($server:ty, $client:ty) => {
|
|
impl<C: XConnection> GlobalDispatch<$server, Global> for ServerState<C>
|
|
where
|
|
ServerState<C>: Dispatch<$server, ClientGlobalWrapper<$client>>,
|
|
MyWorld: wayland_client::Dispatch<$client, ()>,
|
|
{
|
|
fn bind(
|
|
state: &mut Self,
|
|
_: &DisplayHandle,
|
|
_: &wayland_server::Client,
|
|
resource: wayland_server::New<$server>,
|
|
data: &Global,
|
|
data_init: &mut wayland_server::DataInit<'_, Self>,
|
|
) {
|
|
let client = ClientGlobalWrapper::<$client>::default();
|
|
let server = data_init.init(resource, client.clone());
|
|
client
|
|
.0
|
|
.set(state.world.global_list.registry().bind::<$client, _, _>(
|
|
data.name,
|
|
server.version(),
|
|
&state.qh,
|
|
(),
|
|
))
|
|
.unwrap();
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
macro_rules! global_dispatch_with_events {
|
|
($server:ty, $client:ty) => {
|
|
impl<C: XConnection> GlobalDispatch<$server, Global> for ServerState<C>
|
|
where
|
|
$server: Resource,
|
|
$client: Proxy,
|
|
ServerState<C>: Dispatch<$server, Entity>,
|
|
MyWorld: wayland_client::Dispatch<$client, Entity>,
|
|
{
|
|
fn bind(
|
|
state: &mut Self,
|
|
_: &DisplayHandle,
|
|
_: &wayland_server::Client,
|
|
resource: wayland_server::New<$server>,
|
|
data: &Global,
|
|
data_init: &mut wayland_server::DataInit<'_, Self>,
|
|
) {
|
|
let entity = state.world.reserve_entity();
|
|
let server = data_init.init(resource, entity);
|
|
let client = state.world.global_list.registry().bind::<$client, _, _>(
|
|
data.name,
|
|
server.version(),
|
|
&state.qh,
|
|
entity,
|
|
);
|
|
state.world.spawn_at(entity, (server, client));
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
global_dispatch_no_events!(WlShm, client::wl_shm::WlShm);
|
|
global_dispatch_no_events!(WlCompositor, client::wl_compositor::WlCompositor);
|
|
global_dispatch_no_events!(RelativePointerManServer, RelativePointerManClient);
|
|
global_dispatch_no_events!(
|
|
s_dmabuf::zwp_linux_dmabuf_v1::ZwpLinuxDmabufV1,
|
|
c_dmabuf::zwp_linux_dmabuf_v1::ZwpLinuxDmabufV1
|
|
);
|
|
global_dispatch_no_events!(OutputManServer, OutputManClient);
|
|
global_dispatch_no_events!(PointerConstraintsServer, PointerConstraintsClient);
|
|
global_dispatch_no_events!(
|
|
s_tablet::zwp_tablet_manager_v2::ZwpTabletManagerV2,
|
|
c_tablet::zwp_tablet_manager_v2::ZwpTabletManagerV2
|
|
);
|
|
|
|
impl<C: XConnection> GlobalDispatch<WlSeat, Global> for ServerState<C> {
|
|
fn bind(
|
|
state: &mut Self,
|
|
_: &DisplayHandle,
|
|
_: &wayland_server::Client,
|
|
resource: wayland_server::New<WlSeat>,
|
|
data: &Global,
|
|
data_init: &mut wayland_server::DataInit<'_, Self>,
|
|
) {
|
|
let entity = state.world.reserve_entity();
|
|
let server = data_init.init(resource, entity);
|
|
let client = state
|
|
.world
|
|
.global_list
|
|
.registry()
|
|
.bind::<client::wl_seat::WlSeat, _, _>(data.name, server.version(), &state.qh, entity);
|
|
if let Some(c) = &mut state.clipboard_data {
|
|
c.device = Some(c.manager.get_data_device(&state.qh, &client));
|
|
}
|
|
state.world.spawn_at(entity, (server, client));
|
|
}
|
|
}
|
|
|
|
impl<C: XConnection> GlobalDispatch<WlOutput, Global> for ServerState<C> {
|
|
fn bind(
|
|
state: &mut Self,
|
|
_: &DisplayHandle,
|
|
_: &wayland_server::Client,
|
|
resource: wayland_server::New<WlOutput>,
|
|
data: &Global,
|
|
data_init: &mut wayland_server::DataInit<'_, Self>,
|
|
) {
|
|
let entity = state.world.reserve_entity();
|
|
let server = data_init.init(resource, entity);
|
|
let client = state
|
|
.world
|
|
.global_list
|
|
.registry()
|
|
.bind::<client::wl_output::WlOutput, _, _>(
|
|
data.name,
|
|
server.version(),
|
|
&state.qh,
|
|
entity,
|
|
);
|
|
state.world.spawn_at(
|
|
entity,
|
|
(
|
|
server,
|
|
client,
|
|
event::OutputScaleFactor::Output(1),
|
|
event::OutputDimensions::default(),
|
|
),
|
|
);
|
|
state.updated_outputs.push(entity);
|
|
}
|
|
}
|
|
global_dispatch_with_events!(WlDrmServer, WlDrmClient);
|
|
|
|
impl<C: XConnection> GlobalDispatch<XwaylandShellV1, ()> for ServerState<C> {
|
|
fn bind(
|
|
_: &mut Self,
|
|
_: &DisplayHandle,
|
|
_: &wayland_server::Client,
|
|
resource: wayland_server::New<XwaylandShellV1>,
|
|
_: &(),
|
|
data_init: &mut wayland_server::DataInit<'_, Self>,
|
|
) {
|
|
data_init.init(resource, ());
|
|
}
|
|
}
|
|
|
|
impl<C: XConnection> Dispatch<XwaylandShellV1, ()> for ServerState<C> {
|
|
fn request(
|
|
state: &mut Self,
|
|
client: &wayland_server::Client,
|
|
_: &XwaylandShellV1,
|
|
request: <XwaylandShellV1 as Resource>::Request,
|
|
_: &(),
|
|
dhandle: &DisplayHandle,
|
|
data_init: &mut wayland_server::DataInit<'_, Self>,
|
|
) {
|
|
use xwayland_shell_v1::Request;
|
|
match request {
|
|
Request::GetXwaylandSurface { id, surface } => {
|
|
let e: Entity = surface.data().copied().unwrap();
|
|
if state.world.entity(e).unwrap().has::<XwaylandSurfaceV1>() {
|
|
error!("Surface {surface:?} already has the xwayland surface role!");
|
|
client.kill(
|
|
dhandle,
|
|
wayland_client::backend::protocol::ProtocolError {
|
|
code: 0,
|
|
object_id: surface.id().protocol_id(),
|
|
object_interface: "wl_surface".to_string(),
|
|
message: "Surface already has role".to_string(),
|
|
},
|
|
);
|
|
return;
|
|
}
|
|
|
|
data_init.init(id, e);
|
|
}
|
|
Request::Destroy => {}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<C: XConnection> Dispatch<XwaylandSurfaceV1, Entity> for ServerState<C> {
|
|
fn request(
|
|
state: &mut Self,
|
|
_: &wayland_server::Client,
|
|
_: &XwaylandSurfaceV1,
|
|
request: <XwaylandSurfaceV1 as Resource>::Request,
|
|
entity: &Entity,
|
|
_: &DisplayHandle,
|
|
_: &mut wayland_server::DataInit<'_, Self>,
|
|
) {
|
|
use xwayland_surface_v1::Request;
|
|
match request {
|
|
Request::SetSerial {
|
|
serial_lo,
|
|
serial_hi,
|
|
} => {
|
|
let surface_id = state.world.get::<&WlSurface>(*entity).unwrap().id();
|
|
let serial = SurfaceSerial([serial_lo, serial_hi]);
|
|
let win_entity = state
|
|
.world
|
|
.query_mut::<&SurfaceSerial>()
|
|
.without::<&WlSurface>()
|
|
.into_iter()
|
|
.find(|(_, surface_serial)| **surface_serial == serial)
|
|
.map(|i| i.0);
|
|
|
|
if let Some(win_entity) = win_entity {
|
|
let win = *state.world.get::<&x::Window>(win_entity).unwrap();
|
|
debug!("associate {surface_id} with {win:?}");
|
|
state.windows.insert(win, *entity);
|
|
let mut builder = hecs::EntityBuilder::new();
|
|
builder.add_bundle(state.world.take(win_entity).unwrap());
|
|
state.world.insert(*entity, builder.build()).unwrap();
|
|
let data = state.world.entity(*entity).unwrap();
|
|
if data.get::<&WindowData>().unwrap().mapped {
|
|
state.create_role_window(win, *entity);
|
|
}
|
|
} else {
|
|
state.world.insert(*entity, (serial,)).unwrap();
|
|
}
|
|
}
|
|
Request::Destroy => {
|
|
state.world.remove_one::<SurfaceSerial>(*entity).unwrap();
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
}
|