fix: absolute cursor position on scaled outputs

Author: hojjatabdollahi

src/remote_desktop.rs

@@ -30,6 +30,7 @@ pub(crate) struct RemoteDesktopData {
     pub(crate) screen_cast_enabled: bool,
     restore: Option<PersistedRemoteDesktop>,
     pub(crate) ei_sender: Option<EiSender>,
+    pub(crate) stream_offsets: Vec<(u32, (i32, i32))>,
 }
 
 impl Default for RemoteDesktopData {
@@ -42,6 +43,7 @@ impl Default for RemoteDesktopData {
             screen_cast_enabled: false,
             restore: None,
             ei_sender: None,
+            stream_offsets: Vec::new(),
         }
     }
 }
@@ -166,6 +168,32 @@ impl RemoteDesktop {
         }
     }
 
+    /// The global logical offset of a stream (the captured output's position).
+    /// Defaults to (0, 0) if the stream is unknown.
+    async fn stream_offset(
+        &self,
+        connection: &zbus::Connection,
+        session_handle: &zvariant::ObjectPath<'_>,
+        stream: u32,
+    ) -> (i32, i32) {
+        let Some(interface) =
+            crate::session_interface::<SessionData>(connection, session_handle).await
+        else {
+            return (0, 0);
+        };
+        let session_data = interface.get().await;
+        session_data
+            .remote_desktop
+            .as_ref()
+            .and_then(|rd| {
+                rd.stream_offsets
+                    .iter()
+                    .find(|(node, _)| *node == stream)
+                    .map(|(_, off)| *off)
+            })
+            .unwrap_or((0, 0))
+    }
+
     async fn notify(
         &self,
         connection: &zbus::Connection,
@@ -377,6 +405,16 @@ impl RemoteDesktop {
                 .into()
             });
 
+            // Record each stream's global logical offset so absolute pointer input
+            // (sent in a stream's local space) can be mapped to global coordinates.
+            let stream_offsets: Vec<(u32, (i32, i32))> = streams
+                .iter()
+                .map(|(node, props)| (*node, props.position().unwrap_or((0, 0))))
+                .collect();
+            if let Some(remote_desktop) = interface.get_mut().await.remote_desktop.as_mut() {
+                remote_desktop.stream_offsets = stream_offsets;
+            }
+
             PortalResponse::Success(StartResult {
                 devices: device_types,
                 clipboard_enabled,
@@ -442,14 +480,19 @@ impl RemoteDesktop {
         #[zbus(connection)] connection: &zbus::Connection,
         session_handle: zvariant::ObjectPath<'_>,
         _options: HashMap<String, zvariant::OwnedValue>,
-        _stream: u32,
+        stream: u32,
         x: f64,
         y: f64,
     ) {
+        // The coordinates are in the chosen stream's (output's) local space. Resolve
+        // that output's global offset so the EI sender can produce a global position.
+        let offset = self
+            .stream_offset(connection, &session_handle, stream)
+            .await;
         self.notify(
             connection,
             &session_handle,
-            Command::PointerMotionAbsolute { x, y },
+            Command::PointerMotionAbsolute { x, y, offset },
         )
         .await;
     }

src/remote_desktop_ei.rs

@@ -16,7 +16,7 @@ use crate::remote_desktop::{DEVICE_KEYBOARD, DEVICE_POINTER, DEVICE_TOUCHSCREEN}
 #[derive(Debug)]
 pub enum Command {
     PointerMotion { dx: f64, dy: f64 },
-    PointerMotionAbsolute { x: f64, y: f64 },
+    PointerMotionAbsolute { x: f64, y: f64, offset: (i32, i32) },
     PointerButton { button: i32, state: u32 },
     PointerAxis { dx: f64, dy: f64 },
     PointerAxisDiscrete { axis: u32, steps: i32 },
@@ -115,6 +115,7 @@ struct State {
     connection: reis::event::Connection,
     caps: BitFlags<DeviceCapability>,
     devices: HashMap<Device, DeviceState>,
+    abs_regions: Vec<(i32, i32, f64)>,
 }
 
 async fn run(
@@ -127,6 +128,7 @@ async fn run(
         connection,
         caps,
         devices: HashMap::new(),
+        abs_regions: Vec::new(),
     };
     loop {
         tokio::select! {
@@ -155,6 +157,16 @@ impl State {
                 let _ = self.connection.flush();
             }
             EiEvent::DeviceAdded(evt) => {
+                let mut regions = Vec::new();
+                for r in evt.device.regions() {
+                    regions.push((r.x as i32, r.y as i32, r.scale as f64));
+                }
+                if !regions.is_empty() {
+                    // The compositor recreates the absolute-pointer device with a fresh
+                    // region per output whenever an output's scale or geometry changes, so
+                    // replace the stale set rather than accumulating across re-adds.
+                    self.abs_regions = regions;
+                }
                 self.devices.insert(
                     evt.device,
                     DeviceState {
@@ -207,10 +219,22 @@ impl State {
                     p.motion_relative(dx as f32, dy as f32);
                 });
             }
-            // `stream` (which output) is ignored for now; treat as a single space.
-            Command::PointerMotionAbsolute { x, y } => {
+            Command::PointerMotionAbsolute { x, y, offset } => {
+                // `x`/`y` arrive in the stream's *physical* pixel space (we advertise the
+                // physical size to the consumer so it maps 1:1 over the video). Convert to
+                // the compositor's logical space by dividing by the output scale, taken from
+                // the EI absolute-pointer region whose offset matches this stream, then add
+                // the stream's global logical offset.
+                let scale = self
+                    .abs_regions
+                    .iter()
+                    .find(|(rx, ry, _)| *rx == offset.0 && *ry == offset.1)
+                    .map(|(_, _, s)| *s)
+                    .unwrap_or(1.0);
+                let ex = (offset.0 as f64 + x / scale) as f32;
+                let ey = (offset.1 as f64 + y / scale) as f32;
                 self.emit::<ei::PointerAbsolute, _>(serial, time, |p| {
-                    p.motion_absolute(x as f32, y as f32);
+                    p.motion_absolute(ex, ey);
                 });
             }
             Command::PointerButton { button, state } => {

src/screencast.rs

@@ -149,6 +149,14 @@ pub struct StreamProps {
     mapping_id: Option<String>,
 }
 
+impl StreamProps {
+    /// The stream's global logical offset (the captured output's position in the
+    /// compositor layout), used to map absolute input to global coordinates.
+    pub fn position(&self) -> Option<(i32, i32)> {
+        self.position
+    }
+}
+
 #[derive(zvariant::SerializeDict, zvariant::Type)]
 #[zvariant(signature = "a{sv}")]
 struct StartResult {
@@ -270,7 +278,18 @@ pub(crate) async fn capture_from_sources(
     for output in &capture_sources.outputs {
         let info = wayland_helper.output_info(output);
         let (position, size) = if let Some(info) = info {
-            (info.logical_position, info.logical_size.unwrap_or((0, 0)))
+            // Advertise the *physical* (current-mode) size, matching the actual video
+            // buffer, so the consumer maps absolute pointer input 1:1 over the video.
+            // The portal converts these physical coordinates back to the compositor's
+            // logical space on input
+            let physical = info
+                .modes
+                .iter()
+                .find(|m| m.current)
+                .map(|m| m.dimensions)
+                .or(info.logical_size)
+                .unwrap_or((0, 0));
+            (info.logical_position, physical)
         } else {
             (Some((0, 0)), (0, 0))
         };