source: mainline/uspace/srv/hid/display/test/seat.c@ ededdc4

ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since ededdc4 was ededdc4, checked in by Jiri Svoboda <jiri@…>, 3 years ago

Use ds_window_unfocus() when destroying a window
  • Property mode set to 100644
File size: 17.1 KB
Line 
1/*
2 * Copyright (c) 2023 Jiri Svoboda
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29#include <disp_srv.h>
30#include <errno.h>
31#include <pcut/pcut.h>
32#include <str.h>
33
34#include "../client.h"
35#include "../display.h"
36#include "../seat.h"
37#include "../window.h"
38
39PCUT_INIT;
40
41PCUT_TEST_SUITE(seat);
42
43static void test_ds_ev_pending(void *);
44
45static ds_client_cb_t test_ds_client_cb = {
46 .ev_pending = test_ds_ev_pending
47};
48
49static void test_ds_ev_pending(void *arg)
50{
51 bool *called_cb = (bool *) arg;
52 *called_cb = true;
53}
54
55/** Set focus. */
56PCUT_TEST(set_focus)
57{
58 ds_display_t *disp;
59 ds_client_t *client;
60 ds_seat_t *seat;
61 ds_window_t *wnd;
62 display_wnd_params_t params;
63 bool called_cb = false;
64 errno_t rc;
65
66 rc = ds_display_create(NULL, df_none, &disp);
67 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
68
69 rc = ds_client_create(disp, &test_ds_client_cb, &called_cb, &client);
70 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
71
72 rc = ds_seat_create(disp, &seat);
73 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
74
75 display_wnd_params_init(&params);
76 params.rect.p0.x = params.rect.p0.y = 0;
77 params.rect.p1.x = params.rect.p1.y = 1;
78
79 rc = ds_window_create(client, &params, &wnd);
80 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
81
82 ds_seat_set_focus(seat, wnd);
83 PCUT_ASSERT_EQUALS(wnd, seat->focus);
84 PCUT_ASSERT_TRUE(called_cb);
85
86 ds_window_destroy(wnd);
87 ds_seat_destroy(seat);
88 ds_client_destroy(client);
89 ds_display_destroy(disp);
90}
91
92/** Evacuate focus from window.
93 *
94 * After evacuating no window should be focused
95 */
96PCUT_TEST(evac_focus_one_window)
97{
98 ds_display_t *disp;
99 ds_client_t *client;
100 ds_seat_t *seat;
101 ds_window_t *wnd;
102 display_wnd_params_t params;
103 bool called_cb = false;
104 errno_t rc;
105
106 rc = ds_display_create(NULL, df_none, &disp);
107 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
108
109 rc = ds_client_create(disp, &test_ds_client_cb, &called_cb, &client);
110 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
111
112 rc = ds_seat_create(disp, &seat);
113 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
114
115 display_wnd_params_init(&params);
116 params.rect.p0.x = params.rect.p0.y = 0;
117 params.rect.p1.x = params.rect.p1.y = 1;
118
119 rc = ds_window_create(client, &params, &wnd);
120 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
121
122 ds_seat_set_focus(seat, wnd);
123 PCUT_ASSERT_EQUALS(wnd, seat->focus);
124 PCUT_ASSERT_TRUE(called_cb);
125 called_cb = false;
126
127 ds_seat_evac_wnd_refs(seat, wnd);
128 PCUT_ASSERT_NULL(seat->focus);
129 PCUT_ASSERT_TRUE(called_cb);
130
131 ds_window_destroy(wnd);
132 ds_seat_destroy(seat);
133 ds_client_destroy(client);
134 ds_display_destroy(disp);
135}
136
137/** Evacuate popup reference from window.
138 *
139 * After evacuating no window should be set as the popup
140 */
141PCUT_TEST(evac_popup)
142{
143 ds_display_t *disp;
144 ds_client_t *client;
145 ds_seat_t *seat;
146 ds_window_t *wnd;
147 display_wnd_params_t params;
148 bool called_cb = false;
149 errno_t rc;
150
151 rc = ds_display_create(NULL, df_none, &disp);
152 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
153
154 rc = ds_client_create(disp, &test_ds_client_cb, &called_cb, &client);
155 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
156
157 rc = ds_seat_create(disp, &seat);
158 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
159
160 display_wnd_params_init(&params);
161 params.rect.p0.x = params.rect.p0.y = 0;
162 params.rect.p1.x = params.rect.p1.y = 1;
163 params.flags |= wndf_popup;
164
165 rc = ds_window_create(client, &params, &wnd);
166 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
167
168 PCUT_ASSERT_EQUALS(wnd, seat->popup);
169
170 ds_seat_evac_wnd_refs(seat, wnd);
171 PCUT_ASSERT_NULL(seat->popup);
172
173 ds_window_destroy(wnd);
174 ds_seat_destroy(seat);
175 ds_client_destroy(client);
176 ds_display_destroy(disp);
177}
178
179/** Unfocus window when three windows are available */
180PCUT_TEST(unfocus_wnd_three_windows)
181{
182 ds_display_t *disp;
183 ds_client_t *client;
184 ds_seat_t *seat;
185 ds_window_t *w0;
186 ds_window_t *w1;
187 ds_window_t *w2;
188 display_wnd_params_t params;
189 bool called_cb = false;
190 errno_t rc;
191
192 rc = ds_display_create(NULL, df_none, &disp);
193 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
194
195 rc = ds_client_create(disp, &test_ds_client_cb, &called_cb, &client);
196 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
197
198 rc = ds_seat_create(disp, &seat);
199 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
200
201 display_wnd_params_init(&params);
202 params.rect.p0.x = params.rect.p0.y = 0;
203 params.rect.p1.x = params.rect.p1.y = 1;
204
205 rc = ds_window_create(client, &params, &w2);
206 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
207
208 rc = ds_window_create(client, &params, &w1);
209 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
210
211 rc = ds_window_create(client, &params, &w0);
212 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
213
214 PCUT_ASSERT_EQUALS(w0, seat->focus);
215
216 ds_window_unfocus(w0);
217
218 /* The previous window, w2, should be focused now */
219 PCUT_ASSERT_EQUALS(w2, seat->focus);
220
221 ds_window_destroy(w0);
222 ds_window_destroy(w1);
223 ds_seat_destroy(seat);
224 ds_client_destroy(client);
225 ds_display_destroy(disp);
226}
227
228/** Unfocus window when two windows and one system window are available */
229PCUT_TEST(unfocus_wnd_two_windows_one_sys)
230{
231 ds_display_t *disp;
232 ds_client_t *client;
233 ds_seat_t *seat;
234 ds_window_t *w0;
235 ds_window_t *w1;
236 ds_window_t *w2;
237 display_wnd_params_t params;
238 bool called_cb = false;
239 errno_t rc;
240
241 rc = ds_display_create(NULL, df_none, &disp);
242 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
243
244 rc = ds_client_create(disp, &test_ds_client_cb, &called_cb, &client);
245 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
246
247 rc = ds_seat_create(disp, &seat);
248 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
249
250 display_wnd_params_init(&params);
251 params.rect.p0.x = params.rect.p0.y = 0;
252 params.rect.p1.x = params.rect.p1.y = 1;
253
254 params.flags |= wndf_system;
255 rc = ds_window_create(client, &params, &w2);
256 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
257
258 params.flags &= ~wndf_system;
259 rc = ds_window_create(client, &params, &w1);
260 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
261
262 rc = ds_window_create(client, &params, &w0);
263 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
264
265 PCUT_ASSERT_EQUALS(w0, seat->focus);
266
267 ds_window_unfocus(w0);
268
269 /* The previous non-system window is w1, w2 should be skipped */
270 PCUT_ASSERT_EQUALS(w1, seat->focus);
271
272 ds_window_destroy(w0);
273 ds_window_destroy(w1);
274 ds_seat_destroy(seat);
275 ds_client_destroy(client);
276 ds_display_destroy(disp);
277}
278
279/** Unfocus window when one window and one system window is available */
280PCUT_TEST(unfocus_wnd_one_window_one_sys)
281{
282 ds_display_t *disp;
283 ds_client_t *client;
284 ds_seat_t *seat;
285 ds_window_t *w0;
286 ds_window_t *w1;
287 display_wnd_params_t params;
288 bool called_cb = false;
289 errno_t rc;
290
291 rc = ds_display_create(NULL, df_none, &disp);
292 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
293
294 rc = ds_client_create(disp, &test_ds_client_cb, &called_cb, &client);
295 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
296
297 rc = ds_seat_create(disp, &seat);
298 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
299
300 display_wnd_params_init(&params);
301 params.rect.p0.x = params.rect.p0.y = 0;
302 params.rect.p1.x = params.rect.p1.y = 1;
303
304 params.flags |= wndf_system;
305 rc = ds_window_create(client, &params, &w1);
306 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
307
308 params.flags &= ~wndf_system;
309 rc = ds_window_create(client, &params, &w0);
310 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
311
312 PCUT_ASSERT_EQUALS(w0, seat->focus);
313
314 ds_window_unfocus(w0);
315
316 /* Since no non-system window is available, w1 should be focused */
317 PCUT_ASSERT_EQUALS(w1, seat->focus);
318
319 ds_window_destroy(w0);
320 ds_window_destroy(w1);
321 ds_seat_destroy(seat);
322 ds_client_destroy(client);
323 ds_display_destroy(disp);
324}
325
326/** Unfocus window when one window is available */
327PCUT_TEST(unfocus_wnd_one_window)
328{
329 ds_display_t *disp;
330 ds_client_t *client;
331 ds_seat_t *seat;
332 ds_window_t *w0;
333 display_wnd_params_t params;
334 bool called_cb = false;
335 errno_t rc;
336
337 rc = ds_display_create(NULL, df_none, &disp);
338 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
339
340 rc = ds_client_create(disp, &test_ds_client_cb, &called_cb, &client);
341 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
342
343 rc = ds_seat_create(disp, &seat);
344 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
345
346 display_wnd_params_init(&params);
347 params.rect.p0.x = params.rect.p0.y = 0;
348 params.rect.p1.x = params.rect.p1.y = 1;
349
350 rc = ds_window_create(client, &params, &w0);
351 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
352
353 PCUT_ASSERT_EQUALS(w0, seat->focus);
354
355 ds_window_unfocus(w0);
356
357 /* Since no other window is availabe, no window should be focused */
358 PCUT_ASSERT_EQUALS(NULL, seat->focus);
359
360 ds_window_destroy(w0);
361 ds_seat_destroy(seat);
362 ds_client_destroy(client);
363 ds_display_destroy(disp);
364}
365
366/** Switch focus when another window is available. */
367PCUT_TEST(switch_focus_two_windows)
368{
369 ds_display_t *disp;
370 ds_client_t *client;
371 ds_seat_t *seat;
372 ds_window_t *w0;
373 ds_window_t *w1;
374 display_wnd_params_t params;
375 bool called_cb = false;
376 errno_t rc;
377
378 rc = ds_display_create(NULL, df_none, &disp);
379 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
380
381 rc = ds_client_create(disp, &test_ds_client_cb, &called_cb, &client);
382 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
383
384 rc = ds_seat_create(disp, &seat);
385 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
386
387 display_wnd_params_init(&params);
388 params.rect.p0.x = params.rect.p0.y = 0;
389 params.rect.p1.x = params.rect.p1.y = 1;
390
391 rc = ds_window_create(client, &params, &w1);
392 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
393
394 rc = ds_window_create(client, &params, &w0);
395 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
396
397 ds_seat_set_focus(seat, w1);
398 PCUT_ASSERT_EQUALS(w1, seat->focus);
399 PCUT_ASSERT_TRUE(called_cb);
400 called_cb = false;
401
402 ds_seat_switch_focus(seat);
403 PCUT_ASSERT_EQUALS(w0, seat->focus);
404 PCUT_ASSERT_TRUE(called_cb);
405
406 ds_window_destroy(w0);
407 ds_window_destroy(w1);
408 ds_seat_destroy(seat);
409 ds_client_destroy(client);
410 ds_display_destroy(disp);
411}
412
413/** Switch focus with just one existing window.
414 *
415 * After switching the focus should remain with the same window.
416 */
417PCUT_TEST(switch_focus_one_window)
418{
419 ds_display_t *disp;
420 ds_client_t *client;
421 ds_seat_t *seat;
422 ds_window_t *wnd;
423 display_wnd_params_t params;
424 bool called_cb = false;
425 errno_t rc;
426
427 rc = ds_display_create(NULL, df_none, &disp);
428 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
429
430 rc = ds_client_create(disp, &test_ds_client_cb, &called_cb, &client);
431 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
432
433 rc = ds_seat_create(disp, &seat);
434 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
435
436 display_wnd_params_init(&params);
437 params.rect.p0.x = params.rect.p0.y = 0;
438 params.rect.p1.x = params.rect.p1.y = 1;
439
440 rc = ds_window_create(client, &params, &wnd);
441 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
442
443 ds_seat_set_focus(seat, wnd);
444 PCUT_ASSERT_EQUALS(wnd, seat->focus);
445 PCUT_ASSERT_TRUE(called_cb);
446 called_cb = false;
447
448 ds_seat_switch_focus(seat);
449 PCUT_ASSERT_EQUALS(wnd, seat->focus);
450 PCUT_ASSERT_FALSE(called_cb);
451
452 ds_window_destroy(wnd);
453 ds_seat_destroy(seat);
454 ds_client_destroy(client);
455 ds_display_destroy(disp);
456}
457
458/** Test ds_seat_post_kbd_event() with Alt-Tab switches focus */
459PCUT_TEST(post_kbd_event_alt_tab)
460{
461 ds_display_t *disp;
462 ds_client_t *client;
463 ds_seat_t *seat;
464 ds_window_t *w0;
465 ds_window_t *w1;
466 display_wnd_params_t params;
467 bool called_cb = false;
468 kbd_event_t event;
469 errno_t rc;
470
471 rc = ds_display_create(NULL, df_none, &disp);
472 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
473
474 rc = ds_client_create(disp, &test_ds_client_cb, &called_cb, &client);
475 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
476
477 rc = ds_seat_create(disp, &seat);
478 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
479
480 display_wnd_params_init(&params);
481 params.rect.p0.x = params.rect.p0.y = 0;
482 params.rect.p1.x = params.rect.p1.y = 1;
483
484 rc = ds_window_create(client, &params, &w1);
485 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
486
487 rc = ds_window_create(client, &params, &w0);
488 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
489
490 ds_seat_set_focus(seat, w1);
491 PCUT_ASSERT_EQUALS(w1, seat->focus);
492 PCUT_ASSERT_TRUE(called_cb);
493 called_cb = false;
494
495 event.type = KEY_PRESS;
496 event.mods = KM_ALT;
497 event.key = KC_TAB;
498 rc = ds_seat_post_kbd_event(seat, &event);
499 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
500 PCUT_ASSERT_EQUALS(w0, seat->focus);
501 PCUT_ASSERT_TRUE(called_cb);
502
503 ds_window_destroy(w0);
504 ds_window_destroy(w1);
505 ds_seat_destroy(seat);
506 ds_client_destroy(client);
507 ds_display_destroy(disp);
508}
509
510/** Test ds_seat_post_kbd_event() with regular key press delivers to client queue */
511PCUT_TEST(post_kbd_event_regular)
512{
513 ds_display_t *disp;
514 ds_client_t *client;
515 ds_seat_t *seat;
516 ds_window_t *wnd;
517 display_wnd_params_t params;
518 kbd_event_t event;
519 ds_window_t *rwindow;
520 display_wnd_ev_t revent;
521 bool called_cb = false;
522 errno_t rc;
523
524 rc = ds_display_create(NULL, df_none, &disp);
525 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
526
527 rc = ds_client_create(disp, &test_ds_client_cb, &called_cb, &client);
528 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
529
530 rc = ds_seat_create(disp, &seat);
531 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
532
533 display_wnd_params_init(&params);
534 params.rect.p0.x = params.rect.p0.y = 0;
535 params.rect.p1.x = params.rect.p1.y = 1;
536
537 rc = ds_window_create(client, &params, &wnd);
538 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
539
540 ds_seat_set_focus(seat, wnd);
541 PCUT_ASSERT_EQUALS(wnd, seat->focus);
542
543 PCUT_ASSERT_TRUE(called_cb);
544 rc = ds_client_get_event(client, &rwindow, &revent);
545 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
546 called_cb = false;
547
548 event.type = KEY_PRESS;
549 event.key = KC_ENTER;
550 event.mods = 0;
551 event.c = L'\0';
552
553 rc = ds_client_get_event(client, &rwindow, &revent);
554 PCUT_ASSERT_ERRNO_VAL(ENOENT, rc);
555
556 rc = ds_seat_post_kbd_event(seat, &event);
557 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
558 PCUT_ASSERT_TRUE(called_cb);
559
560 rc = ds_client_get_event(client, &rwindow, &revent);
561 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
562 PCUT_ASSERT_EQUALS(wnd, rwindow);
563 PCUT_ASSERT_EQUALS(wev_kbd, revent.etype);
564 PCUT_ASSERT_EQUALS(event.type, revent.ev.kbd.type);
565 PCUT_ASSERT_EQUALS(event.key, revent.ev.kbd.key);
566 PCUT_ASSERT_EQUALS(event.mods, revent.ev.kbd.mods);
567 PCUT_ASSERT_EQUALS(event.c, revent.ev.kbd.c);
568
569 rc = ds_client_get_event(client, &rwindow, &revent);
570 PCUT_ASSERT_ERRNO_VAL(ENOENT, rc);
571
572 ds_window_destroy(wnd);
573 ds_seat_destroy(seat);
574 ds_client_destroy(client);
575 ds_display_destroy(disp);
576}
577
578/** Test ds_seat_post_ptd_event() with click on window switches focus
579 */
580PCUT_TEST(post_ptd_event_wnd_switch)
581{
582 ds_display_t *disp;
583 ds_seat_t *seat;
584 ds_client_t *client;
585 ds_window_t *w0, *w1;
586 display_wnd_params_t params;
587 ptd_event_t event;
588 bool called_cb = false;
589 errno_t rc;
590
591 rc = ds_display_create(NULL, df_none, &disp);
592 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
593
594 rc = ds_seat_create(disp, &seat);
595 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
596
597 rc = ds_client_create(disp, &test_ds_client_cb, &called_cb, &client);
598 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
599
600 /* Set up display size to allow the pointer a range of movement */
601 disp->rect.p1.x = 500;
602 disp->rect.p1.y = 500;
603
604 display_wnd_params_init(&params);
605 params.rect.p0.x = params.rect.p0.y = 0;
606 params.rect.p1.x = params.rect.p1.y = 1;
607
608 rc = ds_window_create(client, &params, &w0);
609 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
610
611 rc = ds_window_create(client, &params, &w1);
612 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
613
614 w0->dpos.x = 10;
615 w0->dpos.y = 10;
616
617 w1->dpos.x = 400;
618 w1->dpos.y = 400;
619
620 /* New window gets focused event */
621 PCUT_ASSERT_TRUE(called_cb);
622
623 called_cb = false;
624
625 ds_seat_set_focus(seat, w0);
626
627 event.type = PTD_MOVE;
628 event.dmove.x = 400;
629 event.dmove.y = 400;
630 rc = ds_seat_post_ptd_event(seat, &event);
631 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
632
633 PCUT_ASSERT_TRUE(called_cb);
634 called_cb = false;
635
636 event.type = PTD_PRESS;
637 event.btn_num = 1;
638 rc = ds_seat_post_ptd_event(seat, &event);
639 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
640 PCUT_ASSERT_TRUE(called_cb);
641 called_cb = false;
642
643 PCUT_ASSERT_EQUALS(w1, seat->focus);
644
645 event.type = PTD_MOVE;
646 event.dmove.x = -400 + 10;
647 event.dmove.y = -400 + 10;
648 rc = ds_seat_post_ptd_event(seat, &event);
649 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
650 PCUT_ASSERT_TRUE(called_cb);
651 called_cb = false;
652
653 event.type = PTD_PRESS;
654 event.btn_num = 1;
655 rc = ds_seat_post_ptd_event(seat, &event);
656 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
657 PCUT_ASSERT_TRUE(called_cb);
658 called_cb = false;
659
660 PCUT_ASSERT_EQUALS(w0, seat->focus);
661
662 ds_window_destroy(w0);
663 ds_window_destroy(w1);
664 ds_client_destroy(client);
665 ds_seat_destroy(seat);
666 ds_display_destroy(disp);
667}
668
669/** Test ds_seat_post_pos_event() */
670PCUT_TEST(post_pos_event)
671{
672 // XXX
673}
674
675/** Set WM cursor */
676PCUT_TEST(set_wm_cursor)
677{
678 ds_display_t *disp;
679 ds_client_t *client;
680 ds_seat_t *seat;
681 bool called_cb = false;
682 errno_t rc;
683
684 rc = ds_display_create(NULL, df_none, &disp);
685 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
686
687 rc = ds_client_create(disp, &test_ds_client_cb, &called_cb, &client);
688 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
689
690 rc = ds_seat_create(disp, &seat);
691 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
692
693 ds_seat_set_wm_cursor(seat, disp->cursor[dcurs_size_ud]);
694 ds_seat_set_wm_cursor(seat, NULL);
695
696 ds_seat_destroy(seat);
697 ds_client_destroy(client);
698 ds_display_destroy(disp);
699}
700
701PCUT_EXPORT(seat);
Note: See TracBrowser for help on using the repository browser.