use {
crate::{
backend::{AxisSource as BackendAxisSource, ButtonState, ScrollAxis},
client::{Client, ClientError},
fixed::Fixed,
ifs::{
wl_output::OutputGlobalOpt,
wl_seat::{
PX_PER_SCROLL, WlSeatGlobal,
wl_pointer::{self, CONTINUOUS, FINGER, PRESSED, RELEASED, WHEEL},
},
},
leaks::Tracker,
object::{Object, Version},
tree::TreeTimeline::LiveTL,
utils::{copyhashmap::CopyHashMap, syncqueue::SyncQueue},
wire::{ZwlrVirtualPointerV1Id, zwlr_virtual_pointer_v1::*},
},
std::rc::Rc,
thiserror::Error,
};
pub struct ZwlrVirtualPointerV1 {
pub id: ZwlrVirtualPointerV1Id,
pub client: Rc<Client>,
pub tracker: Tracker<Self>,
pub version: Version,
pub events: SyncQueue<Event>,
pub seat: Rc<WlSeatGlobal>,
pub output: Option<Rc<OutputGlobalOpt>>,
pub buttons: CopyHashMap<u32, ()>,
}
pub enum Event {
Motion(u32, Fixed, Fixed),
MotionAbsolute(u32, u32, u32, u32, u32),
Button(u32, u32, ButtonState),
Axis(u32, ScrollAxis, Fixed),
AxisSource(BackendAxisSource),
AxisStop(u32, ScrollAxis),
AxisDiscrete(u32, ScrollAxis, Fixed, i32),
}
fn map_axis(axis: u32) -> Result<ScrollAxis, ZwlrVirtualPointerV1Error> {
const VERTICAL_SCROLL: u32 = wl_pointer::VERTICAL_SCROLL as u32;
const HORIZONTAL_SCROLL: u32 = wl_pointer::HORIZONTAL_SCROLL as u32;
let axis = match axis {
VERTICAL_SCROLL => ScrollAxis::Vertical,
HORIZONTAL_SCROLL => ScrollAxis::Horizontal,
n => return Err(ZwlrVirtualPointerV1Error::UnknownAxis(n)),
};
Ok(axis)
}
impl ZwlrVirtualPointerV1 {
fn detach(&self) {
for (button, _) in self.buttons.lock().drain() {
let now = self.client.state.now_usec();
self.seat.button_event(now, button, ButtonState::Released);
}
}
}
impl ZwlrVirtualPointerV1RequestHandler for ZwlrVirtualPointerV1 {
type Error = ZwlrVirtualPointerV1Error;
fn motion(&self, req: Motion, _slf: &Rc<Self>) -> Result<(), Self::Error> {
self.events.push(Event::Motion(req.time, req.dx, req.dy));
Ok(())
}
fn motion_absolute(&self, req: MotionAbsolute, _slf: &Rc<Self>) -> Result<(), Self::Error> {
self.events.push(Event::MotionAbsolute(
req.time,
req.x,
req.y,
req.x_extent,
req.y_extent,
));
Ok(())
}
fn button(&self, req: Button, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let state = match req.state {
RELEASED => ButtonState::Released,
PRESSED => ButtonState::Pressed,
n => return Err(ZwlrVirtualPointerV1Error::UnknownButtonState(n)),
};
self.events.push(Event::Button(req.time, req.button, state));
Ok(())
}
fn axis(&self, req: Axis, _slf: &Rc<Self>) -> Result<(), Self::Error> {
self.events
.push(Event::Axis(req.time, map_axis(req.axis)?, req.value));
Ok(())
}
fn frame(&self, _req: Frame, _slf: &Rc<Self>) -> Result<(), Self::Error> {
fn ms_to_us(ms: u32) -> u64 {
ms as u64 * 1_000
}
let mut axis_time = None;
while let Some(ev) = self.events.pop() {
match ev {
Event::Motion(time, dx, dy) => {
self.seat.motion_event(ms_to_us(time), dx, dy, dx, dy);
}
Event::MotionAbsolute(time, x, y, x_max, y_max) => {
let x = x as f32 / x_max as f32;
let y = y as f32 / y_max as f32;
let rect = self
.output
.as_ref()
.and_then(|c| c.node())
.map(|g| g.node_state[LiveTL].pos.get())
.unwrap_or_else(|| self.client.state.root.node_state[LiveTL].extents.get());
self.seat.motion_absolute_event(ms_to_us(time), rect, x, y);
}
Event::Button(time, button, state) => {
match state {
ButtonState::Released => self.buttons.remove(&button),
ButtonState::Pressed => self.buttons.set(button, ()),
};
self.seat.button_event(ms_to_us(time), button, state);
}
Event::Axis(time, axis, v) => {
axis_time = Some(time);
self.seat.axis_px(v, axis, false);
}
Event::AxisSource(source) => {
self.seat.axis_source(source);
}
Event::AxisStop(time, axis) => {
axis_time = Some(time);
self.seat.axis_stop(axis);
}
Event::AxisDiscrete(time, axis, value, discrete) => {
axis_time = Some(time);
self.seat.axis_px(value, axis, false);
self.seat
.axis_120(discrete.saturating_mul(120), axis, false);
}
}
}
if let Some(time) = axis_time {
self.seat.axis_frame(PX_PER_SCROLL, ms_to_us(time));
}
Ok(())
}
fn axis_source(&self, req: AxisSource, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let source = match req.axis_source {
WHEEL => BackendAxisSource::Wheel,
FINGER => BackendAxisSource::Finger,
CONTINUOUS => BackendAxisSource::Continuous,
n => return Err(ZwlrVirtualPointerV1Error::UnknownAxisSource(n)),
};
self.events.push(Event::AxisSource(source));
Ok(())
}
fn axis_stop(&self, req: AxisStop, _slf: &Rc<Self>) -> Result<(), Self::Error> {
self.events
.push(Event::AxisStop(req.time, map_axis(req.axis)?));
Ok(())
}
fn axis_discrete(&self, req: AxisDiscrete, _slf: &Rc<Self>) -> Result<(), Self::Error> {
self.events.push(Event::AxisDiscrete(
req.time,
map_axis(req.axis)?,
req.value,
req.discrete,
));
Ok(())
}
fn destroy(&self, _req: Destroy, _slf: &Rc<Self>) -> Result<(), Self::Error> {
self.client.remove_obj(self)?;
self.detach();
Ok(())
}
}
object_base! {
self = ZwlrVirtualPointerV1;
version = self.version;
}
impl Object for ZwlrVirtualPointerV1 {
fn break_loops(self: Rc<Self>) {
self.detach();
}
}
simple_add_obj!(ZwlrVirtualPointerV1);
#[derive(Debug, Error)]
pub enum ZwlrVirtualPointerV1Error {
#[error(transparent)]
ClientError(Box<ClientError>),
#[error("Unknown button state {0}")]
UnknownButtonState(u32),
#[error("Unknown axis {0}")]
UnknownAxis(u32),
#[error("Unknown axis source {0}")]
UnknownAxisSource(u32),
}
efrom!(ZwlrVirtualPointerV1Error, ClientError);