`3b2ee0c`

clipboard: add file URI support for clipboard persistence

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 3 months ago

SHA: 3b2ee0cea19347d866287777666b698806bed8b8
Parents: a76ef42
Tree: dd69bf6

8 changed files

Status	File	+	-
M	`Cargo.lock`	6	6
M	`garclip/src/clipboard/entry.rs`	59	0
M	`garclip/src/clipboard/filter.rs`	8	0
M	`garclip/src/clipboard/history.rs`	4	0
M	`garclip/src/daemon/state.rs`	13	0
M	`garclip/src/ipc/protocol.rs`	8	0
M	`garclip/src/x11/atoms.rs`	36	0
M	`garclip/src/x11/transfer.rs`	121	2

Cargo.lockmodified

  [[package]]
  name = "garclip"
 -version = "0.1.0"
 +version = "0.2.0"
  dependencies = [
   "anyhow",
   "base64",
  [[package]]
  name = "garclip-picker"
 -version = "0.1.0"
 +version = "0.2.0"
  dependencies = [
   "anyhow",
   "garclip",
  [[package]]
  name = "garclipctl"
 -version = "0.1.0"
 +version = "0.2.0"
  dependencies = [
   "anyhow",
   "clap",
  [[package]]
  name = "gartk-core"
 -version = "0.1.0"
 +version = "0.3.0"
  dependencies = [
   "serde",
   "thiserror",
  [[package]]
  name = "gartk-render"
 -version = "0.1.0"
 +version = "0.3.0"
  dependencies = [
   "cairo-rs",
   "gartk-core",
  [[package]]
  name = "gartk-x11"
 -version = "0.1.0"
 +version = "0.3.0"
  dependencies = [
   "gartk-core",
   "thiserror",

garclip/src/clipboard/entry.rsmodified

          /// MIME type (e.g., "image/png")
          mime_type: String,
      },
++
 +    /// File URIs (for file manager copy/paste)
 +    Files {
 +        /// File URIs (e.g., "file:///home/user/file.txt")
 +        uris: Vec<String>,
 +        /// Whether this is a cut operation (move vs copy)
 +        is_cut: bool,
 +    },
+ }
  impl ClipboardContent {
              ClipboardContent::Image { data, mime_type } => {
                  format!("[Image: {}, {} bytes]", mime_type, data.len())
+             }
 +            ClipboardContent::Files { uris, is_cut } => {
 +                let action = if *is_cut { "Cut" } else { "Copy" };
 +                let count = uris.len();
 +                if count == 1 {
 +                    // Show the filename for single file
 +                    let path = uris[0].strip_prefix("file://").unwrap_or(&uris[0]);
 +                    let name = std::path::Path::new(path)
 +                        .file_name()
 +                        .map(|n| n.to_string_lossy())
 +                        .unwrap_or_else(|| path.into());
 +                    format!("[{}: {}]", action, name)
 +                } else {
 +                    format!("[{}: {} files]", action, count)
 +                }
 +            }
+         }
+     }
          matches!(self, ClipboardContent::Image { .. })
+     }
 +    /// Check if this content is file URIs
 +    pub fn is_files(&self) -> bool {
 +        matches!(self, ClipboardContent::Files { .. })
 +    }
++
      /// Get text content if this is text
      pub fn as_text(&self) -> Option<&str> {
          match self {
+         }
+     }
 +    /// Get file URIs if this is files
 +    pub fn as_files(&self) -> Option<(&[String], bool)> {
 +        match self {
 +            ClipboardContent::Files { uris, is_cut } => Some((uris, *is_cut)),
 +            _ => None,
 +        }
 +    }
++
      /// Get the content hash for deduplication
      pub fn hash(&self) -> String {
          match self {
                  let hash = blake3::hash(data);
                  hash.to_hex().to_string()
+             }
 +            ClipboardContent::Files { uris, is_cut } => {
 +                // Hash URIs and cut flag together
 +                let mut hasher = blake3::Hasher::new();
 +                for uri in uris {
 +                    hasher.update(uri.as_bytes());
 +                    hasher.update(b"\n");
 +                }
 +                hasher.update(if *is_cut { b"cut" } else { b"copy" });
 +                hasher.finalize().to_hex().to_string()
 +            }
+         }
+     }
          match self {
              ClipboardContent::Text(text) => text.len(),
              ClipboardContent::Image { data, .. } => data.len(),
 +            ClipboardContent::Files { uris, .. } => {
 +                uris.iter().map(|u| u.len()).sum()
 +            }
+         }
+     }
+ }
                      mime_type: mb,
                  },
              ) => a == b && ma == mb,
 +            (
 +                ClipboardContent::Files {
 +                    uris: a,
 +                    is_cut: ca,
 +                },
 +                ClipboardContent::Files {
 +                    uris: b,
 +                    is_cut: cb,
 +                },
 +            ) => a == b && ca == cb,
              _ => false,
+         }
+     }

garclip/src/clipboard/filter.rsmodified

          match content {
              ClipboardContent::Text(text) => self.should_filter_text(text),
              ClipboardContent::Image { data, .. } => self.should_filter_image(data),
 +            ClipboardContent::Files { uris, .. } => {
 +                // Never filter file URIs - they're important
 +                if uris.is_empty() {
 +                    tracing::debug!("Filtering empty file list");
 +                    return true;
 +                }
 +                false
 +            }
+         }
+     }

garclip/src/clipboard/history.rsmodified

              .filter(|e| match &e.content {
                  ClipboardContent::Text(text) => text.to_lowercase().contains(&query_lower),
                  ClipboardContent::Image { .. } => false,
 +                ClipboardContent::Files { uris, .. } => {
 +                    // Search by file paths/names
 +                    uris.iter().any(|uri| uri.to_lowercase().contains(&query_lower))
 +                }
              })
              .take(limit)
              .collect()

garclip/src/daemon/state.rsmodified

                      text: Some(text.clone()),
                      image_data: None,
                      mime_type: None,
 +                    file_uris: None,
 +                    is_cut: None,
                  },
                  ClipboardContent::Image { data, mime_type } => PasteResponse {
                      id: entry.id,
                      text: None,
                      image_data: Some(STANDARD.encode(data)),
                      mime_type: Some(mime_type.clone()),
 +                    file_uris: None,
 +                    is_cut: None,
 +                },
 +                ClipboardContent::Files { uris, is_cut } => PasteResponse {
 +                    id: entry.id,
 +                    content_type: "files".to_string(),
 +                    text: None,
 +                    image_data: None,
 +                    mime_type: None,
 +                    file_uris: Some(uris.clone()),
 +                    is_cut: Some(*is_cut),
                  },
              };
              Response::ok_with_data(response)

garclip/src/ipc/protocol.rsmodified

      /// Image MIME type (if image)
      #[serde(skip_serializing_if = "Option::is_none")]
      pub mime_type: Option<String>,
++
 +    /// File URIs (if files)
 +    #[serde(skip_serializing_if = "Option::is_none")]
 +    pub file_uris: Option<Vec<String>>,
++
 +    /// Whether this is a cut operation (if files)
 +    #[serde(skip_serializing_if = "Option::is_none")]
 +    pub is_cut: Option<bool>,
+ }

garclip/src/x11/atoms.rsmodified

      pub image_bmp: Atom,
      pub image_webp: Atom,
 +    // File clipboard targets
 +    pub text_uri_list: Atom,
 +    pub gnome_copied_files: Atom,
 +    pub kde_cut_selection: Atom,
++
      // Clipboard manager atoms
      pub clipboard_manager: Atom,
      pub save_targets: Atom,
          let image_bmp = conn.intern_atom(false, b"image/bmp")?;
          let image_webp = conn.intern_atom(false, b"image/webp")?;
 +        let text_uri_list = conn.intern_atom(false, b"text/uri-list")?;
 +        let gnome_copied_files = conn.intern_atom(false, b"x-special/gnome-copied-files")?;
 +        let kde_cut_selection = conn.intern_atom(false, b"application/x-kde-cutselection")?;
++
          let clipboard_manager = conn.intern_atom(false, b"CLIPBOARD_MANAGER")?;
          let save_targets = conn.intern_atom(false, b"SAVE_TARGETS")?;
              image_bmp: image_bmp.reply()?.atom,
              image_webp: image_webp.reply()?.atom,
 +            text_uri_list: text_uri_list.reply()?.atom,
 +            gnome_copied_files: gnome_copied_files.reply()?.atom,
 +            kde_cut_selection: kde_cut_selection.reply()?.atom,
++
              clipboard_manager: clipboard_manager.reply()?.atom,
              save_targets: save_targets.reply()?.atom,
              || atom == self.image_webp
+     }
 +    /// Check if an atom is a file clipboard target
 +    pub fn is_file_target(&self, atom: Atom) -> bool {
 +        atom == self.text_uri_list || atom == self.gnome_copied_files
 +    }
++
      /// Get the preferred text target from a list of targets
      pub fn preferred_text_target(&self, targets: &[Atom]) -> Option<Atom> {
          // Prefer UTF8_STRING, then text/plain;charset=utf-8, then STRING
          None
+     }
 +    /// Get the preferred file target from a list of targets
 +    pub fn preferred_file_target(&self, targets: &[Atom]) -> Option<Atom> {
 +        // Prefer gnome-copied-files (includes cut/copy info), then text/uri-list
 +        let preference = [self.gnome_copied_files, self.text_uri_list];
++
 +        for preferred in preference {
 +            if targets.contains(&preferred) {
 +                return Some(preferred);
 +            }
 +        }
 +        None
 +    }
++
      /// Get the list of targets we support for text
      pub fn supported_text_targets(&self) -> Vec<Atom> {
          vec![
              self.image_bmp,
+         ]
+     }
++
 +    /// Get the list of targets we support for file URIs
 +    pub fn supported_file_targets(&self) -> Vec<Atom> {
 +        vec![self.text_uri_list, self.gnome_copied_files]
 +    }
+ }

garclip/src/x11/transfer.rsmodified

          Ok(Some((data, mime_type)))
+     }
 -    /// Request clipboard content (text or image)
 +    /// Request clipboard content (files, images, or text)
      pub fn request_content(&self, selection: Atom) -> Result<Option<ClipboardContent>> {
          let atoms = self.atoms();
              return Ok(None);
+         }
 -        // Prefer images over text (images often have text alternatives)
 +        // Prefer files first (most specialized content type)
 +        if let Some(file_target) = atoms.preferred_file_target(&targets) {
 +            if let Some((uris, is_cut)) = self.request_files_target(selection, file_target)? {
 +                return Ok(Some(ClipboardContent::Files { uris, is_cut }));
 +            }
 +        }
++
 +        // Then images (images often have text alternatives)
          if let Some(img_target) = atoms.preferred_image_target(&targets) {
              if let Some((data, mime)) = self.request_image_target(selection, img_target)? {
                  return Ok(Some(ClipboardContent::Image { data, mime_type: mime }));
          Ok(Some((data, mime_type)))
+     }
 +    /// Request file URIs from clipboard
 +    fn request_files_target(
 +        &self,
 +        selection: Atom,
 +        target: Atom,
 +    ) -> Result<Option<(Vec<String>, bool)>> {
 +        let atoms = self.atoms();
++
 +        self.conn().convert_selection(
 +            self.window(),
 +            selection,
 +            target,
 +            atoms.garclip_data,
 +            CURRENT_TIME,
 +        )?;
 +        self.conn().flush()?;
++
 +        let event = self.wait_for_selection_notify(selection, target)?;
 +        if event.property == x11rb::NONE {
 +            return Ok(None);
 +        }
++
 +        let data = self.read_property_string(atoms.garclip_data)?;
++
 +        // Parse based on format
 +        if target == atoms.gnome_copied_files {
 +            // Format: "copy\nfile:///path1\nfile:///path2" or "cut\n..."
 +            let mut lines = data.lines();
 +            let action = lines.next().unwrap_or("copy");
 +            let is_cut = action == "cut";
 +            let uris: Vec<String> = lines.map(|s| s.to_string()).collect();
 +            if uris.is_empty() {
 +                return Ok(None);
 +            }
 +            Ok(Some((uris, is_cut)))
 +        } else {
 +            // text/uri-list format: "file:///path1\r\nfile:///path2\r\n"
 +            let uris: Vec<String> = data
 +                .lines()
 +                .map(|s| s.trim_end_matches('\r').to_string())
 +                .filter(|s| !s.is_empty() && !s.starts_with('#'))
 +                .collect();
 +            if uris.is_empty() {
 +                return Ok(None);
 +            }
 +            // text/uri-list doesn't indicate cut, assume copy
 +            Ok(Some((uris, false)))
 +        }
 +    }
++
      /// Wait for a SelectionNotify event
      fn wait_for_selection_notify(
          &self,
                          targets.push(atoms.image_png);
+                     }
+                 }
 +                ClipboardContent::Files { is_cut, .. } => {
 +                    targets.extend(atoms.supported_file_targets());
 +                    // Also offer text formats for compatibility
 +                    targets.extend(atoms.supported_text_targets());
 +                    // Add KDE cut indicator if this is a cut operation
 +                    if *is_cut {
 +                        targets.push(atoms.kde_cut_selection);
 +                    }
 +                }
+             }
              self.conn().change_property32(
                  Atom::from(x11rb::protocol::xproto::AtomEnum::INTEGER),
                  &[CURRENT_TIME],
              )?;
 +        } else if atoms.is_file_target(target) {
 +            // Respond with file URIs
 +            match content {
 +                ClipboardContent::Files { uris, is_cut } => {
 +                    let data = if target == atoms.gnome_copied_files {
 +                        // x-special/gnome-copied-files format
 +                        let action = if *is_cut { "cut" } else { "copy" };
 +                        std::iter::once(action.to_string())
 +                            .chain(uris.iter().cloned())
 +                            .collect::<Vec<_>>()
 +                            .join("\n")
 +                    } else {
 +                        // text/uri-list format
 +                        uris.iter()
 +                            .map(|uri| format!("{}\r\n", uri))
 +                            .collect::<String>()
 +                    };
 +                    self.conn().change_property8(
 +                        PropMode::REPLACE,
 +                        event.requestor,
 +                        property,
 +                        target,
 +                        data.as_bytes(),
 +                    )?;
 +                }
 +                _ => success = false,
 +            }
 +        } else if target == atoms.kde_cut_selection {
 +            // KDE cut selection indicator
 +            match content {
 +                ClipboardContent::Files { is_cut, .. } => {
 +                    let data = if *is_cut { "1" } else { "0" };
 +                    self.conn().change_property8(
 +                        PropMode::REPLACE,
 +                        event.requestor,
 +                        property,
 +                        target,
 +                        data.as_bytes(),
 +                    )?;
 +                }
 +                _ => success = false,
 +            }
          } else if atoms.is_text_target(target) {
              // Respond with text
              match content {
                          text.as_bytes(),
                      )?;
+                 }
 +                ClipboardContent::Files { uris, .. } => {
 +                    // For text targets, send URIs as newline-separated text
 +                    let text = uris.join("\n");
 +                    self.conn().change_property8(
 +                        PropMode::REPLACE,
 +                        event.requestor,
 +                        property,
 +                        target,
 +                        text.as_bytes(),
 +                    )?;
 +                }
                  _ => success = false,
+             }
          } else if atoms.is_image_target(target) {