fix: handle Wayland guest grabs and transient empty echoes

Author: thelicato

src/viewer/clipboard.rs

@@ -187,6 +187,7 @@ struct SelectionUiState {
     ignored_remote_content: Option<ClipboardContent>,
     last_seen_content: Option<ClipboardContent>,
     pending_guest_content: Option<ClipboardContent>,
+    awaiting_remote_echo: bool,
 }
 
 impl ClipboardUiState {
@@ -262,9 +263,17 @@ pub(super) fn install_host_clipboard_bridge(
         let input_tx = input_tx.clone();
         move |_| {
             debug("viewer focus entered");
+            let _ = input_tx.send(InputEvent::ClipboardViewerFocused(true));
             refresh_clipboard_state(&picture, &ui_state, &input_tx)
         }
     });
+    focus.connect_leave({
+        let input_tx = input_tx.clone();
+        move |_| {
+            debug("viewer focus left");
+            let _ = input_tx.send(InputEvent::ClipboardViewerFocused(false));
+        }
+    });
     picture.add_controller(focus);
 
     let paste_shortcuts = gtk::EventControllerKey::new();
@@ -293,6 +302,9 @@ pub(super) fn install_host_clipboard_bridge(
             if window.is_active() {
                 debug("window became active");
                 refresh_clipboard_state(&picture, &ui_state, &input_tx);
+            } else {
+                debug("window became inactive");
+                let _ = input_tx.send(InputEvent::ClipboardViewerFocused(false));
             }
         }
     });
@@ -330,6 +342,7 @@ pub(super) fn apply_guest_clipboard(
         selection_state.ignored_remote_content = Some(content.clone());
         selection_state.last_seen_content = (!content.is_empty()).then_some(content.clone());
         selection_state.pending_guest_content = None;
+        selection_state.awaiting_remote_echo = true;
     }
     debug(format!("gtk set_content succeeded for {selection:?}"));
     Ok(())
@@ -373,6 +386,14 @@ pub(super) struct ClipboardSession {
 }
 
 impl ClipboardSession {
+    pub(super) fn set_viewer_focused(&self, focused: bool) {
+        let mut shared = self.shared.lock().expect("clipboard mutex was poisoned");
+        if shared.viewer_focused != focused {
+            shared.viewer_focused = focused;
+            debug(format!("viewer clipboard focus -> {focused}"));
+        }
+    }
+
     /// Publish the current host clipboard to the guest or release ownership if
     /// the host selection no longer contains any MIME types QD2 can forward.
     pub(super) async fn update_host_content(
@@ -468,10 +489,24 @@ impl ClipboardSession {
     }
 }
 
+fn should_accept_remote_grab(
+    current_serial: u32,
+    local_owner: bool,
+    viewer_focused: bool,
+    incoming_serial: u32,
+) -> bool {
+    if viewer_focused && local_owner {
+        return true;
+    }
+
+    incoming_serial > current_serial || (incoming_serial == current_serial && !local_owner)
+}
+
 #[derive(Default)]
 struct ClipboardBridgeState {
     clipboard: SelectionBridgeState,
     primary: SelectionBridgeState,
+    viewer_focused: bool,
 }
 
 #[derive(Default)]
@@ -547,22 +582,35 @@ impl ClipboardHandler for ClipboardListener {
 
         {
             let mut shared = self.shared.lock().expect("clipboard mutex was poisoned");
+            let viewer_focused = shared.viewer_focused;
             let Some(selection_state) = shared.selection_mut(selection) else {
                 debug(format!(
                     "ignoring unsupported guest clipboard selection {selection:?}"
                 ));
                 return;
             };
 
-            if serial < selection_state.current_serial
-                || (serial == selection_state.current_serial && selection_state.local_owner)
-            {
+            if !should_accept_remote_grab(
+                selection_state.current_serial,
+                selection_state.local_owner,
+                viewer_focused,
+                serial,
+            ) {
                 debug(format!(
                     "ignoring stale/conflicting grab: current_serial={} local_owner={}",
                     selection_state.current_serial, selection_state.local_owner
                 ));
                 return;
             }
+            if viewer_focused
+                && selection_state.local_owner
+                && serial <= selection_state.current_serial
+            {
+                debug(format!(
+                    "accepting guest grab while viewer is focused despite local serial {}",
+                    selection_state.current_serial
+                ));
+            }
             selection_state.current_serial = serial;
             selection_state.local_owner = false;
         }
@@ -939,10 +987,23 @@ fn finish_host_snapshot(
             "ignoring GTK clipboard echo from remote-set content for {selection:?}"
         ));
         selection_state.ignored_remote_content = None;
+        selection_state.awaiting_remote_echo = false;
         selection_state.last_seen_content = (!content.is_empty()).then_some(content);
         return;
     }
 
+    if selection_state.awaiting_remote_echo && content.is_empty() {
+        debug(format!(
+            "ignoring transient empty GTK clipboard snapshot after remote set for {selection:?}"
+        ));
+        return;
+    }
+
+    if selection_state.awaiting_remote_echo {
+        selection_state.awaiting_remote_echo = false;
+        selection_state.ignored_remote_content = None;
+    }
+
     if selection_state.last_seen_content.as_ref() == Some(&content) {
         debug(format!("gtk clipboard content unchanged for {selection:?}"));
         return;
@@ -1106,7 +1167,7 @@ mod tests {
     use super::{
         ClipboardContent, ClipboardSelection, IMAGE_PNG, STRING, TEXT, TEXT_HTML, TEXT_PLAIN,
         TEXT_PLAIN_UTF8, TEXT_URI_LIST, UTF8_STRING, canonical_rich_mime,
-        preferred_text_request_mimes, remote_fetch_plan,
+        preferred_text_request_mimes, remote_fetch_plan, should_accept_remote_grab,
     };
 
     #[test]
@@ -1188,4 +1249,11 @@ mod tests {
         assert_eq!(ClipboardSelection::Primary as u32, 1);
         assert_eq!(plan[0].requested_mimes, vec![TEXT_PLAIN_UTF8]);
     }
+
+    #[test]
+    fn focused_viewer_allows_guest_grab_to_override_local_owner() {
+        assert!(should_accept_remote_grab(5, true, true, 0));
+        assert!(!should_accept_remote_grab(5, true, false, 0));
+        assert!(should_accept_remote_grab(5, false, false, 6));
+    }
 }

src/viewer/listener/remote.rs

@@ -91,7 +91,9 @@ impl RemoteConsole {
                 .release(keycode)
                 .await
                 .with_context(|| format!("failed to send key release for qnum {keycode}")),
-            InputEvent::ClipboardHostChanged(_, _) => Ok(()),
+            InputEvent::ClipboardViewerFocused(_) | InputEvent::ClipboardHostChanged(_, _) => {
+                Ok(())
+            }
             InputEvent::MousePress(button) => self
                 .mouse
                 .press(button)

src/viewer/listener/session.rs

@@ -101,6 +101,14 @@ pub(super) async fn listener_session(
             }
             maybe_input = input_rx.recv() => match maybe_input {
                 Some(input) => {
+                    if let InputEvent::ClipboardViewerFocused(focused) = &input {
+                        clipboard::debug(format!("listener received ClipboardViewerFocused({focused})"));
+                        if let Some(clipboard) = &clipboard {
+                            clipboard.set_viewer_focused(*focused);
+                        }
+                        continue;
+                    }
+
                     if let InputEvent::ClipboardHostChanged(selection, content) = &input {
                         clipboard::debug(format!(
                             "listener received ClipboardHostChanged selection={selection:?}: {}",

src/viewer/mod.rs

@@ -972,6 +972,7 @@ enum ViewerEvent {
 enum InputEvent {
     KeyPress(u32),
     KeyRelease(u32),
+    ClipboardViewerFocused(bool),
     ClipboardHostChanged(ClipboardSelection, Option<clipboard::ClipboardContent>),
     MousePress(MouseButton),
     MouseRelease(MouseButton),