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

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

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