source: mainline/uspace/lib/ui/test/scrollbar.c@ 1026cc4

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

Clicking scrollbar through to generate page up / page down
  • Property mode set to 100644
File size: 26.8 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 <mem.h>
32#include <pcut/pcut.h>
33#include <stdbool.h>
34#include <ui/control.h>
35#include <ui/scrollbar.h>
36#include <ui/resource.h>
37#include "../private/pbutton.h"
38#include "../private/scrollbar.h"
39
40PCUT_INIT;
41
42PCUT_TEST_SUITE(scrollbar);
43
44static errno_t testgc_set_clip_rect(void *, gfx_rect_t *);
45static errno_t testgc_set_color(void *, gfx_color_t *);
46static errno_t testgc_fill_rect(void *, gfx_rect_t *);
47static errno_t testgc_update(void *);
48static errno_t testgc_bitmap_create(void *, gfx_bitmap_params_t *,
49 gfx_bitmap_alloc_t *, void **);
50static errno_t testgc_bitmap_destroy(void *);
51static errno_t testgc_bitmap_render(void *, gfx_rect_t *, gfx_coord2_t *);
52static errno_t testgc_bitmap_get_alloc(void *, gfx_bitmap_alloc_t *);
53
54static gfx_context_ops_t ops = {
55 .set_clip_rect = testgc_set_clip_rect,
56 .set_color = testgc_set_color,
57 .fill_rect = testgc_fill_rect,
58 .update = testgc_update,
59 .bitmap_create = testgc_bitmap_create,
60 .bitmap_destroy = testgc_bitmap_destroy,
61 .bitmap_render = testgc_bitmap_render,
62 .bitmap_get_alloc = testgc_bitmap_get_alloc
63};
64
65static void test_scrollbar_up(ui_scrollbar_t *, void *);
66static void test_scrollbar_down(ui_scrollbar_t *, void *);
67static void test_scrollbar_page_up(ui_scrollbar_t *, void *);
68static void test_scrollbar_page_down(ui_scrollbar_t *, void *);
69static void test_scrollbar_moved(ui_scrollbar_t *, void *, gfx_coord_t);
70
71static ui_scrollbar_cb_t test_scrollbar_cb = {
72 .up = test_scrollbar_up,
73 .down = test_scrollbar_down,
74 .page_up = test_scrollbar_page_up,
75 .page_down = test_scrollbar_page_down,
76 .moved = test_scrollbar_moved
77};
78
79static ui_scrollbar_cb_t dummy_scrollbar_cb = {
80};
81
82typedef struct {
83 bool bm_created;
84 bool bm_destroyed;
85 gfx_bitmap_params_t bm_params;
86 void *bm_pixels;
87 gfx_rect_t bm_srect;
88 gfx_coord2_t bm_offs;
89 bool bm_rendered;
90 bool bm_got_alloc;
91} test_gc_t;
92
93typedef struct {
94 test_gc_t *tgc;
95 gfx_bitmap_alloc_t alloc;
96 bool myalloc;
97} testgc_bitmap_t;
98
99typedef struct {
100 bool up;
101 bool down;
102 bool page_up;
103 bool page_down;
104 bool moved;
105 gfx_coord_t pos;
106} test_cb_resp_t;
107
108/** Create and destroy scrollbar */
109PCUT_TEST(create_destroy)
110{
111 errno_t rc;
112 gfx_context_t *gc = NULL;
113 test_gc_t tgc;
114 ui_resource_t *resource = NULL;
115 ui_scrollbar_t *scrollbar = NULL;
116
117 memset(&tgc, 0, sizeof(tgc));
118 rc = gfx_context_new(&ops, &tgc, &gc);
119 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
120
121 rc = ui_resource_create(gc, false, &resource);
122 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
123 PCUT_ASSERT_NOT_NULL(resource);
124
125 rc = ui_scrollbar_create(resource, &scrollbar);
126 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
127 PCUT_ASSERT_NOT_NULL(scrollbar);
128
129 ui_scrollbar_destroy(scrollbar);
130 ui_resource_destroy(resource);
131
132 rc = gfx_context_delete(gc);
133 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
134}
135
136/** ui_scrollbar_destroy() can take NULL argument (no-op) */
137PCUT_TEST(destroy_null)
138{
139 ui_scrollbar_destroy(NULL);
140}
141
142/** ui_scrollbar_ctl() returns control that has a working virtual destructor */
143PCUT_TEST(ctl)
144{
145 errno_t rc;
146 gfx_context_t *gc = NULL;
147 test_gc_t tgc;
148 ui_resource_t *resource = NULL;
149 ui_scrollbar_t *scrollbar = NULL;
150 ui_control_t *control;
151
152 memset(&tgc, 0, sizeof(tgc));
153 rc = gfx_context_new(&ops, &tgc, &gc);
154 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
155
156 rc = ui_resource_create(gc, false, &resource);
157 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
158 PCUT_ASSERT_NOT_NULL(resource);
159
160 rc = ui_scrollbar_create(resource, &scrollbar);
161 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
162 PCUT_ASSERT_NOT_NULL(scrollbar);
163
164 control = ui_scrollbar_ctl(scrollbar);
165 PCUT_ASSERT_NOT_NULL(control);
166
167 ui_control_destroy(control);
168 ui_resource_destroy(resource);
169
170 rc = gfx_context_delete(gc);
171 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
172}
173
174/** Set scrollbar rectangle sets internal field */
175PCUT_TEST(set_rect)
176{
177 errno_t rc;
178 gfx_context_t *gc = NULL;
179 test_gc_t tgc;
180 ui_resource_t *resource = NULL;
181 ui_scrollbar_t *scrollbar = NULL;
182 gfx_rect_t rect;
183
184 memset(&tgc, 0, sizeof(tgc));
185 rc = gfx_context_new(&ops, &tgc, &gc);
186 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
187
188 rc = ui_resource_create(gc, false, &resource);
189 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
190 PCUT_ASSERT_NOT_NULL(resource);
191
192 rc = ui_scrollbar_create(resource, &scrollbar);
193 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
194 PCUT_ASSERT_NOT_NULL(scrollbar);
195
196 rect.p0.x = 1;
197 rect.p0.y = 2;
198 rect.p1.x = 3;
199 rect.p1.y = 4;
200
201 ui_scrollbar_set_rect(scrollbar, &rect);
202 PCUT_ASSERT_INT_EQUALS(rect.p0.x, scrollbar->rect.p0.x);
203 PCUT_ASSERT_INT_EQUALS(rect.p0.y, scrollbar->rect.p0.y);
204 PCUT_ASSERT_INT_EQUALS(rect.p1.x, scrollbar->rect.p1.x);
205 PCUT_ASSERT_INT_EQUALS(rect.p1.y, scrollbar->rect.p1.y);
206
207 ui_scrollbar_destroy(scrollbar);
208 ui_resource_destroy(resource);
209
210 rc = gfx_context_delete(gc);
211 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
212}
213
214/** Paint scrollbar in graphics mode */
215PCUT_TEST(paint_gfx)
216{
217 errno_t rc;
218 gfx_context_t *gc = NULL;
219 test_gc_t tgc;
220 ui_resource_t *resource = NULL;
221 ui_scrollbar_t *scrollbar;
222
223 memset(&tgc, 0, sizeof(tgc));
224 rc = gfx_context_new(&ops, &tgc, &gc);
225 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
226
227 rc = ui_resource_create(gc, false, &resource);
228 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
229 PCUT_ASSERT_NOT_NULL(resource);
230
231 rc = ui_scrollbar_create(resource, &scrollbar);
232 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
233
234 rc = ui_scrollbar_paint_gfx(scrollbar);
235 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
236
237 ui_scrollbar_destroy(scrollbar);
238 ui_resource_destroy(resource);
239
240 rc = gfx_context_delete(gc);
241 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
242}
243
244/** Paint scrollbar in text mode */
245PCUT_TEST(paint_text)
246{
247 errno_t rc;
248 gfx_context_t *gc = NULL;
249 test_gc_t tgc;
250 ui_resource_t *resource = NULL;
251 ui_scrollbar_t *scrollbar;
252 gfx_rect_t rect;
253
254 memset(&tgc, 0, sizeof(tgc));
255 rc = gfx_context_new(&ops, &tgc, &gc);
256 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
257
258 rc = ui_resource_create(gc, true, &resource);
259 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
260 PCUT_ASSERT_NOT_NULL(resource);
261
262 rc = ui_scrollbar_create(resource, &scrollbar);
263 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
264
265 rect.p0.x = 1;
266 rect.p0.y = 1;
267 rect.p1.x = 10;
268 rect.p1.y = 2;
269 ui_scrollbar_set_rect(scrollbar, &rect);
270
271 rc = ui_scrollbar_paint_text(scrollbar);
272 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
273
274 ui_scrollbar_destroy(scrollbar);
275 ui_resource_destroy(resource);
276
277 rc = gfx_context_delete(gc);
278 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
279}
280
281/** ui_scrollbar_through_length() gives correct scrollbar through length */
282PCUT_TEST(through_length)
283{
284 errno_t rc;
285 gfx_context_t *gc = NULL;
286 test_gc_t tgc;
287 ui_resource_t *resource = NULL;
288 ui_scrollbar_t *scrollbar;
289 gfx_coord_t length;
290 gfx_rect_t rect;
291
292 memset(&tgc, 0, sizeof(tgc));
293 rc = gfx_context_new(&ops, &tgc, &gc);
294 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
295
296 rc = ui_resource_create(gc, false, &resource);
297 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
298 PCUT_ASSERT_NOT_NULL(resource);
299
300 rc = ui_scrollbar_create(resource, &scrollbar);
301 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
302
303 PCUT_ASSERT_FALSE(scrollbar->thumb_held);
304
305 rect.p0.x = 10;
306 rect.p0.y = 20;
307 rect.p1.x = 110;
308 rect.p1.y = 120;
309 ui_scrollbar_set_rect(scrollbar, &rect);
310
311 length = ui_scrollbar_through_length(scrollbar);
312
313 /* Total length minus buttons */
314 PCUT_ASSERT_INT_EQUALS(110 - 10 - 2 * 20, length);
315
316 ui_scrollbar_destroy(scrollbar);
317 ui_resource_destroy(resource);
318
319 rc = gfx_context_delete(gc);
320 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
321}
322
323/** ui_scrollbar_move_length() gives correct scrollbar move length */
324PCUT_TEST(move_length)
325{
326 errno_t rc;
327 gfx_context_t *gc = NULL;
328 test_gc_t tgc;
329 ui_resource_t *resource = NULL;
330 ui_scrollbar_t *scrollbar;
331 gfx_coord_t length;
332 gfx_rect_t rect;
333
334 memset(&tgc, 0, sizeof(tgc));
335 rc = gfx_context_new(&ops, &tgc, &gc);
336 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
337
338 rc = ui_resource_create(gc, false, &resource);
339 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
340 PCUT_ASSERT_NOT_NULL(resource);
341
342 rc = ui_scrollbar_create(resource, &scrollbar);
343 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
344
345 PCUT_ASSERT_FALSE(scrollbar->thumb_held);
346
347 rect.p0.x = 10;
348 rect.p0.y = 20;
349 rect.p1.x = 110;
350 rect.p1.y = 120;
351 ui_scrollbar_set_rect(scrollbar, &rect);
352
353 length = ui_scrollbar_move_length(scrollbar);
354
355 /* Total length minus buttons minus default thumb length */
356 PCUT_ASSERT_INT_EQUALS(110 - 10 - 2 * 20 - 20, length);
357
358 ui_scrollbar_destroy(scrollbar);
359 ui_resource_destroy(resource);
360
361 rc = gfx_context_delete(gc);
362 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
363}
364
365/** ui_scrollbar_get_pos() returns scrollbar position */
366PCUT_TEST(get_pos)
367{
368 errno_t rc;
369 gfx_context_t *gc = NULL;
370 test_gc_t tgc;
371 ui_resource_t *resource = NULL;
372 ui_scrollbar_t *scrollbar;
373 gfx_coord_t pos;
374 gfx_rect_t rect;
375
376 memset(&tgc, 0, sizeof(tgc));
377 rc = gfx_context_new(&ops, &tgc, &gc);
378 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
379
380 rc = ui_resource_create(gc, false, &resource);
381 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
382 PCUT_ASSERT_NOT_NULL(resource);
383
384 rc = ui_scrollbar_create(resource, &scrollbar);
385 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
386
387 PCUT_ASSERT_FALSE(scrollbar->thumb_held);
388
389 rect.p0.x = 10;
390 rect.p0.y = 20;
391 rect.p1.x = 110;
392 rect.p1.y = 120;
393 ui_scrollbar_set_rect(scrollbar, &rect);
394
395 scrollbar->pos = 42;
396 pos = ui_scrollbar_get_pos(scrollbar);
397 PCUT_ASSERT_INT_EQUALS(42, pos);
398
399 ui_scrollbar_destroy(scrollbar);
400 ui_resource_destroy(resource);
401
402 rc = gfx_context_delete(gc);
403 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
404}
405
406/** ui_scrollbar_set_thumb_length() sets thumb length */
407PCUT_TEST(set_thumb_length)
408{
409 errno_t rc;
410 gfx_context_t *gc = NULL;
411 test_gc_t tgc;
412 ui_resource_t *resource = NULL;
413 ui_scrollbar_t *scrollbar;
414 gfx_rect_t rect;
415
416 memset(&tgc, 0, sizeof(tgc));
417 rc = gfx_context_new(&ops, &tgc, &gc);
418 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
419
420 rc = ui_resource_create(gc, false, &resource);
421 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
422 PCUT_ASSERT_NOT_NULL(resource);
423
424 rc = ui_scrollbar_create(resource, &scrollbar);
425 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
426
427 PCUT_ASSERT_FALSE(scrollbar->thumb_held);
428
429 rect.p0.x = 10;
430 rect.p0.y = 20;
431 rect.p1.x = 110;
432 rect.p1.y = 120;
433 ui_scrollbar_set_rect(scrollbar, &rect);
434
435 ui_scrollbar_set_thumb_length(scrollbar, 42);
436 PCUT_ASSERT_INT_EQUALS(42, scrollbar->thumb_len);
437
438 ui_scrollbar_destroy(scrollbar);
439 ui_resource_destroy(resource);
440
441 rc = gfx_context_delete(gc);
442 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
443}
444
445/** ui_scrollbar_set_pos() sets thumb position */
446PCUT_TEST(set_pos)
447{
448 errno_t rc;
449 gfx_context_t *gc = NULL;
450 test_gc_t tgc;
451 ui_resource_t *resource = NULL;
452 ui_scrollbar_t *scrollbar;
453 gfx_coord_t pos;
454 gfx_rect_t rect;
455
456 memset(&tgc, 0, sizeof(tgc));
457 rc = gfx_context_new(&ops, &tgc, &gc);
458 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
459
460 rc = ui_resource_create(gc, false, &resource);
461 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
462 PCUT_ASSERT_NOT_NULL(resource);
463
464 rc = ui_scrollbar_create(resource, &scrollbar);
465 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
466
467 PCUT_ASSERT_FALSE(scrollbar->thumb_held);
468
469 rect.p0.x = 10;
470 rect.p0.y = 20;
471 rect.p1.x = 110;
472 rect.p1.y = 120;
473 ui_scrollbar_set_rect(scrollbar, &rect);
474
475 ui_scrollbar_set_pos(scrollbar, -1);
476 pos = ui_scrollbar_get_pos(scrollbar);
477 /* The value is clipped to the minimum possible position (0) */
478 PCUT_ASSERT_INT_EQUALS(0, pos);
479
480 ui_scrollbar_set_pos(scrollbar, 12);
481 pos = ui_scrollbar_get_pos(scrollbar);
482 /* The value is set to the requested value */
483 PCUT_ASSERT_INT_EQUALS(12, pos);
484
485 ui_scrollbar_set_pos(scrollbar, 42);
486 pos = ui_scrollbar_get_pos(scrollbar);
487 /* The value is clipped to the maximum possible position (40) */
488 PCUT_ASSERT_INT_EQUALS(40, pos);
489
490 ui_scrollbar_destroy(scrollbar);
491 ui_resource_destroy(resource);
492
493 rc = gfx_context_delete(gc);
494 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
495}
496
497/** Press and release scrollbar thumb */
498PCUT_TEST(thumb_press_release)
499{
500 errno_t rc;
501 gfx_context_t *gc = NULL;
502 test_gc_t tgc;
503 ui_resource_t *resource = NULL;
504 gfx_coord2_t pos;
505 gfx_rect_t rect;
506 ui_scrollbar_t *scrollbar;
507 test_cb_resp_t resp;
508
509 memset(&tgc, 0, sizeof(tgc));
510 rc = gfx_context_new(&ops, &tgc, &gc);
511 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
512
513 rc = ui_resource_create(gc, false, &resource);
514 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
515 PCUT_ASSERT_NOT_NULL(resource);
516
517 rc = ui_scrollbar_create(resource, &scrollbar);
518 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
519
520 rect.p0.x = 10;
521 rect.p0.y = 20;
522 rect.p1.x = 110;
523 rect.p1.y = 120;
524 ui_scrollbar_set_rect(scrollbar, &rect);
525
526 resp.moved = false;
527 ui_scrollbar_set_cb(scrollbar, &test_scrollbar_cb, &resp);
528
529 PCUT_ASSERT_FALSE(scrollbar->thumb_held);
530
531 pos.x = 11;
532 pos.y = 22;
533
534 ui_scrollbar_thumb_press(scrollbar, &pos);
535 PCUT_ASSERT_TRUE(scrollbar->thumb_held);
536 PCUT_ASSERT_FALSE(resp.moved);
537
538 pos.x = 21;
539 pos.y = 32;
540
541 ui_scrollbar_release(scrollbar, &pos);
542 PCUT_ASSERT_FALSE(scrollbar->thumb_held);
543 PCUT_ASSERT_TRUE(resp.moved);
544 PCUT_ASSERT_INT_EQUALS(10, scrollbar->pos);
545
546 ui_scrollbar_destroy(scrollbar);
547 ui_resource_destroy(resource);
548
549 rc = gfx_context_delete(gc);
550 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
551}
552
553/** Press, update and release scrollbar */
554PCUT_TEST(press_uodate_release)
555{
556 errno_t rc;
557 gfx_context_t *gc = NULL;
558 test_gc_t tgc;
559 ui_resource_t *resource = NULL;
560 gfx_coord2_t pos;
561 gfx_rect_t rect;
562 ui_scrollbar_t *scrollbar;
563 test_cb_resp_t resp;
564
565 memset(&tgc, 0, sizeof(tgc));
566 rc = gfx_context_new(&ops, &tgc, &gc);
567 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
568
569 rc = ui_resource_create(gc, false, &resource);
570 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
571 PCUT_ASSERT_NOT_NULL(resource);
572
573 rc = ui_scrollbar_create(resource, &scrollbar);
574 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
575
576 rect.p0.x = 10;
577 rect.p0.y = 20;
578 rect.p1.x = 110;
579 rect.p1.y = 120;
580 ui_scrollbar_set_rect(scrollbar, &rect);
581
582 resp.moved = false;
583 ui_scrollbar_set_cb(scrollbar, &test_scrollbar_cb, &resp);
584
585 PCUT_ASSERT_FALSE(scrollbar->thumb_held);
586
587 pos.x = 11;
588 pos.y = 22;
589
590 ui_scrollbar_thumb_press(scrollbar, &pos);
591 PCUT_ASSERT_TRUE(scrollbar->thumb_held);
592 PCUT_ASSERT_FALSE(resp.moved);
593
594 pos.x = 21;
595 pos.y = 32;
596
597 ui_scrollbar_update(scrollbar, &pos);
598 PCUT_ASSERT_TRUE(scrollbar->thumb_held);
599 PCUT_ASSERT_TRUE(resp.moved);
600 PCUT_ASSERT_INT_EQUALS(10, scrollbar->pos);
601
602 pos.x = 31;
603 pos.y = 42;
604
605 ui_scrollbar_release(scrollbar, &pos);
606 PCUT_ASSERT_FALSE(scrollbar->thumb_held);
607 PCUT_ASSERT_TRUE(resp.moved);
608 PCUT_ASSERT_INT_EQUALS(20, scrollbar->pos);
609
610 ui_scrollbar_destroy(scrollbar);
611 ui_resource_destroy(resource);
612
613 rc = gfx_context_delete(gc);
614 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
615}
616
617/** ui_scrollbar_up() delivers up event */
618PCUT_TEST(up)
619{
620 ui_scrollbar_t *scrollbar;
621 errno_t rc;
622 gfx_context_t *gc = NULL;
623 test_gc_t tgc;
624 ui_resource_t *resource = NULL;
625 test_cb_resp_t resp;
626
627 memset(&tgc, 0, sizeof(tgc));
628 rc = gfx_context_new(&ops, &tgc, &gc);
629 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
630
631 rc = ui_resource_create(gc, false, &resource);
632 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
633 PCUT_ASSERT_NOT_NULL(resource);
634
635 rc = ui_scrollbar_create(resource, &scrollbar);
636 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
637
638 /* Up with no callbacks set */
639 ui_scrollbar_up(scrollbar);
640
641 /* Up with callback not implementing up */
642 ui_scrollbar_set_cb(scrollbar, &dummy_scrollbar_cb, NULL);
643 ui_scrollbar_up(scrollbar);
644
645 /* Up with real callback set */
646 resp.up = false;
647 ui_scrollbar_set_cb(scrollbar, &test_scrollbar_cb, &resp);
648 ui_scrollbar_up(scrollbar);
649 PCUT_ASSERT_TRUE(resp.up);
650
651 ui_scrollbar_destroy(scrollbar);
652 ui_resource_destroy(resource);
653
654 rc = gfx_context_delete(gc);
655 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
656}
657
658/** ui_scrollbar_down() delivers down event */
659PCUT_TEST(down)
660{
661 ui_scrollbar_t *scrollbar;
662 errno_t rc;
663 gfx_context_t *gc = NULL;
664 test_gc_t tgc;
665 ui_resource_t *resource = NULL;
666 test_cb_resp_t resp;
667
668 memset(&tgc, 0, sizeof(tgc));
669 rc = gfx_context_new(&ops, &tgc, &gc);
670 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
671
672 rc = ui_resource_create(gc, false, &resource);
673 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
674 PCUT_ASSERT_NOT_NULL(resource);
675
676 rc = ui_scrollbar_create(resource, &scrollbar);
677 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
678
679 /* Down with no callbacks set */
680 ui_scrollbar_down(scrollbar);
681
682 /* Down with callback not implementing down */
683 ui_scrollbar_set_cb(scrollbar, &dummy_scrollbar_cb, NULL);
684 ui_scrollbar_down(scrollbar);
685
686 /* Down with real callback set */
687 resp.down = false;
688 ui_scrollbar_set_cb(scrollbar, &test_scrollbar_cb, &resp);
689 ui_scrollbar_down(scrollbar);
690 PCUT_ASSERT_TRUE(resp.down);
691
692 ui_scrollbar_destroy(scrollbar);
693 ui_resource_destroy(resource);
694
695 rc = gfx_context_delete(gc);
696 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
697}
698
699/** ui_scrollbar_page_up() delivers page up event */
700PCUT_TEST(page_up)
701{
702 ui_scrollbar_t *scrollbar;
703 errno_t rc;
704 gfx_context_t *gc = NULL;
705 test_gc_t tgc;
706 ui_resource_t *resource = NULL;
707 test_cb_resp_t resp;
708
709 memset(&tgc, 0, sizeof(tgc));
710 rc = gfx_context_new(&ops, &tgc, &gc);
711 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
712
713 rc = ui_resource_create(gc, false, &resource);
714 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
715 PCUT_ASSERT_NOT_NULL(resource);
716
717 rc = ui_scrollbar_create(resource, &scrollbar);
718 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
719
720 /* Page up with no callbacks set */
721 ui_scrollbar_page_up(scrollbar);
722
723 /* Pge up with callback not implementing page up */
724 ui_scrollbar_set_cb(scrollbar, &dummy_scrollbar_cb, NULL);
725 ui_scrollbar_page_up(scrollbar);
726
727 /* Page up with real callback set */
728 resp.page_up = false;
729 ui_scrollbar_set_cb(scrollbar, &test_scrollbar_cb, &resp);
730 ui_scrollbar_page_up(scrollbar);
731 PCUT_ASSERT_TRUE(resp.page_up);
732
733 ui_scrollbar_destroy(scrollbar);
734 ui_resource_destroy(resource);
735
736 rc = gfx_context_delete(gc);
737 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
738}
739
740/** ui_scrollbar_page_down() delivers page down event */
741PCUT_TEST(page_down)
742{
743 ui_scrollbar_t *scrollbar;
744 errno_t rc;
745 gfx_context_t *gc = NULL;
746 test_gc_t tgc;
747 ui_resource_t *resource = NULL;
748 test_cb_resp_t resp;
749
750 memset(&tgc, 0, sizeof(tgc));
751 rc = gfx_context_new(&ops, &tgc, &gc);
752 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
753
754 rc = ui_resource_create(gc, false, &resource);
755 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
756 PCUT_ASSERT_NOT_NULL(resource);
757
758 rc = ui_scrollbar_create(resource, &scrollbar);
759 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
760
761 /* Page down with no callbacks set */
762 ui_scrollbar_page_down(scrollbar);
763
764 /* Page down with callback not implementing page down */
765 ui_scrollbar_set_cb(scrollbar, &dummy_scrollbar_cb, NULL);
766 ui_scrollbar_page_down(scrollbar);
767
768 /* Page down with real callback set */
769 resp.page_down = false;
770 ui_scrollbar_set_cb(scrollbar, &test_scrollbar_cb, &resp);
771 ui_scrollbar_page_down(scrollbar);
772 PCUT_ASSERT_TRUE(resp.page_down);
773
774 ui_scrollbar_destroy(scrollbar);
775 ui_resource_destroy(resource);
776
777 rc = gfx_context_delete(gc);
778 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
779}
780
781/** ui_scrollbar_moved() delivers moved event */
782PCUT_TEST(moved)
783{
784 ui_scrollbar_t *scrollbar;
785 errno_t rc;
786 gfx_context_t *gc = NULL;
787 test_gc_t tgc;
788 ui_resource_t *resource = NULL;
789 test_cb_resp_t resp;
790
791 memset(&tgc, 0, sizeof(tgc));
792 rc = gfx_context_new(&ops, &tgc, &gc);
793 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
794
795 rc = ui_resource_create(gc, false, &resource);
796 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
797 PCUT_ASSERT_NOT_NULL(resource);
798
799 rc = ui_scrollbar_create(resource, &scrollbar);
800 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
801
802 /* Moved with no callbacks set */
803 ui_scrollbar_moved(scrollbar, 42);
804
805 /* Moved with callback not implementing moved */
806 ui_scrollbar_set_cb(scrollbar, &dummy_scrollbar_cb, NULL);
807 ui_scrollbar_moved(scrollbar, 42);
808
809 /* Moved with real callback set */
810 resp.moved = false;
811 resp.pos = 0;
812 ui_scrollbar_set_cb(scrollbar, &test_scrollbar_cb, &resp);
813 ui_scrollbar_moved(scrollbar, 42);
814 PCUT_ASSERT_TRUE(resp.moved);
815 PCUT_ASSERT_INT_EQUALS(42, resp.pos);
816
817 ui_scrollbar_destroy(scrollbar);
818 ui_resource_destroy(resource);
819
820 rc = gfx_context_delete(gc);
821 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
822}
823
824/** ui_scrollbar_pos_event() detects thumb press/release */
825PCUT_TEST(pos_event_press_release_thumb)
826{
827 errno_t rc;
828 gfx_context_t *gc = NULL;
829 test_gc_t tgc;
830 ui_resource_t *resource = NULL;
831 ui_scrollbar_t *scrollbar;
832 ui_evclaim_t claim;
833 pos_event_t event;
834 gfx_rect_t rect;
835
836 memset(&tgc, 0, sizeof(tgc));
837 rc = gfx_context_new(&ops, &tgc, &gc);
838 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
839
840 rc = ui_resource_create(gc, false, &resource);
841 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
842 PCUT_ASSERT_NOT_NULL(resource);
843
844 rc = ui_scrollbar_create(resource, &scrollbar);
845 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
846
847 PCUT_ASSERT_FALSE(scrollbar->thumb_held);
848
849 rect.p0.x = 20;
850 rect.p0.y = 10;
851 rect.p1.x = 100;
852 rect.p1.y = 30;
853 ui_scrollbar_set_rect(scrollbar, &rect);
854
855 /* Press outside is not claimed and does nothing */
856 event.type = POS_PRESS;
857 event.hpos = 1;
858 event.vpos = 2;
859 claim = ui_scrollbar_pos_event(scrollbar, &event);
860 PCUT_ASSERT_FALSE(scrollbar->thumb_held);
861 PCUT_ASSERT_EQUALS(ui_unclaimed, claim);
862
863 /* Press inside thumb is claimed and depresses it */
864 event.type = POS_PRESS;
865 event.hpos = 50;
866 event.vpos = 20;
867 claim = ui_scrollbar_pos_event(scrollbar, &event);
868 PCUT_ASSERT_TRUE(scrollbar->thumb_held);
869 PCUT_ASSERT_EQUALS(ui_claimed, claim);
870
871 /* Release outside (or anywhere) is claimed and relases thumb */
872 event.type = POS_RELEASE;
873 event.hpos = 41;
874 event.vpos = 32;
875 claim = ui_scrollbar_pos_event(scrollbar, &event);
876 PCUT_ASSERT_FALSE(scrollbar->thumb_held);
877 PCUT_ASSERT_EQUALS(ui_claimed, claim);
878
879 ui_scrollbar_destroy(scrollbar);
880 ui_resource_destroy(resource);
881
882 rc = gfx_context_delete(gc);
883 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
884}
885
886/** ui_scrollbar_pos_event() detects up button press/release */
887PCUT_TEST(pos_event_press_release_up_btn)
888{
889 errno_t rc;
890 gfx_context_t *gc = NULL;
891 test_gc_t tgc;
892 ui_resource_t *resource = NULL;
893 ui_scrollbar_t *scrollbar;
894 ui_evclaim_t claim;
895 pos_event_t event;
896 gfx_rect_t rect;
897
898 memset(&tgc, 0, sizeof(tgc));
899 rc = gfx_context_new(&ops, &tgc, &gc);
900 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
901
902 rc = ui_resource_create(gc, false, &resource);
903 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
904 PCUT_ASSERT_NOT_NULL(resource);
905
906 rc = ui_scrollbar_create(resource, &scrollbar);
907 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
908
909 PCUT_ASSERT_FALSE(scrollbar->thumb_held);
910
911 rect.p0.x = 20;
912 rect.p0.y = 10;
913 rect.p1.x = 100;
914 rect.p1.y = 30;
915 ui_scrollbar_set_rect(scrollbar, &rect);
916
917 /* Press inside up button is claimed and depresses it */
918 event.type = POS_PRESS;
919 event.hpos = 30;
920 event.vpos = 20;
921 claim = ui_scrollbar_pos_event(scrollbar, &event);
922 PCUT_ASSERT_TRUE(scrollbar->btn_up->held);
923 PCUT_ASSERT_EQUALS(ui_claimed, claim);
924
925 ui_scrollbar_destroy(scrollbar);
926 ui_resource_destroy(resource);
927
928 rc = gfx_context_delete(gc);
929 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
930}
931
932/** ui_scrollbar_pos_event() detects down button press/release */
933PCUT_TEST(pos_event_press_relese_down_btn)
934{
935 errno_t rc;
936 gfx_context_t *gc = NULL;
937 test_gc_t tgc;
938 ui_resource_t *resource = NULL;
939 ui_scrollbar_t *scrollbar;
940 ui_evclaim_t claim;
941 pos_event_t event;
942 gfx_rect_t rect;
943
944 memset(&tgc, 0, sizeof(tgc));
945 rc = gfx_context_new(&ops, &tgc, &gc);
946 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
947
948 rc = ui_resource_create(gc, false, &resource);
949 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
950 PCUT_ASSERT_NOT_NULL(resource);
951
952 rc = ui_scrollbar_create(resource, &scrollbar);
953 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
954
955 PCUT_ASSERT_FALSE(scrollbar->thumb_held);
956
957 rect.p0.x = 20;
958 rect.p0.y = 10;
959 rect.p1.x = 100;
960 rect.p1.y = 30;
961 ui_scrollbar_set_rect(scrollbar, &rect);
962
963 /* Press inside down button is claimed and depresses it */
964 event.type = POS_PRESS;
965 event.hpos = 90;
966 event.vpos = 20;
967 claim = ui_scrollbar_pos_event(scrollbar, &event);
968 PCUT_ASSERT_TRUE(scrollbar->btn_down->held);
969 PCUT_ASSERT_EQUALS(ui_claimed, claim);
970
971 ui_scrollbar_destroy(scrollbar);
972 ui_resource_destroy(resource);
973
974 rc = gfx_context_delete(gc);
975 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
976}
977
978static errno_t testgc_set_clip_rect(void *arg, gfx_rect_t *rect)
979{
980 (void) arg;
981 (void) rect;
982 return EOK;
983}
984
985static errno_t testgc_set_color(void *arg, gfx_color_t *color)
986{
987 (void) arg;
988 (void) color;
989 return EOK;
990}
991
992static errno_t testgc_fill_rect(void *arg, gfx_rect_t *rect)
993{
994 (void) arg;
995 (void) rect;
996 return EOK;
997}
998
999static errno_t testgc_update(void *arg)
1000{
1001 (void) arg;
1002 return EOK;
1003}
1004
1005static errno_t testgc_bitmap_create(void *arg, gfx_bitmap_params_t *params,
1006 gfx_bitmap_alloc_t *alloc, void **rbm)
1007{
1008 test_gc_t *tgc = (test_gc_t *) arg;
1009 testgc_bitmap_t *tbm;
1010
1011 tbm = calloc(1, sizeof(testgc_bitmap_t));
1012 if (tbm == NULL)
1013 return ENOMEM;
1014
1015 if (alloc == NULL) {
1016 tbm->alloc.pitch = (params->rect.p1.x - params->rect.p0.x) *
1017 sizeof(uint32_t);
1018 tbm->alloc.off0 = 0;
1019 tbm->alloc.pixels = calloc(sizeof(uint32_t),
1020 (params->rect.p1.x - params->rect.p0.x) *
1021 (params->rect.p1.y - params->rect.p0.y));
1022 tbm->myalloc = true;
1023 if (tbm->alloc.pixels == NULL) {
1024 free(tbm);
1025 return ENOMEM;
1026 }
1027 } else {
1028 tbm->alloc = *alloc;
1029 }
1030
1031 tbm->tgc = tgc;
1032 tgc->bm_created = true;
1033 tgc->bm_params = *params;
1034 tgc->bm_pixels = tbm->alloc.pixels;
1035 *rbm = (void *)tbm;
1036 return EOK;
1037}
1038
1039static errno_t testgc_bitmap_destroy(void *bm)
1040{
1041 testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
1042 if (tbm->myalloc)
1043 free(tbm->alloc.pixels);
1044 tbm->tgc->bm_destroyed = true;
1045 free(tbm);
1046 return EOK;
1047}
1048
1049static errno_t testgc_bitmap_render(void *bm, gfx_rect_t *srect,
1050 gfx_coord2_t *offs)
1051{
1052 testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
1053
1054 tbm->tgc->bm_rendered = true;
1055 if (srect != NULL)
1056 tbm->tgc->bm_srect = *srect;
1057 if (offs != NULL)
1058 tbm->tgc->bm_offs = *offs;
1059 return EOK;
1060}
1061
1062static errno_t testgc_bitmap_get_alloc(void *bm, gfx_bitmap_alloc_t *alloc)
1063{
1064 testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
1065 *alloc = tbm->alloc;
1066 tbm->tgc->bm_got_alloc = true;
1067 return EOK;
1068}
1069
1070static void test_scrollbar_up(ui_scrollbar_t *scrollbar, void *arg)
1071{
1072 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
1073
1074 resp->up = true;
1075}
1076
1077static void test_scrollbar_down(ui_scrollbar_t *scrollbar, void *arg)
1078{
1079 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
1080
1081 resp->down = true;
1082}
1083
1084static void test_scrollbar_page_up(ui_scrollbar_t *scrollbar, void *arg)
1085{
1086 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
1087
1088 resp->page_up = true;
1089}
1090
1091static void test_scrollbar_page_down(ui_scrollbar_t *scrollbar, void *arg)
1092{
1093 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
1094
1095 resp->page_down = true;
1096}
1097
1098static void test_scrollbar_moved(ui_scrollbar_t *scrollbar, void *arg, gfx_coord_t pos)
1099{
1100 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
1101
1102 resp->moved = true;
1103 resp->pos = pos;
1104}
1105
1106PCUT_EXPORT(scrollbar);
Note: See TracBrowser for help on using the repository browser.