1034 lines
35 KiB
Rust
1034 lines
35 KiB
Rust
use super::*;
|
|
use crate::clientside::LateInitObjectKey;
|
|
use log::{debug, trace, warn};
|
|
use macros::simple_event_shunt;
|
|
use std::collections::HashSet;
|
|
use std::os::fd::AsFd;
|
|
use wayland_client::{protocol as client, Proxy};
|
|
use wayland_protocols::{
|
|
wp::{
|
|
pointer_constraints::zv1::{
|
|
client::{
|
|
zwp_confined_pointer_v1::{self, ZwpConfinedPointerV1 as ConfinedPointerClient},
|
|
zwp_locked_pointer_v1::{self, ZwpLockedPointerV1 as LockedPointerClient},
|
|
},
|
|
server::{
|
|
zwp_confined_pointer_v1::ZwpConfinedPointerV1 as ConfinedPointerServer,
|
|
zwp_locked_pointer_v1::ZwpLockedPointerV1 as LockedPointerServer,
|
|
},
|
|
},
|
|
relative_pointer::zv1::{
|
|
client::zwp_relative_pointer_v1::{
|
|
self, ZwpRelativePointerV1 as RelativePointerClient,
|
|
},
|
|
server::zwp_relative_pointer_v1::ZwpRelativePointerV1 as RelativePointerServer,
|
|
},
|
|
tablet::zv2::{
|
|
client::{
|
|
zwp_tablet_pad_group_v2::{self, ZwpTabletPadGroupV2 as TabletPadGroupClient},
|
|
zwp_tablet_pad_ring_v2::{self, ZwpTabletPadRingV2 as TabletPadRingClient},
|
|
zwp_tablet_pad_strip_v2::{self, ZwpTabletPadStripV2 as TabletPadStripClient},
|
|
zwp_tablet_pad_v2::{self, ZwpTabletPadV2 as TabletPadClient},
|
|
zwp_tablet_seat_v2::{self, ZwpTabletSeatV2 as TabletSeatClient},
|
|
zwp_tablet_tool_v2::{self, ZwpTabletToolV2 as TabletToolClient},
|
|
zwp_tablet_v2::{self, ZwpTabletV2 as TabletClient},
|
|
},
|
|
server::{
|
|
zwp_tablet_pad_group_v2::ZwpTabletPadGroupV2 as TabletPadGroupServer,
|
|
zwp_tablet_pad_ring_v2::ZwpTabletPadRingV2 as TabletPadRingServer,
|
|
zwp_tablet_pad_strip_v2::ZwpTabletPadStripV2 as TabletPadStripServer,
|
|
zwp_tablet_pad_v2::ZwpTabletPadV2 as TabletPadServer,
|
|
zwp_tablet_seat_v2::ZwpTabletSeatV2 as TabletSeatServer,
|
|
zwp_tablet_tool_v2::ZwpTabletToolV2 as TabletToolServer,
|
|
zwp_tablet_v2::ZwpTabletV2 as TabletServer,
|
|
},
|
|
},
|
|
},
|
|
xdg::{
|
|
shell::client::{xdg_popup, xdg_surface, xdg_toplevel},
|
|
xdg_output::zv1::{
|
|
client::zxdg_output_v1::{self, ZxdgOutputV1 as ClientXdgOutput},
|
|
server::zxdg_output_v1::ZxdgOutputV1 as ServerXdgOutput,
|
|
},
|
|
},
|
|
};
|
|
use wayland_server::protocol::{
|
|
wl_buffer::WlBuffer, wl_keyboard::WlKeyboard, wl_output::WlOutput, wl_pointer::WlPointer,
|
|
wl_seat::WlSeat, wl_touch::WlTouch,
|
|
};
|
|
|
|
#[derive(Debug)]
|
|
pub(crate) enum SurfaceEvents {
|
|
WlSurface(client::wl_surface::Event),
|
|
XdgSurface(xdg_surface::Event),
|
|
Toplevel(xdg_toplevel::Event),
|
|
Popup(xdg_popup::Event),
|
|
}
|
|
macro_rules! impl_from {
|
|
($type:ty, $variant:ident) => {
|
|
impl From<$type> for ObjectEvent {
|
|
fn from(value: $type) -> Self {
|
|
Self::Surface(SurfaceEvents::$variant(value))
|
|
}
|
|
}
|
|
};
|
|
}
|
|
impl_from!(client::wl_surface::Event, WlSurface);
|
|
impl_from!(xdg_surface::Event, XdgSurface);
|
|
impl_from!(xdg_toplevel::Event, Toplevel);
|
|
impl_from!(xdg_popup::Event, Popup);
|
|
|
|
impl HandleEvent for SurfaceData {
|
|
type Event = SurfaceEvents;
|
|
fn handle_event<C: XConnection>(&mut self, event: Self::Event, state: &mut ServerState<C>) {
|
|
match event {
|
|
SurfaceEvents::WlSurface(event) => self.surface_event(event, state),
|
|
SurfaceEvents::XdgSurface(event) => self.xdg_event(event, state),
|
|
SurfaceEvents::Toplevel(event) => self.toplevel_event(event, state),
|
|
SurfaceEvents::Popup(event) => self.popup_event(event, state),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SurfaceData {
|
|
fn surface_event<C: XConnection>(
|
|
&self,
|
|
event: client::wl_surface::Event,
|
|
state: &mut ServerState<C>,
|
|
) {
|
|
use client::wl_surface::Event;
|
|
|
|
match event {
|
|
Event::Enter { output } => {
|
|
let key: ObjectKey = output.data().copied().unwrap();
|
|
let Some(object) = state.objects.get_mut(key) else {
|
|
return;
|
|
};
|
|
let output: &mut Output = object.as_mut();
|
|
|
|
if let Some(win_data) = self
|
|
.window
|
|
.as_ref()
|
|
.map(|win| state.windows.get_mut(&win).unwrap())
|
|
{
|
|
let (x, y) = match output.position {
|
|
OutputPosition::Xdg { x, y } => (x, y),
|
|
OutputPosition::Wl { x, y } => (x, y),
|
|
};
|
|
win_data.update_output_offset(
|
|
key,
|
|
WindowOutputOffset { x, y },
|
|
state.connection.as_mut().unwrap(),
|
|
);
|
|
output.windows.insert(win_data.window);
|
|
}
|
|
self.server.enter(&output.server);
|
|
debug!("{} entered {}", self.server.id(), output.server.id());
|
|
}
|
|
Event::Leave { output } => {
|
|
let key: ObjectKey = output.data().copied().unwrap();
|
|
let Some(object) = state.objects.get_mut(key) else {
|
|
return;
|
|
};
|
|
let output: &mut Output = object.as_mut();
|
|
self.server.leave(&output.server);
|
|
}
|
|
Event::PreferredBufferScale { factor } => self.server.preferred_buffer_scale(factor),
|
|
other => warn!("unhandled surface request: {other:?}"),
|
|
}
|
|
}
|
|
|
|
fn xdg_event<C: XConnection>(&mut self, event: xdg_surface::Event, state: &mut ServerState<C>) {
|
|
let connection = state.connection.as_mut().unwrap();
|
|
let xdg_surface::Event::Configure { serial } = event else {
|
|
unreachable!();
|
|
};
|
|
|
|
let xdg = self.xdg_mut().unwrap();
|
|
xdg.surface.ack_configure(serial);
|
|
xdg.configured = true;
|
|
|
|
if let Some(pending) = xdg.pending.take() {
|
|
let window = state.associated_windows[self.key];
|
|
let window = state.windows.get_mut(&window).unwrap();
|
|
let x = pending.x + window.output_offset.x;
|
|
let y = pending.y + window.output_offset.y;
|
|
let width = if pending.width > 0 {
|
|
pending.width as u16
|
|
} else {
|
|
window.attrs.dims.width
|
|
};
|
|
let height = if pending.height > 0 {
|
|
pending.height as u16
|
|
} else {
|
|
window.attrs.dims.height
|
|
};
|
|
debug!("configuring {:?}: {x}x{y}, {width}x{height}", window.window);
|
|
connection.set_window_dims(
|
|
window.window,
|
|
PendingSurfaceState {
|
|
x,
|
|
y,
|
|
width: width as _,
|
|
height: height as _,
|
|
},
|
|
);
|
|
window.attrs.dims = WindowDims {
|
|
x: x as i16,
|
|
y: y as i16,
|
|
width,
|
|
height,
|
|
};
|
|
}
|
|
|
|
if let Some(SurfaceAttach { buffer, x, y }) = self.attach.take() {
|
|
self.client.attach(buffer.as_ref(), x, y);
|
|
}
|
|
if let Some(cb) = self.frame_callback.take() {
|
|
self.client.frame(&state.qh, cb);
|
|
}
|
|
self.client.commit();
|
|
}
|
|
|
|
fn toplevel_event<C: XConnection>(
|
|
&mut self,
|
|
event: xdg_toplevel::Event,
|
|
state: &mut ServerState<C>,
|
|
) {
|
|
match event {
|
|
xdg_toplevel::Event::Configure {
|
|
width,
|
|
height,
|
|
states,
|
|
} => {
|
|
debug!("configuring toplevel {width}x{height}, {states:?}");
|
|
if let Some(SurfaceRole::Toplevel(Some(toplevel))) = &mut self.role {
|
|
let prev_fs = toplevel.fullscreen;
|
|
toplevel.fullscreen =
|
|
states.contains(&(u32::from(xdg_toplevel::State::Fullscreen) as u8));
|
|
if toplevel.fullscreen != prev_fs {
|
|
let window = state.associated_windows[self.key];
|
|
let data = C::ExtraData::create(state);
|
|
state.connection.as_mut().unwrap().set_fullscreen(
|
|
window,
|
|
toplevel.fullscreen,
|
|
data,
|
|
);
|
|
}
|
|
};
|
|
|
|
self.xdg_mut().unwrap().pending = Some(PendingSurfaceState {
|
|
width,
|
|
height,
|
|
..Default::default()
|
|
});
|
|
}
|
|
xdg_toplevel::Event::Close => {
|
|
let window = state.associated_windows[self.key];
|
|
state.close_x_window(window);
|
|
}
|
|
ref other => warn!("unhandled xdgtoplevel event: {other:?}"),
|
|
}
|
|
}
|
|
|
|
fn popup_event<C: XConnection>(&mut self, event: xdg_popup::Event, _: &mut ServerState<C>) {
|
|
match event {
|
|
xdg_popup::Event::Configure {
|
|
x,
|
|
y,
|
|
width,
|
|
height,
|
|
} => {
|
|
trace!("popup configure: {x}x{y}, {width}x{height}");
|
|
self.xdg_mut().unwrap().pending = Some(PendingSurfaceState {
|
|
x,
|
|
y,
|
|
width,
|
|
height,
|
|
});
|
|
}
|
|
xdg_popup::Event::Repositioned { .. } => {}
|
|
other => todo!("{other:?}"),
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct GenericObject<Server: Resource, Client: Proxy> {
|
|
pub server: Server,
|
|
pub client: Client,
|
|
}
|
|
|
|
impl<S: Resource + 'static, C: Proxy + 'static> GenericObject<S, C> {
|
|
fn from_client<XC: XConnection>(client: C, state: &mut ServerState<XC>) -> &Self
|
|
where
|
|
Self: Into<WrappedObject>,
|
|
for<'a> &'a Self: TryFrom<&'a Object, Error = String>,
|
|
ServerState<XC>: wayland_server::Dispatch<S, ObjectKey>,
|
|
C::Event: Send + Into<ObjectEvent>,
|
|
{
|
|
let key = state.objects.insert_with_key(|key| {
|
|
let server = state
|
|
.client
|
|
.as_ref()
|
|
.unwrap()
|
|
.create_resource::<_, _, ServerState<XC>>(&state.dh, 1, key)
|
|
.unwrap();
|
|
let obj_key: &LateInitObjectKey<C> = client.data().unwrap();
|
|
obj_key.init(key);
|
|
|
|
Self { client, server }.into()
|
|
});
|
|
|
|
state.objects[key].as_ref()
|
|
}
|
|
}
|
|
|
|
pub trait GenericObjectExt {
|
|
type Server: Resource;
|
|
type Client: Proxy;
|
|
}
|
|
|
|
impl<S: Resource, C: Proxy> GenericObjectExt for GenericObject<S, C> {
|
|
type Server = S;
|
|
type Client = C;
|
|
}
|
|
|
|
pub type Buffer = GenericObject<WlBuffer, client::wl_buffer::WlBuffer>;
|
|
impl HandleEvent for Buffer {
|
|
type Event = client::wl_buffer::Event;
|
|
fn handle_event<C: XConnection>(&mut self, _: Self::Event, _: &mut ServerState<C>) {
|
|
// The only event from a buffer would be the release.
|
|
self.server.release();
|
|
}
|
|
}
|
|
|
|
pub type Seat = GenericObject<WlSeat, client::wl_seat::WlSeat>;
|
|
impl HandleEvent for Seat {
|
|
type Event = client::wl_seat::Event;
|
|
|
|
fn handle_event<C: XConnection>(&mut self, event: Self::Event, _: &mut ServerState<C>) {
|
|
simple_event_shunt! {
|
|
self.server, event: client::wl_seat::Event => [
|
|
Capabilities { |capabilities| convert_wenum(capabilities) },
|
|
Name { name }
|
|
]
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct Pointer {
|
|
server: WlPointer,
|
|
pub client: client::wl_pointer::WlPointer,
|
|
pending_enter: PendingEnter,
|
|
}
|
|
|
|
impl Pointer {
|
|
pub fn new(server: WlPointer, client: client::wl_pointer::WlPointer) -> Self {
|
|
Self {
|
|
server,
|
|
client,
|
|
pending_enter: PendingEnter(None),
|
|
}
|
|
}
|
|
}
|
|
|
|
struct PendingEnter(Option<client::wl_pointer::Event>);
|
|
|
|
impl HandleEvent for Pointer {
|
|
type Event = client::wl_pointer::Event;
|
|
|
|
fn handle_event<C: XConnection>(&mut self, event: Self::Event, state: &mut ServerState<C>) {
|
|
// Workaround GTK (stupidly) autoclosing popups if it receives an wl_pointer.enter
|
|
// event shortly after creation.
|
|
// When Niri creates a popup, it immediately sends wl_pointer.enter on the new surface,
|
|
// generating an EnterNotify event, and Xwayland will send a release button event.
|
|
// In its menu implementation, GTK treats EnterNotify "this menu is now active" and will
|
|
// destroy the menu if this occurs within a 500 ms interval (which it always does with
|
|
// Niri). Other compositors do not run into this problem because they appear to not send
|
|
// wl_pointer.enter until the user actually moves the mouse in the popup.
|
|
let mut process_event = Vec::new();
|
|
match event {
|
|
client::wl_pointer::Event::Enter {
|
|
serial,
|
|
ref surface,
|
|
surface_x,
|
|
surface_y,
|
|
} => 'enter: {
|
|
let surface_key: ObjectKey = surface.data().copied().unwrap();
|
|
let Some(surface_data): Option<&SurfaceData> =
|
|
state.objects.get(surface_key).map(|o| o.as_ref())
|
|
else {
|
|
warn!("could not enter surface: stale surface");
|
|
break 'enter;
|
|
};
|
|
|
|
let mut do_enter = || {
|
|
debug!("entering surface ({serial})");
|
|
self.server
|
|
.enter(serial, &surface_data.server, surface_x, surface_y);
|
|
let window = surface_data.window.unwrap();
|
|
state.connection.as_mut().unwrap().raise_to_top(window);
|
|
state.last_hovered = Some(window);
|
|
};
|
|
|
|
if matches!(surface_data.role, Some(SurfaceRole::Popup(_))) {
|
|
match self.pending_enter.0.take() {
|
|
Some(e) => {
|
|
let client::wl_pointer::Event::Enter {
|
|
serial: pending_serial,
|
|
..
|
|
} = e
|
|
else {
|
|
unreachable!();
|
|
};
|
|
if serial == pending_serial {
|
|
do_enter();
|
|
} else {
|
|
self.pending_enter.0 = Some(event);
|
|
}
|
|
}
|
|
None => {
|
|
self.pending_enter.0 = Some(event);
|
|
}
|
|
}
|
|
} else {
|
|
self.pending_enter.0.take();
|
|
do_enter();
|
|
}
|
|
}
|
|
client::wl_pointer::Event::Leave { serial, surface } => {
|
|
if !surface.is_alive() {
|
|
return;
|
|
}
|
|
debug!("leaving surface ({serial})");
|
|
self.pending_enter.0.take();
|
|
if let Some(surface) = state.get_server_surface_from_client(surface) {
|
|
self.server.leave(serial, surface);
|
|
} else {
|
|
warn!("could not leave surface: stale surface");
|
|
}
|
|
}
|
|
client::wl_pointer::Event::Motion {
|
|
time,
|
|
surface_x,
|
|
surface_y,
|
|
} => {
|
|
if let Some(p) = &self.pending_enter.0 {
|
|
let client::wl_pointer::Event::Enter {
|
|
serial,
|
|
surface,
|
|
surface_x,
|
|
surface_y,
|
|
} = p
|
|
else {
|
|
unreachable!();
|
|
};
|
|
process_event.push(client::wl_pointer::Event::Enter {
|
|
serial: *serial,
|
|
surface: surface.clone(),
|
|
surface_x: *surface_x,
|
|
surface_y: *surface_y,
|
|
});
|
|
process_event.push(event);
|
|
trace!("resending enter ({serial}) before motion");
|
|
} else {
|
|
self.server.motion(time, surface_x, surface_y);
|
|
}
|
|
}
|
|
_ => simple_event_shunt! {
|
|
self.server, event: client::wl_pointer::Event => [
|
|
Enter {
|
|
serial,
|
|
|surface| {
|
|
let Some(surface_data) = state.get_server_surface_from_client(surface) else {
|
|
return;
|
|
};
|
|
surface_data
|
|
},
|
|
surface_x,
|
|
surface_y
|
|
},
|
|
Leave {
|
|
serial,
|
|
|surface| {
|
|
let Some(surface_data) = state.get_server_surface_from_client(surface) else {
|
|
return;
|
|
};
|
|
surface_data
|
|
}
|
|
},
|
|
Motion {
|
|
time,
|
|
surface_x,
|
|
surface_y
|
|
},
|
|
Frame,
|
|
Button {
|
|
serial,
|
|
time,
|
|
button,
|
|
|state| convert_wenum(state)
|
|
},
|
|
Axis {
|
|
time,
|
|
|axis| convert_wenum(axis),
|
|
value
|
|
},
|
|
AxisSource {
|
|
|axis_source| convert_wenum(axis_source)
|
|
},
|
|
AxisStop {
|
|
time,
|
|
|axis| convert_wenum(axis)
|
|
},
|
|
AxisDiscrete {
|
|
|axis| convert_wenum(axis),
|
|
discrete
|
|
},
|
|
AxisValue120 {
|
|
|axis| convert_wenum(axis),
|
|
value120
|
|
},
|
|
AxisRelativeDirection {
|
|
|axis| convert_wenum(axis),
|
|
|direction| convert_wenum(direction)
|
|
}
|
|
]
|
|
},
|
|
}
|
|
|
|
for event in process_event {
|
|
self.handle_event(event, state);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub type Keyboard = GenericObject<WlKeyboard, client::wl_keyboard::WlKeyboard>;
|
|
impl HandleEvent for Keyboard {
|
|
type Event = client::wl_keyboard::Event;
|
|
|
|
fn handle_event<C: XConnection>(&mut self, event: Self::Event, state: &mut ServerState<C>) {
|
|
match event {
|
|
client::wl_keyboard::Event::Enter {
|
|
serial,
|
|
surface,
|
|
keys,
|
|
} => {
|
|
let key: ObjectKey = surface.data().copied().unwrap();
|
|
if let Some(data) = state
|
|
.objects
|
|
.get(key)
|
|
.map(|o| <_ as AsRef<SurfaceData>>::as_ref(o))
|
|
{
|
|
state.last_kb_serial = Some(serial);
|
|
state.to_focus = Some(data.window.unwrap());
|
|
self.server.enter(serial, &data.server, keys);
|
|
}
|
|
}
|
|
client::wl_keyboard::Event::Leave { serial, surface } => {
|
|
if !surface.is_alive() {
|
|
return;
|
|
}
|
|
let key: ObjectKey = surface.data().copied().unwrap();
|
|
if let Some(data) = state
|
|
.objects
|
|
.get(key)
|
|
.map(|o| <_ as AsRef<SurfaceData>>::as_ref(o))
|
|
{
|
|
if state.to_focus == Some(data.window.unwrap()) {
|
|
state.to_focus.take();
|
|
} else {
|
|
state.unfocus = true;
|
|
}
|
|
self.server.leave(serial, &data.server);
|
|
}
|
|
}
|
|
_ => simple_event_shunt! {
|
|
self.server, event: client::wl_keyboard::Event => [
|
|
Keymap {
|
|
|format| convert_wenum(format),
|
|
|fd| fd.as_fd(),
|
|
size
|
|
},
|
|
Key {
|
|
serial,
|
|
time,
|
|
key,
|
|
|state| convert_wenum(state)
|
|
},
|
|
Modifiers {
|
|
serial,
|
|
mods_depressed,
|
|
mods_latched,
|
|
mods_locked,
|
|
group
|
|
},
|
|
RepeatInfo {
|
|
rate,
|
|
delay
|
|
}
|
|
]
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
pub type Touch = GenericObject<WlTouch, client::wl_touch::WlTouch>;
|
|
impl HandleEvent for Touch {
|
|
type Event = client::wl_touch::Event;
|
|
fn handle_event<C: XConnection>(&mut self, event: Self::Event, state: &mut ServerState<C>) {
|
|
simple_event_shunt! {
|
|
self.server, event: client::wl_touch::Event => [
|
|
Down {
|
|
serial,
|
|
time,
|
|
|surface| {
|
|
let Some(surface_data) = state.get_server_surface_from_client(surface) else {
|
|
return;
|
|
};
|
|
surface_data
|
|
},
|
|
id,
|
|
x,
|
|
y
|
|
},
|
|
Up {
|
|
serial,
|
|
time,
|
|
id
|
|
},
|
|
Motion {
|
|
time,
|
|
id,
|
|
x,
|
|
y
|
|
},
|
|
Frame,
|
|
Cancel,
|
|
Shape {
|
|
id,
|
|
major,
|
|
minor
|
|
},
|
|
Orientation {
|
|
id,
|
|
orientation
|
|
}
|
|
]
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct XdgOutput {
|
|
pub client: ClientXdgOutput,
|
|
pub server: ServerXdgOutput,
|
|
}
|
|
|
|
#[derive(Copy, Clone)]
|
|
pub enum OutputPosition {
|
|
Wl { x: i32, y: i32 },
|
|
Xdg { x: i32, y: i32 },
|
|
}
|
|
|
|
pub struct Output {
|
|
pub client: client::wl_output::WlOutput,
|
|
pub server: WlOutput,
|
|
pub xdg: Option<XdgOutput>,
|
|
windows: HashSet<x::Window>,
|
|
position: OutputPosition,
|
|
}
|
|
|
|
impl Output {
|
|
pub fn new(client: client::wl_output::WlOutput, server: WlOutput) -> Self {
|
|
Self {
|
|
client,
|
|
server,
|
|
xdg: None,
|
|
windows: HashSet::new(),
|
|
position: OutputPosition::Wl { x: 0, y: 0 },
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub enum OutputEvent {
|
|
Wl(client::wl_output::Event),
|
|
Xdg(zxdg_output_v1::Event),
|
|
}
|
|
|
|
impl From<client::wl_output::Event> for ObjectEvent {
|
|
fn from(value: client::wl_output::Event) -> Self {
|
|
Self::Output(OutputEvent::Wl(value))
|
|
}
|
|
}
|
|
|
|
impl From<zxdg_output_v1::Event> for ObjectEvent {
|
|
fn from(value: zxdg_output_v1::Event) -> Self {
|
|
Self::Output(OutputEvent::Xdg(value))
|
|
}
|
|
}
|
|
|
|
impl HandleEvent for Output {
|
|
type Event = OutputEvent;
|
|
|
|
fn handle_event<C: XConnection>(&mut self, event: Self::Event, state: &mut ServerState<C>) {
|
|
match event {
|
|
OutputEvent::Xdg(event) => self.xdg_event(event, state),
|
|
OutputEvent::Wl(event) => self.wl_event(event, state),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Output {
|
|
fn update_offset<C: XConnection>(
|
|
&mut self,
|
|
offset: OutputPosition,
|
|
state: &mut ServerState<C>,
|
|
) {
|
|
if matches!(offset, OutputPosition::Wl { .. })
|
|
&& matches!(self.position, OutputPosition::Xdg { .. })
|
|
{
|
|
return;
|
|
}
|
|
|
|
self.position = offset;
|
|
let (x, y, id) = match offset {
|
|
OutputPosition::Xdg { x, y } => (x, y, self.xdg.as_ref().unwrap().server.id()),
|
|
OutputPosition::Wl { x, y } => (x, y, self.server.id()),
|
|
};
|
|
debug!("moving {id} to {x}x{y}");
|
|
self.windows.retain(|window| {
|
|
let Some(data): Option<&mut WindowData> = state.windows.get_mut(window) else {
|
|
return false;
|
|
};
|
|
|
|
data.update_output_offset(
|
|
self.server.data().copied().unwrap(),
|
|
WindowOutputOffset { x, y },
|
|
state.connection.as_mut().unwrap(),
|
|
);
|
|
|
|
return true;
|
|
});
|
|
}
|
|
fn wl_event<C: XConnection>(
|
|
&mut self,
|
|
event: client::wl_output::Event,
|
|
state: &mut ServerState<C>,
|
|
) {
|
|
if let client::wl_output::Event::Geometry { x, y, .. } = event {
|
|
self.update_offset(OutputPosition::Wl { x, y }, state);
|
|
}
|
|
|
|
simple_event_shunt! {
|
|
self.server, event: client::wl_output::Event => [
|
|
Name { name },
|
|
Description { description },
|
|
Mode {
|
|
|flags| convert_wenum(flags),
|
|
width,
|
|
height,
|
|
refresh
|
|
},
|
|
Scale { factor },
|
|
Geometry {
|
|
x,
|
|
y,
|
|
physical_width,
|
|
physical_height,
|
|
|subpixel| convert_wenum(subpixel),
|
|
make,
|
|
model,
|
|
|transform| convert_wenum(transform)
|
|
},
|
|
Done
|
|
]
|
|
}
|
|
}
|
|
|
|
fn xdg_event<C: XConnection>(
|
|
&mut self,
|
|
event: zxdg_output_v1::Event,
|
|
state: &mut ServerState<C>,
|
|
) {
|
|
if let zxdg_output_v1::Event::LogicalPosition { x, y } = event {
|
|
self.update_offset(OutputPosition::Xdg { x, y }, state);
|
|
}
|
|
let xdg = &self.xdg.as_ref().unwrap().server;
|
|
simple_event_shunt! {
|
|
xdg, event: zxdg_output_v1::Event => [
|
|
LogicalPosition { x, y },
|
|
LogicalSize { width, height },
|
|
Done,
|
|
Name { name },
|
|
Description { description }
|
|
]
|
|
}
|
|
}
|
|
}
|
|
|
|
pub type Drm = GenericObject<WlDrmServer, WlDrmClient>;
|
|
impl HandleEvent for Drm {
|
|
type Event = wl_drm::client::wl_drm::Event;
|
|
|
|
fn handle_event<C: XConnection>(&mut self, event: Self::Event, _: &mut ServerState<C>) {
|
|
simple_event_shunt! {
|
|
self.server, event: wl_drm::client::wl_drm::Event => [
|
|
Device { name },
|
|
Format { format },
|
|
Authenticated,
|
|
Capabilities { value }
|
|
]
|
|
}
|
|
}
|
|
}
|
|
|
|
pub type DmabufFeedback = GenericObject<
|
|
s_dmabuf::zwp_linux_dmabuf_feedback_v1::ZwpLinuxDmabufFeedbackV1,
|
|
c_dmabuf::zwp_linux_dmabuf_feedback_v1::ZwpLinuxDmabufFeedbackV1,
|
|
>;
|
|
impl HandleEvent for DmabufFeedback {
|
|
type Event = c_dmabuf::zwp_linux_dmabuf_feedback_v1::Event;
|
|
|
|
fn handle_event<C: XConnection>(&mut self, event: Self::Event, _: &mut ServerState<C>) {
|
|
simple_event_shunt! {
|
|
self.server, event: c_dmabuf::zwp_linux_dmabuf_feedback_v1::Event => [
|
|
Done,
|
|
FormatTable { |fd| fd.as_fd(), size },
|
|
MainDevice { device },
|
|
TrancheDone,
|
|
TrancheTargetDevice { device },
|
|
TrancheFormats { indices },
|
|
TrancheFlags { |flags| convert_wenum(flags) }
|
|
]
|
|
}
|
|
}
|
|
}
|
|
|
|
pub type RelativePointer = GenericObject<RelativePointerServer, RelativePointerClient>;
|
|
impl HandleEvent for RelativePointer {
|
|
type Event = zwp_relative_pointer_v1::Event;
|
|
|
|
fn handle_event<C: XConnection>(&mut self, event: Self::Event, _: &mut ServerState<C>) {
|
|
simple_event_shunt! {
|
|
self.server, event: zwp_relative_pointer_v1::Event => [
|
|
RelativeMotion {
|
|
utime_hi,
|
|
utime_lo,
|
|
dx,
|
|
dy,
|
|
dx_unaccel,
|
|
dy_unaccel
|
|
}
|
|
]
|
|
}
|
|
}
|
|
}
|
|
|
|
pub type LockedPointer = GenericObject<LockedPointerServer, LockedPointerClient>;
|
|
impl HandleEvent for LockedPointer {
|
|
type Event = zwp_locked_pointer_v1::Event;
|
|
|
|
fn handle_event<C: XConnection>(&mut self, event: Self::Event, _: &mut ServerState<C>) {
|
|
simple_event_shunt! {
|
|
self.server, event: zwp_locked_pointer_v1::Event => [
|
|
Locked,
|
|
Unlocked
|
|
]
|
|
}
|
|
}
|
|
}
|
|
|
|
pub type ConfinedPointer = GenericObject<ConfinedPointerServer, ConfinedPointerClient>;
|
|
impl HandleEvent for ConfinedPointer {
|
|
type Event = zwp_confined_pointer_v1::Event;
|
|
|
|
fn handle_event<C: XConnection>(&mut self, event: Self::Event, _: &mut ServerState<C>) {
|
|
simple_event_shunt! {
|
|
self.server, event: zwp_confined_pointer_v1::Event => [
|
|
Confined,
|
|
Unconfined
|
|
]
|
|
}
|
|
}
|
|
}
|
|
|
|
pub type TabletSeat = GenericObject<TabletSeatServer, TabletSeatClient>;
|
|
impl HandleEvent for TabletSeat {
|
|
type Event = zwp_tablet_seat_v2::Event;
|
|
|
|
fn handle_event<C: XConnection>(&mut self, event: Self::Event, state: &mut ServerState<C>) {
|
|
simple_event_shunt! {
|
|
self.server, event: zwp_tablet_seat_v2::Event => [
|
|
TabletAdded {
|
|
|id| &Tablet::from_client(id, state).server
|
|
},
|
|
ToolAdded {
|
|
|id| &TabletTool::from_client(id, state).server
|
|
},
|
|
PadAdded {
|
|
|id| &TabletPad::from_client(id, state).server
|
|
}
|
|
]
|
|
}
|
|
}
|
|
}
|
|
|
|
pub type Tablet = GenericObject<TabletServer, TabletClient>;
|
|
impl HandleEvent for Tablet {
|
|
type Event = zwp_tablet_v2::Event;
|
|
|
|
fn handle_event<C: XConnection>(&mut self, event: Self::Event, _: &mut ServerState<C>) {
|
|
simple_event_shunt! {
|
|
self.server, event: zwp_tablet_v2::Event => [
|
|
Name { name },
|
|
Id { vid, pid },
|
|
Path { path },
|
|
Done,
|
|
Removed
|
|
]
|
|
}
|
|
}
|
|
}
|
|
|
|
pub type TabletPad = GenericObject<TabletPadServer, TabletPadClient>;
|
|
impl HandleEvent for TabletPad {
|
|
type Event = zwp_tablet_pad_v2::Event;
|
|
|
|
fn handle_event<C: XConnection>(&mut self, event: Self::Event, state: &mut ServerState<C>) {
|
|
simple_event_shunt! {
|
|
self.server, event: zwp_tablet_pad_v2::Event => [
|
|
Group { |pad_group| &TabletPadGroup::from_client(pad_group, state).server },
|
|
Path { path },
|
|
Buttons { buttons },
|
|
Done,
|
|
Button {
|
|
time,
|
|
button,
|
|
|state| convert_wenum(state)
|
|
},
|
|
Enter {
|
|
serial,
|
|
|tablet| {
|
|
let key: &LateInitObjectKey<TabletClient> = tablet.data().unwrap();
|
|
let Some(tablet): Option<&Tablet> = state.objects.get(**key).map(|o| o.as_ref()) else {
|
|
return;
|
|
};
|
|
&tablet.server
|
|
},
|
|
|surface| {
|
|
let Some(surface_data) = state.get_server_surface_from_client(surface) else {
|
|
return;
|
|
};
|
|
surface_data
|
|
}
|
|
},
|
|
Leave {
|
|
serial,
|
|
|surface| {
|
|
let Some(surface_data) = state.get_server_surface_from_client(surface) else {
|
|
return;
|
|
};
|
|
surface_data
|
|
}
|
|
},
|
|
Removed
|
|
]
|
|
}
|
|
}
|
|
}
|
|
|
|
pub type TabletTool = GenericObject<TabletToolServer, TabletToolClient>;
|
|
impl HandleEvent for TabletTool {
|
|
type Event = zwp_tablet_tool_v2::Event;
|
|
|
|
fn handle_event<C: XConnection>(&mut self, event: Self::Event, state: &mut ServerState<C>) {
|
|
simple_event_shunt! {
|
|
self.server, event: zwp_tablet_tool_v2::Event => [
|
|
Type { |tool_type| convert_wenum(tool_type) },
|
|
HardwareSerial { hardware_serial_hi, hardware_serial_lo },
|
|
HardwareIdWacom { hardware_id_hi, hardware_id_lo },
|
|
Capability { |capability| convert_wenum(capability) },
|
|
Done,
|
|
Removed,
|
|
ProximityIn {
|
|
serial,
|
|
|tablet| {
|
|
let key: &LateInitObjectKey<TabletClient> = tablet.data().unwrap();
|
|
let Some(tablet): Option<&Tablet> = state.objects.get(**key).map(|o| o.as_ref()) else {
|
|
return;
|
|
};
|
|
&tablet.server
|
|
},
|
|
|surface| {
|
|
let Some(surface_data) = state.get_server_surface_from_client(surface) else {
|
|
return;
|
|
};
|
|
surface_data
|
|
}
|
|
},
|
|
ProximityOut,
|
|
Down { serial },
|
|
Up,
|
|
Motion { x, y },
|
|
Pressure { pressure },
|
|
Tilt { tilt_x, tilt_y },
|
|
Rotation { degrees },
|
|
Slider { position },
|
|
Wheel { degrees, clicks },
|
|
Button { serial, button, |state| convert_wenum(state) },
|
|
Frame { time },
|
|
]
|
|
}
|
|
}
|
|
}
|
|
|
|
pub type TabletPadGroup = GenericObject<TabletPadGroupServer, TabletPadGroupClient>;
|
|
impl HandleEvent for TabletPadGroup {
|
|
type Event = zwp_tablet_pad_group_v2::Event;
|
|
|
|
fn handle_event<C: XConnection>(&mut self, event: Self::Event, state: &mut ServerState<C>) {
|
|
simple_event_shunt! {
|
|
self.server, event: zwp_tablet_pad_group_v2::Event => [
|
|
Buttons { buttons },
|
|
Ring { |ring| &TabletPadRing::from_client(ring, state).server },
|
|
Strip { |strip| &TabletPadStrip::from_client(strip, state).server },
|
|
Modes { modes },
|
|
Done,
|
|
ModeSwitch { time, serial, mode }
|
|
]
|
|
}
|
|
}
|
|
}
|
|
|
|
pub type TabletPadRing = GenericObject<TabletPadRingServer, TabletPadRingClient>;
|
|
impl HandleEvent for TabletPadRing {
|
|
type Event = zwp_tablet_pad_ring_v2::Event;
|
|
|
|
fn handle_event<C: XConnection>(&mut self, event: Self::Event, _: &mut ServerState<C>) {
|
|
simple_event_shunt! {
|
|
self.server, event: zwp_tablet_pad_ring_v2::Event => [
|
|
Source { |source| convert_wenum(source) },
|
|
Angle { degrees },
|
|
Stop,
|
|
Frame { time }
|
|
]
|
|
}
|
|
}
|
|
}
|
|
|
|
pub type TabletPadStrip = GenericObject<TabletPadStripServer, TabletPadStripClient>;
|
|
impl HandleEvent for TabletPadStrip {
|
|
type Event = zwp_tablet_pad_strip_v2::Event;
|
|
|
|
fn handle_event<C: XConnection>(&mut self, event: Self::Event, _: &mut ServerState<C>) {
|
|
simple_event_shunt! {
|
|
self.server, event: zwp_tablet_pad_strip_v2::Event => [
|
|
Source { |source| convert_wenum(source) },
|
|
Position { position },
|
|
Stop,
|
|
Frame { time }
|
|
]
|
|
}
|
|
}
|
|
}
|