jay-compositor 1.13.0

The Jay compositor
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

use {
    crate::{
        client::{Client, ClientError},
        ifs::{
            ipc::{
                DeviceData, IpcLocation, IpcVtable, OfferData, Role, x_data_offer::XDataOffer,
                x_data_source::XDataSource,
            },
            wl_seat::WlSeatGlobal,
        },
        state::State,
        xwayland::XWaylandEvent,
    },
    XWaylandEvent::IpcSetOffer,
    std::rc::Rc,
};

linear_ids!(XIpcDeviceIds, XIpcDeviceId, u64);

pub struct XIpcDevice {
    pub id: XIpcDeviceId,
    pub clipboard: DeviceData<XDataOffer>,
    pub primary_selection: DeviceData<XDataOffer>,
    pub seat: Rc<WlSeatGlobal>,
    pub state: Rc<State>,
    pub client: Rc<Client>,
}

#[derive(Default)]
pub struct XClipboardIpc;

#[derive(Default)]
pub struct XPrimarySelectionIpc;

pub trait XIpc {
    const LOCATION: IpcLocation;

    fn x_unset(seat: &Rc<WlSeatGlobal>);

    fn x_device_data(dd: &XIpcDevice) -> &DeviceData<XDataOffer>;
}

impl XIpc for XClipboardIpc {
    const LOCATION: IpcLocation = IpcLocation::Clipboard;

    fn x_unset(seat: &Rc<WlSeatGlobal>) {
        seat.unset_selection();
    }

    fn x_device_data(dd: &XIpcDevice) -> &DeviceData<XDataOffer> {
        &dd.clipboard
    }
}

impl XIpc for XPrimarySelectionIpc {
    const LOCATION: IpcLocation = IpcLocation::PrimarySelection;

    fn x_unset(seat: &Rc<WlSeatGlobal>) {
        seat.unset_primary_selection();
    }

    fn x_device_data(dd: &XIpcDevice) -> &DeviceData<XDataOffer> {
        &dd.primary_selection
    }
}

impl<T: XIpc> IpcVtable for T {
    type Device = XIpcDevice;
    type Source = XDataSource;
    type Offer = XDataOffer;

    fn get_device_data(dd: &Self::Device) -> &DeviceData<Self::Offer> {
        T::x_device_data(dd)
    }

    fn get_device_seat(dd: &Self::Device) -> Rc<WlSeatGlobal> {
        dd.seat.clone()
    }

    fn create_offer(
        dd: &Rc<Self::Device>,
        data: OfferData<Self::Device>,
    ) -> Result<Rc<Self::Offer>, ClientError> {
        debug_assert!(dd.client.is_xwayland);
        let rc = Rc::new(XDataOffer {
            offer_id: dd.state.data_offer_ids.next(),
            device: dd.clone(),
            data,
            tracker: Default::default(),
            location: T::LOCATION,
        });
        track!(dd.client, rc);
        Ok(rc)
    }

    fn send_selection(dd: &Self::Device, offer: Option<&Rc<Self::Offer>>) {
        dd.state
            .xwayland
            .queue
            .push(XWaylandEvent::IpcSetSelection {
                seat: dd.seat.id(),
                location: T::LOCATION,
                offer: offer.cloned(),
            });
    }

    fn send_offer(dd: &Self::Device, offer: &Rc<Self::Offer>) {
        dd.state.xwayland.queue.push(IpcSetOffer {
            location: T::LOCATION,
            seat: dd.seat.id(),
            offer: offer.clone(),
        });
    }

    fn unset(seat: &Rc<WlSeatGlobal>, _role: Role) {
        T::x_unset(seat)
    }

    fn device_client(dd: &Rc<Self::Device>) -> &Rc<Client> {
        &dd.client
    }
}