wl_proxy/protocols/wayland/
wl_data_device_manager.rs

1//! data transfer interface
2//!
3//! The wl_data_device_manager is a singleton global object that
4//! provides access to inter-client data transfer mechanisms such as
5//! copy-and-paste and drag-and-drop.  These mechanisms are tied to
6//! a wl_seat and this interface lets a client get a wl_data_device
7//! corresponding to a wl_seat.
8//!
9//! Depending on the version bound, the objects created from the bound
10//! wl_data_device_manager object will have different requirements for
11//! functioning properly. See wl_data_source.set_actions,
12//! wl_data_offer.accept and wl_data_offer.finish for details.
13
14use crate::protocol_helpers::prelude::*;
15use super::super::all_types::*;
16
17/// A wl_data_device_manager object.
18///
19/// See the documentation of [the module][self] for the interface description.
20pub struct WlDataDeviceManager {
21    core: ObjectCore,
22    handler: HandlerHolder<dyn WlDataDeviceManagerHandler>,
23}
24
25struct DefaultHandler;
26
27impl WlDataDeviceManagerHandler for DefaultHandler { }
28
29impl ConcreteObject for WlDataDeviceManager {
30    const XML_VERSION: u32 = 3;
31    const INTERFACE: ObjectInterface = ObjectInterface::WlDataDeviceManager;
32    const INTERFACE_NAME: &str = "wl_data_device_manager";
33}
34
35impl WlDataDeviceManager {
36    /// Sets a new handler.
37    pub fn set_handler(&self, handler: impl WlDataDeviceManagerHandler) {
38        self.set_boxed_handler(Box::new(handler));
39    }
40
41    /// Sets a new, already boxed handler.
42    pub fn set_boxed_handler(&self, handler: Box<dyn WlDataDeviceManagerHandler>) {
43        if self.core.state.destroyed.get() {
44            return;
45        }
46        self.handler.set(Some(handler));
47    }
48}
49
50impl Debug for WlDataDeviceManager {
51    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
52        f.debug_struct("WlDataDeviceManager")
53            .field("server_obj_id", &self.core.server_obj_id.get())
54            .field("client_id", &self.core.client_id.get())
55            .field("client_obj_id", &self.core.client_obj_id.get())
56            .finish()
57    }
58}
59
60impl WlDataDeviceManager {
61    /// Since when the create_data_source message is available.
62    pub const MSG__CREATE_DATA_SOURCE__SINCE: u32 = 1;
63
64    /// create a new data source
65    ///
66    /// Create a new data source.
67    ///
68    /// # Arguments
69    ///
70    /// - `id`: data source to create
71    #[inline]
72    pub fn try_send_create_data_source(
73        &self,
74        id: &Rc<WlDataSource>,
75    ) -> Result<(), ObjectError> {
76        let (
77            arg0,
78        ) = (
79            id,
80        );
81        let arg0_obj = arg0;
82        let arg0 = arg0_obj.core();
83        let core = self.core();
84        let Some(id) = core.server_obj_id.get() else {
85            return Err(ObjectError(ObjectErrorKind::ReceiverNoServerId));
86        };
87        arg0.generate_server_id(arg0_obj.clone())
88            .map_err(|e| ObjectError(ObjectErrorKind::GenerateServerId("id", e)))?;
89        let arg0_id = arg0.server_obj_id.get().unwrap_or(0);
90        #[cfg(feature = "logging")]
91        if self.core.state.log {
92            #[cold]
93            fn log(state: &State, id: u32, arg0: u32) {
94                let (millis, micros) = time_since_epoch();
95                let prefix = &state.log_prefix;
96                let args = format_args!("[{millis:7}.{micros:03}] {prefix}server      <= wl_data_device_manager#{}.create_data_source(id: wl_data_source#{})\n", id, arg0);
97                state.log(args);
98            }
99            log(&self.core.state, id, arg0_id);
100        }
101        let Some(endpoint) = &self.core.state.server else {
102            return Ok(());
103        };
104        if !endpoint.flush_queued.replace(true) {
105            self.core.state.add_flushable_endpoint(endpoint, None);
106        }
107        let mut outgoing_ref = endpoint.outgoing.borrow_mut();
108        let outgoing = &mut *outgoing_ref;
109        let mut fmt = outgoing.formatter();
110        fmt.words([
111            id,
112            0,
113            arg0_id,
114        ]);
115        Ok(())
116    }
117
118    /// create a new data source
119    ///
120    /// Create a new data source.
121    ///
122    /// # Arguments
123    ///
124    /// - `id`: data source to create
125    #[inline]
126    pub fn send_create_data_source(
127        &self,
128        id: &Rc<WlDataSource>,
129    ) {
130        let res = self.try_send_create_data_source(
131            id,
132        );
133        if let Err(e) = res {
134            log_send("wl_data_device_manager.create_data_source", &e);
135        }
136    }
137
138    /// create a new data source
139    ///
140    /// Create a new data source.
141    #[inline]
142    pub fn new_try_send_create_data_source(
143        &self,
144    ) -> Result<Rc<WlDataSource>, ObjectError> {
145        let id = self.core.create_child();
146        self.try_send_create_data_source(
147            &id,
148        )?;
149        Ok(id)
150    }
151
152    /// create a new data source
153    ///
154    /// Create a new data source.
155    #[inline]
156    pub fn new_send_create_data_source(
157        &self,
158    ) -> Rc<WlDataSource> {
159        let id = self.core.create_child();
160        self.send_create_data_source(
161            &id,
162        );
163        id
164    }
165
166    /// Since when the get_data_device message is available.
167    pub const MSG__GET_DATA_DEVICE__SINCE: u32 = 1;
168
169    /// create a new data device
170    ///
171    /// Create a new data device for a given seat.
172    ///
173    /// # Arguments
174    ///
175    /// - `id`: data device to create
176    /// - `seat`: seat associated with the data device
177    #[inline]
178    pub fn try_send_get_data_device(
179        &self,
180        id: &Rc<WlDataDevice>,
181        seat: &Rc<WlSeat>,
182    ) -> Result<(), ObjectError> {
183        let (
184            arg0,
185            arg1,
186        ) = (
187            id,
188            seat,
189        );
190        let arg0_obj = arg0;
191        let arg0 = arg0_obj.core();
192        let arg1 = arg1.core();
193        let core = self.core();
194        let Some(id) = core.server_obj_id.get() else {
195            return Err(ObjectError(ObjectErrorKind::ReceiverNoServerId));
196        };
197        let arg1_id = match arg1.server_obj_id.get() {
198            None => return Err(ObjectError(ObjectErrorKind::ArgNoServerId("seat"))),
199            Some(id) => id,
200        };
201        arg0.generate_server_id(arg0_obj.clone())
202            .map_err(|e| ObjectError(ObjectErrorKind::GenerateServerId("id", e)))?;
203        let arg0_id = arg0.server_obj_id.get().unwrap_or(0);
204        #[cfg(feature = "logging")]
205        if self.core.state.log {
206            #[cold]
207            fn log(state: &State, id: u32, arg0: u32, arg1: u32) {
208                let (millis, micros) = time_since_epoch();
209                let prefix = &state.log_prefix;
210                let args = format_args!("[{millis:7}.{micros:03}] {prefix}server      <= wl_data_device_manager#{}.get_data_device(id: wl_data_device#{}, seat: wl_seat#{})\n", id, arg0, arg1);
211                state.log(args);
212            }
213            log(&self.core.state, id, arg0_id, arg1_id);
214        }
215        let Some(endpoint) = &self.core.state.server else {
216            return Ok(());
217        };
218        if !endpoint.flush_queued.replace(true) {
219            self.core.state.add_flushable_endpoint(endpoint, None);
220        }
221        let mut outgoing_ref = endpoint.outgoing.borrow_mut();
222        let outgoing = &mut *outgoing_ref;
223        let mut fmt = outgoing.formatter();
224        fmt.words([
225            id,
226            1,
227            arg0_id,
228            arg1_id,
229        ]);
230        Ok(())
231    }
232
233    /// create a new data device
234    ///
235    /// Create a new data device for a given seat.
236    ///
237    /// # Arguments
238    ///
239    /// - `id`: data device to create
240    /// - `seat`: seat associated with the data device
241    #[inline]
242    pub fn send_get_data_device(
243        &self,
244        id: &Rc<WlDataDevice>,
245        seat: &Rc<WlSeat>,
246    ) {
247        let res = self.try_send_get_data_device(
248            id,
249            seat,
250        );
251        if let Err(e) = res {
252            log_send("wl_data_device_manager.get_data_device", &e);
253        }
254    }
255
256    /// create a new data device
257    ///
258    /// Create a new data device for a given seat.
259    ///
260    /// # Arguments
261    ///
262    /// - `seat`: seat associated with the data device
263    #[inline]
264    pub fn new_try_send_get_data_device(
265        &self,
266        seat: &Rc<WlSeat>,
267    ) -> Result<Rc<WlDataDevice>, ObjectError> {
268        let id = self.core.create_child();
269        self.try_send_get_data_device(
270            &id,
271            seat,
272        )?;
273        Ok(id)
274    }
275
276    /// create a new data device
277    ///
278    /// Create a new data device for a given seat.
279    ///
280    /// # Arguments
281    ///
282    /// - `seat`: seat associated with the data device
283    #[inline]
284    pub fn new_send_get_data_device(
285        &self,
286        seat: &Rc<WlSeat>,
287    ) -> Rc<WlDataDevice> {
288        let id = self.core.create_child();
289        self.send_get_data_device(
290            &id,
291            seat,
292        );
293        id
294    }
295}
296
297/// A message handler for [`WlDataDeviceManager`] proxies.
298pub trait WlDataDeviceManagerHandler: Any {
299    /// Event handler for wl_display.delete_id messages deleting the ID of this object.
300    ///
301    /// The default handler forwards the event to the client, if any.
302    #[inline]
303    fn delete_id(&mut self, slf: &Rc<WlDataDeviceManager>) {
304        slf.core.delete_id();
305    }
306
307    /// create a new data source
308    ///
309    /// Create a new data source.
310    ///
311    /// # Arguments
312    ///
313    /// - `id`: data source to create
314    #[inline]
315    fn handle_create_data_source(
316        &mut self,
317        slf: &Rc<WlDataDeviceManager>,
318        id: &Rc<WlDataSource>,
319    ) {
320        if !slf.core.forward_to_server.get() {
321            return;
322        }
323        let res = slf.try_send_create_data_source(
324            id,
325        );
326        if let Err(e) = res {
327            log_forward("wl_data_device_manager.create_data_source", &e);
328        }
329    }
330
331    /// create a new data device
332    ///
333    /// Create a new data device for a given seat.
334    ///
335    /// # Arguments
336    ///
337    /// - `id`: data device to create
338    /// - `seat`: seat associated with the data device
339    ///
340    /// All borrowed proxies passed to this function are guaranteed to be
341    /// immutable and non-null.
342    #[inline]
343    fn handle_get_data_device(
344        &mut self,
345        slf: &Rc<WlDataDeviceManager>,
346        id: &Rc<WlDataDevice>,
347        seat: &Rc<WlSeat>,
348    ) {
349        if !slf.core.forward_to_server.get() {
350            return;
351        }
352        let res = slf.try_send_get_data_device(
353            id,
354            seat,
355        );
356        if let Err(e) = res {
357            log_forward("wl_data_device_manager.get_data_device", &e);
358        }
359    }
360}
361
362impl ObjectPrivate for WlDataDeviceManager {
363    fn new(state: &Rc<State>, version: u32) -> Rc<Self> {
364        Rc::<Self>::new_cyclic(|slf| Self {
365            core: ObjectCore::new(state, slf.clone(), ObjectInterface::WlDataDeviceManager, version),
366            handler: Default::default(),
367        })
368    }
369
370    fn delete_id(self: Rc<Self>) -> Result<(), (ObjectError, Rc<dyn Object>)> {
371        let Some(mut handler) = self.handler.try_borrow_mut() else {
372            return Err((ObjectError(ObjectErrorKind::HandlerBorrowed), self));
373        };
374        if let Some(handler) = &mut *handler {
375            handler.delete_id(&self);
376        } else {
377            self.core.delete_id();
378        }
379        Ok(())
380    }
381
382    fn handle_request(self: Rc<Self>, client: &Rc<Client>, msg: &[u32], fds: &mut VecDeque<Rc<OwnedFd>>) -> Result<(), ObjectError> {
383        let Some(mut handler) = self.handler.try_borrow_mut() else {
384            return Err(ObjectError(ObjectErrorKind::HandlerBorrowed));
385        };
386        let handler = &mut *handler;
387        match msg[1] & 0xffff {
388            0 => {
389                let [
390                    arg0,
391                ] = msg[2..] else {
392                    return Err(ObjectError(ObjectErrorKind::WrongMessageSize(msg.len() as u32 * 4, 12)));
393                };
394                #[cfg(feature = "logging")]
395                if self.core.state.log {
396                    #[cold]
397                    fn log(state: &State, client_id: u64, id: u32, arg0: u32) {
398                        let (millis, micros) = time_since_epoch();
399                        let prefix = &state.log_prefix;
400                        let args = format_args!("[{millis:7}.{micros:03}] {prefix}client#{:<4} -> wl_data_device_manager#{}.create_data_source(id: wl_data_source#{})\n", client_id, id, arg0);
401                        state.log(args);
402                    }
403                    log(&self.core.state, client.endpoint.id, msg[0], arg0);
404                }
405                let arg0_id = arg0;
406                let arg0 = WlDataSource::new(&self.core.state, self.core.version);
407                arg0.core().set_client_id(client, arg0_id, arg0.clone())
408                    .map_err(|e| ObjectError(ObjectErrorKind::SetClientId(arg0_id, "id", e)))?;
409                let arg0 = &arg0;
410                if let Some(handler) = handler {
411                    (**handler).handle_create_data_source(&self, arg0);
412                } else {
413                    DefaultHandler.handle_create_data_source(&self, arg0);
414                }
415            }
416            1 => {
417                let [
418                    arg0,
419                    arg1,
420                ] = msg[2..] else {
421                    return Err(ObjectError(ObjectErrorKind::WrongMessageSize(msg.len() as u32 * 4, 16)));
422                };
423                #[cfg(feature = "logging")]
424                if self.core.state.log {
425                    #[cold]
426                    fn log(state: &State, client_id: u64, id: u32, arg0: u32, arg1: u32) {
427                        let (millis, micros) = time_since_epoch();
428                        let prefix = &state.log_prefix;
429                        let args = format_args!("[{millis:7}.{micros:03}] {prefix}client#{:<4} -> wl_data_device_manager#{}.get_data_device(id: wl_data_device#{}, seat: wl_seat#{})\n", client_id, id, arg0, arg1);
430                        state.log(args);
431                    }
432                    log(&self.core.state, client.endpoint.id, msg[0], arg0, arg1);
433                }
434                let arg0_id = arg0;
435                let arg0 = WlDataDevice::new(&self.core.state, self.core.version);
436                arg0.core().set_client_id(client, arg0_id, arg0.clone())
437                    .map_err(|e| ObjectError(ObjectErrorKind::SetClientId(arg0_id, "id", e)))?;
438                let arg1_id = arg1;
439                let Some(arg1) = client.endpoint.lookup(arg1_id) else {
440                    return Err(ObjectError(ObjectErrorKind::NoClientObject(client.endpoint.id, arg1_id)));
441                };
442                let Ok(arg1) = (arg1 as Rc<dyn Any>).downcast::<WlSeat>() else {
443                    let o = client.endpoint.lookup(arg1_id).unwrap();
444                    return Err(ObjectError(ObjectErrorKind::WrongObjectType("seat", o.core().interface, ObjectInterface::WlSeat)));
445                };
446                let arg0 = &arg0;
447                let arg1 = &arg1;
448                if let Some(handler) = handler {
449                    (**handler).handle_get_data_device(&self, arg0, arg1);
450                } else {
451                    DefaultHandler.handle_get_data_device(&self, arg0, arg1);
452                }
453            }
454            n => {
455                let _ = client;
456                let _ = msg;
457                let _ = fds;
458                let _ = handler;
459                return Err(ObjectError(ObjectErrorKind::UnknownMessageId(n)));
460            }
461        }
462        Ok(())
463    }
464
465    fn handle_event(self: Rc<Self>, server: &Endpoint, msg: &[u32], fds: &mut VecDeque<Rc<OwnedFd>>) -> Result<(), ObjectError> {
466        let Some(mut handler) = self.handler.try_borrow_mut() else {
467            return Err(ObjectError(ObjectErrorKind::HandlerBorrowed));
468        };
469        let handler = &mut *handler;
470        match msg[1] & 0xffff {
471            n => {
472                let _ = server;
473                let _ = msg;
474                let _ = fds;
475                let _ = handler;
476                return Err(ObjectError(ObjectErrorKind::UnknownMessageId(n)));
477            }
478        }
479    }
480
481    fn get_request_name(&self, id: u32) -> Option<&'static str> {
482        let name = match id {
483            0 => "create_data_source",
484            1 => "get_data_device",
485            _ => return None,
486        };
487        Some(name)
488    }
489
490    fn get_event_name(&self, id: u32) -> Option<&'static str> {
491        let _ = id;
492        None
493    }
494}
495
496impl Object for WlDataDeviceManager {
497    fn core(&self) -> &ObjectCore {
498        &self.core
499    }
500
501    fn unset_handler(&self) {
502        self.handler.set(None);
503    }
504
505    fn get_handler_any_ref(&self) -> Result<HandlerRef<'_, dyn Any>, HandlerAccessError> {
506        let borrowed = self.handler.try_borrow().ok_or(HandlerAccessError::AlreadyBorrowed)?;
507        if borrowed.is_none() {
508            return Err(HandlerAccessError::NoHandler);
509        }
510        Ok(HandlerRef::map(borrowed, |handler| &**handler.as_ref().unwrap() as &dyn Any))
511    }
512
513    fn get_handler_any_mut(&self) -> Result<HandlerMut<'_, dyn Any>, HandlerAccessError> {
514        let borrowed = self.handler.try_borrow_mut().ok_or(HandlerAccessError::AlreadyBorrowed)?;
515        if borrowed.is_none() {
516            return Err(HandlerAccessError::NoHandler);
517        }
518        Ok(HandlerMut::map(borrowed, |handler| &mut **handler.as_mut().unwrap() as &mut dyn Any))
519    }
520}
521
522impl WlDataDeviceManager {
523    /// Since when the dnd_action.none enum variant is available.
524    pub const ENM__DND_ACTION_NONE__SINCE: u32 = 1;
525    /// Since when the dnd_action.copy enum variant is available.
526    pub const ENM__DND_ACTION_COPY__SINCE: u32 = 1;
527    /// Since when the dnd_action.move enum variant is available.
528    pub const ENM__DND_ACTION_MOVE__SINCE: u32 = 1;
529    /// Since when the dnd_action.ask enum variant is available.
530    pub const ENM__DND_ACTION_ASK__SINCE: u32 = 1;
531}
532
533/// drag and drop actions
534///
535/// This is a bitmask of the available/preferred actions in a
536/// drag-and-drop operation.
537///
538/// In the compositor, the selected action is a result of matching the
539/// actions offered by the source and destination sides.  "action" events
540/// with a "none" action will be sent to both source and destination if
541/// there is no match. All further checks will effectively happen on
542/// (source actions ∩ destination actions).
543///
544/// In addition, compositors may also pick different actions in
545/// reaction to key modifiers being pressed. One common design that
546/// is used in major toolkits (and the behavior recommended for
547/// compositors) is:
548///
549/// - If no modifiers are pressed, the first match (in bit order)
550///   will be used.
551/// - Pressing Shift selects "move", if enabled in the mask.
552/// - Pressing Control selects "copy", if enabled in the mask.
553///
554/// Behavior beyond that is considered implementation-dependent.
555/// Compositors may for example bind other modifiers (like Alt/Meta)
556/// or drags initiated with other buttons than BTN_LEFT to specific
557/// actions (e.g. "ask").
558#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
559#[derive(Default)]
560pub struct WlDataDeviceManagerDndAction(pub u32);
561
562/// An iterator over the set bits in a [`WlDataDeviceManagerDndAction`].
563///
564/// You can construct this with the `IntoIterator` implementation of `WlDataDeviceManagerDndAction`.
565#[derive(Clone, Debug)]
566pub struct WlDataDeviceManagerDndActionIter(pub u32);
567
568impl WlDataDeviceManagerDndAction {
569    /// no action
570    pub const NONE: Self = Self(0);
571
572    /// copy action
573    pub const COPY: Self = Self(1);
574
575    /// move action
576    pub const MOVE: Self = Self(2);
577
578    /// ask action
579    pub const ASK: Self = Self(4);
580}
581
582impl WlDataDeviceManagerDndAction {
583    #[inline]
584    pub const fn empty() -> Self {
585        Self(0)
586    }
587
588    #[inline]
589    #[must_use]
590    pub const fn is_empty(self) -> bool {
591        self.0 == 0
592    }
593
594    #[inline]
595    #[must_use]
596    pub const fn contains(self, other: Self) -> bool {
597        self.0 & other.0 == other.0
598    }
599
600    #[inline]
601    #[must_use]
602    pub const fn intersects(self, other: Self) -> bool {
603        self.0 & other.0 != 0
604    }
605
606    #[inline]
607    pub const fn insert(&mut self, other: Self) {
608        *self = self.union(other);
609    }
610
611    #[inline]
612    pub const fn remove(&mut self, other: Self) {
613        *self = self.difference(other);
614    }
615
616    #[inline]
617    pub const fn toggle(&mut self, other: Self) {
618        *self = self.symmetric_difference(other);
619    }
620
621    #[inline]
622    pub const fn set(&mut self, other: Self, value: bool) {
623        if value {
624            self.insert(other);
625        } else {
626            self.remove(other);
627        }
628    }
629
630    #[inline]
631    #[must_use]
632    pub const fn intersection(self, other: Self) -> Self {
633        Self(self.0 & other.0)
634    }
635
636    #[inline]
637    #[must_use]
638    pub const fn union(self, other: Self) -> Self {
639        Self(self.0 | other.0)
640    }
641
642    #[inline]
643    #[must_use]
644    pub const fn difference(self, other: Self) -> Self {
645        Self(self.0 & !other.0)
646    }
647
648    #[inline]
649    #[must_use]
650    pub const fn complement(self) -> Self {
651        Self(!self.0)
652    }
653
654    #[inline]
655    #[must_use]
656    pub const fn symmetric_difference(self, other: Self) -> Self {
657        Self(self.0 ^ other.0)
658    }
659
660    #[inline]
661    pub const fn all_known() -> Self {
662        #[allow(clippy::eq_op, clippy::identity_op)]
663        Self(0 | 0 | 1 | 2 | 4)
664    }
665}
666
667impl Iterator for WlDataDeviceManagerDndActionIter {
668    type Item = WlDataDeviceManagerDndAction;
669
670    fn next(&mut self) -> Option<Self::Item> {
671        if self.0 == 0 {
672            return None;
673        }
674        let bit = 1 << self.0.trailing_zeros();
675        self.0 &= !bit;
676        Some(WlDataDeviceManagerDndAction(bit))
677    }
678}
679
680impl IntoIterator for WlDataDeviceManagerDndAction {
681    type Item = WlDataDeviceManagerDndAction;
682    type IntoIter = WlDataDeviceManagerDndActionIter;
683
684    fn into_iter(self) -> Self::IntoIter {
685        WlDataDeviceManagerDndActionIter(self.0)
686    }
687}
688
689impl BitAnd for WlDataDeviceManagerDndAction {
690    type Output = Self;
691
692    fn bitand(self, rhs: Self) -> Self::Output {
693        self.intersection(rhs)
694    }
695}
696
697impl BitAndAssign for WlDataDeviceManagerDndAction {
698    fn bitand_assign(&mut self, rhs: Self) {
699        *self = self.intersection(rhs);
700    }
701}
702
703impl BitOr for WlDataDeviceManagerDndAction {
704    type Output = Self;
705
706    fn bitor(self, rhs: Self) -> Self::Output {
707        self.union(rhs)
708    }
709}
710
711impl BitOrAssign for WlDataDeviceManagerDndAction {
712    fn bitor_assign(&mut self, rhs: Self) {
713        *self = self.union(rhs);
714    }
715}
716
717impl BitXor for WlDataDeviceManagerDndAction {
718    type Output = Self;
719
720    fn bitxor(self, rhs: Self) -> Self::Output {
721        self.symmetric_difference(rhs)
722    }
723}
724
725impl BitXorAssign for WlDataDeviceManagerDndAction {
726    fn bitxor_assign(&mut self, rhs: Self) {
727        *self = self.symmetric_difference(rhs);
728    }
729}
730
731impl Sub for WlDataDeviceManagerDndAction {
732    type Output = Self;
733
734    fn sub(self, rhs: Self) -> Self::Output {
735        self.difference(rhs)
736    }
737}
738
739impl SubAssign for WlDataDeviceManagerDndAction {
740    fn sub_assign(&mut self, rhs: Self) {
741        *self = self.difference(rhs);
742    }
743}
744
745impl Not for WlDataDeviceManagerDndAction {
746    type Output = Self;
747
748    fn not(self) -> Self::Output {
749        self.complement()
750    }
751}
752
753impl Debug for WlDataDeviceManagerDndAction {
754    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
755        let mut v = self.0;
756        let mut first = true;
757        if v & 1 == 1 {
758            v &= !1;
759            if first {
760                first = false;
761            } else {
762                f.write_str(" | ")?;
763            }
764            f.write_str("COPY")?;
765        }
766        if v & 2 == 2 {
767            v &= !2;
768            if first {
769                first = false;
770            } else {
771                f.write_str(" | ")?;
772            }
773            f.write_str("MOVE")?;
774        }
775        if v & 4 == 4 {
776            v &= !4;
777            if first {
778                first = false;
779            } else {
780                f.write_str(" | ")?;
781            }
782            f.write_str("ASK")?;
783        }
784        if v != 0 {
785            if first {
786                first = false;
787            } else {
788                f.write_str(" | ")?;
789            }
790            write!(f, "0x{v:032x}")?;
791        }
792        if first {
793            f.write_str("NONE")?;
794        }
795        Ok(())
796    }
797}
wl_proxy/protocols/wayland/wl_data_device_manager.rs

wl_proxy/protocols/wayland/
wl_data_device_manager.rs
