From 3d4a6b21f31b70b4c6db07f7a7bc4b6136004bae Mon Sep 17 00:00:00 2001 From: Julian Orth Date: Sat, 30 Apr 2022 13:45:20 +0200 Subject: [PATCH] autocommit 2022-04-30 13:45:20 CEST --- src/backend.rs | 9 +- src/backends/metal/input.rs | 15 ++- src/backends/x.rs | 2 +- src/client.rs | 6 +- src/client/objects.rs | 5 + src/client/tasks.rs | 2 +- src/fixed.rs | 24 ++-- src/globals.rs | 4 +- src/ifs/ipc.rs | 12 +- src/ifs/ipc/wl_data_source.rs | 4 +- src/ifs/wl_output.rs | 2 +- src/ifs/wl_seat.rs | 9 +- src/ifs/wl_seat/event_handling.rs | 57 ++++++++-- src/ifs/wl_seat/pointer_owner.rs | 6 + src/ifs/wl_seat/wl_pointer.rs | 4 +- .../zwp_relative_pointer_manager_v1.rs | 104 ++++++++++++++++++ src/ifs/wl_seat/zwp_relative_pointer_v1.rs | 62 +++++++++++ src/ifs/wl_surface.rs | 4 + .../wl_surface/xdg_surface/xdg_toplevel.rs | 4 +- src/libinput/event.rs | 10 +- src/libinput/sys.rs | 2 + src/tree.rs | 9 ++ src/tree/container.rs | 2 +- src/tree/toplevel.rs | 16 +-- wire/zwp_relative_pointer_manager_v1.txt | 10 ++ wire/zwp_relative_pointer_v1.txt | 16 +++ 26 files changed, 340 insertions(+), 60 deletions(-) create mode 100644 src/ifs/wl_seat/zwp_relative_pointer_manager_v1.rs create mode 100644 src/ifs/wl_seat/zwp_relative_pointer_v1.rs create mode 100644 wire/zwp_relative_pointer_manager_v1.txt create mode 100644 wire/zwp_relative_pointer_v1.txt diff --git a/src/backend.rs b/src/backend.rs index a62516af..c21de5e5 100644 --- a/src/backend.rs +++ b/src/backend.rs @@ -144,8 +144,13 @@ pub enum AxisSource { pub enum InputEvent { Key(u32, KeyState), ConnectorPosition(ConnectorId, Fixed, Fixed), - #[allow(dead_code)] - Motion(Fixed, Fixed), + Motion { + time_usec: u64, + dx: Fixed, + dy: Fixed, + dx_unaccelerated: Fixed, + dy_unaccelerated: Fixed, + }, Button(u32, KeyState), Axis(Fixed, ScrollAxis), diff --git a/src/backends/metal/input.rs b/src/backends/metal/input.rs index 082a5c47..b6517089 100644 --- a/src/backends/metal/input.rs +++ b/src/backends/metal/input.rs @@ -15,6 +15,7 @@ use { }, std::rc::Rc, }; +use crate::fixed::Fixed; macro_rules! unpack { ($slf:expr, $ev:expr) => {{ @@ -148,7 +149,7 @@ impl MetalBackend { dev.event(InputEvent::AxisDiscrete(scroll_discrete as _, sa)); scroll = PX_PER_SCROLL * scroll_discrete; } - dev.event(InputEvent::Axis(scroll.into(), sa)); + dev.event(InputEvent::Axis(Fixed::from_f64(scroll), sa)); } } dev.event(InputEvent::Frame); @@ -174,10 +175,20 @@ impl MetalBackend { let (event, dev) = unpack!(self, event, pointer_event); let mut dx = event.dx(); let mut dy = event.dy(); + let mut dx_unaccelerated = event.dx_unaccelerated(); + let mut dy_unaccelerated = event.dy_unaccelerated(); if let Some(matrix) = dev.transform_matrix.get() { dx = matrix[0][0] * dx + matrix[0][1] * dy; dy = matrix[1][0] * dx + matrix[1][1] * dy; + dx_unaccelerated = matrix[0][0] * dx_unaccelerated + matrix[0][1] * dy_unaccelerated; + dy_unaccelerated = matrix[1][0] * dx_unaccelerated + matrix[1][1] * dy_unaccelerated; } - dev.event(InputEvent::Motion(dx.into(), dy.into())); + dev.event(InputEvent::Motion { + time_usec: event.time_usec(), + dx: Fixed::from_f64(dx), + dy: Fixed::from_f64(dy), + dx_unaccelerated: Fixed::from_f64(dx_unaccelerated), + dy_unaccelerated: Fixed::from_f64(dy_unaccelerated), + }); } } diff --git a/src/backends/x.rs b/src/backends/x.rs index 40d13404..b24d9d10 100644 --- a/src/backends/x.rs +++ b/src/backends/x.rs @@ -761,7 +761,7 @@ impl XBackend { }; seat.mouse_event(InputEvent::AxisSource(AxisSource::Wheel)); seat.mouse_event(InputEvent::AxisDiscrete(val, axis)); - seat.mouse_event(InputEvent::Axis((val as f64 * PX_PER_SCROLL).into(), axis)); + seat.mouse_event(InputEvent::Axis(Fixed::from_f64(val as f64 * PX_PER_SCROLL), axis)); seat.mouse_event(InputEvent::Frame); } } else { diff --git a/src/client.rs b/src/client.rs index 2fa10ac5..1584efc8 100644 --- a/src/client.rs +++ b/src/client.rs @@ -366,9 +366,9 @@ impl Client { self.flush_request.trigger(); } - pub fn flush(&self) { - self.flush_request.trigger(); - } + // pub fn flush(&self) { + // self.flush_request.trigger(); + // } pub async fn check_queue_size(&self) { if self.swapchain.borrow_mut().exceeds_limit() { diff --git a/src/client/objects.rs b/src/client/objects.rs index da108298..5c69cc99 100644 --- a/src/client/objects.rs +++ b/src/client/objects.rs @@ -33,6 +33,8 @@ use { }, std::{cell::RefCell, mem, ops::DerefMut, rc::Rc}, }; +use crate::ifs::wl_seat::wl_pointer::WlPointer; +use crate::wire::WlPointerId; pub struct Objects { pub display: CloneCell>>, @@ -48,6 +50,7 @@ pub struct Objects { pub xdg_positioners: CopyHashMap>, pub regions: CopyHashMap>, pub buffers: CopyHashMap>, + pub pointers: CopyHashMap>, pub xdg_wm_bases: CopyHashMap>, pub seats: CopyHashMap>, ids: RefCell>, @@ -71,6 +74,7 @@ impl Objects { xdg_positioners: Default::default(), regions: Default::default(), buffers: Default::default(), + pointers: Default::default(), xdg_wm_bases: Default::default(), seats: Default::default(), ids: RefCell::new(vec![]), @@ -104,6 +108,7 @@ impl Objects { self.buffers.clear(); self.xdg_wm_bases.clear(); self.seats.clear(); + self.pointers.clear(); } pub fn id(&self, client_data: &Client) -> Result diff --git a/src/client/tasks.rs b/src/client/tasks.rs index 98aea2d0..14e50482 100644 --- a/src/client/tasks.rs +++ b/src/client/tasks.rs @@ -78,7 +78,7 @@ async fn receive(data: Rc) { if let Err(e) = obj.handle_request(request, parser) { return Err(ClientError::RequestError(Box::new(e))); } - data.flush(); + // data.flush(); } }; let res: Result<(), ClientError> = recv.await; diff --git a/src/fixed.rs b/src/fixed.rs index a57ba10a..3f9a44e4 100644 --- a/src/fixed.rs +++ b/src/fixed.rs @@ -8,6 +8,14 @@ use std::{ pub struct Fixed(pub i32); impl Fixed { + pub fn from_f64(f: f64) -> Self { + Self((f * 256.0) as i32) + } + + pub fn to_f64(self) -> f64 { + self.0 as f64 / 256.0 + } + pub fn from_1616(i: i32) -> Self { Self(i >> 8) } @@ -25,27 +33,15 @@ impl Fixed { } } -impl From for Fixed { - fn from(v: f64) -> Self { - Self((v * 256.0) as i32) - } -} - -impl From for f64 { - fn from(v: Fixed) -> Self { - v.0 as f64 / 256.0 - } -} - impl Debug for Fixed { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - Debug::fmt(&f64::from(*self), f) + Debug::fmt(&self.to_f64(), f) } } impl Display for Fixed { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - Display::fmt(&f64::from(*self), f) + Display::fmt(&self.to_f64(), f) } } diff --git a/src/globals.rs b/src/globals.rs index e0a22cb2..397806e7 100644 --- a/src/globals.rs +++ b/src/globals.rs @@ -39,6 +39,7 @@ use { }, thiserror::Error, }; +use crate::ifs::wl_seat::zwp_relative_pointer_manager_v1::ZwpRelativePointerManagerV1Global; #[derive(Debug, Error)] pub enum GlobalsError { @@ -134,6 +135,7 @@ impl Globals { add_singleton!(ZxdgOutputManagerV1Global); add_singleton!(JayCompositorGlobal); add_singleton!(ZwlrScreencopyManagerV1Global); + add_singleton!(ZwpRelativePointerManagerV1Global); if backend.supports_idle() { add_singleton!(ZwpIdleInhibitManagerV1Global); @@ -206,7 +208,7 @@ impl Globals { for registry in registries.values() { f(registry); } - c.flush(); + // c.flush(); }); } diff --git a/src/ifs/ipc.rs b/src/ifs/ipc.rs index 776b5e06..2f559924 100644 --- a/src/ifs/ipc.rs +++ b/src/ifs/ipc.rs @@ -79,7 +79,6 @@ impl Default for DeviceData { pub struct OfferData { device: CloneCell>>, source: CloneCell>>, - client: Rc, shared: Rc, } @@ -190,7 +189,7 @@ pub fn detach_seat(src: &T::Source) { if !data.state.get().contains(SOURCE_STATE_FINISHED) { T::send_cancelled(src); } - data.client.flush(); + // data.client.flush(); } pub fn offer_source_to(src: &Rc, client: &Rc) { @@ -218,7 +217,6 @@ pub fn offer_source_to(src: &Rc, client: &Rc) { let offer_data = OfferData { device: CloneCell::new(Some(dd.clone())), source: CloneCell::new(Some(src.clone())), - client: client.clone(), shared: shared.clone(), }; let offer = T::create_offer(client, dd, offer_data, id); @@ -246,8 +244,8 @@ fn add_mime_type(src: &T::Source, mime_type: &str) { if data.mime_types.borrow_mut().insert(mime_type.to_string()) { for (_, offer) in &data.offers { T::send_mime_type(&offer, mime_type); - let data = T::get_offer_data(&offer); - data.client.flush(); + // let data = T::get_offer_data(&offer); + // data.client.flush(); } } } @@ -321,7 +319,7 @@ fn receive(offer: &T::Offer, mime_type: &str, fd: Rc) { let data = T::get_offer_data(offer); if let Some(src) = data.source.get() { T::send_send(&src, mime_type, fd); - let data = T::get_source_data(&src); - data.client.flush(); + // let data = T::get_source_data(&src); + // data.client.flush(); } } diff --git a/src/ifs/ipc/wl_data_source.rs b/src/ifs/ipc/wl_data_source.rs index cc64537d..ecc566ec 100644 --- a/src/ifs/ipc/wl_data_source.rs +++ b/src/ifs/ipc/wl_data_source.rs @@ -78,10 +78,10 @@ impl WlDataSource { if shared.selected_action.replace(action) != action { for (_, offer) in &self.data.offers { offer.send_action(action); - offer.client.flush(); + // offer.client.flush(); } self.send_action(action); - self.data.client.flush(); + // self.data.client.flush(); } } diff --git a/src/ifs/wl_output.rs b/src/ifs/wl_output.rs index 6ea60d59..7891fc6e 100644 --- a/src/ifs/wl_output.rs +++ b/src/ifs/wl_output.rs @@ -126,7 +126,7 @@ impl WlOutputGlobal { for xdg in xdg.values() { xdg.send_updates(); } - binding.client.flush(); + // binding.client.flush(); } } } diff --git a/src/ifs/wl_seat.rs b/src/ifs/wl_seat.rs index 6e1a9e87..806980e4 100644 --- a/src/ifs/wl_seat.rs +++ b/src/ifs/wl_seat.rs @@ -4,6 +4,8 @@ mod pointer_owner; pub mod wl_keyboard; pub mod wl_pointer; pub mod wl_touch; +pub mod zwp_relative_pointer_manager_v1; +pub mod zwp_relative_pointer_v1; pub use event_handling::NodeSeatState; use { @@ -65,6 +67,8 @@ use { thiserror::Error, uapi::{c, Errno, OwnedFd}, }; +use crate::ifs::wl_seat::zwp_relative_pointer_v1::ZwpRelativePointerV1; +use crate::wire::ZwpRelativePointerV1Id; const POINTER: u32 = 1; const KEYBOARD: u32 = 2; @@ -467,7 +471,7 @@ impl WlSeatGlobal { T::send_selection(device, ObjectId::NONE.into()); }), } - client.flush(); + // client.flush(); } Ok(()) } @@ -608,6 +612,7 @@ impl WlSeatGlobal { id, client: client.clone(), pointers: Default::default(), + relative_pointers: Default::default(), keyboards: Default::default(), version, tracker: Default::default(), @@ -652,6 +657,7 @@ pub struct WlSeat { pub id: WlSeatId, pub client: Rc, pointers: CopyHashMap>, + relative_pointers: CopyHashMap>, keyboards: CopyHashMap>, version: u32, tracker: Tracker, @@ -814,6 +820,7 @@ impl Object for WlSeat { } } self.pointers.clear(); + self.relative_pointers.clear(); self.keyboards.clear(); } } diff --git a/src/ifs/wl_seat/event_handling.rs b/src/ifs/wl_seat/event_handling.rs index 03a2a071..45346f46 100644 --- a/src/ifs/wl_seat/event_handling.rs +++ b/src/ifs/wl_seat/event_handling.rs @@ -33,6 +33,7 @@ use { smallvec::SmallVec, std::rc::Rc, }; +use crate::ifs::wl_seat::zwp_relative_pointer_v1::ZwpRelativePointerV1; #[derive(Default)] pub struct NodeSeatState { @@ -155,7 +156,7 @@ impl WlSeatGlobal { match event { InputEvent::Key(k, s) => self.key_event(k, s), InputEvent::ConnectorPosition(o, x, y) => self.connector_position_event(o, x, y), - InputEvent::Motion(dx, dy) => self.motion_event(dx, dy), + InputEvent::Motion { dx, dy, dx_unaccelerated, dy_unaccelerated, time_usec } => self.motion_event(time_usec, dx, dy, dx_unaccelerated, dy_unaccelerated), InputEvent::Button(b, s) => self.pointer_owner.button(self, b, s), InputEvent::AxisSource(s) => self.pointer_owner.axis_source(s), @@ -183,7 +184,8 @@ impl WlSeatGlobal { self.set_new_position(x, y); } - fn motion_event(self: &Rc, dx: Fixed, dy: Fixed) { + fn motion_event(self: &Rc, time_usec: u64, dx: Fixed, dy: Fixed, dx_unaccelerated: Fixed, dy_unaccelerated: Fixed) { + self.pointer_owner.relative_motion(self, time_usec, dx, dy, dx_unaccelerated, dy_unaccelerated); let (mut x, mut y) = self.pos.get(); x += dx; y += dy; @@ -327,8 +329,8 @@ impl WlSeatGlobal { } fn for_each_pointer(&self, ver: u32, client: ClientId, mut f: C) - where - C: FnMut(&Rc), + where + C: FnMut(&Rc), { self.for_each_seat(ver, client, |seat| { let pointers = seat.pointers.lock(); @@ -338,6 +340,18 @@ impl WlSeatGlobal { }) } + fn for_each_relative_pointer(&self, client: ClientId, mut f: C) + where + C: FnMut(&Rc), + { + self.for_each_seat(0, client, |seat| { + let pointers = seat.relative_pointers.lock(); + for pointer in pointers.values() { + f(pointer); + } + }) + } + fn for_each_kb(&self, ver: u32, client: ClientId, mut f: C) where C: FnMut(&Rc), @@ -383,14 +397,24 @@ impl WlSeatGlobal { } fn surface_pointer_event(&self, ver: u32, surface: &WlSurface, mut f: F) - where - F: FnMut(&Rc), + where + F: FnMut(&Rc), { let client = &surface.client; self.for_each_pointer(ver, client.id, |p| { f(p); }); - client.flush(); + // client.flush(); + } + + fn surface_relative_pointer_event(&self, surface: &WlSurface, mut f: F) + where + F: FnMut(&Rc), + { + let client = &surface.client; + self.for_each_relative_pointer(client.id, |p| { + f(p); + }); } fn surface_kb_event(&self, ver: u32, surface: &WlSurface, mut f: F) @@ -401,7 +425,7 @@ impl WlSeatGlobal { self.for_each_kb(ver, client.id, |p| { f(p); }); - client.flush(); + // client.flush(); } fn set_new_position(self: &Rc, x: Fixed, y: Fixed) { @@ -492,6 +516,15 @@ impl WlSeatGlobal { } } +// Relative motion callbacks +impl WlSeatGlobal { + pub fn relative_motion_surface(&self, surface: &WlSurface, time_usec: u64, dx: Fixed, dy: Fixed, dx_unaccelerated: Fixed, dy_unaccelerated: Fixed) { + self.surface_relative_pointer_event(surface, |p| { + p.send_relative_motion(time_usec, dx, dy, dx_unaccelerated, dy_unaccelerated); + }); + } +} + // Enter callbacks impl WlSeatGlobal { pub fn enter_toplevel(self: &Rc, n: Rc) { @@ -594,7 +627,7 @@ impl WlSeatGlobal { if let Some(src) = &dnd.src { src.on_leave(); } - surface.client.flush(); + // surface.client.flush(); } pub fn dnd_surface_drop(&self, surface: &WlSurface, dnd: &Dnd) { @@ -606,7 +639,7 @@ impl WlSeatGlobal { if let Some(src) = &dnd.src { src.on_drop(); } - surface.client.flush(); + // surface.client.flush(); } pub fn dnd_surface_enter( @@ -628,7 +661,7 @@ impl WlSeatGlobal { dd.send_enter(surface.id, x, y, WlDataOfferId::NONE, serial); }) } - surface.client.flush(); + // surface.client.flush(); } pub fn dnd_surface_motion(&self, surface: &WlSurface, dnd: &Dnd, x: Fixed, y: Fixed) { @@ -637,6 +670,6 @@ impl WlSeatGlobal { dd.send_motion(x, y); }) } - surface.client.flush(); + // surface.client.flush(); } } diff --git a/src/ifs/wl_seat/pointer_owner.rs b/src/ifs/wl_seat/pointer_owner.rs index d96023f3..e5ed775f 100644 --- a/src/ifs/wl_seat/pointer_owner.rs +++ b/src/ifs/wl_seat/pointer_owner.rs @@ -58,6 +58,12 @@ impl PointerOwnerHolder { } } + pub fn relative_motion(&self, seat: &Rc, time_usec: u64, dx: Fixed, dy: Fixed, dx_unaccelerated: Fixed, dy_unaccelerated: Fixed) { + if let Some(n) = self.owner.get().axis_node(seat) { + n.node_on_pointer_relative_motion(seat, time_usec, dx, dy, dx_unaccelerated, dy_unaccelerated); + } + } + pub fn apply_changes(&self, seat: &Rc) { self.owner.get().apply_changes(seat) } diff --git a/src/ifs/wl_seat/wl_pointer.rs b/src/ifs/wl_seat/wl_pointer.rs index cc549858..2d849dd4 100644 --- a/src/ifs/wl_seat/wl_pointer.rs +++ b/src/ifs/wl_seat/wl_pointer.rs @@ -64,7 +64,7 @@ impl PendingScroll { pub struct WlPointer { id: WlPointerId, - seat: Rc, + pub seat: Rc, pub tracker: Tracker, } @@ -205,7 +205,7 @@ impl Object for WlPointer { } } -simple_add_obj!(WlPointer); +dedicated_add_obj!(WlPointer, WlPointerId, pointers); #[derive(Debug, Error)] pub enum WlPointerError { diff --git a/src/ifs/wl_seat/zwp_relative_pointer_manager_v1.rs b/src/ifs/wl_seat/zwp_relative_pointer_manager_v1.rs new file mode 100644 index 00000000..3b37fbcd --- /dev/null +++ b/src/ifs/wl_seat/zwp_relative_pointer_manager_v1.rs @@ -0,0 +1,104 @@ +use std::rc::Rc; +use thiserror::Error; +use crate::client::{Client, ClientError}; +use crate::globals::{Global, GlobalName}; +use crate::ifs::wl_seat::zwp_relative_pointer_v1::ZwpRelativePointerV1; +use crate::leaks::Tracker; +use crate::object::Object; +use crate::utils::buffd::{MsgParser, MsgParserError}; +use crate::wire::ZwpRelativePointerManagerV1Id; +use crate::wire::zwp_relative_pointer_manager_v1::*; + +pub struct ZwpRelativePointerManagerV1Global { + pub name: GlobalName, +} + +pub struct ZwpRelativePointerManagerV1 { + pub id: ZwpRelativePointerManagerV1Id, + pub client: Rc, + pub tracker: Tracker, +} + +impl ZwpRelativePointerManagerV1Global { + pub fn new(name: GlobalName) -> Self { + Self { name } + } + + fn bind_( + self: Rc, + id: ZwpRelativePointerManagerV1Id, + client: &Rc, + _version: u32, + ) -> Result<(), ZwpRelativePointerManagerV1Error> { + let obj = Rc::new(ZwpRelativePointerManagerV1 { + id, + client: client.clone(), + tracker: Default::default(), + }); + track!(client, obj); + client.add_client_obj(&obj)?; + Ok(()) + } +} + +global_base!(ZwpRelativePointerManagerV1Global, ZwpRelativePointerManagerV1, ZwpRelativePointerManagerV1Error); + +impl Global for ZwpRelativePointerManagerV1Global { + fn singleton(&self) -> bool { + true + } + + fn version(&self) -> u32 { + 1 + } +} + +simple_add_global!(ZwpRelativePointerManagerV1Global); + +impl ZwpRelativePointerManagerV1 { + fn destroy(&self, parser: MsgParser<'_, '_>) -> Result<(), ZwpRelativePointerManagerV1Error> { + let _req: Destroy = self.client.parse(self, parser)?; + self.client.remove_obj(self)?; + Ok(()) + } + + fn get_relative_pointer(&self, parser: MsgParser<'_, '_>) -> Result<(), ZwpRelativePointerManagerV1Error> { + let req: GetRelativePointer = self.client.parse(self, parser)?; + let pointer = self.client.lookup(req.pointer)?; + let rp = Rc::new(ZwpRelativePointerV1 { + id: req.id, + client: self.client.clone(), + seat: pointer.seat.clone(), + tracker: Default::default(), + }); + track!(self.client, rp); + self.client.add_client_obj(&rp)?; + pointer.seat.relative_pointers.set(req.id, rp); + Ok(()) + } +} + +object_base! { + ZwpRelativePointerManagerV1; + + DESTROY => destroy, + GET_RELATIVE_POINTER => get_relative_pointer, +} + +impl Object for ZwpRelativePointerManagerV1 { + fn num_requests(&self) -> u32 { + GET_RELATIVE_POINTER + 1 + } +} + +simple_add_obj!(ZwpRelativePointerManagerV1); + +#[derive(Debug, Error)] +pub enum ZwpRelativePointerManagerV1Error { + #[error("Parsing failed")] + MsgParserError(#[source] Box), + #[error(transparent)] + ClientError(Box), +} +efrom!(ZwpRelativePointerManagerV1Error, MsgParserError); +efrom!(ZwpRelativePointerManagerV1Error, ClientError); diff --git a/src/ifs/wl_seat/zwp_relative_pointer_v1.rs b/src/ifs/wl_seat/zwp_relative_pointer_v1.rs new file mode 100644 index 00000000..46c1ecc1 --- /dev/null +++ b/src/ifs/wl_seat/zwp_relative_pointer_v1.rs @@ -0,0 +1,62 @@ +use std::rc::Rc; +use thiserror::Error; +use crate::client::{Client, ClientError}; +use crate::fixed::Fixed; +use crate::ifs::wl_seat::{WlSeat}; +use crate::leaks::Tracker; +use crate::object::Object; +use crate::utils::buffd::{MsgParser, MsgParserError}; +use crate::wire::ZwpRelativePointerV1Id; +use crate::wire::zwp_relative_pointer_v1::*; + +pub struct ZwpRelativePointerV1 { + pub id: ZwpRelativePointerV1Id, + pub client: Rc, + pub seat: Rc, + pub tracker: Tracker, +} + +impl ZwpRelativePointerV1 { + pub fn send_relative_motion(&self, time_usec: u64, dx: Fixed, dy: Fixed, dx_unaccelerated: Fixed, dy_unaccelerated: Fixed) { + self.client.event(RelativeMotion { + self_id: self.id, + utime_hi: (time_usec >> 32) as u32, + utime_lo: time_usec as u32, + dx, + dy, + dx_unaccelerated, + dy_unaccelerated, + }); + } + + fn destroy(&self, parser: MsgParser<'_, '_>) -> Result<(), ZwpRelativePointerV1Error> { + let _req: Destroy = self.client.parse(self, parser)?; + self.seat.relative_pointers.remove(&self.id); + self.client.remove_obj(self)?; + Ok(()) + } +} + +object_base! { + ZwpRelativePointerV1; + + DESTROY => destroy, +} + +impl Object for ZwpRelativePointerV1 { + fn num_requests(&self) -> u32 { + DESTROY + 1 + } +} + +simple_add_obj!(ZwpRelativePointerV1); + +#[derive(Debug, Error)] +pub enum ZwpRelativePointerV1Error { + #[error(transparent)] + ClientError(Box), + #[error("Parsing failed")] + MsgParserError(Box), +} +efrom!(ZwpRelativePointerV1Error, ClientError); +efrom!(ZwpRelativePointerV1Error, MsgParserError); diff --git a/src/ifs/wl_surface.rs b/src/ifs/wl_surface.rs index 82fe2771..6a6a195e 100644 --- a/src/ifs/wl_surface.rs +++ b/src/ifs/wl_surface.rs @@ -796,6 +796,10 @@ impl Node for WlSurface { seat.motion_surface(&*self, x, y) } + fn node_on_pointer_relative_motion(&self, seat: &Rc, time_usec: u64, dx: Fixed, dy: Fixed, dx_unaccelerated: Fixed, dy_unaccelerated: Fixed) { + seat.relative_motion_surface(self, time_usec, dx, dy, dx_unaccelerated, dy_unaccelerated); + } + fn node_on_dnd_drop(&self, dnd: &Dnd) { dnd.seat.dnd_surface_drop(self, dnd); } diff --git a/src/ifs/wl_surface/xdg_surface/xdg_toplevel.rs b/src/ifs/wl_surface/xdg_surface/xdg_toplevel.rs index ac423c17..9603bcc5 100644 --- a/src/ifs/wl_surface/xdg_surface/xdg_toplevel.rs +++ b/src/ifs/wl_surface/xdg_surface/xdg_toplevel.rs @@ -152,7 +152,7 @@ impl XdgToplevel { fn send_close(&self) { self.xdg.surface.client.event(Close { self_id: self.id }); - self.xdg.surface.client.flush(); + // self.xdg.surface.client.flush(); } fn send_configure(&self, width: i32, height: i32) { @@ -472,7 +472,7 @@ impl ToplevelNode for XdgToplevel { } self.send_configure_checked(nw, nh); self.xdg.do_send_configure(); - self.xdg.surface.client.flush(); + // self.xdg.surface.client.flush(); } self.xdg.set_absolute_desired_extents(rect); } diff --git a/src/libinput/event.rs b/src/libinput/event.rs index 0f9ec764..5974e4e6 100644 --- a/src/libinput/event.rs +++ b/src/libinput/event.rs @@ -16,6 +16,7 @@ use { }, std::marker::PhantomData, }; +use crate::libinput::sys::{libinput_event_pointer_get_dx_unaccelerated, libinput_event_pointer_get_dy_unaccelerated}; pub struct LibInputEvent<'a> { pub(super) event: *mut libinput_event, @@ -101,6 +102,14 @@ impl<'a> LibInputEventPointer<'a> { unsafe { libinput_event_pointer_get_dy(self.event) } } + pub fn dx_unaccelerated(&self) -> f64 { + unsafe { libinput_event_pointer_get_dx_unaccelerated(self.event) } + } + + pub fn dy_unaccelerated(&self) -> f64 { + unsafe { libinput_event_pointer_get_dy_unaccelerated(self.event) } + } + pub fn button(&self) -> u32 { unsafe { libinput_event_pointer_get_button(self.event) } } @@ -121,7 +130,6 @@ impl<'a> LibInputEventPointer<'a> { unsafe { libinput_event_pointer_has_axis(self.event, axis.raw() as _) != 0 } } - #[allow(dead_code)] pub fn time_usec(&self) -> u64 { unsafe { libinput_event_pointer_get_time_usec(self.event) } } diff --git a/src/libinput/sys.rs b/src/libinput/sys.rs index 494eb884..bd122c3e 100644 --- a/src/libinput/sys.rs +++ b/src/libinput/sys.rs @@ -74,6 +74,8 @@ extern "C" { pub fn libinput_event_pointer_get_time_usec(event: *mut libinput_event_pointer) -> u64; pub fn libinput_event_pointer_get_dx(event: *mut libinput_event_pointer) -> f64; pub fn libinput_event_pointer_get_dy(event: *mut libinput_event_pointer) -> f64; + pub fn libinput_event_pointer_get_dx_unaccelerated(event: *mut libinput_event_pointer) -> f64; + pub fn libinput_event_pointer_get_dy_unaccelerated(event: *mut libinput_event_pointer) -> f64; pub fn libinput_event_pointer_get_button(event: *mut libinput_event_pointer) -> u32; pub fn libinput_event_pointer_get_button_state( event: *mut libinput_event_pointer, diff --git a/src/tree.rs b/src/tree.rs index e5b4f5ed..346675d2 100644 --- a/src/tree.rs +++ b/src/tree.rs @@ -198,6 +198,15 @@ pub trait Node: 'static { let _ = y; } + fn node_on_pointer_relative_motion(&self, seat: &Rc, time_usec: u64, dx: Fixed, dy: Fixed, dx_unaccelerated: Fixed, dy_unaccelerated: Fixed) { + let _ = seat; + let _ = time_usec; + let _ = dx; + let _ = dy; + let _ = dx_unaccelerated; + let _ = dy_unaccelerated; + } + fn node_on_dnd_drop(&self, dnd: &Dnd) { let _ = dnd; } diff --git a/src/tree/container.rs b/src/tree/container.rs index 215f5445..3e58660d 100644 --- a/src/tree/container.rs +++ b/src/tree/container.rs @@ -1158,7 +1158,7 @@ impl Node for ContainerNode { Some(s) => s, _ => return, }; - let mut scroll = self.scroll.get() + f64::from(scroll); + let mut scroll = self.scroll.get() + scroll.to_f64(); let discrete = (scroll / PX_PER_SCROLL).round(); scroll -= discrete * PX_PER_SCROLL; self.scroll.set(scroll); diff --git a/src/tree/toplevel.rs b/src/tree/toplevel.rs index 257637e2..56854470 100644 --- a/src/tree/toplevel.rs +++ b/src/tree/toplevel.rs @@ -262,13 +262,15 @@ impl ToplevelData { let placeholder = Rc::new(PlaceholderNode::new_for(state, node.clone())); parent.cnode_replace_child(node.tl_as_node(), placeholder.clone()); let mut kb_foci = Default::default(); - if let Some(container) = ws.container.get() { - kb_foci = collect_kb_foci(container.clone()); - container.tl_set_visible(false); - } - for stacked in ws.stacked.iter() { - collect_kb_foci2(stacked.deref().clone().stacked_into_node(), &mut kb_foci); - stacked.stacked_set_visible(false); + if ws.visible.get() { + if let Some(container) = ws.container.get() { + kb_foci = collect_kb_foci(container.clone()); + container.tl_set_visible(false); + } + for stacked in ws.stacked.iter() { + collect_kb_foci2(stacked.deref().clone().stacked_into_node(), &mut kb_foci); + stacked.stacked_set_visible(false); + } } *data = Some(FullscreenedData { placeholder, diff --git a/wire/zwp_relative_pointer_manager_v1.txt b/wire/zwp_relative_pointer_manager_v1.txt new file mode 100644 index 00000000..ca123393 --- /dev/null +++ b/wire/zwp_relative_pointer_manager_v1.txt @@ -0,0 +1,10 @@ +# requests + +msg destroy = 0 { + +} + +msg get_relative_pointer = 1 { + id: id(zwp_relative_pointer_v1), + pointer: id(wl_pointer), +} diff --git a/wire/zwp_relative_pointer_v1.txt b/wire/zwp_relative_pointer_v1.txt new file mode 100644 index 00000000..8d884b26 --- /dev/null +++ b/wire/zwp_relative_pointer_v1.txt @@ -0,0 +1,16 @@ +# requests + +msg destroy = 0 { + +} + +# events + +msg relative_motion = 0 { + utime_hi: u32, + utime_lo: u32, + dx: fixed, + dy: fixed, + dx_unaccelerated: fixed, + dy_unaccelerated: fixed, +}