1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163

use std::sync::{Arc, Mutex};

use wayland_protocols::{
    misc::gtk_primary_selection::client::gtk_primary_selection_device::{
        self, GtkPrimarySelectionDevice,
    },
    unstable::primary_selection::v1::client::zwp_primary_selection_device_v1::{
        self, ZwpPrimarySelectionDeviceV1,
    },
};

use wayland_client::protocol::wl_seat::WlSeat;

use crate::primary_selection::offer::PrimarySelectionOfferImpl;
use crate::primary_selection::source::PrimarySelectionSourceImpl;

use super::PrimarySelectionDeviceManager;
use super::PrimarySelectionOffer;
use super::PrimarySelectionSource;

/// Handle to support primary selection on a given seat.
///
/// This type provides you with copy/paste actions. It is associated with a seat upon creation.
pub struct PrimarySelectionDevice {
    device: PrimarySelectionDeviceImpl,
    inner: Arc<Mutex<PrimarySelectionDeviceInner>>,
}

/// Possible supported primary selection devices.
enum PrimarySelectionDeviceImpl {
    Zwp(ZwpPrimarySelectionDeviceV1),
    Gtk(GtkPrimarySelectionDevice),
}

/// Inner state for `PrimarySelectionDevice`.
struct PrimarySelectionDeviceInner {
    /// Current selection.
    selection: Option<PrimarySelectionOffer>,

    /// List of known offers.
    know_offers: Vec<PrimarySelectionOffer>,
}

impl PrimarySelectionDeviceInner {
    /// Provide a primary selection source as the new content for the primary selection.
    ///
    /// Correspond to traditional copy/paste behavior. Setting the source to `None` will clear
    /// the selection.
    fn set_selection(&mut self, offer: Option<PrimarySelectionOfferImpl>) {
        let offer = match offer {
            Some(offer) => offer,
            None => {
                // Drop the current offer if any.
                self.selection = None;
                return;
            }
        };

        if let Some(id) = self.know_offers.iter().position(|o| o.offer == offer) {
            self.selection = Some(self.know_offers.swap_remove(id));
        } else {
            panic!("Compositor set an unknown primary offer for a primary selection.")
        }
    }
}

impl Drop for PrimarySelectionDevice {
    fn drop(&mut self) {
        match self.device {
            PrimarySelectionDeviceImpl::Zwp(ref device) => device.destroy(),
            PrimarySelectionDeviceImpl::Gtk(ref device) => device.destroy(),
        }
    }
}

impl PrimarySelectionDevice {
    /// Create the `PrimarySelectionDevice` helper for this seat.
    pub fn init_for_seat(manager: &PrimarySelectionDeviceManager, seat: &WlSeat) -> Self {
        let inner = Arc::new(Mutex::new(PrimarySelectionDeviceInner {
            selection: None,
            know_offers: Vec::new(),
        }));

        let inner2 = inner.clone();

        let device = match manager {
            PrimarySelectionDeviceManager::Zwp(zwp_manager) => {
                let device = zwp_manager.get_device(seat);

                device.quick_assign(move |_, event, _| {
                    let mut inner = inner2.lock().unwrap();

                    use zwp_primary_selection_device_v1::Event;
                    match event {
                        Event::DataOffer { offer } => {
                            inner.know_offers.push(PrimarySelectionOffer::from_zwp(offer))
                        }
                        Event::Selection { id } => {
                            let id = id.map(PrimarySelectionOfferImpl::Zwp);
                            inner.set_selection(id);
                        }
                        _ => unreachable!(),
                    }
                });

                PrimarySelectionDeviceImpl::Zwp(device.detach())
            }
            PrimarySelectionDeviceManager::Gtk(gtk_manager) => {
                let device = gtk_manager.get_device(seat);

                device.quick_assign(move |_, event, _| {
                    let mut inner = inner2.lock().unwrap();

                    use gtk_primary_selection_device::Event;
                    match event {
                        Event::DataOffer { offer } => {
                            inner.know_offers.push(PrimarySelectionOffer::from_gtk(offer))
                        }
                        Event::Selection { id } => {
                            let id = id.map(PrimarySelectionOfferImpl::Gtk);
                            inner.set_selection(id);
                        }
                        _ => unreachable!(),
                    }
                });
                PrimarySelectionDeviceImpl::Gtk(device.detach())
            }
        };

        Self { device, inner }
    }

    /// Provide a primary selection source as the new content for the primary selection.
    ///
    /// Correspond to traditional copy/paste behavior. Setting the source to `None` will clear
    /// the selection.
    pub fn set_selection(&self, source: &Option<PrimarySelectionSource>, serial: u32) {
        match self.device {
            PrimarySelectionDeviceImpl::Zwp(ref device) => {
                let source = source.as_ref().map(|source| match source.source {
                    PrimarySelectionSourceImpl::Zwp(ref source) => source,
                    // We can't reach `Gtk` source in `Zwp`.
                    _ => unreachable!(),
                });
                device.set_selection(source, serial);
            }
            PrimarySelectionDeviceImpl::Gtk(ref device) => {
                let source = source.as_ref().map(|source| match source.source {
                    PrimarySelectionSourceImpl::Gtk(ref source) => source,
                    // We can't reach `Zwp` source in `Gtk`.
                    _ => unreachable!(),
                });
                device.set_selection(source, serial);
            }
        }
    }

    /// Access the `PrimarySelectionOffer` currently associated with the primary selection buffer.
    pub fn with_selection<F: FnOnce(Option<&PrimarySelectionOffer>) -> T, T>(&self, f: F) -> T {
        let inner = self.inner.lock().unwrap();
        f(inner.selection.as_ref())
    }
}