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

use {
    crate::{
        ifs::wl_surface::xdg_surface::XdgSurface,
        it::{
            test_error::TestError,
            test_ifs::test_xdg_toplevel::{TestXdgToplevel, TestXdgToplevelCore},
            test_object::TestObject,
            test_transport::TestTransport,
            testrun::ParseFull,
        },
        utils::buffd::MsgParser,
        wire::{XdgSurfaceId, xdg_surface::*},
    },
    std::{cell::Cell, rc::Rc},
};

pub struct TestXdgSurface {
    pub id: XdgSurfaceId,
    pub tran: Rc<TestTransport>,
    pub _server: Rc<XdgSurface>,
    pub destroyed: Cell<bool>,
    pub last_serial: Cell<Option<u32>>,
}

impl TestXdgSurface {
    pub fn destroy(&self) -> Result<(), TestError> {
        if !self.destroyed.replace(true) {
            self.tran.send(Destroy { self_id: self.id })?;
        }
        Ok(())
    }

    pub async fn create_toplevel(&self) -> Result<Rc<TestXdgToplevel>, TestError> {
        let id = self.tran.id();
        self.tran.send(GetToplevel {
            self_id: self.id,
            id,
        })?;
        let core = Rc::new(TestXdgToplevelCore {
            id,
            tran: self.tran.clone(),
            destroyed: Cell::new(false),
            configured: Cell::new(false),
            configured_waiter: Cell::new(None),
            width: Cell::new(0),
            height: Cell::new(0),
            states: Default::default(),
            close_requested: Cell::new(false),
        });
        self.tran.add_obj(core.clone())?;
        self.tran.sync().await;
        let client = self.tran.get_client()?;
        let server = client.lookup(id)?;
        let tl = Rc::new(TestXdgToplevel { core, server });
        Ok(tl)
    }

    pub fn ack_configure(&self, serial: u32) -> Result<(), TestError> {
        self.tran.send(AckConfigure {
            self_id: self.id,
            serial,
        })?;
        Ok(())
    }

    fn handle_configure(&self, parser: MsgParser<'_, '_>) -> Result<(), TestError> {
        let ev = Configure::parse_full(parser)?;
        self.last_serial.set(Some(ev.serial));
        Ok(())
    }
}

impl Drop for TestXdgSurface {
    fn drop(&mut self) {
        let _ = self.destroy();
    }
}

test_object! {
    TestXdgSurface, XdgSurface;

    CONFIGURE => handle_configure,
}

impl TestObject for TestXdgSurface {}