Changeset d284ce9 in mainline for uspace/lib


Ignore:
Timestamp:
2020-10-27T21:56:15Z (5 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f03d1308
Parents:
f7a90df
Message:

Let ui_window handle window decoration, display window

Location:
uspace/lib/ui
Files:
9 edited

Legend:

Unmodified
Added
Removed

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

    rf7a90df rd284ce9  
    3737#define _UI_TYPES_WINDOW_H
    3838
     39#include <io/pos_event.h>
     40
    3941struct ui_window;
    4042typedef struct ui_window ui_window_t;
    … …  
    4345typedef struct {
    4446        /** Window rectangle */
    45         gfx_rect_t *rect;
     47        gfx_rect_t rect;
    4648        /** Window caption */
    4749        const char *caption;
    48 } ui_window_params_t;
     50} ui_wnd_params_t;
     51
     52/** Window callbacks */
     53typedef struct ui_window_cb {
     54        void (*close)(ui_window_t *, void *);
     55        void (*pos)(ui_window_t *, void *, pos_event_t *);
     56} ui_window_cb_t;
    4957
    5058#endif

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

    rf7a90df rd284ce9  
    4444extern errno_t ui_create_disp(display_t *, ui_t **);
    4545extern void ui_destroy(ui_t *);
     46extern void ui_quit(ui_t *);
     47extern void ui_run(ui_t *);
    4648
    4749#endif

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

    rf7a90df rd284ce9  
    3838
    3939#include <errno.h>
     40#include <gfx/context.h>
     41#include <gfx/coord.h>
    4042#include <types/ui/ui.h>
     43#include <types/ui/resource.h>
    4144#include <types/ui/window.h>
    4245
    43 extern void ui_window_params_init(ui_window_params_t *);
    44 extern errno_t ui_window_create(ui_t *, ui_window_params_t *,
     46extern void ui_wnd_params_init(ui_wnd_params_t *);
     47extern errno_t ui_window_create(ui_t *, ui_wnd_params_t *,
    4548    ui_window_t **);
     49extern void ui_window_set_cb(ui_window_t *, ui_window_cb_t *, void *);
    4650extern void ui_window_destroy(ui_window_t *);
     51extern ui_resource_t *ui_window_get_res(ui_window_t *);
     52extern gfx_context_t *ui_window_get_gc(ui_window_t *);
     53extern void ui_window_get_app_rect(ui_window_t *, gfx_rect_t *);
    4754
    4855#endif

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

    rf7a90df rd284ce9  
    5050        /** Output owned by UI, clean up when destroying UI */
    5151        bool myoutput;
     52        /** @c true if terminating */
     53        bool quit;
    5254};
    5355

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

    rf7a90df rd284ce9  
    4040#include <display.h>
    4141#include <gfx/context.h>
     42#include <io/pos_event.h>
    4243
    4344/** Actual structure of window.
    … …  
    4849        /** Containing user interface */
    4950        struct ui *ui;
     51        /** Callbacks */
     52        struct ui_window_cb *cb;
     53        /** Callback argument */
     54        void *arg;
    5055        /** Display window */
    5156        display_window_t *dwindow;
    … …  
    5863};
    5964
     65extern void ui_window_close(ui_window_t *);
     66extern void ui_window_pos(ui_window_t *, pos_event_t *);
     67
    6068#endif
    6169

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

    rf7a90df rd284ce9  
    3636#include <display.h>
    3737#include <errno.h>
     38#include <fibril.h>
    3839#include <stdlib.h>
    3940#include <ui/ui.h>
    … …  
    6566        ui->display = display;
    6667        ui->myoutput = true;
     68        *rui = ui;
    6769        return EOK;
    6870}
    … …  
    101103}
    102104
     105/** Execute user interface.
     106 *
     107 * This function returns once the application starts the termination
     108 * process by calling ui_quit(@a ui).
     109 *
     110 * @param ui User interface
     111 */
     112void ui_run(ui_t *ui)
     113{
     114        while (!ui->quit)
     115                fibril_usleep(100000);
     116}
     117
     118/** Terminate user interface.
     119 *
     120 * Calling this function causes the user interface to terminate
     121 * (i.e. exit from ui_run()). This would be typically called from
     122 * an event handler.
     123 *
     124 * @param ui User interface
     125 */
     126void ui_quit(ui_t *ui)
     127{
     128        ui->quit = true;
     129}
     130
    103131/** @}
    104132 */

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

    rf7a90df rd284ce9  
    226226 *
    227227 * @param wdecor Window decoration
    228  * @param pos Position where the title bar was pressed
    229228 */
    230229void ui_wdecor_close(ui_wdecor_t *wdecor)

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

    rf7a90df rd284ce9  
    3737#include <errno.h>
    3838#include <gfx/context.h>
     39#include <io/pos_event.h>
    3940#include <mem.h>
    4041#include <stdlib.h>
    … …  
    4445#include "../private/dummygc.h"
    4546#include "../private/ui.h"
     47#include "../private/wdecor.h"
    4648#include "../private/window.h"
     49
     50static void dwnd_close_event(void *);
     51static void dwnd_focus_event(void *);
     52static void dwnd_kbd_event(void *, kbd_event_t *);
     53static void dwnd_pos_event(void *, pos_event_t *);
     54static void dwnd_unfocus_event(void *);
     55
     56static display_wnd_cb_t dwnd_cb = {
     57        .close_event = dwnd_close_event,
     58        .focus_event = dwnd_focus_event,
     59        .kbd_event = dwnd_kbd_event,
     60        .pos_event = dwnd_pos_event,
     61        .unfocus_event = dwnd_unfocus_event
     62};
     63
     64static void wd_close(ui_wdecor_t *, void *);
     65static void wd_move(ui_wdecor_t *, void *, gfx_coord2_t *);
     66
     67static ui_wdecor_cb_t wdecor_cb = {
     68        .close = wd_close,
     69        .move = wd_move
     70};
    4771
    4872/** Initialize window parameters structure.
    … …  
    5377 * @param params Window parameters structure
    5478 */
    55 void ui_window_params_init(ui_window_params_t *params)
    56 {
    57         memset(params, 0, sizeof(ui_window_params_t));
     79void ui_wnd_params_init(ui_wnd_params_t *params)
     80{
     81        memset(params, 0, sizeof(ui_wnd_params_t));
    5882}
    5983
    … …  
    6589 * @return EOK on success or an error code
    6690 */
    67 errno_t ui_window_create(ui_t *ui, ui_window_params_t *params,
     91errno_t ui_window_create(ui_t *ui, ui_wnd_params_t *params,
    6892    ui_window_t **rwindow)
    6993{
    … …  
    82106
    83107        display_wnd_params_init(&dparams);
     108        dparams.rect = params->rect;
    84109
    85110        if (ui->display != NULL) {
    86                 rc = display_window_create(ui->display, &dparams, NULL, NULL,
    87                     &dwindow);
     111                rc = display_window_create(ui->display, &dparams, &dwnd_cb,
     112                    (void *) window, &dwindow);
    88113                if (rc != EOK)
    89114                        goto error;
    … …  
    108133        if (rc != EOK)
    109134                goto error;
     135
     136        ui_wdecor_set_rect(wdecor, &params->rect);
     137        ui_wdecor_set_cb(wdecor, &wdecor_cb, (void *) window);
     138        ui_wdecor_paint(wdecor);
    110139
    111140        window->ui = ui;
    … …  
    145174}
    146175
     176/** Set window callbacks.
     177 *
     178 * @param window Window
     179 * @param cb Window decoration callbacks
     180 * @param arg Callback argument
     181 */
     182void ui_window_set_cb(ui_window_t *window, ui_window_cb_t *cb, void *arg)
     183{
     184        window->cb = cb;
     185        window->arg = arg;
     186}
     187
     188ui_resource_t *ui_window_get_res(ui_window_t *window)
     189{
     190        return window->res;
     191}
     192
     193gfx_context_t *ui_window_get_gc(ui_window_t *window)
     194{
     195        return window->gc;
     196}
     197
     198void ui_window_get_app_rect(ui_window_t *window, gfx_rect_t *rect)
     199{
     200        ui_wdecor_geom_t geom;
     201
     202        ui_wdecor_get_geom(window->wdecor, &geom);
     203        *rect = geom.app_area_rect;
     204}
     205
     206/** Handle window close event. */
     207static void dwnd_close_event(void *arg)
     208{
     209        ui_window_t *window = (ui_window_t *) arg;
     210
     211        ui_window_close(window);
     212}
     213
     214/** Handle window focus event. */
     215static void dwnd_focus_event(void *arg)
     216{
     217        ui_window_t *window = (ui_window_t *) arg;
     218
     219        if (window->wdecor != NULL) {
     220                ui_wdecor_set_active(window->wdecor, true);
     221                ui_wdecor_paint(window->wdecor);
     222        }
     223}
     224
     225/** Handle window keyboard event */
     226static void dwnd_kbd_event(void *arg, kbd_event_t *kbd_event)
     227{
     228        ui_window_t *window = (ui_window_t *) arg;
     229
     230        (void) window;
     231        (void) kbd_event;
     232}
     233
     234/** Handle window position event */
     235static void dwnd_pos_event(void *arg, pos_event_t *event)
     236{
     237        ui_window_t *window = (ui_window_t *) arg;
     238
     239        /* Make sure we don't process events until fully initialized */
     240        if (window->wdecor == NULL)
     241                return;
     242
     243        ui_wdecor_pos_event(window->wdecor, event);
     244        ui_window_pos(window, event);
     245}
     246
     247/** Handle window unfocus event. */
     248static void dwnd_unfocus_event(void *arg)
     249{
     250        ui_window_t *window = (ui_window_t *) arg;
     251
     252        if (window->wdecor != NULL) {
     253                ui_wdecor_set_active(window->wdecor, false);
     254                ui_wdecor_paint(window->wdecor);
     255        }
     256}
     257
     258/** Window decoration requested window closure.
     259 *
     260 * @param wdecor Window decoration
     261 * @param arg Argument (demo)
     262 */
     263static void wd_close(ui_wdecor_t *wdecor, void *arg)
     264{
     265        ui_window_t *window = (ui_window_t *) arg;
     266
     267        ui_window_close(window);
     268}
     269
     270/** Window decoration requested window move.
     271 *
     272 * @param wdecor Window decoration
     273 * @param arg Argument (demo)
     274 * @param pos Position where the title bar was pressed
     275 */
     276static void wd_move(ui_wdecor_t *wdecor, void *arg, gfx_coord2_t *pos)
     277{
     278        ui_window_t *window = (ui_window_t *) arg;
     279
     280        (void) display_window_move_req(window->dwindow, pos);
     281}
     282
     283/** Send window close event.
     284 *
     285 * @param window Window
     286 */
     287void ui_window_close(ui_window_t *window)
     288{
     289        if (window->cb != NULL && window->cb->close != NULL)
     290                window->cb->close(window, window->arg);
     291}
     292
     293/** Send window position event.
     294 *
     295 * @param window Window
     296 */
     297void ui_window_pos(ui_window_t *window, pos_event_t *pos)
     298{
     299        if (window->cb != NULL && window->cb->pos != NULL)
     300                window->cb->pos(window, window->arg, pos);
     301}
     302
    147303/** @}
    148304 */

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

    rf7a90df rd284ce9  
    2727 */
    2828
     29#include <gfx/context.h>
     30#include <gfx/coord.h>
     31#include <io/pos_event.h>
    2932#include <mem.h>
    3033#include <pcut/pcut.h>
    3134#include <stdbool.h>
     35#include <ui/resource.h>
    3236#include <ui/ui.h>
    3337#include <ui/window.h>
    … …  
    3842PCUT_TEST_SUITE(window);
    3943
     44static void test_window_close(ui_window_t *, void *);
     45static void test_window_pos(ui_window_t *, void *, pos_event_t *);
     46
     47static ui_window_cb_t test_window_cb = {
     48        .close = test_window_close,
     49        .pos = test_window_pos
     50};
     51
     52static ui_window_cb_t dummy_window_cb = {
     53};
     54
     55typedef struct {
     56        bool close;
     57        bool pos;
     58        pos_event_t pos_event;
     59} test_cb_resp_t;
     60
    4061/** Create and destroy window */
    4162PCUT_TEST(create_destroy)
    … …  
    4364        errno_t rc;
    4465        ui_t *ui = NULL;
    45         ui_window_params_t params;
    46         ui_window_t *window = NULL;
    47 
    48         rc = ui_create_disp(NULL, &ui);
    49         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    50 
    51         ui_window_params_init(&params);
     66        ui_wnd_params_t params;
     67        ui_window_t *window = NULL;
     68
     69        rc = ui_create_disp(NULL, &ui);
     70        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     71
     72        ui_wnd_params_init(&params);
    5273        params.caption = "Hello";
    5374
    … …  
    6687}
    6788
     89/** ui_window_get_res/gc/rect() return valid objects */
     90PCUT_TEST(get_res_gc_rect)
     91{
     92        errno_t rc;
     93        ui_t *ui = NULL;
     94        ui_wnd_params_t params;
     95        ui_window_t *window = NULL;
     96        ui_resource_t *res;
     97        gfx_context_t *gc;
     98        gfx_rect_t rect;
     99
     100        rc = ui_create_disp(NULL, &ui);
     101        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     102
     103        ui_wnd_params_init(&params);
     104        params.caption = "Hello";
     105
     106        rc = ui_window_create(ui, &params, &window);
     107        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     108        PCUT_ASSERT_NOT_NULL(window);
     109
     110        res = ui_window_get_res(window);
     111        PCUT_ASSERT_NOT_NULL(res);
     112
     113        gc = ui_window_get_gc(window);
     114        PCUT_ASSERT_NOT_NULL(gc);
     115
     116        ui_window_get_app_rect(window, &rect);
     117
     118        ui_window_destroy(window);
     119        ui_destroy(ui);
     120}
     121
     122/** ui_window_close() calls close callback set via ui_window_set_cb() */
     123PCUT_TEST(close)
     124{
     125        errno_t rc;
     126        ui_t *ui = NULL;
     127        ui_wnd_params_t params;
     128        ui_window_t *window = NULL;
     129        test_cb_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        /* Close callback with no callbacks set */
     142        ui_window_close(window);
     143
     144        /* Close callback with close callback not implemented */
     145        ui_window_set_cb(window, &dummy_window_cb, NULL);
     146        ui_window_close(window);
     147
     148        /* Close callback with real callback set */
     149        resp.close = false;
     150        ui_window_set_cb(window, &test_window_cb, &resp);
     151        ui_window_close(window);
     152        PCUT_ASSERT_TRUE(resp.close);
     153
     154        ui_window_destroy(window);
     155        ui_destroy(ui);
     156}
     157
     158/** ui_window_pos() calls pos callback set via ui_window_set_cb() */
     159PCUT_TEST(pos)
     160{
     161        errno_t rc;
     162        ui_t *ui = NULL;
     163        ui_wnd_params_t params;
     164        ui_window_t *window = NULL;
     165        pos_event_t pos_event;
     166        test_cb_resp_t resp;
     167
     168        rc = ui_create_disp(NULL, &ui);
     169        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     170
     171        ui_wnd_params_init(&params);
     172        params.caption = "Hello";
     173
     174        rc = ui_window_create(ui, &params, &window);
     175        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     176        PCUT_ASSERT_NOT_NULL(window);
     177
     178        pos_event.pos_id = 1;
     179        pos_event.type = POS_PRESS;
     180        pos_event.btn_num = 2;
     181        pos_event.hpos = 3;
     182        pos_event.vpos = 4;
     183
     184        /* Pos callback with no callbacks set */
     185        ui_window_pos(window, &pos_event);
     186
     187        /* Pos callback with pos callback not implemented */
     188        ui_window_set_cb(window, &dummy_window_cb, NULL);
     189        ui_window_pos(window, &pos_event);
     190
     191        /* Pos callback with real callback set */
     192        resp.pos = false;
     193        ui_window_set_cb(window, &test_window_cb, &resp);
     194        ui_window_pos(window, &pos_event);
     195        PCUT_ASSERT_TRUE(resp.pos);
     196        PCUT_ASSERT_INT_EQUALS(pos_event.pos_id, resp.pos_event.pos_id);
     197        PCUT_ASSERT_EQUALS(pos_event.type, resp.pos_event.type);
     198        PCUT_ASSERT_INT_EQUALS(pos_event.btn_num, resp.pos_event.btn_num);
     199        PCUT_ASSERT_INT_EQUALS(pos_event.hpos, resp.pos_event.hpos);
     200        PCUT_ASSERT_INT_EQUALS(pos_event.vpos, resp.pos_event.vpos);
     201
     202        ui_window_destroy(window);
     203        ui_destroy(ui);
     204}
     205
     206static void test_window_close(ui_window_t *window, void *arg)
     207{
     208        test_cb_resp_t *resp = (test_cb_resp_t *) arg;
     209
     210        resp->close = true;
     211}
     212
     213static void test_window_pos(ui_window_t *window, void *arg,
     214    pos_event_t *event)
     215{
     216        test_cb_resp_t *resp = (test_cb_resp_t *) arg;
     217
     218        resp->pos = true;
     219        resp->pos_event = *event;
     220}
     221
    68222PCUT_EXPORT(window);
Note: See TracChangeset for help on using the changeset viewer.