Changeset 3583ffb in mainline


Ignore:
Timestamp:
2020-11-08T19:51:04Z (4 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
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/terminal/terminal.c

    r8c772c4 r3583ffb  
    835835
    836836        term->gc = ui_window_get_gc(term->window);
     837        term->ui_res = ui_window_get_res(term->window);
    837838
    838839        ui_window_set_cb(term->window, &terminal_window_cb, (void *) term);

  • uspace/app/terminal/terminal.h

    r8c772c4 r3583ffb  
    5757        ui_t *ui;
    5858        ui_window_t *window;
     59        ui_resource_t *ui_res;
    5960        gfx_context_t *gc;
    6061

  • uspace/app/uidemo/uidemo.c

    r8c772c4 r3583ffb  
    9999        ui_demo_t demo;
    100100        gfx_rect_t rect;
     101        ui_resource_t *ui_res;
    101102        errno_t rc;
    102103
    … …  
    126127        demo.window = window;
    127128
     129        ui_res = ui_window_get_res(window);
     130
    128131        rc = ui_fixed_create(&demo.fixed);
    129132        if (rc != EOK) {
    … …  
    132135        }
    133136
    134         rc = ui_label_create(ui, "Hello there!", &demo.label);
     137        rc = ui_label_create(ui_res, "Hello there!", &demo.label);
    135138        if (rc != EOK) {
    136139                printf("Error creating label.\n");
    … …  
    151154        }
    152155
    153         rc = ui_pbutton_create(ui, "Confirm", &demo.pb1);
     156        rc = ui_pbutton_create(ui_res, "Confirm", &demo.pb1);
    154157        if (rc != EOK) {
    155158                printf("Error creating button.\n");
    … …  
    173176        }
    174177
    175         rc = ui_pbutton_create(ui, "Cancel", &demo.pb2);
     178        rc = ui_pbutton_create(ui_res, "Cancel", &demo.pb2);
    176179        if (rc != EOK) {
    177180                printf("Error creating button.\n");

  • uspace/lib/ui/include/ui/label.h

    r8c772c4 r3583ffb  
    4242#include <types/ui/control.h>
    4343#include <types/ui/label.h>
    44 #include <types/ui/ui.h>
     44#include <types/ui/resource.h>
    4545
    46 extern errno_t ui_label_create(ui_t *, const char *,
     46extern errno_t ui_label_create(ui_resource_t *, const char *,
    4747    ui_label_t **);
    4848extern void ui_label_destroy(ui_label_t *);

  • uspace/lib/ui/include/ui/pbutton.h

    r8c772c4 r3583ffb  
    4343#include <types/ui/event.h>
    4444#include <types/ui/pbutton.h>
    45 #include <types/ui/ui.h>
     45#include <types/ui/resource.h>
    4646#include <stdbool.h>
    4747
    48 extern errno_t ui_pbutton_create(ui_t *, const char *,
     48extern errno_t ui_pbutton_create(ui_resource_t *, const char *,
    4949    ui_pbutton_t **);
    5050extern void ui_pbutton_destroy(ui_pbutton_t *);

  • uspace/lib/ui/include/ui/wdecor.h

    r8c772c4 r3583ffb  
    4141#include <io/pos_event.h>
    4242#include <stdbool.h>
    43 #include <types/ui/ui.h>
     43#include <types/ui/resource.h>
    4444#include <types/ui/wdecor.h>
    4545
    46 extern errno_t ui_wdecor_create(ui_t *, const char *,
     46extern errno_t ui_wdecor_create(ui_resource_t *, const char *,
    4747    ui_wdecor_t **);
    4848extern void ui_wdecor_destroy(ui_wdecor_t *);

  • uspace/lib/ui/include/ui/window.h

    r8c772c4 r3583ffb  
    5353extern void ui_window_add(ui_window_t *, ui_control_t *);
    5454extern void ui_window_remove(ui_window_t *, ui_control_t *);
     55extern ui_resource_t *ui_window_get_res(ui_window_t *);
    5556extern gfx_context_t *ui_window_get_gc(ui_window_t *);
    5657extern void ui_window_get_app_rect(ui_window_t *, gfx_rect_t *);

  • uspace/lib/ui/private/ui.h

    r8c772c4 r3583ffb  
    4848        /** Display */
    4949        display_t *display;
    50         /** UI resource */
    51         struct ui_resource *resource;
    5250        /** Output owned by UI, clean up when destroying UI */
    5351        bool myoutput;

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

    r8c772c4 r3583ffb  
    4545#include "../private/label.h"
    4646#include "../private/resource.h"
    47 #include "../private/ui.h"
    4847
    4948static void ui_label_ctl_destroy(void *);
    … …  
    6564 * @return EOK on success, ENOMEM if out of memory
    6665 */
    67 errno_t ui_label_create(ui_t *ui, const char *text,
     66errno_t ui_label_create(ui_resource_t *resource, const char *text,
    6867    ui_label_t **rlabel)
    6968{
    … …  
    8887        }
    8988
    90         label->res = ui->resource;
     89        label->res = resource;
    9190        label->halign = gfx_halign_left;
    9291        *rlabel = label;

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

    r8c772c4 r3583ffb  
    4747#include "../private/pbutton.h"
    4848#include "../private/resource.h"
    49 #include "../private/ui.h"
    5049
    5150/** Caption movement when button is pressed down */
    … …  
    7372 * @return EOK on success, ENOMEM if out of memory
    7473 */
    75 errno_t ui_pbutton_create(ui_t *ui, const char *caption,
     74errno_t ui_pbutton_create(ui_resource_t *resource, const char *caption,
    7675    ui_pbutton_t **rpbutton)
    7776{
    … …  
    9796        }
    9897
    99         pbutton->res = ui->resource;
     98        pbutton->res = resource;
    10099        *rpbutton = pbutton;
    101100        return EOK;

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

    r8c772c4 r3583ffb  
    4646#include <ui/wdecor.h>
    4747#include "../private/resource.h"
    48 #include "../private/ui.h"
    4948#include "../private/wdecor.h"
    5049
    … …  
    6261 * @return EOK on success, ENOMEM if out of memory
    6362 */
    64 errno_t ui_wdecor_create(ui_t *ui, const char *caption,
     63errno_t ui_wdecor_create(ui_resource_t *resource, const char *caption,
    6564    ui_wdecor_t **rwdecor)
    6665{
    … …  
    7877        }
    7978
    80         rc = ui_pbutton_create(ui, "X", &wdecor->btn_close);
     79        rc = ui_pbutton_create(resource, "X", &wdecor->btn_close);
    8180        if (rc != EOK) {
    8281                free(wdecor->caption);
    … …  
    8887            (void *)wdecor);
    8988
    90         wdecor->res = ui->resource;
     89        wdecor->res = resource;
    9190        wdecor->active = true;
    9291        *rwdecor = wdecor;

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

    r8c772c4 r3583ffb  
    135135                goto error;
    136136
    137         ui->resource = res;
    138 
    139         rc = ui_wdecor_create(ui, params->caption, &wdecor);
     137        rc = ui_wdecor_create(res, params->caption, &wdecor);
    140138        if (rc != EOK)
    141139                goto error;
    … …  
    225223}
    226224
    227 /** Get window GC.
    228  *
    229  * Return the grapic context of the window. It is relative to the upper-left
    230  * corner of the window.
    231  *
    232  * @param window Window
    233  * @return Graphic context
    234  */
     225ui_resource_t *ui_window_get_res(ui_window_t *window)
     226{
     227        return window->res;
     228}
     229
    235230gfx_context_t *ui_window_get_gc(ui_window_t *window)
    236231{
    … …  
    238233}
    239234
    240 /** Get window application rectangle.
    241  *
    242  * Return the window's application rectangle. This is a rectangle covering
    243  * everything apart from the window frame and title bar.
    244  *
    245  * @param window Window
    246  * @param rect Place to store application rectangle
    247  */
    248235void ui_window_get_app_rect(ui_window_t *window, gfx_rect_t *rect)
    249236{
    … …  
    254241}
    255242
    256 /** Paint window.
    257  *
    258  * @param window Window
    259  * @return EOK on success or an error code
    260  */
    261243errno_t ui_window_paint(ui_window_t *window)
    262244{

  • 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.