Changeset b71c0fc in mainline


Ignore:
Timestamp:
2020-11-07T16:07:22Z (4 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
d55ab823
Parents:
fa01c05
Message:

Make fixed layout a UI control and hook it up to the window

Location:
uspace
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/uidemo/uidemo.c

    rfa01c05 rb71c0fc  
    3434
    3535#include <gfx/coord.h>
    36 #include <io/pos_event.h>
    3736#include <stdio.h>
    3837#include <str.h>
    … …  
    4342#include <ui/resource.h>
    4443#include <ui/ui.h>
    45 #include <ui/wdecor.h>
    4644#include <ui/window.h>
    4745#include "uidemo.h"
    4846
    4947static void wnd_close(ui_window_t *, void *);
    50 static errno_t wnd_paint(ui_window_t *, void *);
    51 static void wnd_pos(ui_window_t *, void *, pos_event_t *pos);
    5248
    5349static ui_window_cb_t window_cb = {
    54         .close = wnd_close,
    55         .paint = wnd_paint,
    56         .pos = wnd_pos
     50        .close = wnd_close
    5751};
    5852
    … …  
    7367
    7468        ui_quit(demo->ui);
    75 }
    76 
    77 /** Window paint request.
    78  *
    79  * @param window Window
    80  * @param arg Argument (demo)
    81  * @return EOK on success or an error code
    82  */
    83 static errno_t wnd_paint(ui_window_t *window, void *arg)
    84 {
    85         ui_demo_t *demo = (ui_demo_t *) arg;
    86         errno_t rc;
    87 
    88         /* Let window paint its background */
    89         rc = ui_window_def_paint(window);
    90         if (rc != EOK)
    91                 return rc;
    92 
    93         return ui_fixed_paint(demo->fixed);
    94 }
    95 
    96 /** Window position event.
    97  *
    98  * @param window Window
    99  * @param arg Argument (demo)
    100  */
    101 static void wnd_pos(ui_window_t *window, void *arg, pos_event_t *event)
    102 {
    103         ui_demo_t *demo = (ui_demo_t *) arg;
    104 
    105         /* Make sure we don't process events until fully initialized */
    106         if (demo->fixed == NULL)
    107                 return;
    108 
    109         ui_fixed_pos_event(demo->fixed, event);
    11069}
    11170
    … …  
    240199        }
    241200
     201        ui_window_add(window, ui_fixed_ctl(demo.fixed));
     202
    242203        rc = ui_window_paint(window);
    243204        if (rc != EOK) {
    … …  
    248209        ui_run(ui);
    249210
    250         ui_fixed_destroy(demo.fixed);
    251211        ui_window_destroy(window);
    252212        ui_destroy(ui);

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

    rfa01c05 rb71c0fc  
    4545extern errno_t ui_fixed_create(ui_fixed_t **);
    4646extern void ui_fixed_destroy(ui_fixed_t *);
     47extern ui_control_t *ui_fixed_ctl(ui_fixed_t *);
    4748extern errno_t ui_fixed_add(ui_fixed_t *, ui_control_t *);
    4849extern void ui_fixed_remove(ui_fixed_t *, ui_control_t *);

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

    rfa01c05 rb71c0fc  
    4040#include <gfx/context.h>
    4141#include <gfx/coord.h>
     42#include <io/pos_event.h>
     43#include <types/ui/control.h>
    4244#include <types/ui/ui.h>
    4345#include <types/ui/resource.h>
    … …  
    4951extern void ui_window_set_cb(ui_window_t *, ui_window_cb_t *, void *);
    5052extern void ui_window_destroy(ui_window_t *);
     53extern void ui_window_add(ui_window_t *, ui_control_t *);
     54extern void ui_window_remove(ui_window_t *, ui_control_t *);
    5155extern ui_resource_t *ui_window_get_res(ui_window_t *);
    5256extern gfx_context_t *ui_window_get_gc(ui_window_t *);
    … …  
    5458extern errno_t ui_window_paint(ui_window_t *);
    5559extern errno_t ui_window_def_paint(ui_window_t *);
     60extern void ui_window_def_pos(ui_window_t *, pos_event_t *);
    5661
    5762#endif

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

    rfa01c05 rb71c0fc  
    4848 */
    4949struct ui_fixed {
     50        /** Base control object */
     51        struct ui_control *control;
    5052        /** Layout elements (ui_fixed_elem_t) */
    5153        list_t elem;

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

    rfa01c05 rb71c0fc  
    6363        /** Window decoration */
    6464        struct ui_wdecor *wdecor;
     65        /** Top-level control in the application area */
     66        struct ui_control *control;
    6567};
    6668

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

    rfa01c05 rb71c0fc  
    8181 * extended data).
    8282 *
    83  * @param control Control
     83 * @param control Control or @c NULL
    8484 */
    8585void ui_control_destroy(ui_control_t *control)
    8686{
     87        if (control == NULL)
     88                return;
     89
    8790        return control->ops->destroy(control->ext);
    8891}

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

    rfa01c05 rb71c0fc  
    4444#include "../private/fixed.h"
    4545
     46static void ui_fixed_ctl_destroy(void *);
     47static errno_t ui_fixed_ctl_paint(void *);
     48static ui_evclaim_t ui_fixed_ctl_pos_event(void *, pos_event_t *);
     49
     50/** Push button control ops */
     51ui_control_ops_t ui_fixed_ops = {
     52        .destroy = ui_fixed_ctl_destroy,
     53        .paint = ui_fixed_ctl_paint,
     54        .pos_event = ui_fixed_ctl_pos_event
     55};
     56
    4657/** Create new fixed layout.
    4758 *
    … …  
    5263{
    5364        ui_fixed_t *fixed;
     65        errno_t rc;
    5466
    5567        fixed = calloc(1, sizeof(ui_fixed_t));
    5668        if (fixed == NULL)
    5769                return ENOMEM;
     70
     71        rc = ui_control_new(&ui_fixed_ops, (void *) fixed, &fixed->control);
     72        if (rc != EOK) {
     73                free(fixed);
     74                return rc;
     75        }
    5876
    5977        list_initialize(&fixed->elem);
    … …  
    83101        }
    84102
     103        ui_control_delete(fixed->control);
    85104        free(fixed);
     105}
     106
     107/** Get base control from fixed layout.
     108 *
     109 * @param fixed Fixed layout
     110 * @return Control
     111 */
     112ui_control_t *ui_fixed_ctl(ui_fixed_t *fixed)
     113{
     114        return fixed->control;
    86115}
    87116
    … …  
    203232}
    204233
     234/** Destroy fixed layout control.
     235 *
     236 * @param arg Argument (ui_fixed_t *)
     237 */
     238void ui_fixed_ctl_destroy(void *arg)
     239{
     240        ui_fixed_t *fixed = (ui_fixed_t *) arg;
     241
     242        ui_fixed_destroy(fixed);
     243}
     244
     245/** Paint fixed layout control.
     246 *
     247 * @param arg Argument (ui_fixed_t *)
     248 * @return EOK on success or an error code
     249 */
     250errno_t ui_fixed_ctl_paint(void *arg)
     251{
     252        ui_fixed_t *fixed = (ui_fixed_t *) arg;
     253
     254        return ui_fixed_paint(fixed);
     255}
     256
     257/** Handle fixed layout control position event.
     258 *
     259 * @param arg Argument (ui_fixed_t *)
     260 * @param pos_event Position event
     261 * @return @c ui_claimed iff the event is claimed
     262 */
     263ui_evclaim_t ui_fixed_ctl_pos_event(void *arg, pos_event_t *event)
     264{
     265        ui_fixed_t *fixed = (ui_fixed_t *) arg;
     266
     267        return ui_fixed_pos_event(fixed, event);
     268}
     269
    205270/** @}
    206271 */

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

    rfa01c05 rb71c0fc  
    4242#include <mem.h>
    4343#include <stdlib.h>
     44#include <ui/control.h>
    4445#include <ui/resource.h>
    4546#include <ui/wdecor.h>
    4647#include <ui/window.h>
     48#include "../private/control.h"
    4749#include "../private/dummygc.h"
    4850#include "../private/resource.h"
    … …  
    170172                return;
    171173
     174        ui_control_destroy(window->control);
    172175        ui_wdecor_destroy(window->wdecor);
    173176        ui_resource_destroy(window->res);
    … …  
    177180}
    178181
     182/** Add control to window.
     183 *
     184 * Only one control can be added to a window. If more than one control
     185 * is added, the results are undefined.
     186 *
     187 * @param fixed Fixed layout
     188 * @param control Control
     189 * @return EOK on success, ENOMEM if out of memory
     190 */
     191void ui_window_add(ui_window_t *window, ui_control_t *control)
     192{
     193        assert(window->control == NULL);
     194
     195        window->control = control;
     196        control->elemp = (void *) window;
     197}
     198
     199/** Remove control from window.
     200 *
     201 * @param window Window
     202 * @param control Control
     203 */
     204void ui_window_remove(ui_window_t *window, ui_control_t *control)
     205{
     206        assert(window->control == control);
     207        assert((ui_window_t *) control->elemp == window);
     208
     209        window->control = NULL;
     210        control->elemp = NULL;
     211}
     212
    179213/** Set window callbacks.
    180214 *
    … …  
    343377        if (window->cb != NULL && window->cb->pos != NULL)
    344378                window->cb->pos(window, window->arg, pos);
     379        else
     380                ui_window_def_pos(window, pos);
    345381}
    346382
    … …  
    375411                return rc;
    376412
     413        if (window->control != NULL)
     414                return ui_control_paint(window->control);
     415
    377416        return EOK;
    378417}
    379418
     419/** Default window position event routine.
     420 *
     421 * @param window Window
     422 * @return EOK on success or an error code
     423 */
     424void ui_window_def_pos(ui_window_t *window, pos_event_t *pos)
     425{
     426        if (window->control != NULL)
     427                ui_control_pos_event(window->control, pos);
     428}
     429
    380430/** @}
    381431 */

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

    rfa01c05 rb71c0fc  
    8383}
    8484
     85/** ui_fixed_ctl() returns control that has a working virtual destructor */
     86PCUT_TEST(ctl)
     87{
     88        ui_fixed_t *fixed;
     89        ui_control_t *control;
     90        errno_t rc;
     91
     92        rc = ui_fixed_create(&fixed);
     93        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     94
     95        control = ui_fixed_ctl(fixed);
     96        PCUT_ASSERT_NOT_NULL(control);
     97
     98        ui_control_destroy(control);
     99}
     100
    85101/** ui_fixed_add() / ui_fixed_remove() adds/removes control */
    86102PCUT_TEST(add_remove)

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

    rfa01c05 rb71c0fc  
    3232#include <pcut/pcut.h>
    3333#include <stdbool.h>
     34#include <ui/control.h>
    3435#include <ui/label.h>
    3536#include <ui/resource.h>
    … …  
    9596{
    9697        ui_label_destroy(NULL);
     98}
     99
     100/** ui_label_ctl() returns control that has a working virtual destructor */
     101PCUT_TEST(ctl)
     102{
     103        ui_label_t *label;
     104        ui_control_t *control;
     105        errno_t rc;
     106
     107        rc = ui_label_create(NULL, "Hello", &label);
     108        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     109
     110        control = ui_label_ctl(label);
     111        PCUT_ASSERT_NOT_NULL(control);
     112
     113        ui_control_destroy(control);
    97114}
    98115

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

    rfa01c05 rb71c0fc  
    3232#include <pcut/pcut.h>
    3333#include <stdbool.h>
     34#include <ui/control.h>
    3435#include <ui/pbutton.h>
    3536#include <ui/resource.h>
    … …  
    104105{
    105106        ui_pbutton_destroy(NULL);
     107}
     108
     109/** ui_pbutton_ctl() returns control that has a working virtual destructor */
     110PCUT_TEST(ctl)
     111{
     112        ui_pbutton_t *pbutton;
     113        ui_control_t *control;
     114        errno_t rc;
     115
     116        rc = ui_pbutton_create(NULL, "Hello", &pbutton);
     117        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     118
     119        control = ui_pbutton_ctl(pbutton);
     120        PCUT_ASSERT_NOT_NULL(control);
     121
     122        ui_control_destroy(control);
    106123}
    107124

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

    rfa01c05 rb71c0fc  
    3434#include <pcut/pcut.h>
    3535#include <stdbool.h>
     36#include <ui/control.h>
    3637#include <ui/resource.h>
    3738#include <ui/ui.h>
    … …  
    6061
    6162static ui_window_cb_t dummy_window_cb = {
     63};
     64
     65static errno_t test_ctl_paint(void *);
     66static ui_evclaim_t test_ctl_pos_event(void *, pos_event_t *);
     67
     68static ui_control_ops_t test_ctl_ops = {
     69        .paint = test_ctl_paint,
     70        .pos_event = test_ctl_pos_event
    6271};
    6372
    … …  
    7483} test_cb_resp_t;
    7584
     85typedef struct {
     86        errno_t rc;
     87        ui_evclaim_t claim;
     88        bool paint;
     89        bool pos;
     90        pos_event_t pos_event;
     91} test_ctl_resp_t;
     92
    7693/** Create and destroy window */
    7794PCUT_TEST(create_destroy)
    … …  
    100117{
    101118        ui_window_destroy(NULL);
     119}
     120
     121/** ui_window_add()/ui_window_remove() ... */
     122PCUT_TEST(add_remove)
     123{
     124        errno_t rc;
     125        ui_t *ui = NULL;
     126        ui_wnd_params_t params;
     127        ui_window_t *window = NULL;
     128        ui_control_t *control = NULL;
     129        test_ctl_resp_t resp;
     130
     131        rc = ui_create_disp(NULL, &ui);
     132        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     133
     134        ui_wnd_params_init(&params);
     135        params.caption = "Hello";
     136
     137        rc = ui_window_create(ui, &params, &window);
     138        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     139        PCUT_ASSERT_NOT_NULL(window);
     140
     141        rc = ui_control_new(&test_ctl_ops, &resp, &control);
     142        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     143
     144        /* Control not called since it hasn't been added yet */
     145        resp.rc = ENOMEM;
     146        resp.paint = false;
     147        rc = ui_window_def_paint(window);
     148        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     149        PCUT_ASSERT_FALSE(resp.paint);
     150
     151        ui_window_add(window, control);
     152
     153        /* Now paint request should be delivered to control */
     154        resp.rc = EOK;
     155        resp.paint = false;
     156        rc = ui_window_def_paint(window);
     157        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     158        PCUT_ASSERT_TRUE(resp.paint);
     159
     160        ui_window_remove(window, control);
     161
     162        /*
     163         * After having removed the control the request should no longer
     164         * be delivered to it.
     165         */
     166        resp.rc = ENOMEM;
     167        resp.paint = false;
     168        rc = ui_window_def_paint(window);
     169        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     170        PCUT_ASSERT_FALSE(resp.paint);
     171
     172        ui_window_destroy(window);
     173        ui_destroy(ui);
    102174}
    103175
    … …  
    166238        ui_wnd_params_t params;
    167239        ui_window_t *window = NULL;
    168 
    169         rc = ui_create_disp(NULL, &ui);
    170         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    171 
    172         ui_wnd_params_init(&params);
    173         params.caption = "Hello";
    174 
    175         rc = ui_window_create(ui, &params, &window);
    176         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    177         PCUT_ASSERT_NOT_NULL(window);
    178 
    179         ui_window_def_paint(window);
     240        ui_control_t *control = NULL;
     241        test_ctl_resp_t resp;
     242
     243        rc = ui_create_disp(NULL, &ui);
     244        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     245
     246        ui_wnd_params_init(&params);
     247        params.caption = "Hello";
     248
     249        rc = ui_window_create(ui, &params, &window);
     250        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     251        PCUT_ASSERT_NOT_NULL(window);
     252
     253        rc = ui_control_new(&test_ctl_ops, &resp, &control);
     254        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     255
     256        ui_window_add(window, control);
     257
     258        resp.rc = EOK;
     259        resp.paint = false;
     260        rc = ui_window_def_paint(window);
     261        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
     262        PCUT_ASSERT_TRUE(resp.paint);
     263
     264        resp.rc = ENOMEM;
     265        resp.paint = false;
     266        rc = ui_window_def_paint(window);
     267        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
     268        PCUT_ASSERT_TRUE(resp.paint);
     269
     270        PCUT_ASSERT_TRUE(resp.paint);
     271
     272        /* Need to remove first because we didn't implement the destructor */
     273        ui_window_remove(window, control);
     274
     275        ui_window_destroy(window);
     276        ui_destroy(ui);
     277}
     278
     279/** ui_window_def_pos() delivers position event to control in window */
     280PCUT_TEST(def_pos)
     281{
     282        errno_t rc;
     283        ui_t *ui = NULL;
     284        ui_wnd_params_t params;
     285        ui_window_t *window = NULL;
     286        ui_control_t *control = NULL;
     287        test_ctl_resp_t resp;
     288        pos_event_t event;
     289
     290        rc = ui_create_disp(NULL, &ui);
     291        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     292
     293        ui_wnd_params_init(&params);
     294        params.caption = "Hello";
     295
     296        rc = ui_window_create(ui, &params, &window);
     297        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     298
     299        rc = ui_control_new(&test_ctl_ops, &resp, &control);
     300        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     301
     302        ui_window_add(window, control);
     303
     304        event.pos_id = 1;
     305        event.type = POS_PRESS;
     306        event.btn_num = 2;
     307        event.hpos = 3;
     308        event.vpos = 4;
     309
     310        resp.pos = false;
     311        resp.claim = ui_claimed;
     312
     313        ui_window_def_pos(window, &event);
     314
     315        PCUT_ASSERT_TRUE(resp.pos);
     316        PCUT_ASSERT_INT_EQUALS(event.pos_id, resp.pos_event.pos_id);
     317        PCUT_ASSERT_INT_EQUALS(event.type, resp.pos_event.type);
     318        PCUT_ASSERT_INT_EQUALS(event.btn_num, resp.pos_event.btn_num);
     319        PCUT_ASSERT_INT_EQUALS(event.hpos, resp.pos_event.hpos);
     320        PCUT_ASSERT_INT_EQUALS(event.vpos, resp.pos_event.vpos);
     321
     322        /* Need to remove first because we didn't implement the destructor */
     323        ui_window_remove(window, control);
    180324
    181325        ui_window_destroy(window);
    … …  
    470614}
    471615
     616static errno_t test_ctl_paint(void *arg)
     617{
     618        test_ctl_resp_t *resp = (test_ctl_resp_t *) arg;
     619
     620        resp->paint = true;
     621        return resp->rc;
     622}
     623
     624static ui_evclaim_t test_ctl_pos_event(void *arg, pos_event_t *event)
     625{
     626        test_ctl_resp_t *resp = (test_ctl_resp_t *) arg;
     627
     628        resp->pos = true;
     629        resp->pos_event = *event;
     630
     631        return resp->claim;
     632}
     633
    472634PCUT_EXPORT(window);
Note: See TracChangeset for help on using the changeset viewer.