timer.slint - Codebrowser

1	// Copyright © SixtyFPS GmbH <info@slint.dev>
2	// SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-Slint-Royalty-free-2.0 OR LicenseRef-Slint-Software-3.0
3
4	export global G {
5	in-out property <bool> tArunning: `true`;
6	}
7
8	component SubCompo {
9
10	out property <string> r;
11
12	HorizontalLayout {
13	Rectangle {}
14	Timer {
15	interval: `1s`;
16	triggered => { r += "A"; }
17	running <=> G.tArunning;
18	}
19	Timer {
20	interval: `1.502s`;
21	triggered => { r += "B"; }
22	}
23	for l in ["c", "d"] : Rectangle {
24	Timer {
25	interval: `3.0003s`;
26	triggered => { r += l; }
27	}
28	}
29	}
30	init => {
31	// instentiate the repeater
32	debug(root.preferred-height);
33	}
34	}
35
36	export component TestCase inherits Window {
37
38	out property <string> result;
39	out property <string> second_result: s.r;
40
41	in property <int> tm2duration;
42	in property <bool> tm2running <=> tm2.running;
43
44	vl := VerticalLayout {
45	if `true`: HorizontalLayout {
46	Timer {
47	interval: `1s`;
48	triggered => { result += "1"; }
49	}
50	}
51	}
52	out property <bool> test: vl.max-width == `0`;
53
54	Rectangle {
55	tm2 := Timer {
56	running: `false`;
57	interval: tm2duration * `1ms`;
58	triggered => { result += "2"; }
59	}
60	}
61
62	Rectangle {
63	oops := Timer {
64	interval: -`5ms`;
65	triggered => { result += "oops"; }
66	}
67	s := SubCompo { }
68	}
69
70
71	}
72	/*
73
74	```rust
75	let instance = TestCase::new().unwrap();
76	assert!(instance.get_test());
77	assert_eq!(instance.get_result(), "");
78	slint_testing::mock_elapsed_time(991);
79	assert_eq!(instance.get_result(), "");
80	slint_testing::mock_elapsed_time(10);
81	assert_eq!(instance.get_result(), "1");
82	instance.set_tm2running(true);
83	assert_eq!(instance.get_result(), "1");
84	slint_testing::mock_elapsed_time(500);
85	// despite we say to ellapse 500ms, the changed callback is only called once
86	slint_testing::mock_elapsed_time(510);
87	// Same, the timer event are only called onced
88	assert_eq!(instance.get_result(), "121");
89	slint_testing::mock_elapsed_time(0);
90	assert_eq!(instance.get_result(), "1212");
91	slint_testing::mock_elapsed_time(0);
92	assert_eq!(instance.get_result(), "12122");
93	instance.set_tm2duration(50);
94	slint_testing::mock_elapsed_time(8);
95	// even though we changed the duration, the timer fires before the changed callback
96	assert_eq!(instance.get_result(), "121222");
97	slint_testing::mock_elapsed_time(49);
98	assert_eq!(instance.get_result(), "121222");
99	slint_testing::mock_elapsed_time(2);
100	assert_eq!(instance.get_result(), "1212222");
101	slint_testing::mock_elapsed_time(47);
102	assert_eq!(instance.get_result(), "1212222");
103	instance.set_tm2duration(18);
104	slint_testing::mock_elapsed_time(2);
105	assert_eq!(instance.get_result(), "1212222");
106	slint_testing::mock_elapsed_time(19);
107	assert_eq!(instance.get_result(), "12122222");
108
109	for _ in 0..20 {
110	slint_testing::mock_elapsed_time(500);
111	}
112	assert_eq!(instance.get_second_result(), "ABAcdABAABAcdABAAcdBAABAcd");
113	instance.global::<G<'_>>().set_tArunning(false);
114	for _ in 0..20 {
115	slint_testing::mock_elapsed_time(500);
116	}
117	assert_eq!(instance.get_second_result(), "ABAcdABAABAcdABAAcdBAABAcdBcdBBcdBcdB");
118	```
119
120	```cpp
121	auto handle = TestCase::create();
122	const TestCase &instance = handle;*
123	assert(instance.get_test());
124	assert_eq(instance.get_result(), "");
125	slint_testing::mock_elapsed_time(991);
126	assert_eq(instance.get_result(), "");
127	slint_testing::mock_elapsed_time(10);
128	assert_eq(instance.get_result(), "1");
129	instance.set_tm2running(true);
130	assert_eq(instance.get_result(), "1");
131	slint_testing::mock_elapsed_time(500);
132	// despite we say to ellapse 500ms, the changed callback is only called once
133	slint_testing::mock_elapsed_time(510);
134	// Same, the timer event are only called onced
135	assert_eq(instance.get_result(), "121");
136	slint_testing::mock_elapsed_time(0);
137	assert_eq(instance.get_result(), "1212");
138	slint_testing::mock_elapsed_time(0);
139	assert_eq(instance.get_result(), "12122");
140	instance.set_tm2duration(50);
141	slint_testing::mock_elapsed_time(8);
142	// even though we changed the duration, the timer fires before the changed callback
143	assert_eq(instance.get_result(), "121222");
144	slint_testing::mock_elapsed_time(49);
145	assert_eq(instance.get_result(), "121222");
146	slint_testing::mock_elapsed_time(2);
147	assert_eq(instance.get_result(), "1212222");
148	slint_testing::mock_elapsed_time(47);
149	assert_eq(instance.get_result(), "1212222");
150	instance.set_tm2duration(18);
151	slint_testing::mock_elapsed_time(2);
152	assert_eq(instance.get_result(), "1212222");
153	slint_testing::mock_elapsed_time(19);
154	assert_eq(instance.get_result(), "12122222");
155
156	for (int i = 0; i < 20; ++i) {
157	slint_testing::mock_elapsed_time(500);
158	}
159	assert_eq(instance.get_second_result(), "ABAcdABAABAcdABAAcdBAABAcd");
160
161	instance.global<G>().set_tArunning(false);
162	for (int i = 0; i < 20; ++i) {
163	slint_testing::mock_elapsed_time(500);
164	}
165	assert_eq(instance.get_second_result(), "ABAcdABAABAcdABAAcdBAABAcdBcdBBcdBcdB");
166	```
167
168	```js
169	var instance = new slint.TestCase({});
170	assert(instance.test);
171	assert.equal(instance.result, "");
172	slintlib.private_api.mock_elapsed_time(991);
173	assert.equal(instance.result, "");
174	slintlib.private_api.mock_elapsed_time(10);
175	assert.equal(instance.result, "1");
176	instance.tm2running = true;
177	assert.equal(instance.result, "1");
178	slintlib.private_api.mock_elapsed_time(500);
179	// despite we say to ellapse 500ms, the changed callback is only called once
180	slintlib.private_api.mock_elapsed_time(510);
181	// Same, the timer event are only called onced
182	assert.equal(instance.result, "121");
183	slintlib.private_api.mock_elapsed_time(0);
184	assert.equal(instance.result, "1212");
185	slintlib.private_api.mock_elapsed_time(0);
186	assert.equal(instance.result, "12122");
187	instance.tm2duration = 50;
188	slintlib.private_api.mock_elapsed_time(8);
189	// even though we changed the duration, the timer fires before the changed callback
190	assert.equal(instance.result, "121222");
191	slintlib.private_api.mock_elapsed_time(49);
192	assert.equal(instance.result, "121222");
193	slintlib.private_api.mock_elapsed_time(2);
194	assert.equal(instance.result, "1212222");
195	slintlib.private_api.mock_elapsed_time(47);
196	assert.equal(instance.result, "1212222");
197	instance.tm2duration = 18;
198	slintlib.private_api.mock_elapsed_time(2);
199	assert.equal(instance.result, "1212222");
200	slintlib.private_api.mock_elapsed_time(19);
201	assert.equal(instance.result, "12122222");
202
203	for (var i = 0; i < 20; ++i) {
204	slintlib.private_api.mock_elapsed_time(500);
205	}
206	assert.equal(instance.second_result, "ABAcdABAABAcdABAAcdBAABAcd");
207
208	instance.G.tArunning = false;
209	for (var i = 0; i < 20; ++i) {
210	slintlib.private_api.mock_elapsed_time(500);
211	}
212	assert.equal(instance.second_result, "ABAcdABAABAcdABAAcdBAABAcdBcdBBcdBcdB");
213	```
214	*/