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

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

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