clipboard-rs

To use clipboard-rs in your Rust project, add it to your Cargo.toml dependencies file.

[dependencies]
clipboard-rs = "0.3.5"

Use ctx.get_image() to retrieve clipboard images. The returned image type (likely RustImage) provides methods like save_to_path and thumbnail for processing.

use clipboard_rs::{common::RustImage, Clipboard, ClipboardContext};

const TMP_PATH: &str = "/tmp/";

fn main() {
	let ctx = ClipboardContext::new().unwrap();
	let img = ctx.get_image();

	match img {
		Ok(img) => {
			img.save_to_path(format!("{}test.png", TMP_PATH).as_str())
				.unwrap();

			let resize_img = img.thumbnail(300, 300).unwrap();

			resize_img
				.save_to_path(format!("{}test_thumbnail.png", TMP_PATH).as_str())
				.unwrap();
		}
		Err(err) => {
			println!("err={}", err);
		}
	}
}

You can use ClipboardContext to check for available formats and retrieve common content types like plain text, HTML, or Rich Text (RTF). Use ctx.has(ContentFormat) to check for existence before retrieving.

use clipboard_rs::{Clipboard, ClipboardContext, ContentFormat};

fn main() {
	nlet ctx = ClipboardContext::new().unwrap();
	let types = ctx.available_formats().unwrap();
	println!("{:?}", types);

	let has_rtf = ctx.has(ContentFormat::Rtf);
	println!("has_rtf={}", has_rtf);

	let rtf = ctx.get_rich_text().unwrap_or("".to_string());
	println!("rtf={}", rtf);

	let has_html = ctx.has(ContentFormat::Html);
	println!("has_html={}", has_html);

	let html = ctx.get_html().unwrap_or("".to_string());

	let content = ctx.get_text().unwrap_or("".to_string());
	println!("txt={}", content);
}

If a specific helper method doesn't exist, you can retrieve raw data for any supported type using ctx.get_buffer(type_identifier). This returns a byte buffer which you can then convert (e.g., to a UTF-8 string).

use clipboard_rs::{Clipboard, ClipboardContext};

fn main() {
    let ctx = ClipboardContext::new().unwrap();
    let types = ctx.available_formats().unwrap();
    println!("{:?}", types);

    // Use a specific type identifier like "public.html"
    let buffer = ctx.get_buffer("public.html").unwrap();

    let string = String::from_utf8(buffer).unwrap();
    println!("{}", string);
}

On Linux (X11), reading large data (like high-resolution images) might fail due to the default 500ms timeout. You can increase this timeout using ClipboardContext::new_with_options and providing ClipboardContextX11Options.

#[cfg(unix)]
fn setup_clipboard() -> ClipboardContext {
	// Set read_timeout to None or a specific duration to prevent interruption
	ClipboardContext::new_with_options(ClipboardContextX11Options { read_timeout: None }).unwrap()
}

#[cfg(not(unix))]
fn setup_clipboard(ctx: &mut ClipboardContext) -> ClipboardContext {
	ClipboardContext::new().unwrap()
}

The library supports various data formats across different operating systems. Note that Android support is currently under development (🚧).

A RustImageBuffer is a wrapper around a Vec<u8> containing encoded image data (e.g., a complete PNG or JPEG file). It is the return type for all conversion methods in the RustImage trait.

Use get_bytes() to access the raw encoded byte slice or save_to_path(path) to write the buffer directly to a file.

#[cfg(feature = "image")]
impl RustImageBuffer {
    pub fn get_bytes(&self) -> &[u8] {
        &self.0
    }

    pub fn save_to_path(&self, path: &str) -> Result<()> {
        std::fs::write(path, &self.0)?;
        Ok(())
    }
}

To react to clipboard updates, implement the ClipboardHandler trait. This is typically used in conjunction with a listener loop or event system provided by the library to trigger logic whenever the clipboard content changes.

pub trait ClipboardHandler {
	fn on_clipboard_change(&mut self);
}

The ClipboardContent enum represents the various types of data that can be stored in the clipboard. It supports text, RTF, HTML, images (requires image feature), file paths, and generic 'other' data.

By implementing the ContentData trait, you can interact with any ClipboardContent variant using a unified interface to retrieve its format, raw bytes, or string representation.

use clipboard_rs::ClipboardContent;

// Example of matching on content
match content {
    ClipboardContent::Text(t) => println!("Text: {}", t),
    ClipboardContent::Image(img) => println!("Image data available"),
    _ => println!("Other content type"),
}

// Using ContentData methods
let format = content.get_format();
let bytes = content.as_bytes();
let text_result = content.as_str();