smithay-clipboard 0.6.0

Provides access to the wayland clipboard for client applications.
Documentation 
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

#![macro_use]

use std::fs::File;
use std::io::Result;
use std::os::unix::io::FromRawFd;
use std::sync::mpsc::Sender;

use sctk::reexports::client::protocol::wl_keyboard::Event as KeyboardEvent;
use sctk::reexports::client::protocol::wl_pointer::Event as PointerEvent;
use sctk::reexports::client::protocol::wl_seat::WlSeat;
use sctk::reexports::client::DispatchData;

use super::dispatch_data::ClipboardDispatchData;

/// Macro to handle load for selection and primary clipboards.
macro_rules! handle_load {
    ($env:ident, $sel_ty:ident, $seat:ident, $queue:ident, $tx:ident ) => {
        let result = $env.$sel_ty(&$seat, |device| {
            let (mut reader, mime_type) = match device.with_selection(|offer| {
                // Check that we have an offer.
                let offer = match offer {
                    Some(offer) => offer,
                    None => return None,
                };

                // Check that we can work with advertised mime type and pick the one
                // that suits us more.
                let mime_type = match offer.with_mime_types(MimeType::find_allowed) {
                    Some(mime_type) => mime_type,
                    None => return None,
                };

                // Request given the mime type.
                let reader = offer.receive(mime_type.to_string()).ok()?;
                Some((reader, mime_type))
            }) {
                Some((reader, mime_type)) => (reader, mime_type),
                None => {
                    handlers::reply_error(&$tx, "offer receive failed.");
                    return ();
                }
            };

            // If we fail here, it means that we likely won't be able
            // to read clipboard anyway, so return and reply to prevent block/crash.
            if $queue.sync_roundtrip(&mut (), |_, _, _| unreachable!()).is_err() {
                handlers::reply_error(&$tx, "failed to access clipboard.");
                return;
            };

            let mut contents = String::new();
            let result = reader.read_to_string(&mut contents).map(|_| {
                if mime_type == MimeType::Utf8String {
                    mime::normilize_to_lf(contents)
                } else {
                    contents
                }
            });

            let _ = $tx.send(result);
        });

        // Send back that we've failed to load data from the clipboard.
        if result.is_err() {
            handlers::reply_error(&$tx, "failed to access clipboard.");
        }
    };
}

/// Macro to handle store for selection and primary clipboards.
macro_rules! handle_store {
    ($env:ident,
     $sel_source:ident, $sel_device:ident, $event_ty:ident,
     $seat:ident, $serial:ident, $queue:ident, $contents:ident) => {
        let data_source = $env.$sel_source(
            vec![MimeType::TextPlainUtf8.to_string(), MimeType::Utf8String.to_string()],
            move |event, _| {
                if let $event_ty::Send { mut pipe, .. } = event {
                    write!(pipe, "{}", $contents).unwrap();
                }
            },
        );

        let _ = $env.$sel_device(&$seat, |device| {
            device.set_selection(&Some(data_source), $serial);

            let _ = $queue.sync_roundtrip(&mut (), |_, _, _| unreachable!());
        });
    };
}

/// Reply an error to a clipboard master.
pub fn reply_error(tx: &Sender<Result<String>>, description: &str) {
    let _ = tx.send(Err(std::io::Error::new(std::io::ErrorKind::Other, description)));
}

/// Update seat and serial on pointer events.
pub fn pointer_handler(seat: WlSeat, event: PointerEvent, mut dispatch_data: DispatchData) {
    let dispatch_data = match dispatch_data.get::<ClipboardDispatchData>() {
        Some(dispatch_data) => dispatch_data,
        None => return,
    };
    match event {
        PointerEvent::Enter { serial, .. } => {
            dispatch_data.set_last_seat(seat, serial);
        }
        PointerEvent::Button { serial, .. } => {
            dispatch_data.set_last_seat(seat, serial);
        }
        _ => {}
    }
}

/// Update seat and serial on keyboard events.
pub fn keyboard_handler(seat: WlSeat, event: KeyboardEvent, mut dispatch_data: DispatchData) {
    let dispatch_data = match dispatch_data.get::<ClipboardDispatchData>() {
        Some(dispatch_data) => dispatch_data,
        None => return,
    };
    match event {
        KeyboardEvent::Enter { serial, .. } => {
            dispatch_data.set_last_seat(seat, serial);
        }
        KeyboardEvent::Key { serial, .. } => {
            dispatch_data.set_last_seat(seat, serial);
        }
        KeyboardEvent::Leave { .. } => {
            dispatch_data.remove_seat(seat);
        }
        KeyboardEvent::Keymap { fd, .. } => {
            // Prevent fd leaking.
            let _ = unsafe { File::from_raw_fd(fd) };
        }
        _ => {}
    }
}