Remove copypasta and maintain our own fork

src/lib.rs

@@ -1,53 +1,48 @@
-use raw_window_handle::{HasRawWindowHandle, RawWindowHandle};
-use std::cell::RefCell;
+#[cfg(all(
+    unix,
+    not(any(
+        target_os = "macos",
+        target_os = "android",
+        target_os = "emscripten"
+    ))
+))]
+#[path = "platform/linux.rs"]
+mod platform;
+
+#[cfg(not(all(
+    unix,
+    not(any(
+        target_os = "macos",
+        target_os = "android",
+        target_os = "emscripten"
+    ))
+)))]
+#[path = "platform/not_linux.rs"]
+mod platform;
+
+use raw_window_handle::HasRawWindowHandle;
 use std::error::Error;
 
 pub struct Clipboard {
-    raw: RefCell<Box<dyn copypasta::ClipboardProvider>>,
+    raw: Box<dyn ClipboardProvider>,
 }
 
 impl Clipboard {
     pub fn new<W: HasRawWindowHandle>(
         window: &W,
     ) -> Result<Self, Box<dyn Error>> {
-        let raw = match window.raw_window_handle() {
-            #[cfg(all(
-                unix,
-                not(any(
-                    target_os = "macos",
-                    target_os = "android",
-                    target_os = "emscripten"
-                ))
-            ))]
-            RawWindowHandle::Wayland(handle) => {
-                assert!(!handle.display.is_null());
+        let raw = platform::new_clipboard(window)?;
 
-                Box::new(unsafe {
-                    let (_, raw) = copypasta::wayland_clipboard::create_clipboards_from_external(
-                        handle.display as *mut _,
-                    );
-
-                    raw
-                }) as _
-            }
-            _ => Box::new(copypasta::ClipboardContext::new()?) as _,
-        };
-
-        Ok(Clipboard {
-            raw: RefCell::new(raw),
-        })
+        Ok(Clipboard { raw })
     }
 
     pub fn read(&self) -> Result<String, Box<dyn Error>> {
         // TODO: Think about use of `RefCell`
         // Maybe we should make `read` mutable (?)
-        self.raw.borrow_mut().get_contents()
-    }
-
-    pub fn write(
-        &mut self,
-        contents: impl Into<String>,
-    ) -> Result<(), Box<dyn Error>> {
-        self.raw.borrow_mut().set_contents(contents.into())
+        self.raw.read()
     }
 }
+
+pub trait ClipboardProvider {
+    fn read(&self) -> Result<String, Box<dyn Error>>;
+}

src/platform/linux.rs

@@ -0,0 +1,36 @@
+use crate::ClipboardProvider;
+
+use raw_window_handle::{HasRawWindowHandle, RawWindowHandle};
+use std::error::Error;
+
+pub use window_clipboard_wayland as wayland;
+pub use window_clipboard_x11 as x11;
+
+pub fn new_clipboard<W: HasRawWindowHandle>(
+    window: &W,
+) -> Result<Box<dyn ClipboardProvider>, Box<dyn Error>> {
+    let clipboard = match window.raw_window_handle() {
+        RawWindowHandle::Wayland(handle) => {
+            assert!(!handle.display.is_null());
+
+            Box::new(unsafe {
+                wayland::Clipboard::new(handle.display as *mut _)
+            }) as _
+        }
+        _ => Box::new(x11::Clipboard::new()?) as _,
+    };
+
+    Ok(clipboard)
+}
+
+impl ClipboardProvider for wayland::Clipboard {
+    fn read(&self) -> Result<String, Box<dyn Error>> {
+        self.read()
+    }
+}
+
+impl ClipboardProvider for x11::Clipboard {
+    fn read(&self) -> Result<String, Box<dyn Error>> {
+        self.read()
+    }
+}

src/platform/not_linux.rs

@@ -0,0 +1,29 @@
+use crate::ClipboardProvider;
+
+pub fn new_clipboard<W: HasRawWindowHandle>(
+    _window: &W,
+) -> Result<Box<dyn ClipboardProvider>, Box<dyn Error>> {
+    #[cfg(target_os = "windows")]
+    {
+        Ok(Box::new(window_clipboard_windows::Clipboard::new()?))
+    }
+
+    #[cfg(target_os = "macos")]
+    {
+        Ok(Box::new(window_clipboard_macos::Clipboard::new()?))
+    }
+}
+
+#[cfg(target_os = "windows")]
+impl ClipboardProvider for window_clipboard_windows::Clipboard {
+    fn read(&self) -> Result<String, Box<dyn Error>> {
+        self.read()
+    }
+}
+
+#[cfg(target_os = "macos")]
+impl ClipboardProvider for window_clipboard_macos::Clipboard {
+    fn read(&self) -> Result<String, Box<dyn Error>> {
+        self.read()
+    }
+}