Changeset 3583ffb in mainline for uspace/lib/ui/test


Ignore:
Timestamp:
2020-11-08T19:51:04Z (5 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f93e4e3
Parents:
8c772c4
Message:

Revert "Create UI controls based on UI object…"

This was a mistake. Controls need ui_resource object, which must be
(at least currently) specific to a window and cannot be obtained from
ui_t.

Location:
uspace/lib/ui/test
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/ui/test/label.c

    r8c772c4 r3583ffb  
    3434#include <ui/control.h>
    3535#include <ui/label.h>
    36 #include <ui/ui.h>
     36#include <ui/resource.h>
    3737#include "../private/label.h"
    3838
    … …  
    4040
    4141PCUT_TEST_SUITE(label);
     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
     60typedef struct {
     61        bool bm_created;
     62        bool bm_destroyed;
     63        gfx_bitmap_params_t bm_params;
     64        void *bm_pixels;
     65        gfx_rect_t bm_srect;
     66        gfx_coord2_t bm_offs;
     67        bool bm_rendered;
     68        bool bm_got_alloc;
     69} test_gc_t;
     70
     71typedef struct {
     72        test_gc_t *tgc;
     73        gfx_bitmap_alloc_t alloc;
     74        bool myalloc;
     75} testgc_bitmap_t;
    4276
    4377typedef struct {
    … …  
    149183{
    150184        errno_t rc;
    151         ui_t *ui;
    152         ui_label_t *label;
    153 
    154         rc = ui_create_disp(NULL, &ui);
    155         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    156 
    157         rc = ui_label_create(ui, "Hello", &label);
     185        gfx_context_t *gc = NULL;
     186        test_gc_t tgc;
     187        ui_resource_t *resource = NULL;
     188        ui_label_t *label;
     189
     190        memset(&tgc, 0, sizeof(tgc));
     191        rc = gfx_context_new(&ops, &tgc, &gc);
     192        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     193
     194        rc = ui_resource_create(gc, &resource);
     195        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     196        PCUT_ASSERT_NOT_NULL(resource);
     197
     198        rc = ui_label_create(resource, "Hello", &label);
    158199        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    159200
    … …  
    162203
    163204        ui_label_destroy(label);
    164         ui_destroy(ui);
     205        ui_resource_destroy(resource);
     206
     207        rc = gfx_context_delete(gc);
     208        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     209}
     210
     211static errno_t testgc_set_color(void *arg, gfx_color_t *color)
     212{
     213        (void) arg;
     214        (void) color;
     215        return EOK;
     216}
     217
     218static errno_t testgc_fill_rect(void *arg, gfx_rect_t *rect)
     219{
     220        (void) arg;
     221        (void) rect;
     222        return EOK;
     223}
     224
     225static errno_t testgc_bitmap_create(void *arg, gfx_bitmap_params_t *params,
     226    gfx_bitmap_alloc_t *alloc, void **rbm)
     227{
     228        test_gc_t *tgc = (test_gc_t *) arg;
     229        testgc_bitmap_t *tbm;
     230
     231        tbm = calloc(1, sizeof(testgc_bitmap_t));
     232        if (tbm == NULL)
     233                return ENOMEM;
     234
     235        if (alloc == NULL) {
     236                tbm->alloc.pitch = (params->rect.p1.x - params->rect.p0.x) *
     237                    sizeof(uint32_t);
     238                tbm->alloc.off0 = 0;
     239                tbm->alloc.pixels = calloc(sizeof(uint32_t),
     240                    (params->rect.p1.x - params->rect.p0.x) *
     241                    (params->rect.p1.y - params->rect.p0.y));
     242                tbm->myalloc = true;
     243                if (tbm->alloc.pixels == NULL) {
     244                        free(tbm);
     245                        return ENOMEM;
     246                }
     247        } else {
     248                tbm->alloc = *alloc;
     249        }
     250
     251        tbm->tgc = tgc;
     252        tgc->bm_created = true;
     253        tgc->bm_params = *params;
     254        tgc->bm_pixels = tbm->alloc.pixels;
     255        *rbm = (void *)tbm;
     256        return EOK;
     257}
     258
     259static errno_t testgc_bitmap_destroy(void *bm)
     260{
     261        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
     262        if (tbm->myalloc)
     263                free(tbm->alloc.pixels);
     264        tbm->tgc->bm_destroyed = true;
     265        free(tbm);
     266        return EOK;
     267}
     268
     269static errno_t testgc_bitmap_render(void *bm, gfx_rect_t *srect,
     270    gfx_coord2_t *offs)
     271{
     272        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
     273        tbm->tgc->bm_rendered = true;
     274        tbm->tgc->bm_srect = *srect;
     275        tbm->tgc->bm_offs = *offs;
     276        return EOK;
     277}
     278
     279static errno_t testgc_bitmap_get_alloc(void *bm, gfx_bitmap_alloc_t *alloc)
     280{
     281        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
     282        *alloc = tbm->alloc;
     283        tbm->tgc->bm_got_alloc = true;
     284        return EOK;
    165285}
    166286

  • uspace/lib/ui/test/pbutton.c

    r8c772c4 r3583ffb  
    3434#include <ui/control.h>
    3535#include <ui/pbutton.h>
    36 #include <ui/ui.h>
     36#include <ui/resource.h>
    3737#include "../private/pbutton.h"
    3838
    … …  
    4040
    4141PCUT_TEST_SUITE(pbutton);
     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};
    4259
    4360static void test_pbutton_clicked(ui_pbutton_t *, void *);
    … …  
    4966static ui_pbutton_cb_t dummy_pbutton_cb = {
    5067};
     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;
    5185
    5286typedef struct {
    … …  
    135169{
    136170        errno_t rc;
    137         ui_t *ui;
    138         ui_pbutton_t *pbutton;
    139 
    140         rc = ui_create_disp(NULL, &ui);
    141         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    142 
    143         rc = ui_pbutton_create(ui, "Hello", &pbutton);
     171        gfx_context_t *gc = NULL;
     172        test_gc_t tgc;
     173        ui_resource_t *resource = NULL;
     174        ui_pbutton_t *pbutton;
     175
     176        memset(&tgc, 0, sizeof(tgc));
     177        rc = gfx_context_new(&ops, &tgc, &gc);
     178        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     179
     180        rc = ui_resource_create(gc, &resource);
     181        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     182        PCUT_ASSERT_NOT_NULL(resource);
     183
     184        rc = ui_pbutton_create(resource, "Hello", &pbutton);
    144185        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    145186
    … …  
    148189
    149190        ui_pbutton_destroy(pbutton);
    150         ui_destroy(ui);
     191        ui_resource_destroy(resource);
     192
     193        rc = gfx_context_delete(gc);
     194        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    151195}
    152196
    … …  
    181225{
    182226        errno_t rc;
    183         ui_t *ui;
     227        gfx_context_t *gc = NULL;
     228        test_gc_t tgc;
     229        ui_resource_t *resource = NULL;
    184230        ui_pbutton_t *pbutton;
    185231        test_cb_resp_t resp;
    186232
    187         rc = ui_create_disp(NULL, &ui);
    188         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    189 
    190         rc = ui_pbutton_create(ui, "Hello", &pbutton);
     233        memset(&tgc, 0, sizeof(tgc));
     234        rc = gfx_context_new(&ops, &tgc, &gc);
     235        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     236
     237        rc = ui_resource_create(gc, &resource);
     238        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     239        PCUT_ASSERT_NOT_NULL(resource);
     240
     241        rc = ui_pbutton_create(resource, "Hello", &pbutton);
    191242        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    192243
    … …  
    208259
    209260        ui_pbutton_destroy(pbutton);
    210         ui_destroy(ui);
     261        ui_resource_destroy(resource);
     262
     263        rc = gfx_context_delete(gc);
     264        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    211265}
    212266
    … …  
    215269{
    216270        errno_t rc;
    217         ui_t *ui;
     271        gfx_context_t *gc = NULL;
     272        test_gc_t tgc;
     273        ui_resource_t *resource = NULL;
    218274        ui_pbutton_t *pbutton;
    219275        test_cb_resp_t resp;
    220276
    221         rc = ui_create_disp(NULL, &ui);
    222         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    223 
    224         rc = ui_pbutton_create(ui, "Hello", &pbutton);
     277        memset(&tgc, 0, sizeof(tgc));
     278        rc = gfx_context_new(&ops, &tgc, &gc);
     279        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     280
     281        rc = ui_resource_create(gc, &resource);
     282        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     283        PCUT_ASSERT_NOT_NULL(resource);
     284
     285        rc = ui_pbutton_create(resource, "Hello", &pbutton);
    225286        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    226287
    … …  
    247308
    248309        ui_pbutton_destroy(pbutton);
    249         ui_destroy(ui);
     310        ui_resource_destroy(resource);
     311
     312        rc = gfx_context_delete(gc);
     313        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    250314}
    251315
    … …  
    254318{
    255319        errno_t rc;
    256         ui_t *ui;
     320        gfx_context_t *gc = NULL;
     321        test_gc_t tgc;
     322        ui_resource_t *resource = NULL;
    257323        ui_pbutton_t *pbutton;
    258324        test_cb_resp_t resp;
    259325
    260         rc = ui_create_disp(NULL, &ui);
    261         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    262 
    263         rc = ui_pbutton_create(ui, "Hello", &pbutton);
     326        memset(&tgc, 0, sizeof(tgc));
     327        rc = gfx_context_new(&ops, &tgc, &gc);
     328        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     329
     330        rc = ui_resource_create(gc, &resource);
     331        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     332        PCUT_ASSERT_NOT_NULL(resource);
     333
     334        rc = ui_pbutton_create(resource, "Hello", &pbutton);
    264335        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    265336
    … …  
    291362
    292363        ui_pbutton_destroy(pbutton);
    293         ui_destroy(ui);
     364        ui_resource_destroy(resource);
     365
     366        rc = gfx_context_delete(gc);
     367        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    294368}
    295369
    … …  
    298372{
    299373        errno_t rc;
    300         ui_t *ui;
     374        gfx_context_t *gc = NULL;
     375        test_gc_t tgc;
     376        ui_resource_t *resource = NULL;
    301377        ui_pbutton_t *pbutton;
    302378        ui_evclaim_t claim;
    … …  
    304380        gfx_rect_t rect;
    305381
    306         rc = ui_create_disp(NULL, &ui);
    307         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    308 
    309         rc = ui_pbutton_create(ui, "Hello", &pbutton);
     382        memset(&tgc, 0, sizeof(tgc));
     383        rc = gfx_context_new(&ops, &tgc, &gc);
     384        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     385
     386        rc = ui_resource_create(gc, &resource);
     387        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     388        PCUT_ASSERT_NOT_NULL(resource);
     389
     390        rc = ui_pbutton_create(resource, "Hello", &pbutton);
    310391        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    311392
    … …  
    343424
    344425        ui_pbutton_destroy(pbutton);
    345         ui_destroy(ui);
     426        ui_resource_destroy(resource);
     427
     428        rc = gfx_context_delete(gc);
     429        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    346430}
    347431
    … …  
    350434{
    351435        errno_t rc;
    352         ui_t *ui;
     436        gfx_context_t *gc = NULL;
     437        test_gc_t tgc;
     438        ui_resource_t *resource = NULL;
    353439        ui_pbutton_t *pbutton;
    354440        pos_event_t event;
    355441        gfx_rect_t rect;
    356442
    357         rc = ui_create_disp(NULL, &ui);
    358         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    359 
    360         rc = ui_pbutton_create(ui, "Hello", &pbutton);
     443        memset(&tgc, 0, sizeof(tgc));
     444        rc = gfx_context_new(&ops, &tgc, &gc);
     445        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     446
     447        rc = ui_resource_create(gc, &resource);
     448        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     449        PCUT_ASSERT_NOT_NULL(resource);
     450
     451        rc = ui_pbutton_create(resource, "Hello", &pbutton);
    361452        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    362453
    … …  
    391482
    392483        ui_pbutton_destroy(pbutton);
    393         ui_destroy(ui);
     484        ui_resource_destroy(resource);
     485
     486        rc = gfx_context_delete(gc);
     487        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     488}
     489
     490static errno_t testgc_set_color(void *arg, gfx_color_t *color)
     491{
     492        (void) arg;
     493        (void) color;
     494        return EOK;
     495}
     496
     497static errno_t testgc_fill_rect(void *arg, gfx_rect_t *rect)
     498{
     499        (void) arg;
     500        (void) rect;
     501        return EOK;
     502}
     503
     504static errno_t testgc_bitmap_create(void *arg, gfx_bitmap_params_t *params,
     505    gfx_bitmap_alloc_t *alloc, void **rbm)
     506{
     507        test_gc_t *tgc = (test_gc_t *) arg;
     508        testgc_bitmap_t *tbm;
     509
     510        tbm = calloc(1, sizeof(testgc_bitmap_t));
     511        if (tbm == NULL)
     512                return ENOMEM;
     513
     514        if (alloc == NULL) {
     515                tbm->alloc.pitch = (params->rect.p1.x - params->rect.p0.x) *
     516                    sizeof(uint32_t);
     517                tbm->alloc.off0 = 0;
     518                tbm->alloc.pixels = calloc(sizeof(uint32_t),
     519                    (params->rect.p1.x - params->rect.p0.x) *
     520                    (params->rect.p1.y - params->rect.p0.y));
     521                tbm->myalloc = true;
     522                if (tbm->alloc.pixels == NULL) {
     523                        free(tbm);
     524                        return ENOMEM;
     525                }
     526        } else {
     527                tbm->alloc = *alloc;
     528        }
     529
     530        tbm->tgc = tgc;
     531        tgc->bm_created = true;
     532        tgc->bm_params = *params;
     533        tgc->bm_pixels = tbm->alloc.pixels;
     534        *rbm = (void *)tbm;
     535        return EOK;
     536}
     537
     538static errno_t testgc_bitmap_destroy(void *bm)
     539{
     540        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
     541        if (tbm->myalloc)
     542                free(tbm->alloc.pixels);
     543        tbm->tgc->bm_destroyed = true;
     544        free(tbm);
     545        return EOK;
     546}
     547
     548static errno_t testgc_bitmap_render(void *bm, gfx_rect_t *srect,
     549    gfx_coord2_t *offs)
     550{
     551        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
     552        tbm->tgc->bm_rendered = true;
     553        tbm->tgc->bm_srect = *srect;
     554        tbm->tgc->bm_offs = *offs;
     555        return EOK;
     556}
     557
     558static errno_t testgc_bitmap_get_alloc(void *bm, gfx_bitmap_alloc_t *alloc)
     559{
     560        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
     561        *alloc = tbm->alloc;
     562        tbm->tgc->bm_got_alloc = true;
     563        return EOK;
    394564}
    395565

  • uspace/lib/ui/test/wdecor.c

    r8c772c4 r3583ffb  
    3333#include <stdbool.h>
    3434#include <ui/pbutton.h>
    35 #include <ui/ui.h>
     35#include <ui/resource.h>
    3636#include <ui/wdecor.h>
    3737#include "../private/wdecor.h"
    … …  
    4040
    4141PCUT_TEST_SUITE(wdecor);
     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};
    4259
    4360static void test_wdecor_close(ui_wdecor_t *, void *);
    … …  
    5168static ui_wdecor_cb_t dummy_wdecor_cb = {
    5269};
     70
     71typedef struct {
     72        bool bm_created;
     73        bool bm_destroyed;
     74        gfx_bitmap_params_t bm_params;
     75        void *bm_pixels;
     76        gfx_rect_t bm_srect;
     77        gfx_coord2_t bm_offs;
     78        bool bm_rendered;
     79        bool bm_got_alloc;
     80} test_gc_t;
     81
     82typedef struct {
     83        test_gc_t *tgc;
     84        gfx_bitmap_alloc_t alloc;
     85        bool myalloc;
     86} testgc_bitmap_t;
    5387
    5488typedef struct {
    … …  
    125159{
    126160        errno_t rc;
    127         ui_t *ui;
    128         ui_wdecor_t *wdecor;
    129 
    130         rc = ui_create_disp(NULL, &ui);
    131         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    132 
    133         rc = ui_wdecor_create(ui, "Hello", &wdecor);
     161        gfx_context_t *gc = NULL;
     162        test_gc_t tgc;
     163        ui_resource_t *resource = NULL;
     164        ui_wdecor_t *wdecor;
     165
     166        memset(&tgc, 0, sizeof(tgc));
     167        rc = gfx_context_new(&ops, &tgc, &gc);
     168        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     169
     170        rc = ui_resource_create(gc, &resource);
     171        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     172        PCUT_ASSERT_NOT_NULL(resource);
     173
     174        rc = ui_wdecor_create(resource, "Hello", &wdecor);
    134175        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    135176
    … …  
    138179
    139180        ui_wdecor_destroy(wdecor);
    140         ui_destroy(ui);
     181        ui_resource_destroy(resource);
     182
     183        rc = gfx_context_delete(gc);
     184        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    141185}
    142186
    … …  
    327371}
    328372
     373static errno_t testgc_set_color(void *arg, gfx_color_t *color)
     374{
     375        (void) arg;
     376        (void) color;
     377        return EOK;
     378}
     379
     380static errno_t testgc_fill_rect(void *arg, gfx_rect_t *rect)
     381{
     382        (void) arg;
     383        (void) rect;
     384        return EOK;
     385}
     386
     387static errno_t testgc_bitmap_create(void *arg, gfx_bitmap_params_t *params,
     388    gfx_bitmap_alloc_t *alloc, void **rbm)
     389{
     390        test_gc_t *tgc = (test_gc_t *) arg;
     391        testgc_bitmap_t *tbm;
     392
     393        tbm = calloc(1, sizeof(testgc_bitmap_t));
     394        if (tbm == NULL)
     395                return ENOMEM;
     396
     397        if (alloc == NULL) {
     398                tbm->alloc.pitch = (params->rect.p1.x - params->rect.p0.x) *
     399                    sizeof(uint32_t);
     400                tbm->alloc.off0 = 0;
     401                tbm->alloc.pixels = calloc(sizeof(uint32_t),
     402                    (params->rect.p1.x - params->rect.p0.x) *
     403                    (params->rect.p1.y - params->rect.p0.y));
     404                tbm->myalloc = true;
     405                if (tbm->alloc.pixels == NULL) {
     406                        free(tbm);
     407                        return ENOMEM;
     408                }
     409        } else {
     410                tbm->alloc = *alloc;
     411        }
     412
     413        tbm->tgc = tgc;
     414        tgc->bm_created = true;
     415        tgc->bm_params = *params;
     416        tgc->bm_pixels = tbm->alloc.pixels;
     417        *rbm = (void *)tbm;
     418        return EOK;
     419}
     420
     421static errno_t testgc_bitmap_destroy(void *bm)
     422{
     423        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
     424        if (tbm->myalloc)
     425                free(tbm->alloc.pixels);
     426        tbm->tgc->bm_destroyed = true;
     427        free(tbm);
     428        return EOK;
     429}
     430
     431static errno_t testgc_bitmap_render(void *bm, gfx_rect_t *srect,
     432    gfx_coord2_t *offs)
     433{
     434        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
     435        tbm->tgc->bm_rendered = true;
     436        tbm->tgc->bm_srect = *srect;
     437        tbm->tgc->bm_offs = *offs;
     438        return EOK;
     439}
     440
     441static errno_t testgc_bitmap_get_alloc(void *bm, gfx_bitmap_alloc_t *alloc)
     442{
     443        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
     444        *alloc = tbm->alloc;
     445        tbm->tgc->bm_got_alloc = true;
     446        return EOK;
     447}
     448
    329449static void test_wdecor_close(ui_wdecor_t *wdecor, void *arg)
    330450{

  • uspace/lib/ui/test/window.c

    r8c772c4 r3583ffb  
    3535#include <stdbool.h>
    3636#include <ui/control.h>
     37#include <ui/resource.h>
    3738#include <ui/ui.h>
    3839#include <ui/window.h>
    … …  
    173174}
    174175
    175 /** ui_window_get_gc/rect() return valid objects */
    176 PCUT_TEST(gc_rect)
    177 {
    178         errno_t rc;
    179         ui_t *ui = NULL;
    180         ui_wnd_params_t params;
    181         ui_window_t *window = NULL;
     176/** ui_window_get_res/gc/rect() return valid objects */
     177PCUT_TEST(get_res_gc_rect)
     178{
     179        errno_t rc;
     180        ui_t *ui = NULL;
     181        ui_wnd_params_t params;
     182        ui_window_t *window = NULL;
     183        ui_resource_t *res;
    182184        gfx_context_t *gc;
    183185        gfx_rect_t rect;
    … …  
    192194        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    193195        PCUT_ASSERT_NOT_NULL(window);
     196
     197        res = ui_window_get_res(window);
     198        PCUT_ASSERT_NOT_NULL(res);
    194199
    195200        gc = ui_window_get_gc(window);
Note: See TracChangeset for help on using the changeset viewer.