#![deny(clippy::all, clippy::if_not_else, clippy::enum_glob_use)]
use std::borrow::Cow;
use std::ffi::c_void;
use std::io::Result;
use std::sync::mpsc::{self, Receiver};
use sctk::reexports::calloop::channel::{self, Sender};
use sctk::reexports::client::backend::Backend;
use sctk::reexports::client::protocol::wl_surface::WlSurface;
use sctk::reexports::client::Connection;
#[cfg(feature = "dnd")]
pub mod dnd;
pub mod mime;
mod state;
pub mod text;
mod worker;
use mime::{AllowedMimeTypes, AsMimeTypes, MimeType};
use state::Target;
use text::Text;
pub type SimpleClipboard = Clipboard<WlSurface>;
pub struct Clipboard<T> {
request_sender: Sender<worker::Command<T>>,
request_receiver: Receiver<Result<(Vec<u8>, MimeType)>>,
clipboard_thread: Option<std::thread::JoinHandle<()>>,
connection: Connection,
}
impl<T: 'static + Send + Clone> Clipboard<T> {
pub unsafe fn new(display: *mut c_void) -> Self {
let backend = unsafe { Backend::from_foreign_display(display.cast()) };
let connection = Connection::from_backend(backend);
let (request_sender, rx_chan) = channel::channel();
let (clipboard_reply_sender, request_receiver) = mpsc::channel();
let name = String::from("smithay-clipboard");
let clipboard_thread =
worker::spawn(name, connection.clone(), rx_chan, clipboard_reply_sender);
Self { request_receiver, request_sender, clipboard_thread, connection }
}
pub fn load<D: AllowedMimeTypes + 'static>(&self) -> Result<D> {
self.load_inner(Target::Clipboard, D::allowed())
}
pub fn load_text(&self) -> Result<String> {
self.load::<Text>().map(|t| t.0)
}
pub fn load_primary<D: AllowedMimeTypes + 'static>(&self) -> Result<D> {
self.load_inner(Target::Primary, D::allowed())
}
pub fn load_primary_text(&self) -> Result<String> {
self.load_primary::<Text>().map(|t| t.0)
}
pub fn load_mime<D: TryFrom<(Vec<u8>, MimeType)>>(
&self,
allowed: impl Into<Cow<'static, [MimeType]>>,
) -> Result<D> {
self.load_inner(Target::Clipboard, allowed).and_then(|d| {
D::try_from(d).map_err(|_| {
std::io::Error::new(
std::io::ErrorKind::Other,
"Failed to load data of the requested type.",
)
})
})
}
pub fn load_primary_mime<D: TryFrom<(Vec<u8>, MimeType)>>(
&self,
allowed: impl Into<Cow<'static, [MimeType]>>,
) -> Result<D> {
self.load_inner(Target::Primary, allowed).and_then(|d| {
D::try_from(d).map_err(|_| {
std::io::Error::new(
std::io::ErrorKind::Other,
"Failed to load data of the requested type.",
)
})
})
}
pub fn store<D: AsMimeTypes + Send + 'static>(&self, data: D) {
self.store_inner(data, Target::Clipboard);
}
pub fn store_text<D: Into<String>>(&self, text: D) {
self.store(Text(text.into()));
}
pub fn store_primary<D: AsMimeTypes + Send + 'static>(&self, data: D) {
self.store_inner(data, Target::Primary);
}
pub fn store_primary_text<D: Into<String>>(&self, text: D) {
self.store_primary(Text(text.into()));
}
fn load_inner<D: TryFrom<(Vec<u8>, MimeType)> + 'static>(
&self,
target: Target,
allowed: impl Into<Cow<'static, [MimeType]>>,
) -> Result<D> {
let _ = self.request_sender.send(worker::Command::Load(allowed.into(), target));
match self.request_receiver.recv() {
Ok(res) => res.and_then(|(data, mime)| {
D::try_from((data, mime)).map_err(|_| {
std::io::Error::new(
std::io::ErrorKind::Other,
"Failed to load data of the requested type.",
)
})
}),
Err(_) => Err(std::io::Error::new(std::io::ErrorKind::Other, "clipboard is dead.")),
}
}
fn store_inner<D: AsMimeTypes + Send + 'static>(&self, data: D, target: Target) {
let request = worker::Command::Store(Box::new(data), target);
let _ = self.request_sender.send(request);
}
}
impl<T> Drop for Clipboard<T> {
fn drop(&mut self) {
let _ = self.request_sender.send(worker::Command::Exit);
if let Some(clipboard_thread) = self.clipboard_thread.take() {
let _ = clipboard_thread.join();
}
}
}