source: mainline/uspace/lib/ui/test/scrollbar.c@ 26c90dd

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

Do not forget to test.
  • Property mode set to 100644
File size: 32.1 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(thumb_press_update_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/** Press and release up through */
618PCUT_TEST(up_through_press_release)
619{
620 errno_t rc;
621 gfx_context_t *gc = NULL;
622 test_gc_t tgc;
623 ui_resource_t *resource = NULL;
624 gfx_coord2_t pos;
625 gfx_rect_t rect;
626 ui_scrollbar_t *scrollbar;
627 test_cb_resp_t resp;
628
629 memset(&tgc, 0, sizeof(tgc));
630 rc = gfx_context_new(&ops, &tgc, &gc);
631 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
632
633 rc = ui_resource_create(gc, false, &resource);
634 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
635 PCUT_ASSERT_NOT_NULL(resource);
636
637 rc = ui_scrollbar_create(resource, &scrollbar);
638 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
639
640 rect.p0.x = 10;
641 rect.p0.y = 20;
642 rect.p1.x = 110;
643 rect.p1.y = 120;
644 ui_scrollbar_set_rect(scrollbar, &rect);
645
646 resp.page_up = false;
647 ui_scrollbar_set_cb(scrollbar, &test_scrollbar_cb, &resp);
648
649 PCUT_ASSERT_FALSE(scrollbar->up_through_held);
650
651 ui_scrollbar_up_through_press(scrollbar);
652 PCUT_ASSERT_TRUE(scrollbar->up_through_held);
653 PCUT_ASSERT_TRUE(resp.page_up);
654
655 /* Position does not matter here */
656 pos.x = 11;
657 pos.y = 22;
658
659 ui_scrollbar_release(scrollbar, &pos);
660 PCUT_ASSERT_FALSE(scrollbar->up_through_held);
661
662 ui_scrollbar_destroy(scrollbar);
663 ui_resource_destroy(resource);
664
665 rc = gfx_context_delete(gc);
666 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
667}
668
669/** Press and release down through */
670PCUT_TEST(down_through_press_release)
671{
672 errno_t rc;
673 gfx_context_t *gc = NULL;
674 test_gc_t tgc;
675 ui_resource_t *resource = NULL;
676 gfx_coord2_t pos;
677 gfx_rect_t rect;
678 ui_scrollbar_t *scrollbar;
679 test_cb_resp_t resp;
680
681 memset(&tgc, 0, sizeof(tgc));
682 rc = gfx_context_new(&ops, &tgc, &gc);
683 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
684
685 rc = ui_resource_create(gc, false, &resource);
686 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
687 PCUT_ASSERT_NOT_NULL(resource);
688
689 rc = ui_scrollbar_create(resource, &scrollbar);
690 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
691
692 rect.p0.x = 10;
693 rect.p0.y = 20;
694 rect.p1.x = 110;
695 rect.p1.y = 120;
696 ui_scrollbar_set_rect(scrollbar, &rect);
697
698 resp.page_down = false;
699 ui_scrollbar_set_cb(scrollbar, &test_scrollbar_cb, &resp);
700
701 PCUT_ASSERT_FALSE(scrollbar->down_through_held);
702
703 ui_scrollbar_down_through_press(scrollbar);
704 PCUT_ASSERT_TRUE(scrollbar->down_through_held);
705 PCUT_ASSERT_TRUE(resp.page_down);
706
707 /* Position does not matter here */
708 pos.x = 11;
709 pos.y = 22;
710
711 ui_scrollbar_release(scrollbar, &pos);
712 PCUT_ASSERT_FALSE(scrollbar->down_through_held);
713
714 ui_scrollbar_destroy(scrollbar);
715 ui_resource_destroy(resource);
716
717 rc = gfx_context_delete(gc);
718 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
719}
720
721/** ui_scrollbar_up() delivers up event */
722PCUT_TEST(up)
723{
724 ui_scrollbar_t *scrollbar;
725 errno_t rc;
726 gfx_context_t *gc = NULL;
727 test_gc_t tgc;
728 ui_resource_t *resource = NULL;
729 test_cb_resp_t resp;
730
731 memset(&tgc, 0, sizeof(tgc));
732 rc = gfx_context_new(&ops, &tgc, &gc);
733 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
734
735 rc = ui_resource_create(gc, false, &resource);
736 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
737 PCUT_ASSERT_NOT_NULL(resource);
738
739 rc = ui_scrollbar_create(resource, &scrollbar);
740 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
741
742 /* Up with no callbacks set */
743 ui_scrollbar_up(scrollbar);
744
745 /* Up with callback not implementing up */
746 ui_scrollbar_set_cb(scrollbar, &dummy_scrollbar_cb, NULL);
747 ui_scrollbar_up(scrollbar);
748
749 /* Up with real callback set */
750 resp.up = false;
751 ui_scrollbar_set_cb(scrollbar, &test_scrollbar_cb, &resp);
752 ui_scrollbar_up(scrollbar);
753 PCUT_ASSERT_TRUE(resp.up);
754
755 ui_scrollbar_destroy(scrollbar);
756 ui_resource_destroy(resource);
757
758 rc = gfx_context_delete(gc);
759 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
760}
761
762/** ui_scrollbar_down() delivers down event */
763PCUT_TEST(down)
764{
765 ui_scrollbar_t *scrollbar;
766 errno_t rc;
767 gfx_context_t *gc = NULL;
768 test_gc_t tgc;
769 ui_resource_t *resource = NULL;
770 test_cb_resp_t resp;
771
772 memset(&tgc, 0, sizeof(tgc));
773 rc = gfx_context_new(&ops, &tgc, &gc);
774 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
775
776 rc = ui_resource_create(gc, false, &resource);
777 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
778 PCUT_ASSERT_NOT_NULL(resource);
779
780 rc = ui_scrollbar_create(resource, &scrollbar);
781 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
782
783 /* Down with no callbacks set */
784 ui_scrollbar_down(scrollbar);
785
786 /* Down with callback not implementing down */
787 ui_scrollbar_set_cb(scrollbar, &dummy_scrollbar_cb, NULL);
788 ui_scrollbar_down(scrollbar);
789
790 /* Down with real callback set */
791 resp.down = false;
792 ui_scrollbar_set_cb(scrollbar, &test_scrollbar_cb, &resp);
793 ui_scrollbar_down(scrollbar);
794 PCUT_ASSERT_TRUE(resp.down);
795
796 ui_scrollbar_destroy(scrollbar);
797 ui_resource_destroy(resource);
798
799 rc = gfx_context_delete(gc);
800 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
801}
802
803/** ui_scrollbar_page_up() delivers page up event */
804PCUT_TEST(page_up)
805{
806 ui_scrollbar_t *scrollbar;
807 errno_t rc;
808 gfx_context_t *gc = NULL;
809 test_gc_t tgc;
810 ui_resource_t *resource = NULL;
811 test_cb_resp_t resp;
812
813 memset(&tgc, 0, sizeof(tgc));
814 rc = gfx_context_new(&ops, &tgc, &gc);
815 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
816
817 rc = ui_resource_create(gc, false, &resource);
818 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
819 PCUT_ASSERT_NOT_NULL(resource);
820
821 rc = ui_scrollbar_create(resource, &scrollbar);
822 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
823
824 /* Page up with no callbacks set */
825 ui_scrollbar_page_up(scrollbar);
826
827 /* Pge up with callback not implementing page up */
828 ui_scrollbar_set_cb(scrollbar, &dummy_scrollbar_cb, NULL);
829 ui_scrollbar_page_up(scrollbar);
830
831 /* Page up with real callback set */
832 resp.page_up = false;
833 ui_scrollbar_set_cb(scrollbar, &test_scrollbar_cb, &resp);
834 ui_scrollbar_page_up(scrollbar);
835 PCUT_ASSERT_TRUE(resp.page_up);
836
837 ui_scrollbar_destroy(scrollbar);
838 ui_resource_destroy(resource);
839
840 rc = gfx_context_delete(gc);
841 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
842}
843
844/** ui_scrollbar_page_down() delivers page down event */
845PCUT_TEST(page_down)
846{
847 ui_scrollbar_t *scrollbar;
848 errno_t rc;
849 gfx_context_t *gc = NULL;
850 test_gc_t tgc;
851 ui_resource_t *resource = NULL;
852 test_cb_resp_t resp;
853
854 memset(&tgc, 0, sizeof(tgc));
855 rc = gfx_context_new(&ops, &tgc, &gc);
856 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
857
858 rc = ui_resource_create(gc, false, &resource);
859 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
860 PCUT_ASSERT_NOT_NULL(resource);
861
862 rc = ui_scrollbar_create(resource, &scrollbar);
863 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
864
865 /* Page down with no callbacks set */
866 ui_scrollbar_page_down(scrollbar);
867
868 /* Page down with callback not implementing page down */
869 ui_scrollbar_set_cb(scrollbar, &dummy_scrollbar_cb, NULL);
870 ui_scrollbar_page_down(scrollbar);
871
872 /* Page down with real callback set */
873 resp.page_down = false;
874 ui_scrollbar_set_cb(scrollbar, &test_scrollbar_cb, &resp);
875 ui_scrollbar_page_down(scrollbar);
876 PCUT_ASSERT_TRUE(resp.page_down);
877
878 ui_scrollbar_destroy(scrollbar);
879 ui_resource_destroy(resource);
880
881 rc = gfx_context_delete(gc);
882 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
883}
884
885/** ui_scrollbar_moved() delivers moved event */
886PCUT_TEST(moved)
887{
888 ui_scrollbar_t *scrollbar;
889 errno_t rc;
890 gfx_context_t *gc = NULL;
891 test_gc_t tgc;
892 ui_resource_t *resource = NULL;
893 test_cb_resp_t resp;
894
895 memset(&tgc, 0, sizeof(tgc));
896 rc = gfx_context_new(&ops, &tgc, &gc);
897 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
898
899 rc = ui_resource_create(gc, false, &resource);
900 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
901 PCUT_ASSERT_NOT_NULL(resource);
902
903 rc = ui_scrollbar_create(resource, &scrollbar);
904 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
905
906 /* Moved with no callbacks set */
907 ui_scrollbar_moved(scrollbar, 42);
908
909 /* Moved with callback not implementing moved */
910 ui_scrollbar_set_cb(scrollbar, &dummy_scrollbar_cb, NULL);
911 ui_scrollbar_moved(scrollbar, 42);
912
913 /* Moved with real callback set */
914 resp.moved = false;
915 resp.pos = 0;
916 ui_scrollbar_set_cb(scrollbar, &test_scrollbar_cb, &resp);
917 ui_scrollbar_moved(scrollbar, 42);
918 PCUT_ASSERT_TRUE(resp.moved);
919 PCUT_ASSERT_INT_EQUALS(42, resp.pos);
920
921 ui_scrollbar_destroy(scrollbar);
922 ui_resource_destroy(resource);
923
924 rc = gfx_context_delete(gc);
925 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
926}
927
928/** ui_scrollbar_pos_event() detects thumb press/release */
929PCUT_TEST(pos_event_press_release_thumb)
930{
931 errno_t rc;
932 gfx_context_t *gc = NULL;
933 test_gc_t tgc;
934 ui_resource_t *resource = NULL;
935 ui_scrollbar_t *scrollbar;
936 ui_evclaim_t claim;
937 pos_event_t event;
938 gfx_rect_t rect;
939
940 memset(&tgc, 0, sizeof(tgc));
941 rc = gfx_context_new(&ops, &tgc, &gc);
942 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
943
944 rc = ui_resource_create(gc, false, &resource);
945 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
946 PCUT_ASSERT_NOT_NULL(resource);
947
948 rc = ui_scrollbar_create(resource, &scrollbar);
949 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
950
951 PCUT_ASSERT_FALSE(scrollbar->thumb_held);
952
953 rect.p0.x = 20;
954 rect.p0.y = 10;
955 rect.p1.x = 100;
956 rect.p1.y = 30;
957 ui_scrollbar_set_rect(scrollbar, &rect);
958
959 /* Press outside is not claimed and does nothing */
960 event.type = POS_PRESS;
961 event.hpos = 1;
962 event.vpos = 2;
963 claim = ui_scrollbar_pos_event(scrollbar, &event);
964 PCUT_ASSERT_FALSE(scrollbar->thumb_held);
965 PCUT_ASSERT_EQUALS(ui_unclaimed, claim);
966
967 /* Press inside thumb is claimed and depresses it */
968 event.type = POS_PRESS;
969 event.hpos = 50;
970 event.vpos = 20;
971 claim = ui_scrollbar_pos_event(scrollbar, &event);
972 PCUT_ASSERT_TRUE(scrollbar->thumb_held);
973 PCUT_ASSERT_EQUALS(ui_claimed, claim);
974
975 /* Release outside (or anywhere) is claimed and relases thumb */
976 event.type = POS_RELEASE;
977 event.hpos = 41;
978 event.vpos = 32;
979 claim = ui_scrollbar_pos_event(scrollbar, &event);
980 PCUT_ASSERT_FALSE(scrollbar->thumb_held);
981 PCUT_ASSERT_EQUALS(ui_claimed, claim);
982
983 ui_scrollbar_destroy(scrollbar);
984 ui_resource_destroy(resource);
985
986 rc = gfx_context_delete(gc);
987 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
988}
989
990/** ui_scrollbar_pos_event() detects up button press/release */
991PCUT_TEST(pos_event_press_release_up_btn)
992{
993 errno_t rc;
994 gfx_context_t *gc = NULL;
995 test_gc_t tgc;
996 ui_resource_t *resource = NULL;
997 ui_scrollbar_t *scrollbar;
998 ui_evclaim_t claim;
999 pos_event_t event;
1000 gfx_rect_t rect;
1001
1002 memset(&tgc, 0, sizeof(tgc));
1003 rc = gfx_context_new(&ops, &tgc, &gc);
1004 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1005
1006 rc = ui_resource_create(gc, false, &resource);
1007 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1008 PCUT_ASSERT_NOT_NULL(resource);
1009
1010 rc = ui_scrollbar_create(resource, &scrollbar);
1011 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1012
1013 PCUT_ASSERT_FALSE(scrollbar->thumb_held);
1014
1015 rect.p0.x = 20;
1016 rect.p0.y = 10;
1017 rect.p1.x = 100;
1018 rect.p1.y = 30;
1019 ui_scrollbar_set_rect(scrollbar, &rect);
1020
1021 /* Press inside up button is claimed and depresses it */
1022 event.type = POS_PRESS;
1023 event.hpos = 30;
1024 event.vpos = 20;
1025 claim = ui_scrollbar_pos_event(scrollbar, &event);
1026 PCUT_ASSERT_TRUE(scrollbar->btn_up->held);
1027 PCUT_ASSERT_EQUALS(ui_claimed, claim);
1028
1029 ui_scrollbar_destroy(scrollbar);
1030 ui_resource_destroy(resource);
1031
1032 rc = gfx_context_delete(gc);
1033 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1034}
1035
1036/** ui_scrollbar_pos_event() detects up through press/release */
1037PCUT_TEST(pos_event_press_release_up_through)
1038{
1039 errno_t rc;
1040 gfx_context_t *gc = NULL;
1041 test_gc_t tgc;
1042 ui_resource_t *resource = NULL;
1043 ui_scrollbar_t *scrollbar;
1044 ui_evclaim_t claim;
1045 pos_event_t event;
1046 gfx_rect_t rect;
1047
1048 memset(&tgc, 0, sizeof(tgc));
1049 rc = gfx_context_new(&ops, &tgc, &gc);
1050 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1051
1052 rc = ui_resource_create(gc, false, &resource);
1053 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1054 PCUT_ASSERT_NOT_NULL(resource);
1055
1056 rc = ui_scrollbar_create(resource, &scrollbar);
1057 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1058
1059 PCUT_ASSERT_FALSE(scrollbar->up_through_held);
1060
1061 rect.p0.x = 20;
1062 rect.p0.y = 10;
1063 rect.p1.x = 100;
1064 rect.p1.y = 30;
1065 ui_scrollbar_set_rect(scrollbar, &rect);
1066
1067 /* Need to move thumb so that up through can be accessed */
1068 ui_scrollbar_set_pos(scrollbar, 42);
1069
1070 /* Press inside up through is claimed and depresses it */
1071 event.type = POS_PRESS;
1072 event.hpos = 50;
1073 event.vpos = 20;
1074 claim = ui_scrollbar_pos_event(scrollbar, &event);
1075 PCUT_ASSERT_TRUE(scrollbar->up_through_held);
1076 PCUT_ASSERT_EQUALS(ui_claimed, claim);
1077
1078 /* Release outside (or anywhere) is claimed and relases up through */
1079 event.type = POS_RELEASE;
1080 event.hpos = 41;
1081 event.vpos = 32;
1082 claim = ui_scrollbar_pos_event(scrollbar, &event);
1083 PCUT_ASSERT_FALSE(scrollbar->up_through_held);
1084 PCUT_ASSERT_EQUALS(ui_claimed, claim);
1085
1086 ui_scrollbar_destroy(scrollbar);
1087 ui_resource_destroy(resource);
1088
1089 rc = gfx_context_delete(gc);
1090 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1091}
1092
1093/** ui_scrollbar_pos_event() detects down through press/release */
1094PCUT_TEST(pos_event_press_release_down_through)
1095{
1096 errno_t rc;
1097 gfx_context_t *gc = NULL;
1098 test_gc_t tgc;
1099 ui_resource_t *resource = NULL;
1100 ui_scrollbar_t *scrollbar;
1101 ui_evclaim_t claim;
1102 pos_event_t event;
1103 gfx_rect_t rect;
1104
1105 memset(&tgc, 0, sizeof(tgc));
1106 rc = gfx_context_new(&ops, &tgc, &gc);
1107 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1108
1109 rc = ui_resource_create(gc, false, &resource);
1110 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1111 PCUT_ASSERT_NOT_NULL(resource);
1112
1113 rc = ui_scrollbar_create(resource, &scrollbar);
1114 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1115
1116 PCUT_ASSERT_FALSE(scrollbar->up_through_held);
1117
1118 rect.p0.x = 20;
1119 rect.p0.y = 10;
1120 rect.p1.x = 100;
1121 rect.p1.y = 30;
1122 ui_scrollbar_set_rect(scrollbar, &rect);
1123
1124 /* Press inside down through is claimed and depresses it */
1125 event.type = POS_PRESS;
1126 event.hpos = 70;
1127 event.vpos = 20;
1128 claim = ui_scrollbar_pos_event(scrollbar, &event);
1129 PCUT_ASSERT_TRUE(scrollbar->down_through_held);
1130 PCUT_ASSERT_EQUALS(ui_claimed, claim);
1131
1132 /* Release outside (or anywhere) is claimed and relases up through */
1133 event.type = POS_RELEASE;
1134 event.hpos = 41;
1135 event.vpos = 32;
1136 claim = ui_scrollbar_pos_event(scrollbar, &event);
1137 PCUT_ASSERT_FALSE(scrollbar->down_through_held);
1138 PCUT_ASSERT_EQUALS(ui_claimed, claim);
1139
1140 ui_scrollbar_destroy(scrollbar);
1141 ui_resource_destroy(resource);
1142
1143 rc = gfx_context_delete(gc);
1144 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1145}
1146
1147/** ui_scrollbar_pos_event() detects down button press/release */
1148PCUT_TEST(pos_event_press_relese_down_btn)
1149{
1150 errno_t rc;
1151 gfx_context_t *gc = NULL;
1152 test_gc_t tgc;
1153 ui_resource_t *resource = NULL;
1154 ui_scrollbar_t *scrollbar;
1155 ui_evclaim_t claim;
1156 pos_event_t event;
1157 gfx_rect_t rect;
1158
1159 memset(&tgc, 0, sizeof(tgc));
1160 rc = gfx_context_new(&ops, &tgc, &gc);
1161 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1162
1163 rc = ui_resource_create(gc, false, &resource);
1164 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1165 PCUT_ASSERT_NOT_NULL(resource);
1166
1167 rc = ui_scrollbar_create(resource, &scrollbar);
1168 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1169
1170 PCUT_ASSERT_FALSE(scrollbar->thumb_held);
1171
1172 rect.p0.x = 20;
1173 rect.p0.y = 10;
1174 rect.p1.x = 100;
1175 rect.p1.y = 30;
1176 ui_scrollbar_set_rect(scrollbar, &rect);
1177
1178 /* Press inside down button is claimed and depresses it */
1179 event.type = POS_PRESS;
1180 event.hpos = 90;
1181 event.vpos = 20;
1182 claim = ui_scrollbar_pos_event(scrollbar, &event);
1183 PCUT_ASSERT_TRUE(scrollbar->btn_down->held);
1184 PCUT_ASSERT_EQUALS(ui_claimed, claim);
1185
1186 ui_scrollbar_destroy(scrollbar);
1187 ui_resource_destroy(resource);
1188
1189 rc = gfx_context_delete(gc);
1190 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1191}
1192
1193static errno_t testgc_set_clip_rect(void *arg, gfx_rect_t *rect)
1194{
1195 (void) arg;
1196 (void) rect;
1197 return EOK;
1198}
1199
1200static errno_t testgc_set_color(void *arg, gfx_color_t *color)
1201{
1202 (void) arg;
1203 (void) color;
1204 return EOK;
1205}
1206
1207static errno_t testgc_fill_rect(void *arg, gfx_rect_t *rect)
1208{
1209 (void) arg;
1210 (void) rect;
1211 return EOK;
1212}
1213
1214static errno_t testgc_update(void *arg)
1215{
1216 (void) arg;
1217 return EOK;
1218}
1219
1220static errno_t testgc_bitmap_create(void *arg, gfx_bitmap_params_t *params,
1221 gfx_bitmap_alloc_t *alloc, void **rbm)
1222{
1223 test_gc_t *tgc = (test_gc_t *) arg;
1224 testgc_bitmap_t *tbm;
1225
1226 tbm = calloc(1, sizeof(testgc_bitmap_t));
1227 if (tbm == NULL)
1228 return ENOMEM;
1229
1230 if (alloc == NULL) {
1231 tbm->alloc.pitch = (params->rect.p1.x - params->rect.p0.x) *
1232 sizeof(uint32_t);
1233 tbm->alloc.off0 = 0;
1234 tbm->alloc.pixels = calloc(sizeof(uint32_t),
1235 (params->rect.p1.x - params->rect.p0.x) *
1236 (params->rect.p1.y - params->rect.p0.y));
1237 tbm->myalloc = true;
1238 if (tbm->alloc.pixels == NULL) {
1239 free(tbm);
1240 return ENOMEM;
1241 }
1242 } else {
1243 tbm->alloc = *alloc;
1244 }
1245
1246 tbm->tgc = tgc;
1247 tgc->bm_created = true;
1248 tgc->bm_params = *params;
1249 tgc->bm_pixels = tbm->alloc.pixels;
1250 *rbm = (void *)tbm;
1251 return EOK;
1252}
1253
1254static errno_t testgc_bitmap_destroy(void *bm)
1255{
1256 testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
1257 if (tbm->myalloc)
1258 free(tbm->alloc.pixels);
1259 tbm->tgc->bm_destroyed = true;
1260 free(tbm);
1261 return EOK;
1262}
1263
1264static errno_t testgc_bitmap_render(void *bm, gfx_rect_t *srect,
1265 gfx_coord2_t *offs)
1266{
1267 testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
1268
1269 tbm->tgc->bm_rendered = true;
1270 if (srect != NULL)
1271 tbm->tgc->bm_srect = *srect;
1272 if (offs != NULL)
1273 tbm->tgc->bm_offs = *offs;
1274 return EOK;
1275}
1276
1277static errno_t testgc_bitmap_get_alloc(void *bm, gfx_bitmap_alloc_t *alloc)
1278{
1279 testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
1280 *alloc = tbm->alloc;
1281 tbm->tgc->bm_got_alloc = true;
1282 return EOK;
1283}
1284
1285static void test_scrollbar_up(ui_scrollbar_t *scrollbar, void *arg)
1286{
1287 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
1288
1289 resp->up = true;
1290}
1291
1292static void test_scrollbar_down(ui_scrollbar_t *scrollbar, void *arg)
1293{
1294 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
1295
1296 resp->down = true;
1297}
1298
1299static void test_scrollbar_page_up(ui_scrollbar_t *scrollbar, void *arg)
1300{
1301 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
1302
1303 resp->page_up = true;
1304}
1305
1306static void test_scrollbar_page_down(ui_scrollbar_t *scrollbar, void *arg)
1307{
1308 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
1309
1310 resp->page_down = true;
1311}
1312
1313static void test_scrollbar_moved(ui_scrollbar_t *scrollbar, void *arg, gfx_coord_t pos)
1314{
1315 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
1316
1317 resp->moved = true;
1318 resp->pos = pos;
1319}
1320
1321PCUT_EXPORT(scrollbar);
Note: See TracBrowser for help on using the repository browser.