source: mainline/uspace/lib/ui/test/window.c@ aace43d8

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

Make sure window is only show as inactive when it loses last focus

This currently affects the title bar and also the cursor in Terminal.
  • Property mode set to 100644
File size: 23.5 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 <gfx/context.h>
30#include <gfx/coord.h>
31#include <gfx/render.h>
32#include <io/kbd_event.h>
33#include <io/pos_event.h>
34#include <mem.h>
35#include <pcut/pcut.h>
36#include <stdbool.h>
37#include <ui/control.h>
38#include <ui/resource.h>
39#include <ui/ui.h>
40#include <ui/window.h>
41#include "../private/window.h"
42
43PCUT_INIT;
44
45PCUT_TEST_SUITE(window);
46
47static void test_window_minimize(ui_window_t *, void *);
48static void test_window_maximize(ui_window_t *, void *);
49static void test_window_unmaximize(ui_window_t *, void *);
50static void test_window_close(ui_window_t *, void *);
51static void test_window_focus(ui_window_t *, void *, unsigned);
52static void test_window_kbd(ui_window_t *, void *, kbd_event_t *);
53static errno_t test_window_paint(ui_window_t *, void *);
54static void test_window_pos(ui_window_t *, void *, pos_event_t *);
55static void test_window_unfocus(ui_window_t *, void *, unsigned);
56
57static ui_window_cb_t test_window_cb = {
58 .minimize = test_window_minimize,
59 .maximize = test_window_maximize,
60 .unmaximize = test_window_unmaximize,
61 .close = test_window_close,
62 .focus = test_window_focus,
63 .kbd = test_window_kbd,
64 .paint = test_window_paint,
65 .pos = test_window_pos,
66 .unfocus = test_window_unfocus
67};
68
69static ui_window_cb_t dummy_window_cb = {
70};
71
72static errno_t test_ctl_paint(void *);
73static ui_evclaim_t test_ctl_pos_event(void *, pos_event_t *);
74static void test_ctl_unfocus(void *, unsigned);
75
76static ui_control_ops_t test_ctl_ops = {
77 .paint = test_ctl_paint,
78 .pos_event = test_ctl_pos_event,
79 .unfocus = test_ctl_unfocus
80};
81
82typedef struct {
83 errno_t rc;
84 bool minimize;
85 bool maximize;
86 bool unmaximize;
87 bool close;
88 bool focus;
89 unsigned focus_nfocus;
90 bool kbd;
91 kbd_event_t kbd_event;
92 bool paint;
93 bool pos;
94 pos_event_t pos_event;
95 bool unfocus;
96 unsigned unfocus_nfocus;
97} test_cb_resp_t;
98
99typedef struct {
100 errno_t rc;
101 ui_evclaim_t claim;
102 bool paint;
103 bool pos;
104 pos_event_t pos_event;
105 bool unfocus;
106 unsigned unfocus_nfocus;
107} test_ctl_resp_t;
108
109/** Create and destroy window */
110PCUT_TEST(create_destroy)
111{
112 errno_t rc;
113 ui_t *ui = NULL;
114 ui_wnd_params_t params;
115 ui_window_t *window = NULL;
116
117 rc = ui_create_disp(NULL, &ui);
118 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
119
120 ui_wnd_params_init(&params);
121 params.caption = "Hello";
122
123 rc = ui_window_create(ui, &params, &window);
124 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
125 PCUT_ASSERT_NOT_NULL(window);
126
127 ui_window_destroy(window);
128 ui_destroy(ui);
129}
130
131/** ui_window_destroy() can take NULL argument (no-op) */
132PCUT_TEST(destroy_null)
133{
134 ui_window_destroy(NULL);
135}
136
137/** ui_window_add()/ui_window_remove() ... */
138PCUT_TEST(add_remove)
139{
140 errno_t rc;
141 ui_t *ui = NULL;
142 ui_wnd_params_t params;
143 ui_window_t *window = NULL;
144 ui_control_t *control = NULL;
145 test_ctl_resp_t resp;
146
147 rc = ui_create_disp(NULL, &ui);
148 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
149
150 ui_wnd_params_init(&params);
151 params.caption = "Hello";
152
153 rc = ui_window_create(ui, &params, &window);
154 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
155 PCUT_ASSERT_NOT_NULL(window);
156
157 rc = ui_control_new(&test_ctl_ops, &resp, &control);
158 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
159
160 /* Control not called since it hasn't been added yet */
161 resp.rc = ENOMEM;
162 resp.paint = false;
163 rc = ui_window_def_paint(window);
164 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
165 PCUT_ASSERT_FALSE(resp.paint);
166
167 ui_window_add(window, control);
168
169 /* Now paint request should be delivered to control */
170 resp.rc = EOK;
171 resp.paint = false;
172 rc = ui_window_def_paint(window);
173 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
174 PCUT_ASSERT_TRUE(resp.paint);
175
176 ui_window_remove(window, control);
177
178 /*
179 * After having removed the control the request should no longer
180 * be delivered to it.
181 */
182 resp.rc = ENOMEM;
183 resp.paint = false;
184 rc = ui_window_def_paint(window);
185 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
186 PCUT_ASSERT_FALSE(resp.paint);
187
188 ui_window_destroy(window);
189 ui_destroy(ui);
190}
191
192/** ui_window_get_active */
193PCUT_TEST(get_active)
194{
195 errno_t rc;
196 ui_t *ui = NULL;
197 ui_wnd_params_t params;
198 ui_window_t *window1 = NULL;
199 ui_window_t *window2 = NULL;
200 ui_window_t *awnd;
201
202 rc = ui_create_cons(NULL, &ui);
203 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
204
205 awnd = ui_window_get_active(ui);
206 PCUT_ASSERT_NULL(awnd);
207
208 ui_wnd_params_init(&params);
209 params.caption = "Hello";
210
211 rc = ui_window_create(ui, &params, &window1);
212 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
213 PCUT_ASSERT_NOT_NULL(window1);
214
215 awnd = ui_window_get_active(ui);
216 PCUT_ASSERT_EQUALS(window1, awnd);
217
218 rc = ui_window_create(ui, &params, &window2);
219 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
220 PCUT_ASSERT_NOT_NULL(window2);
221
222 awnd = ui_window_get_active(ui);
223 PCUT_ASSERT_EQUALS(window2, awnd);
224
225 ui_window_destroy(window2);
226
227 awnd = ui_window_get_active(ui);
228 PCUT_ASSERT_EQUALS(window1, awnd);
229
230 ui_window_destroy(window1);
231
232 awnd = ui_window_get_active(ui);
233 PCUT_ASSERT_NULL(awnd);
234
235 ui_destroy(ui);
236}
237
238/** ui_window_resize */
239PCUT_TEST(resize)
240{
241 errno_t rc;
242 ui_t *ui = NULL;
243 ui_wnd_params_t params;
244 ui_window_t *window = NULL;
245 gfx_rect_t nrect;
246
247 rc = ui_create_disp(NULL, &ui);
248 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
249
250 ui_wnd_params_init(&params);
251 params.caption = "Hello";
252 params.rect.p0.x = 0;
253 params.rect.p0.y = 0;
254 params.rect.p1.x = 1;
255 params.rect.p1.y = 1;
256
257 rc = ui_window_create(ui, &params, &window);
258 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
259 PCUT_ASSERT_NOT_NULL(window);
260
261 nrect.p0.x = -1;
262 nrect.p0.y = -1;
263 nrect.p1.x = 2;
264 nrect.p1.y = 2;
265 rc = ui_window_resize(window, &nrect);
266 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
267
268 ui_window_destroy(window);
269 ui_destroy(ui);
270}
271
272/** ui_window_get_ui() returns containing UI */
273PCUT_TEST(get_ui)
274{
275 errno_t rc;
276 ui_t *ui = NULL;
277 ui_t *rui;
278 ui_wnd_params_t params;
279 ui_window_t *window = NULL;
280
281 rc = ui_create_disp(NULL, &ui);
282 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
283
284 ui_wnd_params_init(&params);
285 params.caption = "Hello";
286
287 rc = ui_window_create(ui, &params, &window);
288 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
289 PCUT_ASSERT_NOT_NULL(window);
290
291 rui = ui_window_get_ui(window);
292 PCUT_ASSERT_EQUALS(ui, rui);
293
294 ui_window_destroy(window);
295 ui_destroy(ui);
296}
297
298/** ui_window_get_res/gc/rect() return valid objects */
299PCUT_TEST(get_res_gc_rect)
300{
301 errno_t rc;
302 ui_t *ui = NULL;
303 ui_wnd_params_t params;
304 ui_window_t *window = NULL;
305 ui_resource_t *res;
306 gfx_context_t *gc;
307 gfx_rect_t rect;
308
309 rc = ui_create_disp(NULL, &ui);
310 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
311
312 ui_wnd_params_init(&params);
313 params.caption = "Hello";
314
315 rc = ui_window_create(ui, &params, &window);
316 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
317 PCUT_ASSERT_NOT_NULL(window);
318
319 res = ui_window_get_res(window);
320 PCUT_ASSERT_NOT_NULL(res);
321
322 gc = ui_window_get_gc(window);
323 PCUT_ASSERT_NOT_NULL(gc);
324
325 ui_window_get_app_rect(window, &rect);
326
327 ui_window_destroy(window);
328 ui_destroy(ui);
329}
330
331/** ui_window_set_ctl_cursor() */
332PCUT_TEST(set_ctl_cursor)
333{
334 errno_t rc;
335 ui_t *ui = NULL;
336 ui_wnd_params_t params;
337 ui_window_t *window = NULL;
338
339 rc = ui_create_disp(NULL, &ui);
340 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
341
342 ui_wnd_params_init(&params);
343 params.caption = "Hello";
344
345 rc = ui_window_create(ui, &params, &window);
346 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
347 PCUT_ASSERT_NOT_NULL(window);
348
349 ui_window_set_ctl_cursor(window, ui_curs_ibeam);
350
351 ui_window_destroy(window);
352 ui_destroy(ui);
353}
354
355/** ui_window_get_app_gc() return valid GC */
356PCUT_TEST(get_app_gc)
357{
358 errno_t rc;
359 ui_t *ui = NULL;
360 ui_wnd_params_t params;
361 ui_window_t *window = NULL;
362 gfx_context_t *gc;
363
364 rc = ui_create_disp(NULL, &ui);
365 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
366
367 ui_wnd_params_init(&params);
368 params.caption = "Hello";
369 params.rect.p0.x = 0;
370 params.rect.p0.y = 0;
371 params.rect.p0.x = 100;
372 params.rect.p0.y = 100;
373
374 rc = ui_window_create(ui, &params, &window);
375 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
376 PCUT_ASSERT_NOT_NULL(window);
377
378 rc = ui_window_get_app_gc(window, &gc);
379 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
380 PCUT_ASSERT_NOT_NULL(gc);
381
382 rc = gfx_fill_rect(gc, &params.rect);
383 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
384
385 ui_window_destroy(window);
386 ui_destroy(ui);
387}
388
389/** Test ui_window_paint() */
390PCUT_TEST(paint)
391{
392 errno_t rc;
393 ui_t *ui = NULL;
394 ui_wnd_params_t params;
395 ui_window_t *window = NULL;
396
397 rc = ui_create_disp(NULL, &ui);
398 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
399
400 ui_wnd_params_init(&params);
401 params.caption = "Hello";
402
403 rc = ui_window_create(ui, &params, &window);
404 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
405 PCUT_ASSERT_NOT_NULL(window);
406
407 ui_window_paint(window);
408
409 ui_window_destroy(window);
410 ui_destroy(ui);
411}
412
413/** Test ui_window_def_paint() */
414PCUT_TEST(def_paint)
415{
416 errno_t rc;
417 ui_t *ui = NULL;
418 ui_wnd_params_t params;
419 ui_window_t *window = NULL;
420 ui_control_t *control = NULL;
421 test_ctl_resp_t resp;
422
423 rc = ui_create_disp(NULL, &ui);
424 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
425
426 ui_wnd_params_init(&params);
427 params.caption = "Hello";
428
429 rc = ui_window_create(ui, &params, &window);
430 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
431 PCUT_ASSERT_NOT_NULL(window);
432
433 rc = ui_control_new(&test_ctl_ops, &resp, &control);
434 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
435
436 ui_window_add(window, control);
437
438 resp.rc = EOK;
439 resp.paint = false;
440 rc = ui_window_def_paint(window);
441 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
442 PCUT_ASSERT_TRUE(resp.paint);
443
444 resp.rc = ENOMEM;
445 resp.paint = false;
446 rc = ui_window_def_paint(window);
447 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
448 PCUT_ASSERT_TRUE(resp.paint);
449
450 PCUT_ASSERT_TRUE(resp.paint);
451
452 /* Need to remove first because we didn't implement the destructor */
453 ui_window_remove(window, control);
454
455 ui_window_destroy(window);
456 ui_destroy(ui);
457}
458
459/** ui_window_def_pos() delivers position event to control in window */
460PCUT_TEST(def_pos)
461{
462 errno_t rc;
463 ui_t *ui = NULL;
464 ui_wnd_params_t params;
465 ui_window_t *window = NULL;
466 ui_control_t *control = NULL;
467 test_ctl_resp_t resp;
468 pos_event_t event;
469
470 rc = ui_create_disp(NULL, &ui);
471 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
472
473 ui_wnd_params_init(&params);
474 params.caption = "Hello";
475
476 rc = ui_window_create(ui, &params, &window);
477 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
478
479 rc = ui_control_new(&test_ctl_ops, &resp, &control);
480 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
481
482 ui_window_add(window, control);
483
484 event.pos_id = 1;
485 event.type = POS_PRESS;
486 event.btn_num = 2;
487 event.hpos = 3;
488 event.vpos = 4;
489
490 resp.pos = false;
491 resp.claim = ui_claimed;
492
493 ui_window_def_pos(window, &event);
494
495 PCUT_ASSERT_TRUE(resp.pos);
496 PCUT_ASSERT_INT_EQUALS(event.pos_id, resp.pos_event.pos_id);
497 PCUT_ASSERT_INT_EQUALS(event.type, resp.pos_event.type);
498 PCUT_ASSERT_INT_EQUALS(event.btn_num, resp.pos_event.btn_num);
499 PCUT_ASSERT_INT_EQUALS(event.hpos, resp.pos_event.hpos);
500 PCUT_ASSERT_INT_EQUALS(event.vpos, resp.pos_event.vpos);
501
502 /* Need to remove first because we didn't implement the destructor */
503 ui_window_remove(window, control);
504
505 ui_window_destroy(window);
506 ui_destroy(ui);
507}
508
509/** ui_window_def_unfocus() delivers unfocus event to control in window */
510PCUT_TEST(def_unfocus)
511{
512 errno_t rc;
513 ui_t *ui = NULL;
514 ui_wnd_params_t params;
515 ui_window_t *window = NULL;
516 ui_control_t *control = NULL;
517 test_ctl_resp_t resp;
518
519 rc = ui_create_disp(NULL, &ui);
520 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
521
522 ui_wnd_params_init(&params);
523 params.caption = "Hello";
524
525 rc = ui_window_create(ui, &params, &window);
526 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
527
528 rc = ui_control_new(&test_ctl_ops, &resp, &control);
529 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
530
531 ui_window_add(window, control);
532
533 resp.unfocus = false;
534
535 ui_window_def_unfocus(window, 42);
536 PCUT_ASSERT_TRUE(resp.unfocus);
537 PCUT_ASSERT_INT_EQUALS(42, resp.unfocus_nfocus);
538
539 /* Need to remove first because we didn't implement the destructor */
540 ui_window_remove(window, control);
541
542 ui_window_destroy(window);
543 ui_destroy(ui);
544}
545
546/** ui_window_send_minimize() calls minimize callback set via ui_window_set_cb() */
547PCUT_TEST(send_minimize)
548{
549 errno_t rc;
550 ui_t *ui = NULL;
551 ui_wnd_params_t params;
552 ui_window_t *window = NULL;
553 test_cb_resp_t resp;
554
555 rc = ui_create_disp(NULL, &ui);
556 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
557
558 ui_wnd_params_init(&params);
559 params.caption = "Hello";
560
561 rc = ui_window_create(ui, &params, &window);
562 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
563 PCUT_ASSERT_NOT_NULL(window);
564
565 /* Minimize callback with no callbacks set */
566 ui_window_send_minimize(window);
567
568 /* Minimize callback with minimize callback not implemented */
569 ui_window_set_cb(window, &dummy_window_cb, NULL);
570 ui_window_send_minimize(window);
571
572 /* Minimize callback with real callback set */
573 resp.minimize = false;
574 ui_window_set_cb(window, &test_window_cb, &resp);
575 ui_window_send_minimize(window);
576 PCUT_ASSERT_TRUE(resp.minimize);
577
578 ui_window_destroy(window);
579 ui_destroy(ui);
580}
581
582/** ui_window_send_maximize() calls maximize callback set via ui_window_set_cb() */
583PCUT_TEST(send_maximize)
584{
585 errno_t rc;
586 ui_t *ui = NULL;
587 ui_wnd_params_t params;
588 ui_window_t *window = NULL;
589 test_cb_resp_t resp;
590
591 rc = ui_create_disp(NULL, &ui);
592 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
593
594 ui_wnd_params_init(&params);
595 params.caption = "Hello";
596
597 rc = ui_window_create(ui, &params, &window);
598 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
599 PCUT_ASSERT_NOT_NULL(window);
600
601 /* Maximize callback with no callbacks set */
602 ui_window_send_maximize(window);
603
604 /* Maximize callback with maximize callback not implemented */
605 ui_window_set_cb(window, &dummy_window_cb, NULL);
606 ui_window_send_maximize(window);
607
608 /* Maximize callback with real callback set */
609 resp.maximize = false;
610 ui_window_set_cb(window, &test_window_cb, &resp);
611 ui_window_send_maximize(window);
612 PCUT_ASSERT_TRUE(resp.maximize);
613
614 ui_window_destroy(window);
615 ui_destroy(ui);
616}
617
618/** ui_window_send_unmaximize() calls unmaximize callback set via ui_window_set_cb() */
619PCUT_TEST(send_unmaximize)
620{
621 errno_t rc;
622 ui_t *ui = NULL;
623 ui_wnd_params_t params;
624 ui_window_t *window = NULL;
625 test_cb_resp_t resp;
626
627 rc = ui_create_disp(NULL, &ui);
628 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
629
630 ui_wnd_params_init(&params);
631 params.caption = "Hello";
632
633 rc = ui_window_create(ui, &params, &window);
634 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
635 PCUT_ASSERT_NOT_NULL(window);
636
637 /* Unmaximize callback with no callbacks set */
638 ui_window_send_unmaximize(window);
639
640 /* Unmaximize callback with unmaximize callback not implemented */
641 ui_window_set_cb(window, &dummy_window_cb, NULL);
642 ui_window_send_unmaximize(window);
643
644 /* Unmaximize callback with real callback set */
645 resp.unmaximize = false;
646 ui_window_set_cb(window, &test_window_cb, &resp);
647 ui_window_send_unmaximize(window);
648 PCUT_ASSERT_TRUE(resp.unmaximize);
649
650 ui_window_destroy(window);
651 ui_destroy(ui);
652}
653
654/** ui_window_send_close() calls close callback set via ui_window_set_cb() */
655PCUT_TEST(send_close)
656{
657 errno_t rc;
658 ui_t *ui = NULL;
659 ui_wnd_params_t params;
660 ui_window_t *window = NULL;
661 test_cb_resp_t resp;
662
663 rc = ui_create_disp(NULL, &ui);
664 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
665
666 ui_wnd_params_init(&params);
667 params.caption = "Hello";
668
669 rc = ui_window_create(ui, &params, &window);
670 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
671 PCUT_ASSERT_NOT_NULL(window);
672
673 /* Close callback with no callbacks set */
674 ui_window_send_close(window);
675
676 /* Close callback with close callback not implemented */
677 ui_window_set_cb(window, &dummy_window_cb, NULL);
678 ui_window_send_close(window);
679
680 /* Close callback with real callback set */
681 resp.close = false;
682 ui_window_set_cb(window, &test_window_cb, &resp);
683 ui_window_send_close(window);
684 PCUT_ASSERT_TRUE(resp.close);
685
686 ui_window_destroy(window);
687 ui_destroy(ui);
688}
689
690/** ui_window_send_focus() calls focus callback set via ui_window_set_cb() */
691PCUT_TEST(send_focus)
692{
693 errno_t rc;
694 ui_t *ui = NULL;
695 ui_wnd_params_t params;
696 ui_window_t *window = NULL;
697 test_cb_resp_t resp;
698
699 rc = ui_create_disp(NULL, &ui);
700 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
701
702 ui_wnd_params_init(&params);
703 params.caption = "Hello";
704
705 rc = ui_window_create(ui, &params, &window);
706 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
707 PCUT_ASSERT_NOT_NULL(window);
708
709 /* Focus callback with no callbacks set */
710 ui_window_send_focus(window, 42);
711
712 /* Focus callback with focus callback not implemented */
713 ui_window_set_cb(window, &dummy_window_cb, NULL);
714 ui_window_send_focus(window, 42);
715
716 /* Focus callback with real callback set */
717 resp.focus = false;
718 ui_window_set_cb(window, &test_window_cb, &resp);
719 ui_window_send_focus(window, 42);
720 PCUT_ASSERT_TRUE(resp.focus);
721 PCUT_ASSERT_INT_EQUALS(42, resp.focus_nfocus);
722
723 ui_window_destroy(window);
724 ui_destroy(ui);
725}
726
727/** ui_window_send_kbd() calls kbd callback set via ui_window_set_cb() */
728PCUT_TEST(send_kbd)
729{
730 errno_t rc;
731 ui_t *ui = NULL;
732 ui_wnd_params_t params;
733 ui_window_t *window = NULL;
734 kbd_event_t kbd_event;
735 test_cb_resp_t resp;
736
737 rc = ui_create_disp(NULL, &ui);
738 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
739
740 ui_wnd_params_init(&params);
741 params.caption = "Hello";
742
743 rc = ui_window_create(ui, &params, &window);
744 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
745 PCUT_ASSERT_NOT_NULL(window);
746
747 kbd_event.type = POS_PRESS;
748 kbd_event.key = KC_X;
749 kbd_event.mods = 0;
750 kbd_event.c = 'x';
751
752 /* Kbd callback with no callbacks set */
753 ui_window_send_kbd(window, &kbd_event);
754
755 /* Kbd callback with kbd callback not implemented */
756 ui_window_set_cb(window, &dummy_window_cb, NULL);
757 ui_window_send_kbd(window, &kbd_event);
758
759 /* Kbd callback with real callback set */
760 resp.kbd = false;
761 ui_window_set_cb(window, &test_window_cb, &resp);
762 ui_window_send_kbd(window, &kbd_event);
763 PCUT_ASSERT_TRUE(resp.kbd);
764 PCUT_ASSERT_EQUALS(kbd_event.type, resp.kbd_event.type);
765 PCUT_ASSERT_INT_EQUALS(kbd_event.key, resp.kbd_event.key);
766 PCUT_ASSERT_INT_EQUALS(kbd_event.mods, resp.kbd_event.mods);
767 PCUT_ASSERT_INT_EQUALS(kbd_event.c, resp.kbd_event.c);
768
769 ui_window_destroy(window);
770 ui_destroy(ui);
771}
772
773/** ui_window_send_paint() calls paint callback set via ui_window_set_cb() */
774PCUT_TEST(send_paint)
775{
776 errno_t rc;
777 ui_t *ui = NULL;
778 ui_wnd_params_t params;
779 ui_window_t *window = NULL;
780 test_cb_resp_t resp;
781
782 rc = ui_create_disp(NULL, &ui);
783 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
784
785 ui_wnd_params_init(&params);
786 params.caption = "Hello";
787
788 rc = ui_window_create(ui, &params, &window);
789 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
790 PCUT_ASSERT_NOT_NULL(window);
791
792 /* Paint callback with no callbacks set */
793 ui_window_send_paint(window);
794
795 /* Paint callback with paint callback not implemented */
796 ui_window_set_cb(window, &dummy_window_cb, NULL);
797 ui_window_send_paint(window);
798
799 /* Paint callback with real callback set */
800 resp.paint = false;
801 resp.rc = EOK;
802 ui_window_set_cb(window, &test_window_cb, &resp);
803 rc = ui_window_send_paint(window);
804 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
805 PCUT_ASSERT_TRUE(resp.paint);
806
807 ui_window_destroy(window);
808 ui_destroy(ui);
809}
810
811/** ui_window_send_pos() calls pos callback set via ui_window_set_cb() */
812PCUT_TEST(send_pos)
813{
814 errno_t rc;
815 ui_t *ui = NULL;
816 ui_wnd_params_t params;
817 ui_window_t *window = NULL;
818 pos_event_t pos_event;
819 test_cb_resp_t resp;
820
821 rc = ui_create_disp(NULL, &ui);
822 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
823
824 ui_wnd_params_init(&params);
825 params.caption = "Hello";
826
827 rc = ui_window_create(ui, &params, &window);
828 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
829 PCUT_ASSERT_NOT_NULL(window);
830
831 pos_event.pos_id = 1;
832 pos_event.type = POS_PRESS;
833 pos_event.btn_num = 2;
834 pos_event.hpos = 3;
835 pos_event.vpos = 4;
836
837 /* Pos callback with no callbacks set */
838 ui_window_send_pos(window, &pos_event);
839
840 /* Pos callback with pos callback not implemented */
841 ui_window_set_cb(window, &dummy_window_cb, NULL);
842 ui_window_send_pos(window, &pos_event);
843
844 /* Pos callback with real callback set */
845 resp.pos = false;
846 ui_window_set_cb(window, &test_window_cb, &resp);
847 ui_window_send_pos(window, &pos_event);
848 PCUT_ASSERT_TRUE(resp.pos);
849 PCUT_ASSERT_INT_EQUALS(pos_event.pos_id, resp.pos_event.pos_id);
850 PCUT_ASSERT_EQUALS(pos_event.type, resp.pos_event.type);
851 PCUT_ASSERT_INT_EQUALS(pos_event.btn_num, resp.pos_event.btn_num);
852 PCUT_ASSERT_INT_EQUALS(pos_event.hpos, resp.pos_event.hpos);
853 PCUT_ASSERT_INT_EQUALS(pos_event.vpos, resp.pos_event.vpos);
854
855 ui_window_destroy(window);
856 ui_destroy(ui);
857}
858
859/** ui_window_send_unfocus() calls unfocus callback set via ui_window_set_cb() */
860PCUT_TEST(send_unfocus)
861{
862 errno_t rc;
863 ui_t *ui = NULL;
864 ui_wnd_params_t params;
865 ui_window_t *window = NULL;
866 test_cb_resp_t resp;
867
868 rc = ui_create_disp(NULL, &ui);
869 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
870
871 ui_wnd_params_init(&params);
872 params.caption = "Hello";
873
874 rc = ui_window_create(ui, &params, &window);
875 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
876 PCUT_ASSERT_NOT_NULL(window);
877
878 /* Unfocus callback with no callbacks set */
879 ui_window_send_unfocus(window, 42);
880
881 /* Unfocus callback with unfocus callback not implemented */
882 ui_window_set_cb(window, &dummy_window_cb, NULL);
883 ui_window_send_unfocus(window, 42);
884
885 /* Unfocus callback with real callback set */
886 resp.close = false;
887 ui_window_set_cb(window, &test_window_cb, &resp);
888 ui_window_send_unfocus(window, 42);
889 PCUT_ASSERT_TRUE(resp.unfocus);
890 PCUT_ASSERT_INT_EQUALS(42, resp.unfocus_nfocus);
891
892 ui_window_destroy(window);
893 ui_destroy(ui);
894}
895
896static void test_window_minimize(ui_window_t *window, void *arg)
897{
898 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
899
900 resp->minimize = true;
901}
902
903static void test_window_maximize(ui_window_t *window, void *arg)
904{
905 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
906
907 resp->maximize = true;
908}
909
910static void test_window_unmaximize(ui_window_t *window, void *arg)
911{
912 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
913
914 resp->unmaximize = true;
915}
916
917static void test_window_close(ui_window_t *window, void *arg)
918{
919 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
920
921 resp->close = true;
922}
923
924static void test_window_focus(ui_window_t *window, void *arg, unsigned nfocus)
925{
926 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
927
928 resp->focus = true;
929 resp->focus_nfocus = nfocus;
930}
931
932static void test_window_kbd(ui_window_t *window, void *arg,
933 kbd_event_t *event)
934{
935 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
936
937 resp->kbd = true;
938 resp->kbd_event = *event;
939}
940
941static errno_t test_window_paint(ui_window_t *window, void *arg)
942{
943 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
944
945 resp->paint = true;
946 return resp->rc;
947}
948
949static void test_window_pos(ui_window_t *window, void *arg,
950 pos_event_t *event)
951{
952 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
953
954 resp->pos = true;
955 resp->pos_event = *event;
956}
957
958static void test_window_unfocus(ui_window_t *window, void *arg, unsigned nfocus)
959{
960 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
961
962 resp->unfocus = true;
963 resp->unfocus_nfocus = nfocus;
964}
965
966static errno_t test_ctl_paint(void *arg)
967{
968 test_ctl_resp_t *resp = (test_ctl_resp_t *) arg;
969
970 resp->paint = true;
971 return resp->rc;
972}
973
974static ui_evclaim_t test_ctl_pos_event(void *arg, pos_event_t *event)
975{
976 test_ctl_resp_t *resp = (test_ctl_resp_t *) arg;
977
978 resp->pos = true;
979 resp->pos_event = *event;
980
981 return resp->claim;
982}
983
984static void test_ctl_unfocus(void *arg, unsigned nfocus)
985{
986 test_ctl_resp_t *resp = (test_ctl_resp_t *) arg;
987
988 resp->unfocus = true;
989 resp->unfocus_nfocus = nfocus;
990}
991
992PCUT_EXPORT(window);
Note: See TracBrowser for help on using the repository browser.