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

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

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