use std::cell::RefCell;
use thiserror::Error;
#[cfg(feature = "clipboard")]
thread_local! {
static CLIPBOARD: RefCell<Option<arboard::Clipboard>> = const { RefCell::new(None) };
}
#[derive(Error, Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "devtools", derive(serde::Serialize, serde::Deserialize))]
pub enum ClipboardError {
#[error("Clipboard not available")]
NotAvailable,
#[error("Clipboard does not contain a valid image")]
NoImage,
#[error("Clipboard error: {0}")]
Platform(String),
}
#[cfg(all(feature = "clipboard", feature = "ext-image"))]
#[derive(Clone, Debug)]
pub struct ClipboardImage {
pub width: u32,
pub height: u32,
pub pixels: Vec<u8>,
}
pub trait ClipboardProvider: 'static {
fn read_text(&self) -> Result<Option<String>, ClipboardError>;
fn write_text(&mut self, text: &str) -> Result<(), ClipboardError>;
#[cfg(all(feature = "clipboard", feature = "ext-image"))]
fn read_image(&self) -> Result<Option<ClipboardImage>, ClipboardError> {
Err(ClipboardError::NoImage)
}
#[cfg(all(feature = "clipboard", feature = "ext-image"))]
fn write_image(&mut self, _image: &ClipboardImage) -> Result<(), ClipboardError> {
Err(ClipboardError::NotAvailable)
}
}
#[cfg(feature = "clipboard")]
thread_local! {
static CLIPBOARD_PROVIDER: RefCell<Option<Box<dyn ClipboardProvider>>> = const { RefCell::new(None) };
}
#[cfg(feature = "clipboard")]
pub fn set_clipboard_provider(provider: Option<Box<dyn ClipboardProvider>>) {
CLIPBOARD_PROVIDER.with(|cell| {
*cell.borrow_mut() = provider;
});
}
#[cfg(feature = "clipboard")]
struct ArboardProvider;
#[cfg(feature = "clipboard")]
impl ClipboardProvider for ArboardProvider {
fn read_text(&self) -> Result<Option<String>, ClipboardError> {
init()?;
CLIPBOARD.with(|cell| {
let mut cb = cell.borrow_mut();
let cb = cb.as_mut().ok_or(ClipboardError::NotAvailable)?;
match cb.get_text() {
Ok(t) => Ok(Some(t)),
Err(arboard::Error::ContentNotAvailable) => Ok(None),
Err(e) => Err(ClipboardError::Platform(e.to_string())),
}
})
}
fn write_text(&mut self, text: &str) -> Result<(), ClipboardError> {
init()?;
CLIPBOARD.with(|cell| {
let mut cb = cell.borrow_mut();
let cb = cb.as_mut().ok_or(ClipboardError::NotAvailable)?;
cb.set_text(text)
.map_err(|e| ClipboardError::Platform(e.to_string()))
})
}
#[cfg(all(feature = "clipboard", feature = "ext-image"))]
fn read_image(&self) -> Result<Option<ClipboardImage>, ClipboardError> {
init()?;
CLIPBOARD.with(|cell| {
let mut cb = cell.borrow_mut();
let cb = cb.as_mut().ok_or(ClipboardError::NotAvailable)?;
match cb.get_image() {
Ok(img) => Ok(Some(ClipboardImage {
width: img.width as u32,
height: img.height as u32,
pixels: img.bytes.into_owned(),
})),
Err(arboard::Error::ContentNotAvailable) => Ok(None),
Err(_) => Err(ClipboardError::NoImage),
}
})
}
#[cfg(all(feature = "clipboard", feature = "ext-image"))]
fn write_image(&mut self, image: &ClipboardImage) -> Result<(), ClipboardError> {
init()?;
let arboard_img = arboard::ImageData {
width: image.width as usize,
height: image.height as usize,
bytes: std::borrow::Cow::Borrowed(&image.pixels),
};
CLIPBOARD.with(|cell| {
let mut cb = cell.borrow_mut();
let cb = cb.as_mut().ok_or(ClipboardError::NotAvailable)?;
cb.set_image(arboard_img)
.map_err(|e| ClipboardError::Platform(e.to_string()))
})
}
}
pub struct Clipboard;
impl Clipboard {
#[inline]
pub fn new() -> Self {
Self
}
}
impl Default for Clipboard {
#[inline]
fn default() -> Self {
Self::new()
}
}
impl Clipboard {
pub fn read_text(&self) -> Result<Option<String>, ClipboardError> {
#[cfg(feature = "clipboard")]
{
if CLIPBOARD_PROVIDER.with(|c| c.borrow().is_some()) {
return CLIPBOARD_PROVIDER.with(|c| c.borrow().as_ref().unwrap().read_text());
}
ArboardProvider.read_text()
}
#[cfg(not(feature = "clipboard"))]
Err(ClipboardError::NotAvailable)
}
pub fn write_text(&self, text: &str) -> Result<(), ClipboardError> {
#[cfg(feature = "clipboard")]
{
if CLIPBOARD_PROVIDER.with(|c| c.borrow().is_some()) {
return CLIPBOARD_PROVIDER
.with(|c| c.borrow_mut().as_mut().unwrap().write_text(text));
}
ArboardProvider.write_text(text)
}
#[cfg(not(feature = "clipboard"))]
Err(ClipboardError::NotAvailable)
}
}
#[cfg(all(feature = "clipboard", feature = "ext-image"))]
impl Clipboard {
pub fn read_image(&self) -> Result<Option<ClipboardImage>, ClipboardError> {
if CLIPBOARD_PROVIDER.with(|c| c.borrow().is_some()) {
return CLIPBOARD_PROVIDER.with(|c| c.borrow().as_ref().unwrap().read_image());
}
ArboardProvider.read_image()
}
pub fn write_image(&self, image: &ClipboardImage) -> Result<(), ClipboardError> {
if CLIPBOARD_PROVIDER.with(|c| c.borrow().is_some()) {
return CLIPBOARD_PROVIDER
.with(|c| c.borrow_mut().as_mut().unwrap().write_image(image));
}
ArboardProvider.write_image(image)
}
}
#[cfg(feature = "clipboard")]
fn init() -> Result<(), ClipboardError> {
CLIPBOARD.with(|cell| {
let mut cb = cell.borrow_mut();
if cb.is_some() {
return Ok(());
}
match arboard::Clipboard::new() {
Ok(c) => {
*cb = Some(c);
Ok(())
}
Err(e) => {
*cb = None;
Err(ClipboardError::Platform(e.to_string()))
}
}
})
}