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
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::it::test_client::DefaultSeat;
use crate::it::test_client::TestClient;
use crate::it::test_client::TestClientExt;
use crate::it::test_error::TestResult;
use crate::it::test_ifs::test_input_method::TestInputMethod;
use crate::it::test_ifs::test_input_popup_surface::TestInputPopupSurface;
use crate::it::test_ifs::test_text_input::TestTextInput;
use crate::it::test_utils::test_expected_event::TestExpectedEvent;
use crate::it::test_utils::test_surface_ext::TestSurfaceExt;
use crate::it::test_utils::test_window::TestWindow;
use crate::it::testrun::TestRun;
use crate::wire::zwp_text_input_v3;
use std::rc::Rc;

testcase!();

async fn test(run: Rc<TestRun>) -> TestResult {
    let _ds = run.create_default_setup().await?;

    let consumer = create_consumer(&run).await?;
    let supplier = create_supplier(&run).await?;

    consumer.client.compare_screenshot("1", false).await?;

    supplier.client.sync().await;
    tassert!(supplier.activate.next().is_err());

    consumer.text.enable();
    consumer.text.set_cursor_rectangle(100, 100, 100, 100);
    consumer.text.commit();
    consumer.client.sync().await;

    supplier.client.sync().await;
    tassert!(matches!(supplier.activate.next(), Ok(true)));
    tassert!(supplier.done.next().is_ok());

    consumer.client.compare_screenshot("1", false).await?;

    supplier.surface.commit();
    supplier.client.sync().await;

    consumer.client.compare_screenshot("2", false).await?;

    supplier.im.commit_string("hello world");
    supplier.im.commit();
    supplier.client.sync().await;

    consumer.client.sync().await;
    tassert_eq!(
        consumer.commit_string.next().expect("commit string"),
        "hello world"
    );
    tassert!(consumer.done.next().is_ok());

    consumer.text.disable();
    consumer.text.commit();
    consumer.client.sync().await;

    consumer.client.compare_screenshot("3", false).await?;

    Ok(())
}

struct Consumer {
    client: TestClient,
    _seat: DefaultSeat,
    _window: Rc<TestWindow>,
    text: Rc<TestTextInput>,
    _enter: TestExpectedEvent<zwp_text_input_v3::Enter>,
    _leave: TestExpectedEvent<zwp_text_input_v3::Leave>,
    commit_string: TestExpectedEvent<String>,
    done: TestExpectedEvent<zwp_text_input_v3::Done>,
}

async fn create_consumer(run: &Rc<TestRun>) -> TestResult<Consumer> {
    let client = run.create_client()?;
    let seat = client.get_default_seat().await?;
    let text = client.get_text_input(&seat.seat);
    let window = client.create_window().await?;
    window.map2().await?;
    client.sync().await;
    Ok(Consumer {
        _enter: text.enter.expect()?,
        _leave: text.leave.expect()?,
        commit_string: text.commit_string.expect()?,
        done: text.done.expect()?,
        client,
        _seat: seat,
        _window: window,
        text,
    })
}

struct Supplier {
    client: TestClient,
    _seat: DefaultSeat,
    im: Rc<TestInputMethod>,
    surface: TestSurfaceExt,
    _popup: Rc<TestInputPopupSurface>,
    activate: TestExpectedEvent<bool>,
    done: TestExpectedEvent<()>,
}

async fn create_supplier(run: &Rc<TestRun>) -> TestResult<Supplier> {
    let client = run.create_client()?;
    let seat = client.get_default_seat().await?;
    let im = client.get_input_method(&seat.seat);
    let surface = client.create_surface_ext().await?;
    surface.set_color(255, 0, 0, 255);
    surface.map(100, 100).await?;
    let popup = im.get_popup(&surface);
    client.sync().await;
    Ok(Supplier {
        activate: im.activate.expect()?,
        done: im.done.expect()?,
        client,
        _seat: seat,
        im,
        surface,
        _popup: popup,
    })
}