kossLAN/wry
1
0
Fork 0
forked from wry/wry
Code Pull requests Activity

wayland: implement wl_seat v8

Browse source
This commit is contained in:
Julian Orth 2022-05-27 15:39:48 +02:00
parent 145e4dbc24
commit 50c87d6da7
10 changed files with 111 additions and 80 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/ifs/wl_seat.rs
View file

@ -729,7 +729,7 @@ impl Global for WlSeatGlobal {
}
fn version(&self) -> u32 {
7
8
}
fn break_loops(&self) {

45
src/ifs/wl_seat/event_handling.rs
View file

@ -1,6 +1,6 @@
use {
crate::{
backend::{ConnectorId, InputEvent, KeyState},
backend::{ConnectorId, InputEvent, KeyState, AXIS_120},
client::{Client, ClientId},
fixed::Fixed,
ifs::{
@ -16,10 +16,11 @@ use {
wl_pointer::{
self, PendingScroll, WlPointer, AXIS_DISCRETE_SINCE_VERSION,
AXIS_SOURCE_SINCE_VERSION, AXIS_STOP_SINCE_VERSION,
POINTER_FRAME_SINCE_VERSION, WHEEL_TILT, WHEEL_TILT_SINCE_VERSION,
AXIS_VALUE120_SINCE_VERSION, POINTER_FRAME_SINCE_VERSION, WHEEL_TILT,
WHEEL_TILT_SINCE_VERSION,
},
zwp_relative_pointer_v1::ZwpRelativePointerV1,
Dnd, SeatId, WlSeat, WlSeatGlobal, CHANGE_CURSOR_MOVED,
Dnd, SeatId, WlSeat, WlSeatGlobal, CHANGE_CURSOR_MOVED, PX_PER_SCROLL,
},
wl_surface::{xdg_surface::xdg_popup::XdgPopup, WlSurface},
},
@ -192,8 +193,8 @@ impl WlSeatGlobal {
} => self.pointer_owner.button(self, time_usec, button, state),
InputEvent::AxisSource { source } => self.pointer_owner.axis_source(source),
InputEvent::AxisDiscrete { dist, axis } => self.pointer_owner.axis_discrete(dist, axis),
InputEvent::Axis { dist, axis } => self.pointer_owner.axis(dist, axis),
InputEvent::Axis120 { dist, axis } => self.pointer_owner.axis_120(dist, axis),
InputEvent::AxisSmooth { dist, axis } => self.pointer_owner.axis_smooth(dist, axis),
InputEvent::AxisStop { axis } => self.pointer_owner.axis_stop(axis),
InputEvent::AxisFrame { time_usec } => self.pointer_owner.frame(self, time_usec),
}
@ -546,22 +547,28 @@ impl WlSeatGlobal {
self.surface_pointer_event(since, surface, |p| p.send_axis_source(source));
}
let time = (event.time_usec.get() / 1000) as _;
for i in 0..1 {
if let Some(delta) = event.discrete[i].get() {
self.surface_pointer_event(AXIS_DISCRETE_SINCE_VERSION, surface, |p| {
p.send_axis_discrete(i as _, delta)
});
self.for_each_pointer(0, surface.client.id, |p| {
for i in 0..1 {
let axis = i as _;
if let Some(delta) = event.v120[i].get() {
if p.seat.version >= AXIS_VALUE120_SINCE_VERSION {
p.send_axis_value120(axis, delta);
} else if p.seat.version >= AXIS_DISCRETE_SINCE_VERSION {
p.send_axis_discrete(axis, delta / AXIS_120);
}
let px = (delta as f64 / AXIS_120 as f64) * PX_PER_SCROLL;
p.send_axis(time, axis, Fixed::from_f64(px));
} else if let Some(delta) = event.smooth[i].get() {
p.send_axis(time, axis, delta);
}
if p.seat.version >= AXIS_STOP_SINCE_VERSION && event.stop[i].get() {
p.send_axis_stop(time, axis);
}
}
if let Some(delta) = event.axis[i].get() {
self.surface_pointer_event(0, surface, |p| p.send_axis(time, i as _, delta));
if p.seat.version >= POINTER_FRAME_SINCE_VERSION {
p.send_frame();
}
if event.stop[i].get() {
self.surface_pointer_event(AXIS_STOP_SINCE_VERSION, surface, |p| {
p.send_axis_stop(time, i as _)
});
}
}
self.surface_pointer_frame(surface);
});
}
}

8
src/ifs/wl_seat/pointer_owner.rs
View file

@ -39,12 +39,12 @@ impl PointerOwnerHolder {
self.pending_scroll.source.set(Some(axis_source as _));
}
pub fn axis_discrete(&self, delta: i32, axis: ScrollAxis) {
self.pending_scroll.discrete[axis as usize].set(Some(delta));
pub fn axis_120(&self, delta: i32, axis: ScrollAxis) {
self.pending_scroll.v120[axis as usize].set(Some(delta));
}
pub fn axis(&self, delta: Fixed, axis: ScrollAxis) {
self.pending_scroll.axis[axis as usize].set(Some(delta));
pub fn axis_smooth(&self, delta: Fixed, axis: ScrollAxis) {
self.pending_scroll.smooth[axis as usize].set(Some(delta));
}
pub fn axis_stop(&self, axis: ScrollAxis) {

25
src/ifs/wl_seat/wl_pointer.rs
View file

@ -33,11 +33,12 @@ pub const AXIS_SOURCE_SINCE_VERSION: u32 = 5;
pub const AXIS_DISCRETE_SINCE_VERSION: u32 = 5;
pub const AXIS_STOP_SINCE_VERSION: u32 = 5;
pub const WHEEL_TILT_SINCE_VERSION: u32 = 6;
pub const AXIS_VALUE120_SINCE_VERSION: u32 = 8;
#[derive(Default, Debug)]
pub struct PendingScroll {
pub discrete: [Cell<Option<i32>>; 2],
pub axis: [Cell<Option<Fixed>>; 2],
pub v120: [Cell<Option<i32>>; 2],
pub smooth: [Cell<Option<Fixed>>; 2],
pub stop: [Cell<bool>; 2],
pub source: Cell<Option<u32>>,
pub time_usec: Cell<u64>,
@ -46,13 +47,13 @@ pub struct PendingScroll {
impl PendingScroll {
pub fn take(&self) -> Self {
Self {
discrete: [
Cell::new(self.discrete[0].take()),
Cell::new(self.discrete[1].take()),
v120: [
Cell::new(self.v120[0].take()),
Cell::new(self.v120[1].take()),
],
axis: [
Cell::new(self.axis[0].take()),
Cell::new(self.axis[1].take()),
smooth: [
Cell::new(self.smooth[0].take()),
Cell::new(self.smooth[1].take()),
],
stop: [
Cell::new(self.stop[0].take()),
@ -156,6 +157,14 @@ impl WlPointer {
})
}
pub fn send_axis_value120(&self, axis: u32, value120: i32) {
self.seat.client.event(AxisValue120 {
self_id: self.id,
axis,
value120,
})
}
fn set_cursor(&self, parser: MsgParser<'_, '_>) -> Result<(), WlPointerError> {
let req: SetCursor = self.seat.client.parse(self, parser)?;
if !self.seat.client.valid_serial(req.serial) {