@desklink/host 0.3.0 → 0.4.0

package/engine/src/clipboard.rs

@@ -97,6 +97,180 @@ pub fn read_or_explain() -> Result<(String, bool), String> {
     }
 }
 
+/// Each operation uses its own connection: capture drains selection events.
+fn x11_window(display: &str) -> Result<(x11rb::rust_connection::RustConnection, u32)> {
+    use x11rb::connection::Connection;
+    use x11rb::protocol::xproto::{ConnectionExt, CreateWindowAux, WindowClass};
+    let (connection, screen) = x11rb::connect(Some(display))?;
+    let window = connection.generate_id()?;
+    connection
+        .create_window(
+            0,
+            window,
+            connection.setup().roots[screen].root,
+            0,
+            0,
+            1,
+            1,
+            0,
+            WindowClass::INPUT_ONLY,
+            0,
+            &CreateWindowAux::new(),
+        )?
+        .check()?;
+    Ok((connection, window))
+}
+
+fn x11_atom(connection: &impl x11rb::connection::Connection, name: &[u8]) -> Result<u32> {
+    use x11rb::protocol::xproto::ConnectionExt;
+    Ok(connection.intern_atom(false, name)?.reply()?.atom)
+}
+
+/// Own CLIPBOARD until another client replaces it, the engine exits, or X dies.
+/// No INCR send: a single bounded property is the entire supported transfer.
+pub fn x11_write(display: &str, text: &str) -> Result<()> {
+    use x11rb::connection::{Connection, RequestConnection};
+    use x11rb::protocol::{xproto::*, Event};
+    use x11rb::wrapper::ConnectionExt as _;
+    anyhow::ensure!(
+        text.len() <= MAX_CLIPBOARD_BYTES,
+        "refusing to place {} bytes on the clipboard",
+        text.len()
+    );
+    let (connection, window) = x11_window(display)?;
+    // Leave room for the ChangeProperty header and alignment padding.
+    anyhow::ensure!(
+        text.len() <= connection.maximum_request_bytes().saturating_sub(28),
+        "clipboard text is too large for one transfer (INCR is unsupported)"
+    );
+    let selection = x11_atom(&connection, b"CLIPBOARD")?;
+    let targets = x11_atom(&connection, b"TARGETS")?;
+    let utf8 = x11_atom(&connection, b"UTF8_STRING")?;
+    let text_target = x11_atom(&connection, b"TEXT")?;
+    connection
+        .set_selection_owner(window, selection, x11rb::CURRENT_TIME)?
+        .check()?;
+    anyhow::ensure!(
+        connection.get_selection_owner(selection)?.reply()?.owner == window,
+        "the X server refused clipboard ownership"
+    );
+    let text = text.to_owned();
+    std::thread::Builder::new()
+        .name(String::from("desklink-x11-clipboard"))
+        .spawn(move || -> Result<()> {
+            loop {
+                match connection.wait_for_event()? {
+                    Event::SelectionClear(_) => break,
+                    Event::SelectionRequest(request) => {
+                        let property = if request.property == x11rb::NONE {
+                            request.target
+                        } else {
+                            request.property
+                        };
+                        let accepted = if request.target == targets {
+                            connection
+                                .change_property32(
+                                    PropMode::REPLACE,
+                                    request.requestor,
+                                    property,
+                                    AtomEnum::ATOM,
+                                    &[targets, utf8, text_target],
+                                )?
+                                .check()
+                                .is_ok()
+                        } else if request.target == utf8 || request.target == text_target {
+                            connection
+                                .change_property8(
+                                    PropMode::REPLACE,
+                                    request.requestor,
+                                    property,
+                                    utf8,
+                                    text.as_bytes(),
+                                )?
+                                .check()
+                                .is_ok()
+                        } else {
+                            false
+                        };
+                        let reply = SelectionNotifyEvent {
+                            response_type: SELECTION_NOTIFY_EVENT,
+                            sequence: 0,
+                            time: request.time,
+                            requestor: request.requestor,
+                            selection: request.selection,
+                            target: request.target,
+                            property: if accepted { property } else { x11rb::NONE },
+                        };
+                        connection.send_event(
+                            false,
+                            request.requestor,
+                            EventMask::NO_EVENT,
+                            reply,
+                        )?;
+                        connection.flush()?;
+                    }
+                    _ => {}
+                }
+            }
+            Ok(())
+        })?;
+    Ok(())
+}
+
+pub fn x11_read(display: &str) -> Result<(String, bool)> {
+    use x11rb::connection::Connection;
+    use x11rb::protocol::{xproto::ConnectionExt, Event};
+    let (connection, window) = x11_window(display)?;
+    let selection = x11_atom(&connection, b"CLIPBOARD")?;
+    anyhow::ensure!(
+        connection.get_selection_owner(selection)?.reply()?.owner != x11rb::NONE,
+        "the desktop clipboard has no text"
+    );
+    let utf8 = x11_atom(&connection, b"UTF8_STRING")?;
+    let incr = x11_atom(&connection, b"INCR")?;
+    let property = x11_atom(&connection, b"DESKLINK_CLIPBOARD")?;
+    connection.convert_selection(window, selection, utf8, property, x11rb::CURRENT_TIME)?;
+    connection.flush()?;
+    let deadline = std::time::Instant::now() + std::time::Duration::from_millis(2500);
+    loop {
+        if let Some(Event::SelectionNotify(event)) = connection.poll_for_event()? {
+            if event.requestor != window || event.selection != selection {
+                continue;
+            }
+            anyhow::ensure!(
+                event.property != x11rb::NONE,
+                "the desktop clipboard has no text"
+            );
+            let reply = connection
+                .get_property(
+                    true,
+                    window,
+                    property,
+                    x11rb::protocol::xproto::AtomEnum::ANY,
+                    0,
+                    (MAX_CLIPBOARD_BYTES / 4 + 1) as u32,
+                )?
+                .reply()?;
+            // ponytail: one property only; implement INCR when larger transfers are needed.
+            anyhow::ensure!(
+                reply.type_ != incr,
+                "clipboard text is too large for one transfer (INCR is unsupported)"
+            );
+            anyhow::ensure!(
+                reply.format == 8 && reply.type_ == utf8,
+                "the clipboard contents are not UTF-8 text"
+            );
+            let (text, truncated) = bounded_text(&reply.value, MAX_CLIPBOARD_BYTES)?;
+            return Ok((text, truncated || reply.bytes_after > 0));
+        }
+        anyhow::ensure!(
+            std::time::Instant::now() < deadline,
+            "the clipboard owner did not answer"
+        );
+        std::thread::sleep(std::time::Duration::from_millis(5));
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

package/engine/src/clipboard_win.rs

@@ -0,0 +1,8 @@
+//! Windows clipboard seam. This build never reads or writes the clipboard.
+pub const MAX_CLIPBOARD_BYTES: usize = 256 * 1024;
+pub fn read_or_explain() -> Result<(String, bool), String> {
+    Err("Windows clipboard transfer is not implemented in this build.".into())
+}
+pub fn write(_text: &str) -> anyhow::Result<()> {
+    anyhow::bail!("Windows clipboard transfer is not implemented in this build.")
+}

package/engine/src/cursor.rs

@@ -0,0 +1,118 @@
+//! Cursor metadata is independent of pixel damage and never painted into video.
+use crate::protocol::{timestamp_us, CursorPosition};
+use std::time::Instant;
+
+pub type CursorSink = Box<dyn Fn(CursorPosition) + Send + 'static>;
+
+pub struct Reporter {
+    sink: CursorSink,
+    last: Option<(i32, i32, bool)>,
+    bitmap_visible: bool,
+}
+impl Reporter {
+    pub fn new(sink: CursorSink) -> Self {
+        Self {
+            sink,
+            last: None,
+            bitmap_visible: true,
+        }
+    }
+    pub fn update_spa(
+        &mut self,
+        meta: &pipewire::spa::sys::spa_meta_cursor,
+        bitmap: Option<&pipewire::spa::sys::spa_meta_bitmap>,
+        width: usize,
+        height: usize,
+    ) {
+        // SPA id zero is no new data, not a visibility change.
+        if meta.id == 0 {
+            return;
+        }
+        if let Some(bitmap) = bitmap.filter(|b| b.format != 0) {
+            self.bitmap_visible = bitmap.offset != 0;
+        }
+        let (x, y) = (meta.position.x, meta.position.y);
+        self.update(
+            x,
+            y,
+            self.bitmap_visible
+                && x >= 0
+                && y >= 0
+                && (x as usize) < width
+                && (y as usize) < height,
+        );
+    }
+    pub fn update(&mut self, x: i32, y: i32, visible: bool) {
+        if self.last == Some((x, y, visible)) {
+            return;
+        }
+        self.last = Some((x, y, visible));
+        (self.sink)(CursorPosition {
+            x,
+            y,
+            visible,
+            timestamp_us: timestamp_us(Instant::now()),
+        });
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn spa_no_update_off_source_and_invisible_bitmap_are_distinct() {
+        use pipewire::spa::sys::{spa_meta_bitmap, spa_meta_cursor, spa_point, spa_rectangle};
+        let (tx, rx) = std::sync::mpsc::channel();
+        let mut reporter = Reporter::new(Box::new(move |p| {
+            tx.send(p).unwrap();
+        }));
+        let mut meta = spa_meta_cursor {
+            id: 1,
+            flags: 0,
+            position: spa_point { x: 40, y: 60 },
+            hotspot: spa_point { x: 2, y: 3 },
+            bitmap_offset: 0,
+        };
+        reporter.update_spa(&meta, None, 800, 600);
+        meta.id = 0;
+        reporter.update_spa(&meta, None, 800, 600);
+        assert_eq!(rx.try_iter().count(), 1);
+        meta.id = 1;
+        meta.position.x = -1;
+        reporter.update_spa(&meta, None, 800, 600);
+        assert!(!rx.try_recv().unwrap().visible);
+        meta.position.x = 40;
+        let bitmap = spa_meta_bitmap {
+            format: 1,
+            size: spa_rectangle {
+                width: 16,
+                height: 16,
+            },
+            stride: 64,
+            offset: 0,
+        };
+        reporter.update_spa(&meta, Some(&bitmap), 800, 600);
+        assert!(!rx.try_recv().unwrap().visible);
+        reporter.update_spa(&meta, None, 800, 600);
+        assert!(rx.try_recv().is_err(), "no new bitmap retains invisibility");
+    }
+
+    #[test]
+    fn reports_initial_motion_and_visibility_but_not_unchanged_polls() {
+        let (tx, rx) = std::sync::mpsc::channel();
+        let mut reporter = Reporter::new(Box::new(move |p| {
+            tx.send(p).unwrap();
+        }));
+        reporter.update(10, 20, true);
+        reporter.update(10, 20, true);
+        reporter.update(30, 40, true);
+        reporter.update(30, 40, false);
+        let notices: Vec<_> = rx.try_iter().collect();
+        assert_eq!(notices.len(), 3);
+        assert_eq!((notices[1].x, notices[1].y), (30, 40));
+        assert!(!notices[2].visible);
+        assert!(notices
+            .windows(2)
+            .all(|p| p[0].timestamp_us <= p[1].timestamp_us));
+    }
+}

package/engine/src/indicator.rs

@@ -4,6 +4,89 @@ use anyhow::{Context, Result};
 use std::io::{BufRead, BufReader, Write};
 use std::process::{Child, ChildStdin, Command, Stdio};
 
+/// One drawn state of the X11 agent cue, announced by the helper before it
+/// reaches the screen: the window's origin and size plus the inputs of
+/// `desklink_indicator_covered`.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Cue {
+    pub x: i64,
+    pub y: i64,
+    pub size: i64,
+    pub unit: f64,
+    pub opacity: f64,
+    pub click: f64,
+    pub typed: f64,
+    pub threshold: u32,
+    /// Logical radius drawn so far while the shaped cue appears or leaves.
+    pub reveal: f64,
+}
+
+impl Cue {
+    fn parse(line: &str) -> Option<Self> {
+        let mut parts = line.strip_prefix("P ")?.split(' ');
+        let mut next = || parts.next();
+        Some(Self {
+            x: next()?.parse().ok()?,
+            y: next()?.parse().ok()?,
+            size: next()?
+                .parse()
+                .ok()
+                .filter(|size| (1..=1024).contains(size))?,
+            unit: next()?
+                .parse()
+                .ok()
+                .filter(|unit: &f64| unit.is_finite() && *unit > 0.0)?,
+            opacity: next()?.parse().ok()?,
+            click: next()?.parse().ok()?,
+            typed: next()?.parse().ok()?,
+            threshold: next()?.parse().ok()?,
+            reveal: next()?.parse().ok()?,
+        })
+    }
+}
+
+/// The X11 agent cue's announcements, read by the capture loop itself. The
+/// helper writes each state before drawing it, so everything a grab can
+/// contain is already in the pipe when the grab returns.
+#[derive(Default)]
+pub struct CueFeed {
+    reader: Option<BufReader<std::process::ChildStdout>>,
+    line: Vec<u8>,
+    recent: Vec<Cue>,
+}
+
+impl CueFeed {
+    /// The last two states (the newer may not be drawn yet) plus every state
+    /// announced since the previous call.
+    pub fn drain(&mut self) -> Vec<Cue> {
+        let mut states = self.recent.clone();
+        while let Some(reader) = self.reader.as_mut() {
+            match reader.read_until(b'\n', &mut self.line) {
+                Ok(_) if self.line.ends_with(b"\n") => {
+                    if let Some(cue) = Cue::parse(String::from_utf8_lossy(&self.line).trim()) {
+                        states.push(cue);
+                        self.recent.push(cue);
+                        if self.recent.len() > 2 {
+                            self.recent.remove(0);
+                        }
+                    }
+                    self.line.clear();
+                }
+                Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => break,
+                Err(error) if error.kind() == std::io::ErrorKind::Interrupted => {}
+                // The helper exited, and it closes its window before that.
+                _ => {
+                    self.reader = None;
+                    self.recent.clear();
+                }
+            }
+        }
+        states
+    }
+}
+
+pub type Cues = std::sync::Arc<std::sync::Mutex<CueFeed>>;
+
 pub struct Indicator {
     child: Option<Child>,
     input: Option<ChildStdin>,
@@ -11,9 +94,33 @@ pub struct Indicator {
     scale_y: f64,
     #[cfg(target_os = "linux")]
     position: std::sync::Arc<std::sync::Mutex<Option<(i64, i64)>>>,
+    cues: Cues,
+}
+
+#[cfg(target_os = "linux")]
+fn point_wayland_executable() -> Result<std::path::PathBuf> {
+    #[cfg(test)]
+    if let Some(path) = std::env::var_os("DESKLINK_POINT_TEST_ENGINE") {
+        return Ok(path.into());
+    }
+    Ok(std::env::current_exe()?)
 }
 
 impl Indicator {
+    #[cfg(target_os = "linux")]
+    pub fn wayland_layer_shell_available() -> Result<bool> {
+        let mut command = Command::new(point_wayland_executable()?);
+        command.arg("point-layer-shell-probe");
+        match Self::spawn(&mut command, 1.0, 1.0) {
+            Ok(helper) => {
+                helper.stop();
+                Ok(true)
+            }
+            Err(error) if error.to_string().contains("layer_shell_unavailable") => Ok(false),
+            Err(error) => Err(error),
+        }
+    }
+
     #[cfg(target_os = "macos")]
     pub fn start(display_id: u32, width: usize, height: usize) -> Result<Self> {
         let executable = std::env::current_exe()?;
@@ -39,6 +146,77 @@ impl Indicator {
         )
     }
 
+    #[cfg(target_os = "linux")]
+    pub fn start_point(display: &str) -> Result<Self> {
+        Self::spawn(
+            Command::new(std::env::current_exe()?)
+                .arg("point-overlay")
+                .arg(display),
+            1.0,
+            1.0,
+        )
+    }
+
+    #[cfg(target_os = "linux")]
+    pub fn start_point_wayland(
+        width: i32,
+        height: i32,
+        position: Option<(i32, i32)>,
+    ) -> Result<Self> {
+        let (x, y) = position.unwrap_or_default();
+        Self::spawn(
+            Command::new(point_wayland_executable()?)
+                .arg("point-overlay-wayland")
+                .args([
+                    width.to_string(),
+                    height.to_string(),
+                    i32::from(position.is_some()).to_string(),
+                    x.to_string(),
+                    y.to_string(),
+                ]),
+            1.0,
+            1.0,
+        )
+    }
+
+    #[cfg(target_os = "macos")]
+    pub fn start_point(display_id: u32, width: usize, height: usize) -> Result<Self> {
+        let (_, _, points_w, points_h) = crate::mac::display_geometry(display_id)
+            .context("the selected display is unavailable")?;
+        Self::spawn(
+            Command::new(std::env::current_exe()?)
+                .arg("point-overlay")
+                .arg(display_id.to_string()),
+            points_w / width as f64,
+            points_h / height as f64,
+        )
+    }
+
+    #[cfg(all(test, target_os = "linux"))]
+    pub fn test_pid(&self) -> u32 {
+        self.child.as_ref().unwrap().id()
+    }
+
+    pub fn point(&mut self, x: i64, y: i64, timeout_ms: u64, label: &str) -> Result<()> {
+        let input = self.input.as_mut().context("point overlay exited")?;
+        writeln!(
+            input,
+            "P {:.2} {:.2} {timeout_ms} {label}",
+            x as f64 * self.scale_x,
+            y as f64 * self.scale_y
+        )?;
+        Ok(())
+    }
+
+    /// Point markers have no fade: close/clear must remove them and reap the helper.
+    pub fn stop(mut self) {
+        self.input.take();
+        if let Some(mut child) = self.child.take() {
+            let _ = child.kill();
+            let _ = child.wait();
+        }
+    }
+
     #[cfg(target_os = "linux")]
     pub fn start_wayland(width: usize, height: usize) -> Result<Self> {
         let executable = std::env::current_exe()?;
@@ -67,17 +245,42 @@ impl Indicator {
         let stdout = child.stdout.take().unwrap();
         let (ready_tx, ready_rx) = std::sync::mpsc::channel();
         let reader = std::thread::spawn(move || {
+            let mut reader = BufReader::new(stdout);
             let mut ready = String::new();
-            let result = BufReader::new(stdout).read_line(&mut ready);
-            let _ = ready_tx.send(result.is_ok() && ready.trim() == "READY");
+            let _ = reader.read_line(&mut ready);
+            let _ = ready_tx.send((ready.trim().to_owned(), reader));
         });
-        if ready_rx.recv_timeout(std::time::Duration::from_secs(5)) != Ok(true) {
+        let (ready, reader_after) = match ready_rx.recv_timeout(std::time::Duration::from_secs(5)) {
+            Ok((ready, reader)) => (ready, Some(reader)),
+            Err(_) => (String::new(), None),
+        };
+        if ready != "READY" {
             let _ = child.kill();
             let _ = child.wait();
             let _ = reader.join();
-            anyhow::bail!("agent indicator did not open its overlay within 5s");
+            anyhow::bail!("agent indicator did not open its overlay within 5s: {ready}");
+        }
+        drop(reader);
+        // Only the X11 agent cue writes after READY, and only its capture loop
+        // reads; the helper blocks on a full pipe rather than draw unannounced.
+        let cues = Cues::default();
+        #[cfg(not(unix))]
+        drop(reader_after);
+        #[cfg(unix)]
+        if let Some(reader) = reader_after {
+            use std::os::fd::AsRawFd;
+            let fd = reader.get_ref().as_raw_fd();
+            unsafe {
+                libc::fcntl(
+                    fd,
+                    libc::F_SETFL,
+                    libc::fcntl(fd, libc::F_GETFL) | libc::O_NONBLOCK,
+                )
+            };
+            if let Ok(mut feed) = cues.lock() {
+                feed.reader = Some(reader);
+            }
         }
-        let _ = reader.join();
         Ok(Self {
             input: child.stdin.take(),
             child: Some(child),
@@ -85,9 +288,14 @@ impl Indicator {
             scale_y,
             #[cfg(target_os = "linux")]
             position: Default::default(),
+            cues,
         })
     }
 
+    pub fn cues(&self) -> Cues {
+        self.cues.clone()
+    }
+
     #[cfg(target_os = "macos")]
     pub fn pid(&self) -> u32 {
         self.child.as_ref().unwrap().id()
@@ -114,8 +322,12 @@ impl Drop for Indicator {
         // Closing stdin fades the edge and exits; do not wait for the animation.
         self.input.take();
         if let Some(mut child) = self.child.take() {
+            // Keep reading the cue's pipe open until it exits, so it can
+            // still animate out; it leaves at once only when the engine does.
+            let cues = self.cues.clone();
             std::thread::spawn(move || {
                 let _ = child.wait();
+                drop(cues);
             });
         }
     }
@@ -123,6 +335,60 @@ impl Drop for Indicator {
 
 #[cfg(all(test, target_os = "linux"))]
 mod tests {
+    #[test]
+    fn cue_feed_keeps_recent_states_until_the_helper_exits() {
+        use std::os::fd::AsRawFd;
+        let mut child = std::process::Command::new("sh")
+            .args([
+                "-c",
+                "for x in 1 2 3; do echo \"P $x 0 110 1 1 -1 -1 128 99\"; done; read _",
+            ])
+            .stdin(std::process::Stdio::piped())
+            .stdout(std::process::Stdio::piped())
+            .spawn()
+            .unwrap();
+        let reader = super::BufReader::new(child.stdout.take().unwrap());
+        let fd = reader.get_ref().as_raw_fd();
+        unsafe {
+            libc::fcntl(
+                fd,
+                libc::F_SETFL,
+                libc::fcntl(fd, libc::F_GETFL) | libc::O_NONBLOCK,
+            )
+        };
+        let mut feed = super::CueFeed {
+            reader: Some(reader),
+            ..Default::default()
+        };
+        let mut drained = vec![];
+        for _ in 0..200 {
+            drained.extend(feed.drain().into_iter().map(|cue| cue.x));
+            if drained.len() >= 3 {
+                break;
+            }
+            std::thread::sleep(std::time::Duration::from_millis(10));
+        }
+        assert_eq!(
+            drained,
+            [1, 2, 3],
+            "a drain that finds nothing does not block"
+        );
+        let xs =
+            |feed: &mut super::CueFeed| feed.drain().iter().map(|cue| cue.x).collect::<Vec<_>>();
+        assert_eq!(
+            xs(&mut feed),
+            [2, 3],
+            "either of the last two may be on screen"
+        );
+        drop(child.stdin.take());
+        child.wait().unwrap();
+        assert_eq!(xs(&mut feed), [2, 3]);
+        assert!(
+            xs(&mut feed).is_empty(),
+            "a closed helper has no window left"
+        );
+    }
+
     unsafe extern "C" {
         fn desklink_wayland_geometry(
             source_w: i32,