1use std::borrow::Cow;
2use std::collections::HashMap;
3use std::io::{Error, ErrorKind, Read, Result, Write};
4use std::mem;
5use std::os::unix::io::{AsRawFd, RawFd};
6use std::rc::Rc;
7use std::sync::mpsc::Sender;
8
9use sctk::data_device_manager::data_device::{DataDevice, DataDeviceHandler};
10use sctk::data_device_manager::data_offer::{DataOfferError, DataOfferHandler, DragOffer};
11use sctk::data_device_manager::data_source::{CopyPasteSource, DataSourceHandler};
12use sctk::data_device_manager::{DataDeviceManagerState, WritePipe};
13use sctk::primary_selection::device::{PrimarySelectionDevice, PrimarySelectionDeviceHandler};
14use sctk::primary_selection::selection::{PrimarySelectionSource, PrimarySelectionSourceHandler};
15use sctk::primary_selection::PrimarySelectionManagerState;
16use sctk::registry::{ProvidesRegistryState, RegistryState};
17use sctk::seat::pointer::{PointerData, PointerEvent, PointerEventKind, PointerHandler};
18use sctk::seat::{Capability, SeatHandler, SeatState};
19use sctk::{
20 delegate_data_device, delegate_pointer, delegate_primary_selection, delegate_registry,
21 delegate_seat, registry_handlers,
22};
23
24use sctk::reexports::calloop::{LoopHandle, PostAction};
25use sctk::reexports::client::globals::GlobalList;
26use sctk::reexports::client::protocol::wl_data_device::WlDataDevice;
27use sctk::reexports::client::protocol::wl_data_device_manager::DndAction;
28use sctk::reexports::client::protocol::wl_data_source::WlDataSource;
29use sctk::reexports::client::protocol::wl_keyboard::WlKeyboard;
30use sctk::reexports::client::protocol::wl_pointer::WlPointer;
31use sctk::reexports::client::protocol::wl_seat::WlSeat;
32use sctk::reexports::client::protocol::wl_surface::WlSurface;
33use sctk::reexports::client::{Connection, Dispatch, Proxy, QueueHandle};
34use sctk::reexports::protocols::wp::primary_selection::zv1::client::{
35 zwp_primary_selection_device_v1::ZwpPrimarySelectionDeviceV1,
36 zwp_primary_selection_source_v1::ZwpPrimarySelectionSourceV1,
37};
38use wayland_backend::client::ObjectId;
39
40use crate::mime::{normalize_to_lf, MimeType, ALLOWED_MIME_TYPES};
41
42pub struct State {
43 pub primary_selection_manager_state: Option<PrimarySelectionManagerState>,
44 pub data_device_manager_state: Option<DataDeviceManagerState>,
45 pub reply_tx: Sender<Result<String>>,
46 pub exit: bool,
47
48 registry_state: RegistryState,
49 seat_state: SeatState,
50
51 seats: HashMap<ObjectId, ClipboardSeatState>,
52 /// The latest seat which got an event.
53 latest_seat: Option<ObjectId>,
54
55 loop_handle: LoopHandle<'static, Self>,
56 queue_handle: QueueHandle<Self>,
57
58 primary_sources: Vec<PrimarySelectionSource>,
59 primary_selection_content: Rc<[u8]>,
60
61 data_sources: Vec<CopyPasteSource>,
62 data_selection_content: Rc<[u8]>,
63}
64
65impl State {
66 #[must_use]
67 pub fn new(
68 globals: &GlobalList,
69 queue_handle: &QueueHandle<Self>,
70 loop_handle: LoopHandle<'static, Self>,
71 reply_tx: Sender<Result<String>>,
72 ) -> Option<Self> {
73 let mut seats = HashMap::new();
74
75 let data_device_manager_state = DataDeviceManagerState::bind(globals, queue_handle).ok();
76 let primary_selection_manager_state =
77 PrimarySelectionManagerState::bind(globals, queue_handle).ok();
78
79 // When both globals are not available nothing could be done.
80 if data_device_manager_state.is_none() && primary_selection_manager_state.is_none() {
81 return None;
82 }
83
84 let seat_state = SeatState::new(globals, queue_handle);
85 for seat in seat_state.seats() {
86 seats.insert(seat.id(), Default::default());
87 }
88
89 Some(Self {
90 registry_state: RegistryState::new(globals),
91 primary_selection_content: Rc::from([]),
92 data_selection_content: Rc::from([]),
93 queue_handle: queue_handle.clone(),
94 primary_selection_manager_state,
95 primary_sources: Vec::new(),
96 data_device_manager_state,
97 data_sources: Vec::new(),
98 latest_seat: None,
99 loop_handle,
100 exit: false,
101 seat_state,
102 reply_tx,
103 seats,
104 })
105 }
106
107 /// Store selection for the given target.
108 ///
109 /// Selection source is only created when `Some(())` is returned.
110 pub fn store_selection(&mut self, ty: SelectionTarget, contents: String) -> Option<()> {
111 let latest = self.latest_seat.as_ref()?;
112 let seat = self.seats.get_mut(latest)?;
113
114 if !seat.has_focus {
115 return None;
116 }
117
118 let contents = Rc::from(contents.into_bytes());
119
120 match ty {
121 SelectionTarget::Clipboard => {
122 let mgr = self.data_device_manager_state.as_ref()?;
123 self.data_selection_content = contents;
124 let source =
125 mgr.create_copy_paste_source(&self.queue_handle, ALLOWED_MIME_TYPES.iter());
126 source.set_selection(seat.data_device.as_ref().unwrap(), seat.latest_serial);
127 self.data_sources.push(source);
128 },
129 SelectionTarget::Primary => {
130 let mgr = self.primary_selection_manager_state.as_ref()?;
131 self.primary_selection_content = contents;
132 let source =
133 mgr.create_selection_source(&self.queue_handle, ALLOWED_MIME_TYPES.iter());
134 source.set_selection(seat.primary_device.as_ref().unwrap(), seat.latest_serial);
135 self.primary_sources.push(source);
136 },
137 }
138
139 Some(())
140 }
141
142 /// Load selection for the given target.
143 pub fn load_selection(&mut self, ty: SelectionTarget) -> Result<()> {
144 let latest = self
145 .latest_seat
146 .as_ref()
147 .ok_or_else(|| Error::new(ErrorKind::Other, "no events received on any seat"))?;
148 let seat = self
149 .seats
150 .get_mut(latest)
151 .ok_or_else(|| Error::new(ErrorKind::Other, "active seat lost"))?;
152
153 if !seat.has_focus {
154 return Err(Error::new(ErrorKind::Other, "client doesn't have focus"));
155 }
156
157 let (read_pipe, mime_type) = match ty {
158 SelectionTarget::Clipboard => {
159 let selection = seat
160 .data_device
161 .as_ref()
162 .and_then(|data| data.data().selection_offer())
163 .ok_or_else(|| Error::new(ErrorKind::Other, "selection is empty"))?;
164
165 let mime_type =
166 selection.with_mime_types(MimeType::find_allowed).ok_or_else(|| {
167 Error::new(ErrorKind::NotFound, "supported mime-type is not found")
168 })?;
169
170 (
171 selection.receive(mime_type.to_string()).map_err(|err| match err {
172 DataOfferError::InvalidReceive => {
173 Error::new(ErrorKind::Other, "offer is not ready yet")
174 },
175 DataOfferError::Io(err) => err,
176 })?,
177 mime_type,
178 )
179 },
180 SelectionTarget::Primary => {
181 let selection = seat
182 .primary_device
183 .as_ref()
184 .and_then(|data| data.data().selection_offer())
185 .ok_or_else(|| Error::new(ErrorKind::Other, "selection is empty"))?;
186
187 let mime_type =
188 selection.with_mime_types(MimeType::find_allowed).ok_or_else(|| {
189 Error::new(ErrorKind::NotFound, "supported mime-type is not found")
190 })?;
191
192 (selection.receive(mime_type.to_string())?, mime_type)
193 },
194 };
195
196 // Mark FD as non-blocking so we won't block ourselves.
197 unsafe {
198 set_non_blocking(read_pipe.as_raw_fd())?;
199 }
200
201 let mut reader_buffer = [0; 4096];
202 let mut content = Vec::new();
203 let _ = self.loop_handle.insert_source(read_pipe, move |_, file, state| {
204 let file = unsafe { file.get_mut() };
205 loop {
206 match file.read(&mut reader_buffer) {
207 Ok(0) => {
208 let utf8 = String::from_utf8_lossy(&content);
209 let content = match utf8 {
210 Cow::Borrowed(_) => {
211 // Don't clone the read data.
212 let mut to_send = Vec::new();
213 mem::swap(&mut content, &mut to_send);
214 String::from_utf8(to_send).unwrap()
215 },
216 Cow::Owned(content) => content,
217 };
218
219 // Post-process the content according to mime type.
220 let content = match mime_type {
221 MimeType::TextPlainUtf8 | MimeType::TextPlain => {
222 normalize_to_lf(content)
223 },
224 MimeType::Utf8String => content,
225 };
226
227 let _ = state.reply_tx.send(Ok(content));
228 break PostAction::Remove;
229 },
230 Ok(n) => content.extend_from_slice(&reader_buffer[..n]),
231 Err(err) if err.kind() == ErrorKind::WouldBlock => break PostAction::Continue,
232 Err(err) => {
233 let _ = state.reply_tx.send(Err(err));
234 break PostAction::Remove;
235 },
236 };
237 }
238 });
239
240 Ok(())
241 }
242
243 fn send_request(&mut self, ty: SelectionTarget, write_pipe: WritePipe, mime: String) {
244 // We can only send strings, so don't do anything with the mime-type.
245 if MimeType::find_allowed(&[mime]).is_none() {
246 return;
247 }
248
249 // Mark FD as non-blocking so we won't block ourselves.
250 unsafe {
251 if set_non_blocking(write_pipe.as_raw_fd()).is_err() {
252 return;
253 }
254 }
255
256 // Don't access the content on the state directly, since it could change during
257 // the send.
258 let contents = match ty {
259 SelectionTarget::Clipboard => self.data_selection_content.clone(),
260 SelectionTarget::Primary => self.primary_selection_content.clone(),
261 };
262
263 let mut written = 0;
264 let _ = self.loop_handle.insert_source(write_pipe, move |_, file, _| {
265 let file = unsafe { file.get_mut() };
266 loop {
267 match file.write(&contents[written..]) {
268 Ok(n) if written + n == contents.len() => {
269 written += n;
270 break PostAction::Remove;
271 },
272 Ok(n) => written += n,
273 Err(err) if err.kind() == ErrorKind::WouldBlock => break PostAction::Continue,
274 Err(_) => break PostAction::Remove,
275 }
276 }
277 });
278 }
279}
280
281impl SeatHandler for State {
282 fn seat_state(&mut self) -> &mut SeatState {
283 &mut self.seat_state
284 }
285
286 fn new_seat(&mut self, _: &Connection, _: &QueueHandle<Self>, seat: WlSeat) {
287 self.seats.insert(seat.id(), Default::default());
288 }
289
290 fn new_capability(
291 &mut self,
292 _: &Connection,
293 qh: &QueueHandle<Self>,
294 seat: WlSeat,
295 capability: Capability,
296 ) {
297 let seat_state = self.seats.get_mut(&seat.id()).unwrap();
298
299 match capability {
300 Capability::Keyboard => {
301 seat_state.keyboard = Some(seat.get_keyboard(qh, seat.id()));
302
303 // Selection sources are tied to the keyboard, so add/remove decives
304 // when we gain/loss capability.
305
306 if seat_state.data_device.is_none() && self.data_device_manager_state.is_some() {
307 seat_state.data_device = self
308 .data_device_manager_state
309 .as_ref()
310 .map(|mgr| mgr.get_data_device(qh, &seat));
311 }
312
313 if seat_state.primary_device.is_none()
314 && self.primary_selection_manager_state.is_some()
315 {
316 seat_state.primary_device = self
317 .primary_selection_manager_state
318 .as_ref()
319 .map(|mgr| mgr.get_selection_device(qh, &seat));
320 }
321 },
322 Capability::Pointer => {
323 seat_state.pointer = self.seat_state.get_pointer(qh, &seat).ok();
324 },
325 _ => (),
326 }
327 }
328
329 fn remove_capability(
330 &mut self,
331 _: &Connection,
332 _: &QueueHandle<Self>,
333 seat: WlSeat,
334 capability: Capability,
335 ) {
336 let seat_state = self.seats.get_mut(&seat.id()).unwrap();
337 match capability {
338 Capability::Keyboard => {
339 seat_state.data_device = None;
340 seat_state.primary_device = None;
341
342 if let Some(keyboard) = seat_state.keyboard.take() {
343 if keyboard.version() >= 3 {
344 keyboard.release()
345 }
346 }
347 },
348 Capability::Pointer => {
349 if let Some(pointer) = seat_state.pointer.take() {
350 if pointer.version() >= 3 {
351 pointer.release()
352 }
353 }
354 },
355 _ => (),
356 }
357 }
358
359 fn remove_seat(&mut self, _: &Connection, _: &QueueHandle<Self>, seat: WlSeat) {
360 self.seats.remove(&seat.id());
361 }
362}
363
364impl PointerHandler for State {
365 fn pointer_frame(
366 &mut self,
367 _: &Connection,
368 _: &QueueHandle<Self>,
369 pointer: &WlPointer,
370 events: &[PointerEvent],
371 ) {
372 let seat = pointer.data::<PointerData>().unwrap().seat();
373 let seat_id = seat.id();
374 let seat_state = match self.seats.get_mut(&seat_id) {
375 Some(seat_state) => seat_state,
376 None => return,
377 };
378
379 let mut updated_serial = false;
380 for event in events {
381 match event.kind {
382 PointerEventKind::Press { serial, .. }
383 | PointerEventKind::Release { serial, .. } => {
384 updated_serial = true;
385 seat_state.latest_serial = serial;
386 },
387 _ => (),
388 }
389 }
390
391 // Only update the seat we're using when the serial got updated.
392 if updated_serial {
393 self.latest_seat = Some(seat_id);
394 }
395 }
396}
397
398impl DataDeviceHandler for State {
399 fn enter(
400 &mut self,
401 _: &Connection,
402 _: &QueueHandle<Self>,
403 _: &WlDataDevice,
404 _: f64,
405 _: f64,
406 _: &WlSurface,
407 ) {
408 }
409
410 fn leave(&mut self, _: &Connection, _: &QueueHandle<Self>, _: &WlDataDevice) {}
411
412 fn motion(&mut self, _: &Connection, _: &QueueHandle<Self>, _: &WlDataDevice, _: f64, _: f64) {}
413
414 fn drop_performed(&mut self, _: &Connection, _: &QueueHandle<Self>, _: &WlDataDevice) {}
415
416 // The selection is finished and ready to be used.
417 fn selection(&mut self, _: &Connection, _: &QueueHandle<Self>, _: &WlDataDevice) {}
418}
419
420impl DataSourceHandler for State {
421 fn send_request(
422 &mut self,
423 _: &Connection,
424 _: &QueueHandle<Self>,
425 _: &WlDataSource,
426 mime: String,
427 write_pipe: WritePipe,
428 ) {
429 self.send_request(SelectionTarget::Clipboard, write_pipe, mime)
430 }
431
432 fn cancelled(&mut self, _: &Connection, _: &QueueHandle<Self>, deleted: &WlDataSource) {
433 self.data_sources.retain(|source| source.inner() != deleted)
434 }
435
436 fn accept_mime(
437 &mut self,
438 _: &Connection,
439 _: &QueueHandle<Self>,
440 _: &WlDataSource,
441 _: Option<String>,
442 ) {
443 }
444
445 fn dnd_dropped(&mut self, _: &Connection, _: &QueueHandle<Self>, _: &WlDataSource) {}
446
447 fn action(&mut self, _: &Connection, _: &QueueHandle<Self>, _: &WlDataSource, _: DndAction) {}
448
449 fn dnd_finished(&mut self, _: &Connection, _: &QueueHandle<Self>, _: &WlDataSource) {}
450}
451
452impl DataOfferHandler for State {
453 fn source_actions(
454 &mut self,
455 _: &Connection,
456 _: &QueueHandle<Self>,
457 _: &mut DragOffer,
458 _: DndAction,
459 ) {
460 }
461
462 fn selected_action(
463 &mut self,
464 _: &Connection,
465 _: &QueueHandle<Self>,
466 _: &mut DragOffer,
467 _: DndAction,
468 ) {
469 }
470}
471
472impl ProvidesRegistryState for State {
473 registry_handlers![SeatState];
474
475 fn registry(&mut self) -> &mut RegistryState {
476 &mut self.registry_state
477 }
478}
479
480impl PrimarySelectionDeviceHandler for State {
481 fn selection(
482 &mut self,
483 _: &Connection,
484 _: &QueueHandle<Self>,
485 _: &ZwpPrimarySelectionDeviceV1,
486 ) {
487 }
488}
489
490impl PrimarySelectionSourceHandler for State {
491 fn send_request(
492 &mut self,
493 _: &Connection,
494 _: &QueueHandle<Self>,
495 _: &ZwpPrimarySelectionSourceV1,
496 mime: String,
497 write_pipe: WritePipe,
498 ) {
499 self.send_request(ty:SelectionTarget::Primary, write_pipe, mime);
500 }
501
502 fn cancelled(
503 &mut self,
504 _: &Connection,
505 _: &QueueHandle<Self>,
506 deleted: &ZwpPrimarySelectionSourceV1,
507 ) {
508 self.primary_sources.retain(|source: &PrimarySelectionSource| source.inner() != deleted)
509 }
510}
511
512impl Dispatch<WlKeyboard, ObjectId, State> for State {
513 fn event(
514 state: &mut State,
515 _: &WlKeyboard,
516 event: <WlKeyboard as sctk::reexports::client::Proxy>::Event,
517 data: &ObjectId,
518 _: &Connection,
519 _: &QueueHandle<State>,
520 ) {
521 use sctk::reexports::client::protocol::wl_keyboard::Event as WlKeyboardEvent;
522 let seat_state = match state.seats.get_mut(data) {
523 Some(seat_state) => seat_state,
524 None => return,
525 };
526 match event {
527 WlKeyboardEvent::Key { serial, .. } | WlKeyboardEvent::Modifiers { serial, .. } => {
528 seat_state.latest_serial = serial;
529 state.latest_seat = Some(data.clone());
530 },
531 // NOTE both selections rely on keyboard focus.
532 WlKeyboardEvent::Enter { serial, .. } => {
533 seat_state.latest_serial = serial;
534 seat_state.has_focus = true;
535 },
536 WlKeyboardEvent::Leave { .. } => {
537 seat_state.latest_serial = 0;
538 seat_state.has_focus = false;
539 },
540 _ => (),
541 }
542 }
543}
544
545delegate_seat!(State);
546delegate_pointer!(State);
547delegate_data_device!(State);
548delegate_primary_selection!(State);
549delegate_registry!(State);
550
551#[derive(Debug, Clone, Copy)]
552pub enum SelectionTarget {
553 /// The target is clipboard selection.
554 Clipboard,
555 /// The target is primary selection.
556 Primary,
557}
558
559#[derive(Debug, Default)]
560struct ClipboardSeatState {
561 keyboard: Option<WlKeyboard>,
562 pointer: Option<WlPointer>,
563 data_device: Option<DataDevice>,
564 primary_device: Option<PrimarySelectionDevice>,
565 has_focus: bool,
566
567 /// The latest serial used to set the selection content.
568 latest_serial: u32,
569}
570
571impl Drop for ClipboardSeatState {
572 fn drop(&mut self) {
573 if let Some(keyboard) = self.keyboard.take() {
574 if keyboard.version() >= 3 {
575 keyboard.release();
576 }
577 }
578
579 if let Some(pointer) = self.pointer.take() {
580 if pointer.version() >= 3 {
581 pointer.release();
582 }
583 }
584 }
585}
586
587unsafe fn set_non_blocking(raw_fd: RawFd) -> std::io::Result<()> {
588 let flags: i32 = libc::fcntl(raw_fd, cmd:libc::F_GETFL);
589
590 if flags < 0 {
591 return Err(std::io::Error::last_os_error());
592 }
593
594 let result: i32 = libc::fcntl(raw_fd, cmd:libc::F_SETFL, flags | libc::O_NONBLOCK);
595 if result < 0 {
596 return Err(std::io::Error::last_os_error());
597 }
598
599 Ok(())
600}
601