jay-compositor 1.15.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

use crate::client::Client;
use crate::it::test_client::TestClient;
use crate::it::test_error::TestErrorError;
use crate::it::test_ifs::test_data_offer::TestDataOffer;
use crate::it::test_ifs::test_data_source::TestDataSource;
use crate::it::test_ifs::test_seat::TestSeat;
use crate::it::test_ifs::test_surface::TestSurface;
use crate::wire::WlDataDeviceId;
use crate::wire::WlSurfaceId;
use crate::wire::wl_data_device::*;
use std::rc::Rc;

pub struct TestDataDevice {
    pub id: WlDataDeviceId,
    pub client: Rc<Client>,
}

impl TestDataDevice {
    pub fn start_drag(
        &self,
        source: &TestDataSource,
        origin: &TestSurface,
        icon: Option<&TestSurface>,
        serial: u32,
    ) {
        self.client.send_wl_data_device_start_drag(
            self.id,
            source.id,
            origin.id,
            icon.map(|i| i.id).unwrap_or(WlSurfaceId::NONE),
            serial,
        );
    }

    pub fn set_selection(&self, source: &TestDataSource, serial: u32) {
        self.client
            .send_wl_data_device_set_selection(self.id, source.id, serial);
    }
}

synthetic_event_handler!(TestDataDevice);

impl WlDataDeviceEventHandler for TestDataDevice {
    type Error = TestErrorError;

    fn data_offer(&self, ev: DataOffer, _slf: &Rc<Self>) -> Result<(), Self::Error> {
        let offer = Rc::new(TestDataOffer {
            id: ev.id,
            client: self.client.clone(),
        });
        self.client.set_synthetic_event_handler(ev.id, &offer);
        offer.destroy();
        Ok(())
    }

    fn enter(&self, _ev: Enter, _slf: &Rc<Self>) -> Result<(), Self::Error> {
        Ok(())
    }

    fn leave(&self, _ev: Leave, _slf: &Rc<Self>) -> Result<(), Self::Error> {
        Ok(())
    }

    fn motion(&self, _ev: Motion, _slf: &Rc<Self>) -> Result<(), Self::Error> {
        Ok(())
    }

    fn drop_(&self, _ev: Drop, _slf: &Rc<Self>) -> Result<(), Self::Error> {
        Ok(())
    }

    fn selection(&self, _ev: Selection, _slf: &Rc<Self>) -> Result<(), Self::Error> {
        Ok(())
    }
}

impl TestClient {
    pub fn get_data_device(&self, seat: &TestSeat) -> Rc<TestDataDevice> {
        let client = &self.client;
        let id = client.send_wl_data_device_manager_get_data_device(seat.id);
        let dev = Rc::new(TestDataDevice {
            id,
            client: client.clone(),
        });
        client.set_synthetic_event_handler(id, &dev);
        dev
    }
}