feat: add wayland impl for custom mime types

src/lib.rs

@@ -48,6 +48,7 @@ mod platform;
 #[path = "platform/dummy.rs"]
 mod platform;
 
+use mime::{ClipboardLoadData, ClipboardStoreData};
 use raw_window_handle::HasDisplayHandle;
 use std::error::Error;
 
@@ -102,4 +103,38 @@ pub trait ClipboardProvider {
     ) -> Option<Result<(), Box<dyn Error>>> {
         None
     }
+
+    fn read<T: 'static>(&self) -> Option<Result<T, Box<dyn Error>>>
+    where
+        ClipboardLoadData<T>: platform::InnerAllowedMimeTypes,
+    {
+        None
+    }
+
+    fn write<T: Send + Sync + 'static>(
+        &mut self,
+        _contents: ClipboardStoreData<T>,
+    ) -> Option<Result<(), Box<dyn Error>>>
+    where
+        ClipboardStoreData<T>: platform::InnerAsMimeTypes,
+    {
+        None
+    }
+
+    fn read_primary<T: 'static>(&self) -> Option<Result<T, Box<dyn Error>>>
+    where
+        ClipboardLoadData<T>: platform::InnerAllowedMimeTypes,
+    {
+        None
+    }
+
+    fn write_primary<T: Send + Sync + 'static>(
+        &mut self,
+        _contents: ClipboardStoreData<T>,
+    ) -> Option<Result<(), Box<dyn Error>>>
+    where
+        ClipboardStoreData<T>: platform::InnerAsMimeTypes,
+    {
+        None
+    }
 }

src/mime.rs

@@ -0,0 +1,45 @@
+// need a type that can implement traits for storing custom data
+
+use std::{borrow::Cow, error, fmt};
+
+/// Data that can be loaded from the clipboard.
+pub struct ClipboardLoadData<T>(pub T);
+
+/// Describes the mime types which are accepted.
+pub trait AllowedMimeTypes:
+    TryFrom<(Vec<u8>, String)> + Send + Sync + 'static
+{
+    /// List allowed mime types for the type to convert from a byte slice.
+    ///
+    /// Allowed mime types should be listed in order of decreasing preference,
+    /// most preferred first.
+    fn allowed() -> Cow<'static, [String]>;
+}
+
+/// Can be converted to data with the available mime types.
+pub trait AsMimeTypes {
+    /// List available mime types for this data to convert to a byte slice.
+    fn available(&self) -> Cow<'static, [String]>;
+
+    /// Converts a type to a byte slice for the given mime type if possible.
+    fn as_bytes(&self, mime_type: &str) -> Option<Cow<'static, [u8]>>;
+}
+
+/// Data that can be stored to the clipboard.
+pub struct ClipboardStoreData<T> {
+    /// Clipboard data.
+    pub data: T,
+    /// Available mime types for the clipboard data.
+    pub available_mime_types: Vec<Cow<'static, str>>,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct Error;
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "Unsupported mime type")
+    }
+}
+
+impl error::Error for Error {}

src/platform/linux.rs

@@ -1,10 +1,17 @@
-use crate::ClipboardProvider;
+use crate::{
+    mime::{ClipboardLoadData, ClipboardStoreData},
+    ClipboardProvider,
+};
 
 use raw_window_handle::{HasDisplayHandle, RawDisplayHandle};
 use std::error::Error;
+use wayland::MimeType;
 
 pub use clipboard_wayland as wayland;
 pub use clipboard_x11 as x11;
+pub use wayland::{
+    AllowedMimeTypes as InnerAllowedMimeTypes, AsMimeTypes as InnerAsMimeTypes,
+};
 
 pub enum Clipboard {
     Wayland(wayland::Clipboard),
@@ -44,6 +51,62 @@ impl ClipboardProvider for Clipboard {
             }
         }
     }
+
+    fn read<T: 'static>(&self) -> Option<Result<T, Box<dyn Error>>>
+    where
+        ClipboardLoadData<T>: InnerAllowedMimeTypes,
+    {
+        match self {
+            Clipboard::Wayland(c) => {
+                let ret = c.read::<ClipboardLoadData<T>>();
+                Some(ret.map(|ret| ret.0))
+            }
+            Clipboard::X11(_) => None,
+        }
+    }
+
+    fn write<T: Send + Sync + 'static>(
+        &mut self,
+        contents: ClipboardStoreData<T>,
+    ) -> Option<Result<(), Box<dyn Error>>>
+    where
+        ClipboardStoreData<T>: InnerAsMimeTypes,
+    {
+        match self {
+            Clipboard::Wayland(c) => {
+                Some(c.write::<ClipboardStoreData<T>>(contents))
+            }
+            Clipboard::X11(_) => None,
+        }
+    }
+
+    fn read_primary<T: 'static>(&self) -> Option<Result<T, Box<dyn Error>>>
+    where
+        ClipboardLoadData<T>: InnerAllowedMimeTypes,
+    {
+        match self {
+            Clipboard::Wayland(c) => {
+                let ret = c.read_primary::<ClipboardLoadData<T>>();
+                Some(ret.map(|ret| ret.0))
+            }
+            Clipboard::X11(_) => None,
+        }
+    }
+
+    fn write_primary<T: Send + Sync + 'static>(
+        &mut self,
+        contents: ClipboardStoreData<T>,
+    ) -> Option<Result<(), Box<dyn Error>>>
+    where
+        ClipboardStoreData<T>: InnerAsMimeTypes,
+    {
+        match self {
+            Clipboard::Wayland(c) => {
+                Some(c.write_primary::<ClipboardStoreData<T>>(contents))
+            }
+            Clipboard::X11(_) => None,
+        }
+    }
 }
 
 pub unsafe fn connect<W: HasDisplayHandle>(
@@ -58,3 +121,51 @@ pub unsafe fn connect<W: HasDisplayHandle>(
 
     Ok(clipboard)
 }
+
+impl<T: crate::mime::AsMimeTypes> InnerAsMimeTypes for ClipboardLoadData<T> {
+    fn available(&self) -> std::borrow::Cow<'static, [MimeType]> {
+        self.0
+            .available()
+            .into_iter()
+            .map(|m| MimeType::Other(m.clone().into()))
+            .collect()
+    }
+
+    fn as_bytes(
+        &self,
+        mime_type: &MimeType,
+    ) -> Option<std::borrow::Cow<'static, [u8]>> {
+        self.0.as_bytes(mime_type.as_ref())
+    }
+}
+
+impl<T: crate::mime::AllowedMimeTypes> InnerAllowedMimeTypes
+    for ClipboardLoadData<T>
+where
+    ClipboardLoadData<T>: TryFrom<(Vec<u8>, MimeType)>,
+{
+    // TODO select text variants if string matches...
+    fn allowed() -> std::borrow::Cow<'static, [wayland::MimeType]> {
+        T::allowed()
+            .into_iter()
+            .map(|s| MimeType::Other(s.clone().into()))
+            .collect()
+    }
+}
+
+impl<T> TryFrom<(Vec<u8>, MimeType)> for ClipboardLoadData<T>
+where
+    T: for<'b> TryFrom<(Vec<u8>, String)>,
+    T: 'static,
+{
+    type Error = crate::mime::Error;
+
+    fn try_from(
+        (value, mime): (Vec<u8>, MimeType),
+    ) -> Result<Self, Self::Error> {
+        let mime = mime.to_string();
+        Ok(ClipboardLoadData(
+            T::try_from((value, mime)).map_err(|_| crate::mime::Error)?,
+        ))
+    }
+}

wayland/Cargo.toml

@@ -11,3 +11,4 @@ keywords = ["clipboard", "wayland"]
 
 [dependencies]
 smithay-clipboard = { git = "https://github.com/wash2/smithay-clipboard", branch = "mime-types" }
+# smithay-clipboard = { path = "../../smithay-clipboard" }

wayland/src/lib.rs

@@ -18,6 +18,8 @@ use std::{
     sync::{Arc, Mutex},
 };
 
+pub use smithay_clipboard::mime::{AllowedMimeTypes, AsMimeTypes, MimeType};
+
 pub struct Clipboard {
     context: Arc<Mutex<smithay_clipboard::Clipboard>>,
 }
@@ -53,4 +55,34 @@ impl Clipboard {
 
         Ok(())
     }
+
+    pub fn write<T: AsMimeTypes + Send + Sync + 'static>(
+        &mut self,
+        data: T,
+    ) -> Result<(), Box<dyn Error>> {
+        self.context.lock().unwrap().store(data);
+
+        Ok(())
+    }
+
+    pub fn write_primary<T: AsMimeTypes + Send + Sync + 'static>(
+        &mut self,
+        data: T,
+    ) -> Result<(), Box<dyn Error>> {
+        self.context.lock().unwrap().store_primary(data);
+
+        Ok(())
+    }
+
+    pub fn read<T: AllowedMimeTypes + 'static>(
+        &self,
+    ) -> Result<T, Box<dyn Error>> {
+        Ok(self.context.lock().unwrap().load()?)
+    }
+
+    pub fn read_primary<T: AllowedMimeTypes + 'static>(
+        &self,
+    ) -> Result<T, Box<dyn Error>> {
+        Ok(self.context.lock().unwrap().load_primary()?)
+    }
 }