refactor: allow clipboard methods to take generic data

src/lib.rs

@@ -1,3 +1,5 @@
+pub mod mime;
+
 #[cfg(all(
     unix,
     not(any(
@@ -49,49 +51,55 @@ mod platform;
 use raw_window_handle::HasDisplayHandle;
 use std::error::Error;
 
-pub struct Clipboard {
-    raw: Box<dyn ClipboardProvider>,
+pub struct Clipboard<C> {
+    raw: C,
 }
 
-impl Clipboard {
+impl Clipboard<platform::Clipboard> {
     /// Safety: the display handle must be valid for the lifetime of `Clipboard`
     pub unsafe fn connect<W: HasDisplayHandle>(
         window: &W,
     ) -> Result<Self, Box<dyn Error>> {
-        let raw = platform::connect(window)?;
-
-        Ok(Clipboard { raw })
+        Ok(Clipboard {
+            raw: platform::connect(window)?,
+        })
     }
 
     pub fn read(&self) -> Result<String, Box<dyn Error>> {
-        self.raw.read()
+        self.raw.read_text()
     }
 
     pub fn write(&mut self, contents: String) -> Result<(), Box<dyn Error>> {
-        self.raw.write(contents)
+        self.raw.write_text(contents)
     }
 }
 
-impl Clipboard {
+impl<C: ClipboardProvider> Clipboard<C> {
     pub fn read_primary(&self) -> Option<Result<String, Box<dyn Error>>> {
-        self.raw.read_primary()
+        self.raw.read_primary_text()
     }
 
-    pub fn write_primary(&mut self, contents: String) -> Option<Result<(), Box<dyn Error>>> {
-        self.raw.write_primary(contents)
+    pub fn write_primary(
+        &mut self,
+        contents: String,
+    ) -> Option<Result<(), Box<dyn Error>>> {
+        self.raw.write_primary_text(contents)
     }
 }
 
 pub trait ClipboardProvider {
-    fn read(&self) -> Result<String, Box<dyn Error>>;
+    fn read_text(&self) -> Result<String, Box<dyn Error>>;
 
-    fn write(&mut self, contents: String) -> Result<(), Box<dyn Error>>;
+    fn write_text(&mut self, contents: String) -> Result<(), Box<dyn Error>>;
 
-    fn read_primary(&self) -> Option<Result<String, Box<dyn Error>>> {
+    fn read_primary_text(&self) -> Option<Result<String, Box<dyn Error>>> {
         None
     }
 
-    fn write_primary(&mut self, _contents: String) -> Option<Result<(), Box<dyn Error>>> {
+    fn write_primary_text(
+        &mut self,
+        _contents: String,
+    ) -> Option<Result<(), Box<dyn Error>>> {
         None
     }
 }

src/platform/android.rs

@@ -5,8 +5,8 @@ use std::error::Error;
 
 pub fn connect<W: HasDisplayHandle>(
     _window: &W,
-) -> Result<Box<dyn ClipboardProvider>, Box<dyn Error>> {
-    Ok(Box::new(Clipboard::new()?))
+) -> Result<Clipboard, Box<dyn Error>> {
+    Ok(Clipboard::new())
 }
 
 pub struct Clipboard;

src/platform/dummy.rs

@@ -2,15 +2,15 @@ use crate::ClipboardProvider;
 
 use raw_window_handle::HasDisplayHandle;
 
-struct Dummy;
+struct Clipboard;
 
 pub fn connect<W: HasDisplayHandle>(
     _window: &W,
-) -> Result<Box<dyn ClipboardProvider>, Box<dyn std::error::Error>> {
-    Ok(Box::new(Dummy))
+) -> Result<Clipboard, Box<dyn std::error::Error>> {
+    Ok(Clipboard)
 }
 
-impl ClipboardProvider for Dummy {
+impl ClipboardProvider for Clipboard {
     fn read(&self) -> Result<String, Box<dyn std::error::Error>> {
         Err(Box::new(Error::Unimplemented))
     }

src/platform/ios.rs

@@ -5,8 +5,8 @@ use std::error::Error;
 
 pub fn connect<W: HasDisplayHandle>(
     _window: &W,
-) -> Result<Box<dyn ClipboardProvider>, Box<dyn Error>> {
-    Ok(Box::new(Clipboard::new()?))
+) -> Result<Clipboard, Box<dyn Error>> {
+    Clipboard::new()
 }
 
 pub struct Clipboard;

src/platform/linux.rs

@@ -6,51 +6,55 @@ use std::error::Error;
 pub use clipboard_wayland as wayland;
 pub use clipboard_x11 as x11;
 
+pub enum Clipboard {
+    Wayland(wayland::Clipboard),
+    X11(x11::Clipboard),
+}
+
+impl ClipboardProvider for Clipboard {
+    fn read_text(&self) -> Result<String, Box<dyn Error>> {
+        match self {
+            Clipboard::Wayland(c) => c.read_text(),
+            Clipboard::X11(c) => c.read().map_err(Box::from),
+        }
+    }
+
+    fn write_text(&mut self, contents: String) -> Result<(), Box<dyn Error>> {
+        match self {
+            Clipboard::Wayland(c) => c.write_text(contents),
+            Clipboard::X11(c) => c.write(contents).map_err(Box::from),
+        }
+    }
+
+    fn read_primary_text(&self) -> Option<Result<String, Box<dyn Error>>> {
+        match self {
+            Clipboard::Wayland(c) => Some(c.read_primary_text()),
+            Clipboard::X11(c) => Some(c.read_primary().map_err(Box::from)),
+        }
+    }
+
+    fn write_primary_text(
+        &mut self,
+        contents: String,
+    ) -> Option<Result<(), Box<dyn Error>>> {
+        match self {
+            Clipboard::Wayland(c) => Some(c.write_primary_text(contents)),
+            Clipboard::X11(c) => {
+                Some(c.write_primary(contents).map_err(Box::from))
+            }
+        }
+    }
+}
+
 pub unsafe fn connect<W: HasDisplayHandle>(
     window: &W,
-) -> Result<Box<dyn ClipboardProvider>, Box<dyn Error>> {
+) -> Result<Clipboard, Box<dyn Error>> {
     let clipboard = match window.display_handle()?.as_raw() {
-        RawDisplayHandle::Wayland(handle) => {
-            Box::new(wayland::Clipboard::connect(handle.display.as_ptr())) as _
-        }
-        _ => Box::new(x11::Clipboard::connect()?) as _,
+        RawDisplayHandle::Wayland(handle) => Clipboard::Wayland(
+            wayland::Clipboard::connect(handle.display.as_ptr()),
+        ) as _,
+        _ => Clipboard::X11(x11::Clipboard::connect()?) as _,
     };
 
     Ok(clipboard)
 }
-
-impl ClipboardProvider for wayland::Clipboard {
-    fn read(&self) -> Result<String, Box<dyn Error>> {
-        self.read()
-    }
-
-    fn read_primary(&self) -> Option<Result<String, Box<dyn Error>>> {
-        Some(self.read_primary())
-    }
-
-    fn write(&mut self, contents: String) -> Result<(), Box<dyn Error>> {
-        self.write(contents)
-    }
-
-    fn write_primary(&mut self, contents: String) -> Option<Result<(), Box<dyn Error>>> {
-        Some(self.write_primary(contents))
-    }
-}
-
-impl ClipboardProvider for x11::Clipboard {
-    fn read(&self) -> Result<String, Box<dyn Error>> {
-        self.read().map_err(Box::from)
-    }
-
-    fn read_primary(&self) -> Option<Result<String, Box<dyn Error>>> {
-        Some(self.read_primary().map_err(Box::from))
-    }
-
-    fn write(&mut self, contents: String) -> Result<(), Box<dyn Error>> {
-        self.write(contents).map_err(Box::from)
-    }
-
-    fn write_primary(&mut self, contents: String) -> Option<Result<(), Box<dyn Error>>> {
-        Some(self.write_primary(contents).map_err(Box::from))
-    }
-}

src/platform/macos.rs

@@ -1,15 +1,16 @@
 use crate::ClipboardProvider;
 
+pub(crate) use clipboard_macos::Clipboard;
 use raw_window_handle::HasDisplayHandle;
 use std::error::Error;
 
 pub fn connect<W: HasDisplayHandle>(
     _window: &W,
-) -> Result<Box<dyn ClipboardProvider>, Box<dyn Error>> {
-    Ok(Box::new(clipboard_macos::Clipboard::new()?))
+) -> Result<Clipboard, Box<dyn Error>> {
+    Clipboard::new()
 }
 
-impl ClipboardProvider for clipboard_macos::Clipboard {
+impl ClipboardProvider for Clipboard {
     fn read(&self) -> Result<String, Box<dyn Error>> {
         self.read()
     }

src/platform/windows.rs

@@ -7,8 +7,8 @@ use std::error::Error;
 
 pub fn connect<W: HasDisplayHandle>(
     _window: &W,
-) -> Result<Box<dyn ClipboardProvider>, Box<dyn Error>> {
-    Ok(Box::new(Clipboard))
+) -> Result<Clipboard, Box<dyn Error>> {
+    Ok(Clipboard)
 }
 
 pub struct Clipboard;

wayland/Cargo.toml

@@ -10,4 +10,4 @@ documentation = "https://docs.rs/clipboard_wayland"
 keywords = ["clipboard", "wayland"]
 
 [dependencies]
-smithay-clipboard = "0.7"
+smithay-clipboard = { git = "https://github.com/wash2/smithay-clipboard", branch = "mime-types" }

wayland/src/lib.rs

@@ -12,9 +12,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::error::Error;
-use std::ffi::c_void;
-use std::sync::{Arc, Mutex};
+use std::{
+    error::Error,
+    ffi::c_void,
+    sync::{Arc, Mutex},
+};
 
 pub struct Clipboard {
     context: Arc<Mutex<smithay_clipboard::Clipboard>>,
@@ -29,22 +31,25 @@ impl Clipboard {
         Clipboard { context }
     }
 
-    pub fn read(&self) -> Result<String, Box<dyn Error>> {
-        Ok(self.context.lock().unwrap().load()?)
+    pub fn read_text(&self) -> Result<String, Box<dyn Error>> {
+        Ok(self.context.lock().unwrap().load_text()?)
     }
 
-    pub fn read_primary(&self) -> Result<String, Box<dyn Error>> {
-        Ok(self.context.lock().unwrap().load_primary()?)
+    pub fn read_primary_text(&self) -> Result<String, Box<dyn Error>> {
+        Ok(self.context.lock().unwrap().load_primary_text()?)
     }
 
-    pub fn write(&mut self, data: String) -> Result<(), Box<dyn Error>> {
-        self.context.lock().unwrap().store(data);
+    pub fn write_text(&mut self, data: String) -> Result<(), Box<dyn Error>> {
+        self.context.lock().unwrap().store_text(data);
 
         Ok(())
     }
 
-    pub fn write_primary(&mut self, data: String) -> Result<(), Box<dyn Error>> {
-        self.context.lock().unwrap().store_primary(data);
+    pub fn write_primary_text(
+        &mut self,
+        data: String,
+    ) -> Result<(), Box<dyn Error>> {
+        self.context.lock().unwrap().store_primary_text(data);
 
         Ok(())
     }