source: mainline/uspace/lib/ui/test/tab.c@ ed1a948

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

Tab set control

This allows to expand the space available in a dialog window
using stacking, with individual tabs that can be activated
by clicking the handle.
  • Property mode set to 100644
File size: 19.5 KB
RevLine 
[1eaead4]1/*
2 * Copyright (c) 2023 Jiri Svoboda
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29#include <gfx/context.h>
30#include <gfx/coord.h>
31#include <mem.h>
32#include <pcut/pcut.h>
33#include <stdbool.h>
34#include <str.h>
35#include <ui/control.h>
36#include <ui/tab.h>
37#include <ui/tabset.h>
38#include <ui/testctl.h>
39#include <ui/ui.h>
40#include <ui/window.h>
41#include "../private/resource.h"
42#include "../private/tab.h"
43#include "../private/tabset.h"
44
45PCUT_INIT;
46
47PCUT_TEST_SUITE(tab);
48
49/** Create and destroy tab */
50PCUT_TEST(create_destroy)
51{
52 ui_t *ui = NULL;
53 ui_window_t *window = NULL;
54 ui_wnd_params_t params;
55 ui_resource_t *res;
56 ui_tab_set_t *tabset = NULL;
57 ui_tab_t *tab = NULL;
58 errno_t rc;
59
60 rc = ui_create_disp(NULL, &ui);
61 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
62
63 ui_wnd_params_init(&params);
64 params.caption = "Hello";
65
66 rc = ui_window_create(ui, &params, &window);
67 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
68 PCUT_ASSERT_NOT_NULL(window);
69
70 res = ui_window_get_res(window);
71
72 rc = ui_tab_set_create(res, &tabset);
73 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
74
75 rc = ui_tab_create(tabset, "Test", &tab);
76 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
77 PCUT_ASSERT_NOT_NULL(tab);
78
79 /*
80 * Normally we don't need to destroy a tab explicitly, it will
81 * be destroyed along with tab bar, but here we'll test destroying
82 * it explicitly.
83 */
84 ui_tab_destroy(tab);
85 ui_tab_set_destroy(tabset);
86
87 ui_window_destroy(window);
88 ui_destroy(ui);
89}
90
91/** Destroy tab implicitly by destroying the tab set */
92PCUT_TEST(implicit_destroy)
93{
94 ui_t *ui = NULL;
95 ui_window_t *window = NULL;
96 ui_wnd_params_t params;
97 ui_resource_t *res;
98 ui_tab_set_t *tabset = NULL;
99 ui_tab_t *tab = NULL;
100 errno_t rc;
101
102 rc = ui_create_disp(NULL, &ui);
103 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
104
105 ui_wnd_params_init(&params);
106 params.caption = "Hello";
107
108 rc = ui_window_create(ui, &params, &window);
109 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
110 PCUT_ASSERT_NOT_NULL(window);
111
112 res = ui_window_get_res(window);
113
114 rc = ui_tab_set_create(res, &tabset);
115 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
116
117 rc = ui_tab_create(tabset, "Test", &tab);
118 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
119 PCUT_ASSERT_NOT_NULL(tab);
120
121 /* Let the tab be destroyed as part of destroying tab set */
122 ui_tab_set_destroy(tabset);
123
124 ui_window_destroy(window);
125 ui_destroy(ui);
126}
127
128/** ui_tab_destroy() can take NULL argument (no-op) */
129PCUT_TEST(destroy_null)
130{
131 ui_tab_destroy(NULL);
132}
133
134/** ui_tab_first() / ui_tab_next() iterate over tabs */
135PCUT_TEST(first_next)
136{
137 ui_t *ui = NULL;
138 ui_window_t *window = NULL;
139 ui_wnd_params_t params;
140 ui_resource_t *res;
141 ui_tab_set_t *tabset = NULL;
142 ui_tab_t *tab1 = NULL;
143 ui_tab_t *tab2 = NULL;
144 ui_tab_t *t;
145 errno_t rc;
146
147 rc = ui_create_disp(NULL, &ui);
148 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
149
150 ui_wnd_params_init(&params);
151 params.caption = "Hello";
152
153 rc = ui_window_create(ui, &params, &window);
154 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
155 PCUT_ASSERT_NOT_NULL(window);
156
157 res = ui_window_get_res(window);
158
159 rc = ui_tab_set_create(res, &tabset);
160 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
161 PCUT_ASSERT_NOT_NULL(tabset);
162
163 rc = ui_tab_create(tabset, "Test 1", &tab1);
164 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
165 PCUT_ASSERT_NOT_NULL(tab1);
166
167 rc = ui_tab_create(tabset, "Test 2", &tab2);
168 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
169 PCUT_ASSERT_NOT_NULL(tab2);
170
171 t = ui_tab_first(tabset);
172 PCUT_ASSERT_EQUALS(tab1, t);
173
174 t = ui_tab_next(t);
175 PCUT_ASSERT_EQUALS(tab2, t);
176
177 t = ui_tab_next(t);
178 PCUT_ASSERT_NULL(t);
179
180 ui_tab_set_destroy(tabset);
181 ui_window_destroy(window);
182 ui_destroy(ui);
183}
184
185/** ui_tab_last() / ui_tab_prev() iterate over tabs in reverse */
186PCUT_TEST(last_prev)
187{
188 ui_t *ui = NULL;
189 ui_window_t *window = NULL;
190 ui_wnd_params_t params;
191 ui_resource_t *res;
192 ui_tab_set_t *tabset = NULL;
193 ui_tab_t *tab1 = NULL;
194 ui_tab_t *tab2 = NULL;
195 ui_tab_t *t;
196 errno_t rc;
197
198 rc = ui_create_disp(NULL, &ui);
199 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
200
201 ui_wnd_params_init(&params);
202 params.caption = "Hello";
203
204 rc = ui_window_create(ui, &params, &window);
205 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
206 PCUT_ASSERT_NOT_NULL(window);
207
208 res = ui_window_get_res(window);
209
210 rc = ui_tab_set_create(res, &tabset);
211 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
212 PCUT_ASSERT_NOT_NULL(tabset);
213
214 rc = ui_tab_create(tabset, "Test 1", &tab1);
215 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
216 PCUT_ASSERT_NOT_NULL(tab1);
217
218 rc = ui_tab_create(tabset, "Test 2", &tab2);
219 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
220 PCUT_ASSERT_NOT_NULL(tab2);
221
222 t = ui_tab_last(tabset);
223 PCUT_ASSERT_EQUALS(tab2, t);
224
225 t = ui_tab_prev(t);
226 PCUT_ASSERT_EQUALS(tab1, t);
227
228 t = ui_tab_prev(t);
229 PCUT_ASSERT_NULL(t);
230
231 ui_tab_set_destroy(tabset);
232 ui_window_destroy(window);
233 ui_destroy(ui);
234}
235
236/** ui_tab_is_selected() correctly returns tab state */
237PCUT_TEST(is_selected)
238{
239 ui_t *ui = NULL;
240 ui_window_t *window = NULL;
241 ui_wnd_params_t params;
242 ui_resource_t *res;
243 ui_tab_set_t *tabset = NULL;
244 ui_tab_t *tab1 = NULL;
245 ui_tab_t *tab2 = NULL;
246 errno_t rc;
247
248 rc = ui_create_disp(NULL, &ui);
249 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
250
251 ui_wnd_params_init(&params);
252 params.caption = "Hello";
253
254 rc = ui_window_create(ui, &params, &window);
255 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
256 PCUT_ASSERT_NOT_NULL(window);
257
258 res = ui_window_get_res(window);
259
260 rc = ui_tab_set_create(res, &tabset);
261 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
262 PCUT_ASSERT_NOT_NULL(tabset);
263
264 rc = ui_tab_create(tabset, "Test 1", &tab1);
265 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
266
267 /* The first added tab should be automatically selected */
268 PCUT_ASSERT_TRUE(ui_tab_is_selected(tab1));
269
270 rc = ui_tab_create(tabset, "Test 2", &tab2);
271 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
272
273 /* After adding a second tab the first should still be selected */
274 PCUT_ASSERT_TRUE(ui_tab_is_selected(tab1));
275 PCUT_ASSERT_FALSE(ui_tab_is_selected(tab2));
276
277 /* Select second tab */
278 ui_tab_set_select(tabset, tab2);
279
280 /* Now the second tab should be selected */
281 PCUT_ASSERT_FALSE(ui_tab_is_selected(tab1));
282 PCUT_ASSERT_TRUE(ui_tab_is_selected(tab2));
283
284 ui_tab_set_destroy(tabset);
285 ui_window_destroy(window);
286 ui_destroy(ui);
287}
288
289/** ui_tab_add() adds control to tab */
290PCUT_TEST(add)
291{
292 ui_t *ui = NULL;
293 ui_window_t *window = NULL;
294 ui_wnd_params_t params;
295 ui_resource_t *res;
296 ui_tab_set_t *tabset = NULL;
297 ui_tab_t *tab = NULL;
298 ui_test_ctl_t *testctl = NULL;
299 ui_tc_resp_t resp;
300 errno_t rc;
301
302 rc = ui_create_disp(NULL, &ui);
303 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
304
305 ui_wnd_params_init(&params);
306 params.caption = "Hello";
307
308 rc = ui_window_create(ui, &params, &window);
309 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
310 PCUT_ASSERT_NOT_NULL(window);
311
312 res = ui_window_get_res(window);
313
314 rc = ui_tab_set_create(res, &tabset);
315 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
316 PCUT_ASSERT_NOT_NULL(tabset);
317
318 rc = ui_tab_create(tabset, "Test", &tab);
319 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
320 PCUT_ASSERT_NOT_NULL(tab);
321
322 rc = ui_test_ctl_create(&resp, &testctl);
323 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
324
325 /* Add test control to tab */
326 ui_tab_add(tab, ui_test_ctl_ctl(testctl));
327
328 resp.destroy = false;
329
330 ui_tab_set_destroy(tabset);
331
332 /* Destroying the tab should have destroyed the control as well */
333 PCUT_ASSERT_TRUE(resp.destroy);
334
335 ui_window_destroy(window);
336 ui_destroy(ui);
337}
338
339/** ui_tab_remove() removes control to tab */
340PCUT_TEST(remove)
341{
342 ui_t *ui = NULL;
343 ui_window_t *window = NULL;
344 ui_wnd_params_t params;
345 ui_resource_t *res;
346 ui_tab_set_t *tabset = NULL;
347 ui_tab_t *tab = NULL;
348 ui_test_ctl_t *testctl = NULL;
349 ui_tc_resp_t resp;
350 errno_t rc;
351
352 rc = ui_create_disp(NULL, &ui);
353 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
354
355 ui_wnd_params_init(&params);
356 params.caption = "Hello";
357
358 rc = ui_window_create(ui, &params, &window);
359 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
360 PCUT_ASSERT_NOT_NULL(window);
361
362 res = ui_window_get_res(window);
363
364 rc = ui_tab_set_create(res, &tabset);
365 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
366 PCUT_ASSERT_NOT_NULL(tabset);
367
368 rc = ui_tab_create(tabset, "Test", &tab);
369 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
370 PCUT_ASSERT_NOT_NULL(tab);
371
372 rc = ui_test_ctl_create(&resp, &testctl);
373 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
374
375 /* Add test control to tab */
376 ui_tab_add(tab, ui_test_ctl_ctl(testctl));
377
378 /* Rmove control from tab */
379 ui_tab_remove(tab, ui_test_ctl_ctl(testctl));
380
381 resp.destroy = false;
382
383 ui_tab_set_destroy(tabset);
384
385 /* Destroying the tab should NOT have destroyed the control */
386 PCUT_ASSERT_FALSE(resp.destroy);
387
388 ui_test_ctl_destroy(testctl);
389 ui_window_destroy(window);
390 ui_destroy(ui);
391}
392
393/** Paint tab */
394PCUT_TEST(paint)
395{
396 ui_t *ui = NULL;
397 ui_window_t *window = NULL;
398 ui_wnd_params_t params;
399 ui_resource_t *res;
400 ui_tab_set_t *tabset = NULL;
401 ui_tab_t *tab = NULL;
402 errno_t rc;
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 res = ui_window_get_res(window);
415
416 rc = ui_tab_set_create(res, &tabset);
417 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
418 PCUT_ASSERT_NOT_NULL(tabset);
419
420 rc = ui_tab_create(tabset, "Test", &tab);
421 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
422 PCUT_ASSERT_NOT_NULL(tab);
423
424 rc = ui_tab_paint(tab);
425 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
426
427 ui_tab_set_destroy(tabset);
428 ui_window_destroy(window);
429 ui_destroy(ui);
430}
431
432/** ui_tab_kbd_event() delivers keyboard event */
433PCUT_TEST(kbd_event)
434{
435 ui_t *ui = NULL;
436 ui_window_t *window = NULL;
437 ui_wnd_params_t params;
438 ui_resource_t *res;
439 ui_tab_set_t *tabset = NULL;
440 ui_tab_t *tab = NULL;
441 ui_evclaim_t claimed;
442 kbd_event_t event;
443 ui_test_ctl_t *testctl = NULL;
444 ui_tc_resp_t resp;
445 errno_t rc;
446
447 rc = ui_create_disp(NULL, &ui);
448 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
449
450 ui_wnd_params_init(&params);
451 params.caption = "Hello";
452
453 rc = ui_window_create(ui, &params, &window);
454 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
455 PCUT_ASSERT_NOT_NULL(window);
456
457 res = ui_window_get_res(window);
458
459 rc = ui_tab_set_create(res, &tabset);
460 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
461 PCUT_ASSERT_NOT_NULL(tabset);
462
463 /* Without anytabs, event should be unclaimed */
464 event.type = KEY_PRESS;
465 event.key = KC_ENTER;
466 event.mods = 0;
467 claimed = ui_tab_set_kbd_event(tabset, &event);
468 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
469 PCUT_ASSERT_EQUALS(ui_unclaimed, claimed);
470
471 rc = ui_tab_create(tabset, "Test", &tab);
472 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
473 PCUT_ASSERT_NOT_NULL(tab);
474
475 rc = ui_test_ctl_create(&resp, &testctl);
476 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
477
478 /* Set up response */
479 ui_tab_add(tab, ui_test_ctl_ctl(testctl));
480 resp.claim = ui_claimed;
481 resp.kbd = false;
482
483 /* Send keyboard event */
484 event.type = KEY_PRESS;
485 event.key = KC_F10;
486 event.mods = 0;
487 claimed = ui_tab_kbd_event(tab, &event);
488 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
489 PCUT_ASSERT_EQUALS(ui_claimed, claimed);
490
491 /* Make sure event was delivered */
492 PCUT_ASSERT_TRUE(resp.kbd);
493 PCUT_ASSERT_EQUALS(event.type, resp.kevent.type);
494 PCUT_ASSERT_EQUALS(event.key, resp.kevent.key);
495 PCUT_ASSERT_EQUALS(event.mods, resp.kevent.mods);
496
497 ui_tab_set_destroy(tabset);
498 ui_window_destroy(window);
499 ui_destroy(ui);
500}
501
502/** ui_tab_pos_event() delivers position event */
503PCUT_TEST(pos_event)
504{
505 ui_t *ui = NULL;
506 ui_window_t *window = NULL;
507 ui_wnd_params_t params;
508 ui_resource_t *res;
509 ui_tab_set_t *tabset = NULL;
510 gfx_rect_t rect;
511 ui_tab_t *tab = NULL;
512 ui_evclaim_t claimed;
513 pos_event_t event;
514 ui_test_ctl_t *testctl = NULL;
515 ui_tc_resp_t resp;
516 errno_t rc;
517
518 rc = ui_create_disp(NULL, &ui);
519 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
520
521 ui_wnd_params_init(&params);
522 params.caption = "Hello";
523
524 rc = ui_window_create(ui, &params, &window);
525 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
526 PCUT_ASSERT_NOT_NULL(window);
527
528 res = ui_window_get_res(window);
529
530 rc = ui_tab_set_create(res, &tabset);
531 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
532 PCUT_ASSERT_NOT_NULL(tabset);
533
534 rect.p0.x = 0;
535 rect.p0.y = 0;
536 rect.p1.x = 100;
537 rect.p1.y = 200;
538 ui_tab_set_set_rect(tabset, &rect);
539
540 rc = ui_tab_create(tabset, "Test", &tab);
541 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
542 PCUT_ASSERT_NOT_NULL(tab);
543
544 rc = ui_test_ctl_create(&resp, &testctl);
545 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
546
547 /* Set up response */
548 ui_tab_add(tab, ui_test_ctl_ctl(testctl));
549 resp.claim = ui_claimed;
550 resp.pos = false;
551
552 /* Send position event */
553 event.type = POS_PRESS;
554 event.hpos = 10;
555 event.vpos = 40;
556 claimed = ui_tab_pos_event(tab, &event);
557 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
558 PCUT_ASSERT_EQUALS(ui_claimed, claimed);
559
560 /* Make sure event was delivered */
561 PCUT_ASSERT_TRUE(resp.pos);
562 PCUT_ASSERT_EQUALS(event.type, resp.pevent.type);
563 PCUT_ASSERT_EQUALS(event.hpos, resp.pevent.hpos);
564 PCUT_ASSERT_EQUALS(event.vpos, resp.pevent.vpos);
565
566 ui_tab_set_destroy(tabset);
567 ui_window_destroy(window);
568 ui_destroy(ui);
569}
570
571/** ui_tab_handle_width() and ui_tab_handle_height() return dimensions */
572PCUT_TEST(handle_width_height)
573{
574 ui_t *ui = NULL;
575 ui_window_t *window = NULL;
576 ui_wnd_params_t params;
577 ui_resource_t *res;
578 ui_tab_set_t *tabset = NULL;
579 ui_tab_t *tab = NULL;
580 gfx_coord_t w, h;
581 errno_t rc;
582
583 rc = ui_create_disp(NULL, &ui);
584 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
585
586 ui_wnd_params_init(&params);
587 params.caption = "Hello";
588
589 rc = ui_window_create(ui, &params, &window);
590 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
591 PCUT_ASSERT_NOT_NULL(window);
592
593 res = ui_window_get_res(window);
594
595 rc = ui_tab_set_create(res, &tabset);
596 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
597 PCUT_ASSERT_NOT_NULL(tabset);
598
599 rc = ui_tab_create(tabset, "Test", &tab);
600 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
601 PCUT_ASSERT_NOT_NULL(tab);
602
603 w = ui_tab_handle_width(tab);
604 h = ui_tab_handle_height(tab);
605
606 PCUT_ASSERT_INT_EQUALS(50, w);
607 PCUT_ASSERT_INT_EQUALS(25, h);
608
609 ui_tab_set_destroy(tabset);
610 ui_window_destroy(window);
611 ui_destroy(ui);
612}
613
614/** Computing tab geometry */
615PCUT_TEST(get_geom)
616{
617 ui_t *ui = NULL;
618 ui_window_t *window = NULL;
619 ui_wnd_params_t params;
620 ui_resource_t *res;
621 ui_tab_set_t *tabset = NULL;
622 ui_tab_t *tab = NULL;
623 ui_tab_geom_t geom;
624 gfx_rect_t rect;
625 errno_t rc;
626
627 rc = ui_create_disp(NULL, &ui);
628 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
629
630 ui_wnd_params_init(&params);
631 params.caption = "Hello";
632
633 rc = ui_window_create(ui, &params, &window);
634 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
635 PCUT_ASSERT_NOT_NULL(window);
636
637 res = ui_window_get_res(window);
638
639 rc = ui_tab_set_create(res, &tabset);
640 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
641 PCUT_ASSERT_NOT_NULL(tabset);
642
643 rect.p0.x = 1000;
644 rect.p0.y = 2000;
645 rect.p1.x = 1100;
646 rect.p1.y = 2200;
647 ui_tab_set_set_rect(tabset, &rect);
648
649 rc = ui_tab_create(tabset, "Test", &tab);
650 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
651 PCUT_ASSERT_NOT_NULL(tab);
652
653 ui_tab_get_geom(tab, &geom);
654
655 PCUT_ASSERT_INT_EQUALS(1006, geom.handle.p0.x);
656 PCUT_ASSERT_INT_EQUALS(2000, geom.handle.p0.y);
657 PCUT_ASSERT_INT_EQUALS(1056, geom.handle.p1.x);
658 PCUT_ASSERT_INT_EQUALS(2027, geom.handle.p1.y);
659
660 PCUT_ASSERT_INT_EQUALS(1006, geom.handle_area.p0.x);
661 PCUT_ASSERT_INT_EQUALS(2000, geom.handle_area.p0.y);
662 PCUT_ASSERT_INT_EQUALS(1056, geom.handle_area.p1.x);
663 PCUT_ASSERT_INT_EQUALS(2027, geom.handle_area.p1.y);
664
665 PCUT_ASSERT_INT_EQUALS(1000, geom.body.p0.x);
666 PCUT_ASSERT_INT_EQUALS(2025, geom.body.p0.y);
667 PCUT_ASSERT_INT_EQUALS(1100, geom.body.p1.x);
668 PCUT_ASSERT_INT_EQUALS(2200, geom.body.p1.y);
669
670 PCUT_ASSERT_INT_EQUALS(1014, geom.text_pos.x);
671 PCUT_ASSERT_INT_EQUALS(2007, geom.text_pos.y);
672
673 ui_tab_set_destroy(tabset);
674 ui_window_destroy(window);
675 ui_destroy(ui);
676}
677
678/** ui_tab_patint_handle_frame() */
679PCUT_TEST(paint_handle_frame)
680{
681 ui_t *ui = NULL;
682 ui_window_t *window = NULL;
683 ui_wnd_params_t params;
684 ui_resource_t *res;
685 gfx_context_t *gc;
686 gfx_rect_t rect;
687 gfx_rect_t irect;
688 gfx_coord_t chamfer;
689 gfx_color_t *hi_color;
690 gfx_color_t *sh_color;
691 errno_t rc;
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 res = ui_window_get_res(window);
704 gc = ui_window_get_gc(window);
705
706 rect.p0.x = 10;
707 rect.p0.y = 20;
708 rect.p1.x = 100;
709 rect.p1.y = 200;
710
711 chamfer = 4;
712
713 hi_color = res->wnd_highlight_color;
714 sh_color = res->wnd_shadow_color;
715
716 rc = ui_tab_paint_handle_frame(gc, &rect, chamfer, hi_color, sh_color,
717 true, &irect);
718 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
719
720 rc = ui_tab_paint_handle_frame(gc, &rect, chamfer, hi_color, sh_color,
721 false, &irect);
722 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
723
724 ui_window_destroy(window);
725 ui_destroy(ui);
726}
727
728/** ui_tab_paint_body_frame() */
729PCUT_TEST(paint_body_frame)
730{
731 ui_t *ui = NULL;
732 ui_window_t *window = NULL;
733 ui_wnd_params_t params;
734 ui_resource_t *res;
735 ui_tab_set_t *tabset = NULL;
736 ui_tab_t *tab = NULL;
737 errno_t rc;
738
739 rc = ui_create_disp(NULL, &ui);
740 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
741
742 ui_wnd_params_init(&params);
743 params.caption = "Hello";
744
745 rc = ui_window_create(ui, &params, &window);
746 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
747 PCUT_ASSERT_NOT_NULL(window);
748
749 res = ui_window_get_res(window);
750
751 rc = ui_tab_set_create(res, &tabset);
752 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
753 PCUT_ASSERT_NOT_NULL(tabset);
754
755 rc = ui_tab_create(tabset, "Test", &tab);
756 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
757 PCUT_ASSERT_NOT_NULL(tab);
758
759 rc = ui_tab_paint_body_frame(tab);
760 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
761
762 ui_tab_set_destroy(tabset);
763 ui_window_destroy(window);
764 ui_destroy(ui);
765}
766
767/** ui_tab_paint_frame() */
768PCUT_TEST(paint_frame)
769{
770 ui_t *ui = NULL;
771 ui_window_t *window = NULL;
772 ui_wnd_params_t params;
773 ui_resource_t *res;
774 ui_tab_set_t *tabset = NULL;
775 ui_tab_t *tab = NULL;
776 errno_t rc;
777
778 rc = ui_create_disp(NULL, &ui);
779 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
780
781 ui_wnd_params_init(&params);
782 params.caption = "Hello";
783
784 rc = ui_window_create(ui, &params, &window);
785 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
786 PCUT_ASSERT_NOT_NULL(window);
787
788 res = ui_window_get_res(window);
789
790 rc = ui_tab_set_create(res, &tabset);
791 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
792 PCUT_ASSERT_NOT_NULL(tabset);
793
794 rc = ui_tab_create(tabset, "Test", &tab);
795 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
796 PCUT_ASSERT_NOT_NULL(tab);
797
798 rc = ui_tab_paint_frame(tab);
799 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
800
801 ui_tab_set_destroy(tabset);
802 ui_window_destroy(window);
803 ui_destroy(ui);
804}
805
806/** ui_tab_get_res() returns the resource */
807PCUT_TEST(get_res)
808{
809 ui_t *ui = NULL;
810 ui_window_t *window = NULL;
811 ui_wnd_params_t params;
812 ui_resource_t *res;
813 ui_tab_set_t *tabset = NULL;
814 ui_tab_t *tab = NULL;
815 errno_t rc;
816
817 rc = ui_create_disp(NULL, &ui);
818 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
819
820 ui_wnd_params_init(&params);
821 params.caption = "Hello";
822
823 rc = ui_window_create(ui, &params, &window);
824 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
825 PCUT_ASSERT_NOT_NULL(window);
826
827 res = ui_window_get_res(window);
828
829 rc = ui_tab_set_create(res, &tabset);
830 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
831 PCUT_ASSERT_NOT_NULL(tabset);
832
833 rc = ui_tab_create(tabset, "Test", &tab);
834 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
835 PCUT_ASSERT_NOT_NULL(tab);
836
837 PCUT_ASSERT_EQUALS(res, ui_tab_get_res(tab));
838
839 ui_tab_set_destroy(tabset);
840 ui_window_destroy(window);
841 ui_destroy(ui);
842}
843
844PCUT_EXPORT(tab);
Note: See TracBrowser for help on using the repository browser.