feat(wayland): relative pointer

Author: technobaboo

Cargo.lock

@@ -144,6 +144,7 @@ waynest = { git = "https://github.com/verdiwm/waynest.git", default-features = f
 waynest-protocols = { git = "https://github.com/verdiwm/waynest.git", features = [
 	"server",
 	"stable",
+	"unstable",
 	"mesa",
 	"tracing",
 ], default-features = false, optional = true }

Cargo.toml

@@ -68,7 +68,8 @@ pub trait Backend: Send + Sync + 'static {
 	fn set_toplevel_size(&self, size: Vector2<u32>);
 	fn set_toplevel_focused_visuals(&self, focused: bool);
 
-	fn pointer_motion(&self, surface: &SurfaceId, position: Vector2<f32>);
+	fn absolute_pointer_motion(&self, surface: &SurfaceId, position: Vector2<f32>);
+	fn relative_pointer_motion(&self, surface: &SurfaceId, delta: Vector2<f32>);
 	fn pointer_button(&self, surface: &SurfaceId, button: u32, pressed: bool);
 	fn pointer_scroll(
 		&self,
@@ -297,7 +298,7 @@ impl<B: Backend> PanelItemAspect for PanelItem<B> {
 	}
 
 	#[doc = "Send an event to set the pointer's position (in pixels, relative to top-left of surface). This will activate the pointer."]
-	fn pointer_motion(
+	fn absolute_pointer_motion(
 		node: Arc<Node>,
 		_calling_client: Arc<Client>,
 		surface: SurfaceId,
@@ -306,7 +307,25 @@ impl<B: Backend> PanelItemAspect for PanelItem<B> {
 		let Some(panel_item) = panel_item_from_node(&node) else {
 			return Ok(());
 		};
-		panel_item.backend().pointer_motion(&surface, position);
+		panel_item
+			.backend()
+			.absolute_pointer_motion(&surface, position);
+		Ok(())
+	}
+
+	#[doc = "Send an event that the pointer moved a relative amount (in pixels)."]
+	fn relative_pointer_motion(
+		node: Arc<Node>,
+		_calling_client: Arc<Client>,
+		surface: SurfaceId,
+		delta: Vector2<f32>,
+	) -> Result<()> {
+		let Some(panel_item) = panel_item_from_node(&node) else {
+			return Ok(());
+		};
+		panel_item
+			.backend()
+			.relative_pointer_motion(&surface, delta);
 		Ok(())
 	}
 

src/nodes/items/panel.rs

@@ -1,11 +1,12 @@
 use super::surface::SurfaceRole;
 use crate::nodes::items::panel::Geometry;
 use crate::wayland::core::surface::Surface;
+use crate::wayland::relative_pointer::RelativePointer;
 use crate::wayland::{Client, WaylandResult};
 use mint::Vector2;
 use std::sync::Arc;
 use std::sync::Weak;
-use tokio::sync::Mutex;
+use tokio::sync::{Mutex, RwLock};
 use tracing;
 use waynest::ObjectId;
 use waynest_server::Client as _;
@@ -19,6 +20,7 @@ pub struct Pointer {
 	version: u32,
 	focused_surface: Mutex<Weak<Surface>>,
 	cursor_surface: Mutex<Option<Arc<Surface>>>,
+	pub relative_pointer: RwLock<Weak<RelativePointer>>,
 }
 impl Pointer {
 	pub fn new(id: ObjectId, version: u32) -> Self {
@@ -27,17 +29,18 @@ impl Pointer {
 			version,
 			focused_surface: Mutex::new(Weak::new()),
 			cursor_surface: Mutex::new(None),
+			relative_pointer: RwLock::new(Weak::new()),
 		}
 	}
 
-	pub async fn handle_pointer_motion(
+	pub async fn handle_absolute_pointer_motion(
 		&self,
 		client: &mut Client,
 		surface: Arc<Surface>,
 		position: Vector2<f32>,
 	) -> WaylandResult<()> {
 		tracing::debug!(
-			"Handling pointer motion at ({}, {})",
+			"Handling absolute pointer motion at ({}, {})",
 			position.x,
 			position.y
 		);
@@ -91,6 +94,24 @@ impl Pointer {
 		Ok(())
 	}
 
+	pub async fn handle_relative_pointer_motion(
+		&self,
+		client: &mut Client,
+		delta: Vector2<f32>,
+	) -> WaylandResult<()> {
+		tracing::debug!(
+			"Handling relative pointer motion of ({}, {})",
+			delta.x,
+			delta.y
+		);
+
+		let Some(relative_pointer) = self.relative_pointer.read().await.upgrade() else {
+			return Ok(());
+		};
+
+		relative_pointer.send_relative_motion(client, delta).await
+	}
+
 	pub async fn handle_pointer_button(
 		&self,
 		client: &mut Client,

src/wayland/core/pointer.rs

@@ -11,10 +11,13 @@ use waynest_server::Client as _;
 
 #[derive(Debug)]
 pub enum SeatMessage {
-	PointerMotion {
+	AbsolutePointerMotion {
 		surface: Arc<Surface>,
 		position: Vector2<f32>,
 	},
+	RelativePointerMotion {
+		delta: Vector2<f32>,
+	},
 	PointerButton {
 		surface: Arc<Surface>,
 		button: u32,
@@ -82,10 +85,17 @@ impl Seat {
 		message: SeatMessage,
 	) -> WaylandResult<()> {
 		match message {
-			SeatMessage::PointerMotion { surface, position } => {
+			SeatMessage::AbsolutePointerMotion { surface, position } => {
+				if let Some(pointer) = self.pointer.get() {
+					pointer
+						.handle_absolute_pointer_motion(client, surface, position)
+						.await?;
+				}
+			}
+			SeatMessage::RelativePointerMotion { delta } => {
 				if let Some(pointer) = self.pointer.get() {
 					pointer
-						.handle_pointer_motion(client, surface, position)
+						.handle_relative_pointer_motion(client, delta)
 						.await?;
 				}
 			}

src/wayland/core/seat.rs

@@ -4,6 +4,7 @@ mod dmabuf;
 mod mesa_drm;
 mod presentation;
 mod registry;
+mod relative_pointer;
 mod util;
 mod viewporter;
 mod vulkano_data;

src/wayland/mod.rs

@@ -1,3 +1,4 @@
+use crate::wayland::relative_pointer::RelativePointerManager;
 use crate::wayland::{Client, WaylandResult};
 use crate::wayland::{
 	WaylandError,
@@ -24,6 +25,7 @@ use waynest_protocols::server::{
 		presentation_time::wp_presentation::WpPresentation,
 		viewporter::wp_viewporter::WpViewporter,
 	},
+	unstable::relative_pointer_unstable_v1::zwp_relative_pointer_manager_v1::ZwpRelativePointerManagerV1,
 };
 use waynest_server::Client as _;
 
@@ -39,6 +41,7 @@ impl RegistryGlobals {
 	pub const WL_DRM: u32 = 7;
 	pub const PRESENTATION: u32 = 8;
 	pub const VIEWPORTER: u32 = 9;
+	pub const RELATIVE_POINTER: u32 = 10;
 }
 
 #[derive(Debug, waynest_server::RequestDispatcher, Default)]
@@ -141,6 +144,15 @@ impl Registry {
 		)
 		.await?;
 
+		self.global(
+			client,
+			sender_id,
+			RegistryGlobals::RELATIVE_POINTER,
+			RelativePointerManager::INTERFACE.to_string(),
+			RelativePointerManager::VERSION,
+		)
+		.await?;
+
 		Ok(())
 	}
 }
@@ -225,6 +237,11 @@ impl WlRegistry for Registry {
 
 				client.insert(new_id.object_id, Viewporter::new(new_id.object_id))?;
 			}
+			RegistryGlobals::RELATIVE_POINTER => {
+				tracing::info!("Binding zwp_relative_pointer_manager_v1");
+
+				client.insert(new_id.object_id, RelativePointerManager(new_id.object_id))?;
+			}
 			id => {
 				tracing::error!(id, "Wayland: failed to bind to registry global");
 				return Err(WaylandError::UnknownGlobal(name));

src/wayland/registry.rs

@@ -0,0 +1,77 @@
+use crate::wayland::{WaylandError, WaylandResult, core::pointer::Pointer};
+use mint::Vector2;
+use std::sync::Arc;
+use waynest::ObjectId;
+use waynest_protocols::server::unstable::relative_pointer_unstable_v1::{
+	zwp_relative_pointer_manager_v1::*, zwp_relative_pointer_v1::*,
+};
+use waynest_server::Client as _;
+
+#[derive(Debug, waynest_server::RequestDispatcher)]
+#[waynest(error = crate::wayland::WaylandError, connection = crate::wayland::Client)]
+pub struct RelativePointerManager(pub ObjectId);
+impl ZwpRelativePointerManagerV1 for RelativePointerManager {
+	type Connection = crate::wayland::Client;
+
+	async fn destroy(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+	) -> WaylandResult<()> {
+		client.remove(self.0);
+		Ok(())
+	}
+
+	async fn get_relative_pointer(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		id: ObjectId,
+		pointer: ObjectId,
+	) -> WaylandResult<()> {
+		let Some(pointer) = client.get::<Pointer>(pointer) else {
+			return Err(WaylandError::MissingObject(pointer));
+		};
+
+		let relative_pointer = client.insert(id, RelativePointer(id))?;
+
+		*pointer.relative_pointer.write().await = Arc::downgrade(&relative_pointer);
+
+		Ok(())
+	}
+}
+
+#[derive(Debug, waynest_server::RequestDispatcher)]
+#[waynest(error = crate::wayland::WaylandError, connection = crate::wayland::Client)]
+pub struct RelativePointer(pub ObjectId);
+impl RelativePointer {
+	pub async fn send_relative_motion(
+		&self,
+		client: &mut crate::wayland::Client,
+		delta: Vector2<f32>,
+	) -> WaylandResult<()> {
+		self.relative_motion(
+			client,
+			self.0,
+			0,
+			0,
+			(delta.x as f64).into(),
+			(delta.y as f64).into(),
+			(delta.x as f64).into(),
+			(delta.y as f64).into(),
+		)
+		.await
+	}
+}
+impl ZwpRelativePointerV1 for RelativePointer {
+	type Connection = crate::wayland::Client;
+
+	async fn destroy(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+	) -> WaylandResult<()> {
+		client.remove(self.0);
+		Ok(())
+	}
+}

src/wayland/relative_pointer.rs

@@ -191,17 +191,26 @@ impl Backend for XdgBackend {
 			});
 	}
 
-	fn pointer_motion(&self, surface: &SurfaceId, position: Vector2<f32>) {
-		if let Some(surface) = self.surface_from_id(surface) {
-			let _ = self
-				.toplevel()
-				.wl_surface()
-				.message_sink
-				.send(Message::Seat(SeatMessage::PointerMotion {
-					surface,
-					position,
-				}));
-		}
+	fn absolute_pointer_motion(&self, surface: &SurfaceId, position: Vector2<f32>) {
+		let Some(surface) = self.surface_from_id(surface) else {
+			return;
+		};
+		let _ = self
+			.toplevel()
+			.wl_surface()
+			.message_sink
+			.send(Message::Seat(SeatMessage::AbsolutePointerMotion {
+				surface,
+				position,
+			}));
+	}
+
+	fn relative_pointer_motion(&self, _surface: &SurfaceId, delta: Vector2<f32>) {
+		let _ = self
+			.toplevel()
+			.wl_surface()
+			.message_sink
+			.send(Message::Seat(SeatMessage::RelativePointerMotion { delta }));
 	}
 
 	fn pointer_button(&self, surface: &SurfaceId, button: u32, pressed: bool) {