wingy_appkit/

data_transfer.rs

use std::cell::{Cell, RefCell};
use std::collections::HashMap;
use std::io;
use std::ops::{BitOr, ControlFlow};
use std::sync::atomic::{AtomicI64, Ordering};
use std::sync::{Arc, OnceLock};

use dispatch2::MainThreadBound;
use objc2::rc::{Retained, Weak};
use objc2::runtime::AnyObject;
use objc2::{
    AnyThread, ClassType, DefinedClass as _, MainThreadMarker, Message, define_class, msg_send,
};
use objc2_app_kit::{
    NSDragOperation, NSPasteboard, NSPasteboardType, NSPasteboardTypeFileURL, NSPasteboardTypeHTML,
    NSPasteboardTypePNG, NSPasteboardTypeSound, NSPasteboardTypeString, NSPasteboardTypeTIFF,
    NSPasteboardWriting, NSPasteboardWritingOptions,
};
use objc2_foundation::{NSArray, NSData, NSObject, NSObjectProtocol, NSString, NSURL};
use wingy_core::data_transfer::{
    DataTransfer, DataTransferId, DataTransferSend, SendData, TransferType, TypeHint, TypedData,
};
use wingy_core::event_loop::DndAction;
use wingy_core::window::WindowId;

/// A thin wrapper around [`NSPasteboardType`], implementing [`TransferType`].
#[derive(PartialEq, Eq, Debug, Clone)]
pub struct PasteboardType {
    hint: Option<TypeHint>,
    // We need to convert `NSString` to `str` since `NSString` isn't `Send`/`Sync`
    inner: Arc<str>,
}

impl PasteboardType {
    fn from_hint(hint: TypeHint) -> Option<Self> {
        let hint_to_pasteboard_type = unsafe {
            [
                (TypeHint::UriList, NSPasteboardTypeFileURL),
                (TypeHint::Plaintext, NSPasteboardTypeString),
                (TypeHint::Html, NSPasteboardTypeHTML),
                (TypeHint::Image { extension_hint: Some("png") }, NSPasteboardTypePNG),
                (TypeHint::Image { extension_hint: Some("tiff") }, NSPasteboardTypeTIFF),
                (TypeHint::Audio { extension_hint: None }, NSPasteboardTypeSound),
            ]
        };

        hint_to_pasteboard_type.into_iter().find_map(|(haystack, inner)| {
            (haystack.matches(&hint))
                .then(|| Self { hint: Some(hint), inner: inner.to_string().into() })
        })
    }
}

impl From<Retained<NSPasteboardType>> for PasteboardType {
    fn from(value: Retained<NSPasteboardType>) -> Self {
        let pasteboard_type_to_hint = unsafe {
            [
                // Just in case the source application uses the deprecated method, we handle it
                // here
                #[expect(deprecated)]
                (objc2_app_kit::NSFilenamesPboardType, TypeHint::UriList),
                (NSPasteboardTypeFileURL, TypeHint::UriList),
                (NSPasteboardTypeString, TypeHint::Plaintext),
                (NSPasteboardTypeHTML, TypeHint::Html),
                (NSPasteboardTypePNG, TypeHint::Image { extension_hint: Some("png") }),
                (NSPasteboardTypeTIFF, TypeHint::Image { extension_hint: Some("tiff") }),
                (NSPasteboardTypeSound, TypeHint::Audio { extension_hint: None }),
            ]
        };

        let hint = pasteboard_type_to_hint
            .iter()
            .find_map(|(pb_type, hint)| (**pb_type == *value).then_some(hint));

        Self { hint: hint.copied(), inner: value.to_string().into() }
    }
}

impl TransferType for PasteboardType {
    fn hint(&self) -> Option<wingy_core::data_transfer::TypeHint> {
        self.hint
    }

    fn matches(&self, other: &dyn TransferType) -> bool {
        if let Some(other_pb_type) = other.cast_ref::<Self>() {
            *self == *other_pb_type
        } else {
            // If either hint is `None`, return false
            self.hint().is_some_and(|hint| other.hint() == Some(hint))
        }
    }
}

/// A thin wrapper around [`NSPasteboard`], implementing [`DataTransfer`].
#[derive(Debug)]
pub struct Pasteboard {
    transfer_id: DataTransferId,
    ns_pasteboard: MainThreadBound<Retained<NSPasteboard>>,
    change_count: isize,
    types: OnceLock<Arc<[PasteboardType]>>,
}

impl Clone for Pasteboard {
    fn clone(&self) -> Self {
        let inner = self.ns_pasteboard.get_on_main(|inner| {
            MainThreadBound::new(inner.clone(), MainThreadMarker::new().unwrap())
        });

        Self {
            transfer_id: self.transfer_id,
            ns_pasteboard: inner,
            change_count: self.change_count,
            types: self.types.clone(),
        }
    }
}

impl Pasteboard {
    pub(crate) fn new(
        transfer_id: DataTransferId,
        ns_pasteboard: Retained<NSPasteboard>,
        mtm: MainThreadMarker,
    ) -> Self {
        let change_count = ns_pasteboard.changeCount();
        Self {
            transfer_id,
            ns_pasteboard: MainThreadBound::new(ns_pasteboard, mtm),
            change_count,
            types: Default::default(),
        }
    }

    pub(crate) fn change_count(&self) -> isize {
        self.change_count
    }

    fn try_access<R: Send>(&self, f: impl FnOnce(&NSPasteboard) -> R + Send) -> io::Result<R> {
        self.ns_pasteboard.get_on_main(|pasteboard| {
            if pasteboard.changeCount() != self.change_count {
                return Err(io::Error::other("pasteboard contents changed"));
            }
            let result = f(pasteboard);
            if pasteboard.changeCount() != self.change_count {
                return Err(io::Error::other("pasteboard contents changed"));
            }
            Ok(result)
        })
    }

    /// Get the array of [`PasteboardType`]s advertized by this [`Pasteboard`].
    pub fn types(&self) -> &[PasteboardType] {
        self.types.get_or_init(|| {
            self.try_access(|pb| {
                pb.types()
                    .map(|types| types.into_iter().map(PasteboardType::from).collect::<Vec<_>>())
                    .unwrap_or_default()
            })
            .unwrap_or_default()
            .into()
        })
    }

    /// Get the `DataTransferId` of this pasteboard.
    pub fn id(&self) -> DataTransferId {
        self.transfer_id
    }

    /// Get a typed reader for this pasteboard. This is only necessary in the cross-platform case,
    /// as a user downcasting to the platform-specific type can just access the `NSPasteboard`
    /// directly.
    pub(crate) fn with_type(&self, type_: PasteboardTypeSpec) -> PasteboardValue {
        PasteboardValue { type_, pasteboard: self.clone() }
    }
}

impl DataTransfer for Pasteboard {
    fn for_each_available_type<'this>(
        &'this self,
        func: &'_ mut dyn FnMut(&'this dyn TransferType) -> std::ops::ControlFlow<()>,
    ) {
        let _ = self.types().iter().map(|mime| mime as &dyn TransferType).try_for_each(func);
    }
}

#[derive(Debug, Clone)]
pub(crate) enum PasteboardTypeSpec {
    PasteboardType(PasteboardType),
    TypeHint(TypeHint),
}

impl PasteboardTypeSpec {
    pub(crate) fn from_dyn(type_: &dyn TransferType) -> Option<Self> {
        match type_.cast_ref::<PasteboardType>() {
            Some(pb_type) => Some(Self::PasteboardType(pb_type.clone())),
            None => type_.hint().map(Into::into),
        }
    }
}

impl From<TypeHint> for PasteboardTypeSpec {
    fn from(value: TypeHint) -> Self {
        match PasteboardType::from_hint(value) {
            Some(pb_type) => Self::PasteboardType(pb_type),
            None => Self::TypeHint(value),
        }
    }
}

impl PasteboardTypeSpec {
    fn pasteboard_type(&self) -> Option<&PasteboardType> {
        match self {
            PasteboardTypeSpec::PasteboardType(pasteboard_type) => Some(pasteboard_type),
            PasteboardTypeSpec::TypeHint(_) => None,
        }
    }
}

pub fn dnd_action_to_ns_drag_operation(value: DndAction) -> NSDragOperation {
    match value {
        DndAction::Copy => NSDragOperation::Copy,
        DndAction::Move => NSDragOperation::Move,
        DndAction::Link => NSDragOperation::Link,
        DndAction::Private => NSDragOperation::Private,
        _ => NSDragOperation::empty(),
    }
}

pub fn ns_drag_operation_to_dnd_action(value: NSDragOperation) -> Option<DndAction> {
    [
        (NSDragOperation::Copy, DndAction::Copy),
        (NSDragOperation::Move, DndAction::Move),
        (NSDragOperation::Link, DndAction::Link),
        (NSDragOperation::Private, DndAction::Private),
        // Sometimes the OS returns `Generic`, in which case we just fall back to `Copy`.
        (NSDragOperation::Generic, DndAction::Copy),
    ]
    .into_iter()
    .find_map(|(appkit, wingy)| value.contains(appkit).then_some(wingy))
}

pub fn dnd_actions_to_ns_drag_operation(value: &[DndAction]) -> NSDragOperation {
    value
        .iter()
        .copied()
        .map(dnd_action_to_ns_drag_operation)
        .fold(NSDragOperation::empty(), BitOr::bitor)
}

pub fn preferred_drag_operation(
    value: NSDragOperation,
    preference: &[DndAction],
) -> Option<DndAction> {
    preference
        .iter()
        .find(|action| value.intersects(dnd_action_to_ns_drag_operation(**action)))
        .copied()
}

/// A thin wrapper around [`NSPasteboard`], implementing [`TypedData`].
#[derive(Debug)]
pub struct PasteboardValue {
    // The concept of "top-level" types for a pasteboard doesn't always make sense on macOS due to
    // the use of `pasteboardItems`, so we allow using `TypeHint` instead to preserve the user's
    // intention.
    type_: PasteboardTypeSpec,
    pasteboard: Pasteboard,
}

impl TypedData for PasteboardValue {
    fn type_(&self) -> &dyn TransferType {
        match &self.type_ {
            PasteboardTypeSpec::PasteboardType(pasteboard_type) => {
                pasteboard_type as &dyn TransferType
            },
            PasteboardTypeSpec::TypeHint(type_hint) => type_hint,
        }
    }

    fn try_read(&self) -> Option<Box<dyn io::BufRead>> {
        self.try_as_bytes()
            .ok()
            .map(|bytes| Box::new(io::Cursor::new(bytes)) as Box<dyn io::BufRead>)
    }

    fn try_as_bytes(&self) -> io::Result<Vec<u8>> {
        let type_ = self.type_.clone();
        self.pasteboard
            .try_access(|pasteboard| {
                let bytes =
                    pasteboard.dataForType(&NSString::from_str(&type_.pasteboard_type()?.inner))?;
                Some(bytes.to_vec())
            })?
            .ok_or_else(|| {
                io::Error::other(format!(
                    "NSPasteboard doesn't advertise a binary representation for type {:?}",
                    self.type_
                ))
            })
    }

    fn try_as_uris(&self) -> io::Result<Vec<String>> {
        if self.type_().hint() != Some(TypeHint::UriList) {
            return Err(io::ErrorKind::InvalidData.into());
        }

        self.pasteboard.try_access(|pasteboard| {
            let classes = NSArray::from_slice(&[NSURL::class()]);
            let uris = unsafe { pasteboard.readObjectsForClasses_options(&classes, None) }
                .into_iter()
                .flatten()
                .filter_map(|url| url.downcast::<NSURL>().ok())
                .filter_map(|url| {
                    url.filePathURL()
                        .as_deref()
                        .unwrap_or(&url)
                        .absoluteString()
                        .map(|uri| uri.to_string())
                })
                .collect::<Vec<_>>();

            if !uris.is_empty() {
                return Ok(uris);
            }

            // The pasteboard didn't expose any URLs, so we try with the deprecated method.
            #[expect(deprecated)]
            let property_list = pasteboard
                .propertyListForType(unsafe { objc2_app_kit::NSFilenamesPboardType })
                .ok_or(io::ErrorKind::InvalidData)?;

            Ok(property_list
                .downcast::<NSArray>()
                .unwrap()
                .into_iter()
                .filter_map(|file| {
                    NSURL::fileURLWithPath(&file.downcast::<NSString>().unwrap()).absoluteString()
                })
                .map(|uri| uri.to_string())
                .collect())
        })?
    }

    fn try_as_string(&self) -> io::Result<String> {
        let type_ = self.type_.clone();

        self.pasteboard.try_access(|pasteboard| {
            pasteboard
                .stringForType(&NSString::from_str(
                    &type_.pasteboard_type().ok_or(io::ErrorKind::InvalidData)?.inner,
                ))
                .map(|ns_str| ns_str.to_string())
                .ok_or_else(|| io::ErrorKind::InvalidData.into())
        })?
    }
}

#[derive(Debug)]
struct ActivePasteboard {
    window_id: WindowId,
    pb: MainThreadBound<Weak<NSPasteboard>>,
}

#[derive(Debug, Default)]
pub struct Pasteboards {
    inner: RefCell<HashMap<DataTransferId, ActivePasteboard>>,
}

impl Pasteboards {
    pub fn remove_deloaded_pasteboards(&self) {
        self.inner.borrow_mut().retain(|_, ActivePasteboard { pb, .. }| {
            pb.get_on_main(|state| state.load().is_some())
        });
    }

    /// If the data transfer exists, update the pasteboard it points to.
    pub fn set_pasteboard(
        &self,
        id: DataTransferId,
        new_pb: &MainThreadBound<Retained<NSPasteboard>>,
    ) {
        let mut inner = self.inner.borrow_mut();
        if let Some(ActivePasteboard { pb, .. }) = inner.get_mut(&id) {
            *pb = new_pb.get_on_main(|pb| {
                MainThreadBound::new(Weak::from_retained(pb), MainThreadMarker::new().unwrap())
            });
        }
    }

    pub fn insert(
        &self,
        transfer_id: DataTransferId,
        pb: &MainThreadBound<Retained<NSPasteboard>>,
        window_id: WindowId,
    ) {
        let mut inner = self.inner.borrow_mut();
        let transfer = inner.entry(transfer_id).or_insert_with(move || {
            pb.get_on_main(move |pb| ActivePasteboard {
                window_id,
                pb: MainThreadBound::new(Weak::from_retained(pb), MainThreadMarker::new().unwrap()),
            })
        });

        transfer.window_id = window_id;
    }

    pub fn get(&self, id: DataTransferId) -> Option<Pasteboard> {
        self.inner.borrow().get(&id).and_then(|ActivePasteboard { pb, .. }| {
            pb.get_on_main(|state| {
                Some(Pasteboard::new(id, state.load()?, MainThreadMarker::new().unwrap()))
            })
        })
    }

    /// Get the window ID that most-recently saw the provided data transfer.
    pub fn window_id(&self, id: DataTransferId) -> Option<WindowId> {
        self.inner.borrow().get(&id).map(|active_pasteboard| active_pasteboard.window_id)
    }
}

#[derive(Debug)]
struct DragState {
    id: DataTransferId,
    valid_actions: Vec<DndAction>,
}

#[derive(Debug, Default)]
pub(crate) struct DataTransferState {
    pasteboards: Pasteboards,
    clipboard: Cell<Option<(isize, DataTransferId)>>,
    drag: RefCell<Option<DragState>>,
}

impl DataTransferState {
    pub(crate) fn pasteboards(&self) -> &Pasteboards {
        &self.pasteboards
    }

    pub(crate) fn register_drag(
        &self,
        id: DataTransferId,
        pb: &MainThreadBound<Retained<NSPasteboard>>,
        window_id: WindowId,
    ) {
        self.pasteboards.insert(id, pb, window_id);
        self.drag.replace(Some(DragState { id, valid_actions: vec![] }));
    }

    pub(crate) fn remove_drag(&self, id: DataTransferId) {
        let mut state = self.drag.borrow_mut();
        if state.as_ref().is_some_and(|s| s.id == id) {
            *state = None;
        }
    }

    pub(crate) fn current_drag_id(&self) -> Option<DataTransferId> {
        self.drag.borrow().as_ref().map(|state| state.id)
    }

    pub(crate) fn set_valid_dnd_actions(&self, id: DataTransferId, actions: &[DndAction]) -> bool {
        match &mut *self.drag.borrow_mut() {
            Some(state) if state.id == id => {
                state.valid_actions.clear();
                state.valid_actions.extend_from_slice(actions);
                true
            },
            _ => false,
        }
    }

    pub(crate) fn proposed_drag_action(
        &self,
        source_operations: NSDragOperation,
    ) -> Option<DndAction> {
        self.drag
            .borrow()
            .as_ref()
            .and_then(|state| preferred_drag_operation(source_operations, &state.valid_actions))
    }

    pub(crate) fn proposed_drag_operation(
        &self,
        source_operations: NSDragOperation,
    ) -> NSDragOperation {
        self.proposed_drag_action(source_operations)
            .map(dnd_action_to_ns_drag_operation)
            .unwrap_or(NSDragOperation::empty())
    }

    pub(crate) fn clipboard_transfer_id(&self, change_count: isize) -> DataTransferId {
        // Counts downward to keep clipboard IDs disjoint from drag IDs.
        static NEXT_ID: AtomicI64 = AtomicI64::new(-1);

        match self.clipboard.get() {
            Some((cached, id)) if cached == change_count => id,
            _ => {
                let id = DataTransferId::from_raw(NEXT_ID.fetch_sub(1, Ordering::Relaxed));
                self.clipboard.set(Some((change_count, id)));
                id
            },
        }
    }
}

pub(crate) struct PasteboardWriterState {
    data: Box<dyn DataTransferSend>,
    // The macOS drag-and-drop API has some confusing aspects when handling multi-drag. The best
    // we can really do is have the first element contain all the cross-platform items, and
    // any further items are file paths only.
    uri: Option<Retained<NSString>>,
    writable_types: Retained<NSArray<NSPasteboardType>>,
}

impl PasteboardWriter {
    pub(crate) fn new(
        value: Box<dyn DataTransferSend>,
        uri: Option<Retained<NSString>>,
    ) -> Retained<Self> {
        let mut writable_types = Vec::<Retained<NSPasteboardType>>::new();
        value.for_each_available_type(&mut |type_| {
            let Some(spec) = PasteboardTypeSpec::from_dyn(type_) else {
                return ControlFlow::Continue(());
            };

            let Some(pb_type) = spec.pasteboard_type() else {
                return ControlFlow::Continue(());
            };

            writable_types.push(NSString::from_str(&pb_type.inner));

            ControlFlow::Continue(())
        });

        let pb_writer = Self::alloc().set_ivars(PasteboardWriterState {
            data: value,
            uri,
            writable_types: NSArray::from_retained_slice(&writable_types),
        });

        // Unsure if there's an easier way to do this, but this is how `WindowDelegate` does it.
        unsafe { msg_send![super(pb_writer), init] }
    }
}

impl PasteboardWriterState {
    fn data_for_pasteboard_type(
        &self,
        pasteboard_type: &NSPasteboardType,
    ) -> Option<Retained<AnyObject>> {
        if pasteboard_type == unsafe { NSPasteboardTypeFileURL } {
            if let Some(out) = self.uri.clone().map(Into::into) {
                return Some(out);
            }
        }
        let pb_type = PasteboardType::from(pasteboard_type.retain());

        let mut out = None;

        self.data.for_each_available_type(&mut |haystack| {
            if haystack.matches(&pb_type) {
                out = self.data.data_for_type(haystack);
                ControlFlow::Break(())
            } else {
                ControlFlow::Continue(())
            }
        });

        match out? {
            // This should be handled separately
            // TODO: Is there a better way to do this?
            SendData::Uris(_) => None,
            SendData::String(string) => Some(NSString::from_str(&string).into()),
            SendData::Bytes(binary) => Some(NSData::from_vec(binary).into()),
            _ => None,
        }
    }
}

define_class!(
    #[unsafe(super(NSObject))]
    #[thread_kind = AnyThread]
    #[name = "WingyPasteboardWriter"]
    #[ivars = PasteboardWriterState]
    pub(crate) struct PasteboardWriter;

    unsafe impl NSObjectProtocol for PasteboardWriter {}

    unsafe impl NSPasteboardWriting for PasteboardWriter {
        #[unsafe(method_id(writableTypesForPasteboard:))]
        fn writable_types_for_pasteboard(
            &self,
            _: &NSPasteboard,
        ) -> Retained<NSArray<NSPasteboardType>> {
            let vars = self.ivars();
            vars.writable_types.clone()
        }

        #[unsafe(method(writingOptionsForType:pasteboard:))]
        fn writing_options_for_type(
            &self,
            type_: &NSPasteboardType,
            pasteboard: &NSPasteboard,
        ) -> NSPasteboardWritingOptions {
            let _ = type_;
            let _ = pasteboard;
            NSPasteboardWritingOptions::empty()
        }

        #[unsafe(method_id(pasteboardPropertyListForType:))]
        fn pasteboard_property_list_for_type(
            &self,
            type_: &NSPasteboardType,
        ) -> Option<Retained<AnyObject>> {
            let vars = self.ivars();
            vars.data_for_pasteboard_type(type_)
        }
    }
);