Changeset 7cc30e9 in mainline for uspace/lib/display


Ignore:
Timestamp:
2022-10-24T17:50:46Z (3 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
master, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
913add60
Parents:
7a05d924
Message:

Display server needs to store window caption

Even though it does not use it itself, it needs to provide it to
window managers (e.g. Task bar). We need to be able to set caption
for a new window and to change it for an existing window.

Location:
uspace/lib/display
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/display/include/disp_srv.h

    r7a05d924 r7cc30e9  
    6767        errno_t (*window_unmaximize)(void *, sysarg_t);
    6868        errno_t (*window_set_cursor)(void *, sysarg_t, display_stock_cursor_t);
     69        errno_t (*window_set_caption)(void *, sysarg_t, const char *);
    6970        errno_t (*get_event)(void *, sysarg_t *, display_wnd_ev_t *);
    7071        errno_t (*get_info)(void *, display_info_t *);

  • uspace/lib/display/include/display.h

    r7a05d924 r7cc30e9  
    6666extern errno_t display_window_set_cursor(display_window_t *,
    6767    display_stock_cursor_t);
     68extern errno_t display_window_set_caption(display_window_t *, const char *);
    6869
    6970#endif

  • uspace/lib/display/include/ipc/display.h

    r7a05d924 r7cc30e9  
    5050        DISPLAY_WINDOW_RESIZE_REQ,
    5151        DISPLAY_WINDOW_SET_CURSOR,
     52        DISPLAY_WINDOW_SET_CAPTION,
    5253        DISPLAY_WINDOW_UNMAXIMIZE,
    5354        DISPLAY_GET_EVENT,

  • uspace/lib/display/include/types/display/wndparams.h

    r7a05d924 r7cc30e9  
    5858        /** Bounding rectangle */
    5959        gfx_rect_t rect;
     60        /** Window caption */
     61        const char *caption;
    6062        /** Minimum size (when being resized) */
    6163        gfx_coord2_t min_size;

  • uspace/lib/display/private/params.h

    r7a05d924 r7cc30e9  
    11/*
    2  * Copyright (c) 2020 Jiri Svoboda
     2 * Copyright (c) 2022 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    4646} display_wnd_resize_t;
    4747
     48/** Display window parameters encoded for transport
     49 *
     50 * This omits variable-length fields (window caption).
     51 */
     52typedef struct {
     53        /** Bounding rectangle */
     54        gfx_rect_t rect;
     55        /** Window caption size in bytes */
     56        size_t caption_size;
     57        /** Minimum size (when being resized) */
     58        gfx_coord2_t min_size;
     59        /** Initial position (if flag wndf_setpos is set) */
     60        gfx_coord2_t pos;
     61        /** Flags */
     62        display_wnd_flags_t flags;
     63} display_wnd_params_enc_t;
     64
    4865#endif
    4966

  • uspace/lib/display/src/disp_srv.c

    r7a05d924 r7cc30e9  
    6363        sysarg_t wnd_id;
    6464        ipc_call_t call;
     65        display_wnd_params_enc_t eparams;
    6566        display_wnd_params_t params;
     67        char *caption;
    6668        size_t size;
    6769        errno_t rc;
    … …  
    7375        }
    7476
    75         if (size != sizeof(display_wnd_params_t)) {
    76                 async_answer_0(&call, EINVAL);
    77                 async_answer_0(icall, EINVAL);
    78                 return;
    79         }
    80 
    81         rc = async_data_write_finalize(&call, &params, size);
    82         if (rc != EOK) {
     77        if (size != sizeof(display_wnd_params_enc_t)) {
     78                async_answer_0(&call, EINVAL);
     79                async_answer_0(icall, EINVAL);
     80                return;
     81        }
     82
     83        rc = async_data_write_finalize(&call, &eparams, size);
     84        if (rc != EOK) {
     85                async_answer_0(&call, rc);
     86                async_answer_0(icall, rc);
     87                return;
     88        }
     89
     90        caption = calloc(eparams.caption_size + 1, 1);
     91        if (caption == NULL) {
     92                async_answer_0(icall, ENOMEM);
     93                return;
     94        }
     95
     96        if (!async_data_write_receive(&call, &size)) {
     97                free(caption);
     98                async_answer_0(&call, EREFUSED);
     99                async_answer_0(icall, EREFUSED);
     100                return;
     101        }
     102
     103        if (size != eparams.caption_size) {
     104                free(caption);
     105                async_answer_0(&call, EINVAL);
     106                async_answer_0(icall, EINVAL);
     107                return;
     108        }
     109
     110        rc = async_data_write_finalize(&call, caption, eparams.caption_size);
     111        if (rc != EOK) {
     112                free(caption);
    83113                async_answer_0(&call, rc);
    84114                async_answer_0(icall, rc);
    … …  
    87117
    88118        if (srv->ops->window_create == NULL) {
    89                 async_answer_0(icall, ENOTSUP);
    90                 return;
    91         }
     119                free(caption);
     120                async_answer_0(icall, ENOTSUP);
     121                return;
     122        }
     123
     124        /* Decode the parameters from transport */
     125        params.rect = eparams.rect;
     126        params.caption = caption;
     127        params.min_size = eparams.min_size;
     128        params.pos = eparams.pos;
     129        params.flags = eparams.flags;
    92130
    93131        rc = srv->ops->window_create(srv->arg, &params, &wnd_id);
    … …  
    401439        rc = srv->ops->window_set_cursor(srv->arg, wnd_id, cursor);
    402440        async_answer_0(icall, rc);
     441}
     442
     443static void display_window_set_caption_srv(display_srv_t *srv,
     444    ipc_call_t *icall)
     445{
     446        sysarg_t wnd_id;
     447        ipc_call_t call;
     448        char *caption;
     449        size_t size;
     450        errno_t rc;
     451
     452        wnd_id = ipc_get_arg1(icall);
     453
     454        if (!async_data_write_receive(&call, &size)) {
     455                async_answer_0(&call, EREFUSED);
     456                async_answer_0(icall, EREFUSED);
     457                return;
     458        }
     459
     460        caption = calloc(size + 1, 1);
     461        if (caption == NULL) {
     462                async_answer_0(&call, ENOMEM);
     463                async_answer_0(icall, ENOMEM);
     464                return;
     465        }
     466
     467        rc = async_data_write_finalize(&call, caption, size);
     468        if (rc != EOK) {
     469                free(caption);
     470                async_answer_0(&call, rc);
     471                async_answer_0(icall, rc);
     472                return;
     473        }
     474
     475        if (srv->ops->window_set_caption == NULL) {
     476                free(caption);
     477                async_answer_0(icall, ENOTSUP);
     478                return;
     479        }
     480
     481        rc = srv->ops->window_set_caption(srv->arg, wnd_id, caption);
     482        async_answer_0(icall, rc);
     483        free(caption);
    403484}
    404485
    … …  
    538619                case DISPLAY_WINDOW_SET_CURSOR:
    539620                        display_window_set_cursor_srv(srv, &call);
     621                        break;
     622                case DISPLAY_WINDOW_SET_CAPTION:
     623                        display_window_set_caption_srv(srv, &call);
    540624                        break;
    541625                case DISPLAY_GET_EVENT:

  • uspace/lib/display/src/display.c

    r7a05d924 r7cc30e9  
    3838#include <mem.h>
    3939#include <stdlib.h>
     40#include <str.h>
    4041#include "../private/display.h"
    4142#include "../private/params.h"
    … …  
    147148{
    148149        memset(params, 0, sizeof(*params));
     150        params->caption = "";
    149151}
    150152
    … …  
    162164{
    163165        display_window_t *window;
    164         async_exch_t *exch;
    165         aid_t req;
    166         ipc_call_t answer;
    167         errno_t rc;
     166        display_wnd_params_enc_t eparams;
     167        async_exch_t *exch;
     168        aid_t req;
     169        ipc_call_t answer;
     170        errno_t rc;
     171
     172        /* Encode the parameters for transport */
     173        eparams.rect = params->rect;
     174        eparams.caption_size = str_size(params->caption);
     175        eparams.min_size = params->min_size;
     176        eparams.pos = params->pos;
     177        eparams.flags = params->flags;
    168178
    169179        window = calloc(1, sizeof(display_window_t));
    … …  
    173183        exch = async_exchange_begin(display->sess);
    174184        req = async_send_0(exch, DISPLAY_WINDOW_CREATE, &answer);
    175         rc = async_data_write_start(exch, params, sizeof (display_wnd_params_t));
     185
     186        /* Write fixed fields */
     187        rc = async_data_write_start(exch, &eparams,
     188            sizeof (display_wnd_params_enc_t));
     189        if (rc != EOK) {
     190                async_exchange_end(exch);
     191                async_forget(req);
     192                free(window);
     193                return rc;
     194        }
     195
     196        /* Write caption */
     197        rc = async_data_write_start(exch, params->caption,
     198            eparams.caption_size);
    176199        async_exchange_end(exch);
    177200        if (rc != EOK) {
    … …  
    540563            cursor);
    541564        async_exchange_end(exch);
     565        return rc;
     566}
     567
     568/** Set display window caption.
     569 *
     570 * @param window Window
     571 * @param caption New caption
     572 * @return EOK on success or an error code
     573 */
     574errno_t display_window_set_caption(display_window_t *window,
     575    const char *caption)
     576{
     577        async_exch_t *exch;
     578        aid_t req;
     579        ipc_call_t answer;
     580        size_t cap_size;
     581        errno_t rc;
     582
     583        cap_size = str_size(caption);
     584
     585        exch = async_exchange_begin(window->display->sess);
     586        req = async_send_1(exch, DISPLAY_WINDOW_SET_CAPTION, window->id,
     587            &answer);
     588
     589        /* Write caption */
     590        rc = async_data_write_start(exch, caption, cap_size);
     591        async_exchange_end(exch);
     592        if (rc != EOK) {
     593                async_forget(req);
     594                return rc;
     595        }
     596
     597        async_wait_for(req, &rc);
    542598        return rc;
    543599}

  • uspace/lib/display/test/display.c

    r7a05d924 r7cc30e9  
    3838#include <loc.h>
    3939#include <pcut/pcut.h>
     40#include <str.h>
    4041#include "../private/display.h"
    4142
    … …  
    6869static errno_t test_window_unmaximize(void *, sysarg_t);
    6970static errno_t test_window_set_cursor(void *, sysarg_t, display_stock_cursor_t);
     71static errno_t test_window_set_caption(void *, sysarg_t, const char *);
    7072static errno_t test_get_event(void *, sysarg_t *, display_wnd_ev_t *);
    7173static errno_t test_get_info(void *, display_info_t *);
    … …  
    8587        .window_unmaximize = test_window_unmaximize,
    8688        .window_set_cursor = test_window_set_cursor,
     89        .window_set_caption = test_window_set_caption,
    8790        .get_event = test_get_event,
    8891        .get_info = test_get_info
    … …  
    148151        sysarg_t set_cursor_wnd_id;
    149152        display_stock_cursor_t set_cursor_cursor;
     153
     154        bool window_set_caption_called;
     155        sysarg_t set_caption_wnd_id;
     156        char *set_caption_caption;
    150157
    151158        bool get_event_called;
    … …  
    12401247        PCUT_ASSERT_INT_EQUALS(dcurs_size_ud, resp.set_cursor_cursor);
    12411248
     1249        display_window_destroy(wnd);
     1250        display_close(disp);
     1251        rc = loc_service_unregister(sid);
     1252        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1253}
     1254
     1255/** display_window_set_caption() with server returning error response works. */
     1256PCUT_TEST(window_set_caption_failure)
     1257{
     1258        errno_t rc;
     1259        service_id_t sid;
     1260        display_t *disp = NULL;
     1261        display_wnd_params_t params;
     1262        display_window_t *wnd;
     1263        const char *caption;
     1264        test_response_t resp;
     1265
     1266        async_set_fallback_port_handler(test_display_conn, &resp);
     1267
     1268        // FIXME This causes this test to be non-reentrant!
     1269        rc = loc_server_register(test_display_server);
     1270        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1271
     1272        rc = loc_service_register(test_display_svc, &sid);
     1273        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1274
     1275        rc = display_open(test_display_svc, &disp);
     1276        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1277        PCUT_ASSERT_NOT_NULL(disp);
     1278
     1279        resp.rc = EOK;
     1280        display_wnd_params_init(&params);
     1281        params.rect.p0.x = 0;
     1282        params.rect.p0.y = 0;
     1283        params.rect.p0.x = 100;
     1284        params.rect.p0.y = 100;
     1285
     1286        rc = display_window_create(disp, &params, &test_display_wnd_cb,
     1287            (void *) &resp, &wnd);
     1288        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1289        PCUT_ASSERT_NOT_NULL(wnd);
     1290
     1291        caption = "Hello";
     1292
     1293        resp.rc = EIO;
     1294        resp.window_set_caption_called = false;
     1295
     1296        rc = display_window_set_caption(wnd, caption);
     1297        PCUT_ASSERT_INT_EQUALS(wnd->id, resp.set_caption_wnd_id);
     1298        PCUT_ASSERT_TRUE(resp.window_set_caption_called);
     1299        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
     1300        PCUT_ASSERT_INT_EQUALS(0, str_cmp(caption, resp.set_caption_caption));
     1301
     1302        //free(resp.set_caption_caption);
     1303        display_window_destroy(wnd);
     1304        display_close(disp);
     1305        rc = loc_service_unregister(sid);
     1306        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1307}
     1308
     1309/** display_window_set_caption() with server returning success response works. */
     1310PCUT_TEST(window_set_caption_success)
     1311{
     1312        errno_t rc;
     1313        service_id_t sid;
     1314        display_t *disp = NULL;
     1315        display_wnd_params_t params;
     1316        display_window_t *wnd;
     1317        const char *caption;
     1318        test_response_t resp;
     1319
     1320        async_set_fallback_port_handler(test_display_conn, &resp);
     1321
     1322        // FIXME This causes this test to be non-reentrant!
     1323        rc = loc_server_register(test_display_server);
     1324        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1325
     1326        rc = loc_service_register(test_display_svc, &sid);
     1327        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1328
     1329        rc = display_open(test_display_svc, &disp);
     1330        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1331        PCUT_ASSERT_NOT_NULL(disp);
     1332
     1333        resp.rc = EOK;
     1334        display_wnd_params_init(&params);
     1335        params.rect.p0.x = 0;
     1336        params.rect.p0.y = 0;
     1337        params.rect.p0.x = 100;
     1338        params.rect.p0.y = 100;
     1339
     1340        rc = display_window_create(disp, &params, &test_display_wnd_cb,
     1341            (void *) &resp, &wnd);
     1342        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1343        PCUT_ASSERT_NOT_NULL(wnd);
     1344
     1345        caption = "Hello";
     1346
     1347        resp.rc = EOK;
     1348        resp.window_set_caption_called = false;
     1349
     1350        rc = display_window_set_caption(wnd, caption);
     1351        PCUT_ASSERT_INT_EQUALS(wnd->id, resp.set_caption_wnd_id);
     1352        PCUT_ASSERT_TRUE(resp.window_set_caption_called);
     1353        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
     1354        PCUT_ASSERT_INT_EQUALS(0, str_cmp(caption, resp.set_caption_caption));
     1355
     1356        //free(resp.set_caption_caption);
    12421357        display_window_destroy(wnd);
    12431358        display_close(disp);
    … …  
    20182133}
    20192134
     2135static errno_t test_window_set_caption(void *arg, sysarg_t wnd_id,
     2136    const char *caption)
     2137{
     2138        test_response_t *resp = (test_response_t *) arg;
     2139
     2140        resp->window_set_caption_called = true;
     2141        resp->set_caption_wnd_id = wnd_id;
     2142        resp->set_caption_caption = str_dup(caption);
     2143
     2144        return resp->rc;
     2145}
     2146
    20202147static errno_t test_get_event(void *arg, sysarg_t *wnd_id,
    20212148    display_wnd_ev_t *event)
Note: See TracChangeset for help on using the changeset viewer.