source: mainline/uspace/lib/ui/test/rbutton.c@ 7020d1f

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

Radio button

Please don't ask me how I derived the formulae for circle midpoint
algorithm, it's been 8 years and I just don't remember.
  • Property mode set to 100644
File size: 15.7 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 <mem.h>
32#include <pcut/pcut.h>
33#include <stdbool.h>
34#include <ui/control.h>
35#include <ui/rbutton.h>
36#include <ui/resource.h>
37#include "../private/rbutton.h"
38
39PCUT_INIT;
40
41PCUT_TEST_SUITE(rbutton);
42
43static errno_t testgc_set_color(void *, gfx_color_t *);
44static errno_t testgc_fill_rect(void *, gfx_rect_t *);
45static errno_t testgc_bitmap_create(void *, gfx_bitmap_params_t *,
46 gfx_bitmap_alloc_t *, void **);
47static errno_t testgc_bitmap_destroy(void *);
48static errno_t testgc_bitmap_render(void *, gfx_rect_t *, gfx_coord2_t *);
49static errno_t testgc_bitmap_get_alloc(void *, gfx_bitmap_alloc_t *);
50
51static gfx_context_ops_t ops = {
52 .set_color = testgc_set_color,
53 .fill_rect = testgc_fill_rect,
54 .bitmap_create = testgc_bitmap_create,
55 .bitmap_destroy = testgc_bitmap_destroy,
56 .bitmap_render = testgc_bitmap_render,
57 .bitmap_get_alloc = testgc_bitmap_get_alloc
58};
59
60static void test_rbutton_select(ui_rbutton_group_t *, void *, void *);
61
62static ui_rbutton_group_cb_t test_rbutton_group_cb = {
63 .selected = test_rbutton_select
64};
65
66static ui_rbutton_group_cb_t dummy_rbutton_group_cb = {
67};
68
69typedef struct {
70 bool bm_created;
71 bool bm_destroyed;
72 gfx_bitmap_params_t bm_params;
73 void *bm_pixels;
74 gfx_rect_t bm_srect;
75 gfx_coord2_t bm_offs;
76 bool bm_rendered;
77 bool bm_got_alloc;
78} test_gc_t;
79
80typedef struct {
81 test_gc_t *tgc;
82 gfx_bitmap_alloc_t alloc;
83 bool myalloc;
84} testgc_bitmap_t;
85
86typedef struct {
87 bool selected;
88} test_cb_resp_t;
89
90/** Create and destroy radio button */
91PCUT_TEST(create_destroy)
92{
93 ui_rbutton_group_t *group = NULL;
94 ui_rbutton_t *rbutton = NULL;
95 errno_t rc;
96
97 rc = ui_rbutton_group_create(NULL, &group);
98 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
99
100 rc = ui_rbutton_create(group, "Hello", NULL, &rbutton);
101 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
102 PCUT_ASSERT_NOT_NULL(rbutton);
103
104 ui_rbutton_destroy(rbutton);
105 ui_rbutton_group_destroy(group);
106}
107
108/** ui_rbutton_destroy() can take NULL argument (no-op) */
109PCUT_TEST(destroy_null)
110{
111 ui_rbutton_destroy(NULL);
112}
113
114/** ui_rbutton_ctl() returns control that has a working virtual destructor */
115PCUT_TEST(ctl)
116{
117 ui_rbutton_group_t *group = NULL;
118 ui_rbutton_t *rbutton;
119 ui_control_t *control;
120 errno_t rc;
121
122 rc = ui_rbutton_group_create(NULL, &group);
123 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
124
125 rc = ui_rbutton_create(group, "Hello", NULL, &rbutton);
126 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
127
128 control = ui_rbutton_ctl(rbutton);
129 PCUT_ASSERT_NOT_NULL(control);
130
131 ui_control_destroy(control);
132 ui_rbutton_group_destroy(group);
133}
134
135/** Set radio button rectangle sets internal field */
136PCUT_TEST(set_rect)
137{
138 ui_rbutton_group_t *group = NULL;
139 ui_rbutton_t *rbutton;
140 gfx_rect_t rect;
141 errno_t rc;
142
143 rc = ui_rbutton_group_create(NULL, &group);
144 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
145
146 rc = ui_rbutton_create(group, "Hello", NULL, &rbutton);
147 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
148
149 rect.p0.x = 1;
150 rect.p0.y = 2;
151 rect.p1.x = 3;
152 rect.p1.y = 4;
153
154 ui_rbutton_set_rect(rbutton, &rect);
155 PCUT_ASSERT_INT_EQUALS(rect.p0.x, rbutton->rect.p0.x);
156 PCUT_ASSERT_INT_EQUALS(rect.p0.y, rbutton->rect.p0.y);
157 PCUT_ASSERT_INT_EQUALS(rect.p1.x, rbutton->rect.p1.x);
158 PCUT_ASSERT_INT_EQUALS(rect.p1.y, rbutton->rect.p1.y);
159
160 ui_rbutton_destroy(rbutton);
161 ui_rbutton_group_destroy(group);
162}
163
164/** Paint radio button */
165PCUT_TEST(paint)
166{
167 errno_t rc;
168 gfx_context_t *gc = NULL;
169 test_gc_t tgc;
170 ui_rbutton_group_t *group = NULL;
171 ui_resource_t *resource = NULL;
172 ui_rbutton_t *rbutton;
173
174 memset(&tgc, 0, sizeof(tgc));
175 rc = gfx_context_new(&ops, &tgc, &gc);
176 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
177
178 rc = ui_resource_create(gc, &resource);
179 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
180 PCUT_ASSERT_NOT_NULL(resource);
181
182 rc = ui_rbutton_group_create(resource, &group);
183 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
184
185 rc = ui_rbutton_create(group, "Hello", NULL, &rbutton);
186 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
187
188 rc = ui_rbutton_paint(rbutton);
189 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
190
191 ui_rbutton_destroy(rbutton);
192 ui_rbutton_group_destroy(group);
193 ui_resource_destroy(resource);
194
195 rc = gfx_context_delete(gc);
196 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
197}
198
199/** Test ui_rbutton_selected() */
200PCUT_TEST(selected)
201{
202 errno_t rc;
203 ui_rbutton_group_t *group = NULL;
204 ui_rbutton_t *rbutton;
205 test_cb_resp_t resp;
206
207 rc = ui_rbutton_group_create(NULL, &group);
208 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
209
210 rc = ui_rbutton_create(group, "Hello", NULL, &rbutton);
211 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
212
213 /* Selected with no callbacks set */
214 ui_rbutton_selected(rbutton);
215
216 /* Selected with callback not implementing selected */
217 ui_rbutton_group_set_cb(group, &dummy_rbutton_group_cb, NULL);
218 ui_rbutton_selected(rbutton);
219
220 /* Selected with real callback set */
221 resp.selected = false;
222 ui_rbutton_group_set_cb(group, &test_rbutton_group_cb, &resp);
223 ui_rbutton_selected(rbutton);
224 PCUT_ASSERT_TRUE(resp.selected);
225
226 ui_rbutton_destroy(rbutton);
227 ui_rbutton_group_destroy(group);
228}
229
230/** Press and release radio button */
231PCUT_TEST(press_release)
232{
233 errno_t rc;
234 gfx_context_t *gc = NULL;
235 test_gc_t tgc;
236 ui_resource_t *resource = NULL;
237 ui_rbutton_group_t *group = NULL;
238 ui_rbutton_t *rbutton;
239 test_cb_resp_t resp;
240
241 memset(&tgc, 0, sizeof(tgc));
242 rc = gfx_context_new(&ops, &tgc, &gc);
243 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
244
245 rc = ui_resource_create(gc, &resource);
246 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
247 PCUT_ASSERT_NOT_NULL(resource);
248
249 rc = ui_rbutton_group_create(resource, &group);
250 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
251 PCUT_ASSERT_NULL(group->selected);
252
253 rc = ui_rbutton_create(group, "Hello", NULL, &rbutton);
254 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
255 PCUT_ASSERT_EQUALS(group->selected, rbutton);
256
257 resp.selected = false;
258 ui_rbutton_group_set_cb(group, &test_rbutton_group_cb, &resp);
259
260 PCUT_ASSERT_FALSE(rbutton->held);
261 PCUT_ASSERT_FALSE(rbutton->inside);
262
263 ui_rbutton_press(rbutton);
264 PCUT_ASSERT_TRUE(rbutton->held);
265 PCUT_ASSERT_TRUE(rbutton->inside);
266 PCUT_ASSERT_FALSE(resp.selected);
267 PCUT_ASSERT_EQUALS(group->selected, rbutton);
268
269 ui_rbutton_release(rbutton);
270 PCUT_ASSERT_FALSE(rbutton->held);
271 PCUT_ASSERT_TRUE(rbutton->inside);
272 PCUT_ASSERT_TRUE(resp.selected);
273 PCUT_ASSERT_EQUALS(group->selected, rbutton);
274
275 ui_rbutton_destroy(rbutton);
276 ui_rbutton_group_destroy(group);
277 ui_resource_destroy(resource);
278
279 rc = gfx_context_delete(gc);
280 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
281}
282
283/** Press, leave and release radio button */
284PCUT_TEST(press_leave_release)
285{
286 errno_t rc;
287 gfx_context_t *gc = NULL;
288 test_gc_t tgc;
289 ui_resource_t *resource = NULL;
290 ui_rbutton_group_t *group = NULL;
291 ui_rbutton_t *rbutton;
292 test_cb_resp_t resp;
293
294 memset(&tgc, 0, sizeof(tgc));
295 rc = gfx_context_new(&ops, &tgc, &gc);
296 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
297
298 rc = ui_resource_create(gc, &resource);
299 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
300 PCUT_ASSERT_NOT_NULL(resource);
301
302 rc = ui_rbutton_group_create(resource, &group);
303 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
304
305 rc = ui_rbutton_create(group, "Hello", NULL, &rbutton);
306 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
307
308 resp.selected = false;
309 ui_rbutton_group_set_cb(group, &test_rbutton_group_cb, &resp);
310
311 PCUT_ASSERT_FALSE(rbutton->held);
312 PCUT_ASSERT_FALSE(rbutton->inside);
313
314 ui_rbutton_press(rbutton);
315 PCUT_ASSERT_TRUE(rbutton->held);
316 PCUT_ASSERT_TRUE(rbutton->inside);
317 PCUT_ASSERT_FALSE(resp.selected);
318 PCUT_ASSERT_EQUALS(group->selected, rbutton);
319
320 ui_rbutton_leave(rbutton);
321 PCUT_ASSERT_TRUE(rbutton->held);
322 PCUT_ASSERT_FALSE(rbutton->inside);
323 PCUT_ASSERT_FALSE(resp.selected);
324 PCUT_ASSERT_EQUALS(group->selected, rbutton);
325
326 ui_rbutton_release(rbutton);
327 PCUT_ASSERT_FALSE(rbutton->held);
328 PCUT_ASSERT_FALSE(rbutton->inside);
329 PCUT_ASSERT_FALSE(resp.selected);
330 PCUT_ASSERT_EQUALS(group->selected, rbutton);
331
332 ui_rbutton_destroy(rbutton);
333 ui_rbutton_group_destroy(group);
334 ui_resource_destroy(resource);
335
336 rc = gfx_context_delete(gc);
337 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
338}
339
340/** Press, leave, enter and release radio button */
341PCUT_TEST(press_leave_enter_release)
342{
343 errno_t rc;
344 gfx_context_t *gc = NULL;
345 test_gc_t tgc;
346 ui_resource_t *resource = NULL;
347 ui_rbutton_group_t *group = NULL;
348 ui_rbutton_t *rbutton;
349 test_cb_resp_t resp;
350
351 memset(&tgc, 0, sizeof(tgc));
352 rc = gfx_context_new(&ops, &tgc, &gc);
353 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
354
355 rc = ui_resource_create(gc, &resource);
356 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
357 PCUT_ASSERT_NOT_NULL(resource);
358
359 rc = ui_rbutton_group_create(resource, &group);
360 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
361
362 rc = ui_rbutton_create(group, "Hello", NULL, &rbutton);
363 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
364 PCUT_ASSERT_EQUALS(group->selected, rbutton);
365
366 resp.selected = false;
367 ui_rbutton_group_set_cb(group, &test_rbutton_group_cb, &resp);
368
369 PCUT_ASSERT_FALSE(rbutton->held);
370 PCUT_ASSERT_FALSE(rbutton->inside);
371
372 ui_rbutton_press(rbutton);
373 PCUT_ASSERT_TRUE(rbutton->held);
374 PCUT_ASSERT_TRUE(rbutton->inside);
375 PCUT_ASSERT_FALSE(resp.selected);
376 PCUT_ASSERT_EQUALS(group->selected, rbutton);
377
378 ui_rbutton_leave(rbutton);
379 PCUT_ASSERT_TRUE(rbutton->held);
380 PCUT_ASSERT_FALSE(rbutton->inside);
381 PCUT_ASSERT_FALSE(resp.selected);
382 PCUT_ASSERT_EQUALS(group->selected, rbutton);
383
384 ui_rbutton_enter(rbutton);
385 PCUT_ASSERT_TRUE(rbutton->held);
386 PCUT_ASSERT_TRUE(rbutton->inside);
387 PCUT_ASSERT_FALSE(resp.selected);
388 PCUT_ASSERT_EQUALS(group->selected, rbutton);
389
390 ui_rbutton_release(rbutton);
391 PCUT_ASSERT_FALSE(rbutton->held);
392 PCUT_ASSERT_TRUE(rbutton->inside);
393 PCUT_ASSERT_TRUE(resp.selected);
394 PCUT_ASSERT_EQUALS(group->selected, rbutton);
395
396 ui_rbutton_destroy(rbutton);
397 ui_rbutton_group_destroy(group);
398 ui_resource_destroy(resource);
399
400 rc = gfx_context_delete(gc);
401 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
402}
403
404/** ui_pos_event() correctly translates POS_PRESS/POS_RELEASE */
405PCUT_TEST(pos_event_press_release)
406{
407 errno_t rc;
408 gfx_context_t *gc = NULL;
409 test_gc_t tgc;
410 ui_resource_t *resource = NULL;
411 ui_rbutton_group_t *group = NULL;
412 ui_rbutton_t *rbutton;
413 ui_evclaim_t claim;
414 pos_event_t event;
415 gfx_rect_t rect;
416
417 memset(&tgc, 0, sizeof(tgc));
418 rc = gfx_context_new(&ops, &tgc, &gc);
419 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
420
421 rc = ui_resource_create(gc, &resource);
422 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
423 PCUT_ASSERT_NOT_NULL(resource);
424
425 rc = ui_rbutton_group_create(resource, &group);
426 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
427
428 rc = ui_rbutton_create(group, "Hello", NULL, &rbutton);
429 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
430
431 PCUT_ASSERT_FALSE(rbutton->held);
432
433 rect.p0.x = 10;
434 rect.p0.y = 20;
435 rect.p1.x = 30;
436 rect.p1.y = 40;
437 ui_rbutton_set_rect(rbutton, &rect);
438
439 /* Press outside is not claimed and does nothing */
440 event.type = POS_PRESS;
441 event.hpos = 9;
442 event.vpos = 20;
443 claim = ui_rbutton_pos_event(rbutton, &event);
444 PCUT_ASSERT_FALSE(rbutton->held);
445 PCUT_ASSERT_EQUALS(ui_unclaimed, claim);
446
447 /* Press inside is claimed and depresses radio button */
448 event.type = POS_PRESS;
449 event.hpos = 10;
450 event.vpos = 20;
451 claim = ui_rbutton_pos_event(rbutton, &event);
452 PCUT_ASSERT_TRUE(rbutton->held);
453 PCUT_ASSERT_EQUALS(ui_claimed, claim);
454
455 /* Release outside (or anywhere) is claimed and relases radio button */
456 event.type = POS_RELEASE;
457 event.hpos = 9;
458 event.vpos = 20;
459 claim = ui_rbutton_pos_event(rbutton, &event);
460 PCUT_ASSERT_FALSE(rbutton->held);
461 PCUT_ASSERT_EQUALS(ui_claimed, claim);
462
463 ui_rbutton_destroy(rbutton);
464 ui_rbutton_group_destroy(group);
465 ui_resource_destroy(resource);
466
467 rc = gfx_context_delete(gc);
468 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
469}
470
471/** ui_pos_event() correctly translates POS_UPDATE to enter/leave */
472PCUT_TEST(pos_event_enter_leave)
473{
474 errno_t rc;
475 gfx_context_t *gc = NULL;
476 test_gc_t tgc;
477 ui_resource_t *resource = NULL;
478 ui_rbutton_group_t *group = NULL;
479 ui_rbutton_t *rbutton;
480 pos_event_t event;
481 gfx_rect_t rect;
482
483 memset(&tgc, 0, sizeof(tgc));
484 rc = gfx_context_new(&ops, &tgc, &gc);
485 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
486
487 rc = ui_resource_create(gc, &resource);
488 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
489 PCUT_ASSERT_NOT_NULL(resource);
490
491 rc = ui_rbutton_group_create(resource, &group);
492 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
493
494 rc = ui_rbutton_create(group, "Hello", NULL, &rbutton);
495 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
496
497 PCUT_ASSERT_FALSE(rbutton->inside);
498
499 rect.p0.x = 10;
500 rect.p0.y = 20;
501 rect.p1.x = 30;
502 rect.p1.y = 40;
503 ui_rbutton_set_rect(rbutton, &rect);
504
505 /* Moving outside does nothing */
506 event.type = POS_UPDATE;
507 event.hpos = 9;
508 event.vpos = 20;
509 ui_rbutton_pos_event(rbutton, &event);
510 PCUT_ASSERT_FALSE(rbutton->inside);
511
512 /* Moving inside sets inside flag */
513 event.type = POS_UPDATE;
514 event.hpos = 10;
515 event.vpos = 20;
516 ui_rbutton_pos_event(rbutton, &event);
517 PCUT_ASSERT_TRUE(rbutton->inside);
518
519 /* Moving outside clears inside flag */
520 event.type = POS_UPDATE;
521 event.hpos = 9;
522 event.vpos = 20;
523 ui_rbutton_pos_event(rbutton, &event);
524 PCUT_ASSERT_FALSE(rbutton->inside);
525
526 ui_rbutton_destroy(rbutton);
527 ui_rbutton_group_destroy(group);
528 ui_resource_destroy(resource);
529
530 rc = gfx_context_delete(gc);
531 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
532}
533
534static errno_t testgc_set_color(void *arg, gfx_color_t *color)
535{
536 (void) arg;
537 (void) color;
538 return EOK;
539}
540
541static errno_t testgc_fill_rect(void *arg, gfx_rect_t *rect)
542{
543 (void) arg;
544 (void) rect;
545 return EOK;
546}
547
548static errno_t testgc_bitmap_create(void *arg, gfx_bitmap_params_t *params,
549 gfx_bitmap_alloc_t *alloc, void **rbm)
550{
551 test_gc_t *tgc = (test_gc_t *) arg;
552 testgc_bitmap_t *tbm;
553
554 tbm = calloc(1, sizeof(testgc_bitmap_t));
555 if (tbm == NULL)
556 return ENOMEM;
557
558 if (alloc == NULL) {
559 tbm->alloc.pitch = (params->rect.p1.x - params->rect.p0.x) *
560 sizeof(uint32_t);
561 tbm->alloc.off0 = 0;
562 tbm->alloc.pixels = calloc(sizeof(uint32_t),
563 (params->rect.p1.x - params->rect.p0.x) *
564 (params->rect.p1.y - params->rect.p0.y));
565 tbm->myalloc = true;
566 if (tbm->alloc.pixels == NULL) {
567 free(tbm);
568 return ENOMEM;
569 }
570 } else {
571 tbm->alloc = *alloc;
572 }
573
574 tbm->tgc = tgc;
575 tgc->bm_created = true;
576 tgc->bm_params = *params;
577 tgc->bm_pixels = tbm->alloc.pixels;
578 *rbm = (void *)tbm;
579 return EOK;
580}
581
582static errno_t testgc_bitmap_destroy(void *bm)
583{
584 testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
585 if (tbm->myalloc)
586 free(tbm->alloc.pixels);
587 tbm->tgc->bm_destroyed = true;
588 free(tbm);
589 return EOK;
590}
591
592static errno_t testgc_bitmap_render(void *bm, gfx_rect_t *srect,
593 gfx_coord2_t *offs)
594{
595 testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
596 tbm->tgc->bm_rendered = true;
597 tbm->tgc->bm_srect = *srect;
598 tbm->tgc->bm_offs = *offs;
599 return EOK;
600}
601
602static errno_t testgc_bitmap_get_alloc(void *bm, gfx_bitmap_alloc_t *alloc)
603{
604 testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
605 *alloc = tbm->alloc;
606 tbm->tgc->bm_got_alloc = true;
607 return EOK;
608}
609
610static void test_rbutton_select(ui_rbutton_group_t *group, void *arg,
611 void *barg)
612{
613 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
614
615 resp->selected = true;
616}
617
618PCUT_EXPORT(rbutton);
Note: See TracBrowser for help on using the repository browser.