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

Last change on this file since ca95ccd was cde067e, checked in by Jiri Svoboda <jiri@…>, 10 months ago

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