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

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

Add GC operation to set clipping rectangle

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