Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r5d380b6 r5480d5e  
    11/*
    2  * Copyright (c) 2023 Jiri Svoboda
     2 * Copyright (c) 2019 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    6363        sysarg_t wnd_id;
    6464        ipc_call_t call;
    65         display_wnd_params_enc_t eparams;
    6665        display_wnd_params_t params;
    67         char *caption;
    6866        size_t size;
    6967        errno_t rc;
    … …  
    7573        }
    7674
    77         if (size != sizeof(display_wnd_params_enc_t)) {
     75        if (size != sizeof(display_wnd_params_t)) {
    7876                async_answer_0(&call, EINVAL);
    7977                async_answer_0(icall, EINVAL);
    … …  
    8179        }
    8280
    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);
     81        rc = async_data_write_finalize(&call, &params, size);
     82        if (rc != EOK) {
    11383                async_answer_0(&call, rc);
    11484                async_answer_0(icall, rc);
    … …  
    11787
    11888        if (srv->ops->window_create == NULL) {
    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;
    130         params.idev_id = eparams.idev_id;
     89                async_answer_0(icall, ENOTSUP);
     90                return;
     91        }
    13192
    13293        rc = srv->ops->window_create(srv->arg, &params, &wnd_id);
    … …  
    153114{
    154115        sysarg_t wnd_id;
    155         sysarg_t pos_id;
    156116        ipc_call_t call;
    157117        gfx_coord2_t pos;
    … …  
    160120
    161121        wnd_id = ipc_get_arg1(icall);
    162         pos_id = ipc_get_arg2(icall);
    163122
    164123        if (!async_data_write_receive(&call, &size)) {
    … …  
    186145        }
    187146
    188         rc = srv->ops->window_move_req(srv->arg, wnd_id, &pos, pos_id);
     147        rc = srv->ops->window_move_req(srv->arg, wnd_id, &pos);
    189148        async_answer_0(icall, rc);
    190149}
    … …  
    228187}
    229188
    230 static void display_window_get_pos_srv(display_srv_t *srv, ipc_call_t *icall)
    231 {
    232         sysarg_t wnd_id;
    233         ipc_call_t call;
    234         gfx_coord2_t dpos;
    235         size_t size;
    236         errno_t rc;
    237 
    238         wnd_id = ipc_get_arg1(icall);
    239 
    240         if (srv->ops->window_get_pos == NULL) {
    241                 async_answer_0(icall, ENOTSUP);
    242                 return;
    243         }
    244 
    245         if (!async_data_read_receive(&call, &size)) {
    246                 async_answer_0(&call, EREFUSED);
    247                 async_answer_0(icall, EREFUSED);
    248                 return;
    249         }
    250 
    251         rc = srv->ops->window_get_pos(srv->arg, wnd_id, &dpos);
    252         if (rc != EOK) {
    253                 async_answer_0(&call, rc);
    254                 async_answer_0(icall, rc);
     189static void display_window_resize_req_srv(display_srv_t *srv, ipc_call_t *icall)
     190{
     191        sysarg_t wnd_id;
     192        ipc_call_t call;
     193        display_wnd_rsztype_t rsztype;
     194        gfx_coord2_t pos;
     195        size_t size;
     196        errno_t rc;
     197
     198        wnd_id = ipc_get_arg1(icall);
     199        rsztype = (display_wnd_rsztype_t) ipc_get_arg2(icall);
     200
     201        if (!async_data_write_receive(&call, &size)) {
     202                async_answer_0(&call, EREFUSED);
     203                async_answer_0(icall, EREFUSED);
    255204                return;
    256205        }
    … …  
    262211        }
    263212
    264         rc = async_data_read_finalize(&call, &dpos, size);
    265         if (rc != EOK) {
    266                 async_answer_0(&call, rc);
    267                 async_answer_0(icall, rc);
    268                 return;
    269         }
    270 
    271         async_answer_0(icall, EOK);
    272 }
    273 
    274 static void display_window_get_max_rect_srv(display_srv_t *srv,
    275     ipc_call_t *icall)
    276 {
    277         sysarg_t wnd_id;
    278         ipc_call_t call;
    279         gfx_rect_t rect;
    280         size_t size;
    281         errno_t rc;
    282 
    283         wnd_id = ipc_get_arg1(icall);
    284 
    285         if (srv->ops->window_get_max_rect == NULL) {
    286                 async_answer_0(icall, ENOTSUP);
    287                 return;
    288         }
    289 
    290         if (!async_data_read_receive(&call, &size)) {
    291                 async_answer_0(&call, EREFUSED);
    292                 async_answer_0(icall, EREFUSED);
    293                 return;
    294         }
    295 
    296         rc = srv->ops->window_get_max_rect(srv->arg, wnd_id, &rect);
    297         if (rc != EOK) {
    298                 async_answer_0(&call, rc);
    299                 async_answer_0(icall, rc);
    300                 return;
    301         }
    302 
    303         if (size != sizeof(gfx_rect_t)) {
    304                 async_answer_0(&call, EINVAL);
    305                 async_answer_0(icall, EINVAL);
    306                 return;
    307         }
    308 
    309         rc = async_data_read_finalize(&call, &rect, size);
    310         if (rc != EOK) {
    311                 async_answer_0(&call, rc);
    312                 async_answer_0(icall, rc);
    313                 return;
    314         }
    315 
    316         async_answer_0(icall, EOK);
    317 }
    318 
    319 static void display_window_resize_req_srv(display_srv_t *srv, ipc_call_t *icall)
    320 {
    321         sysarg_t wnd_id;
    322         ipc_call_t call;
    323         display_wnd_rsztype_t rsztype;
    324         gfx_coord2_t pos;
    325         sysarg_t pos_id;
    326         size_t size;
    327         errno_t rc;
    328 
    329         wnd_id = ipc_get_arg1(icall);
    330         rsztype = (display_wnd_rsztype_t) ipc_get_arg2(icall);
    331         pos_id = ipc_get_arg3(icall);
    332 
    333         if (!async_data_write_receive(&call, &size)) {
    334                 async_answer_0(&call, EREFUSED);
    335                 async_answer_0(icall, EREFUSED);
    336                 return;
    337         }
    338 
    339         if (size != sizeof(gfx_coord2_t)) {
    340                 async_answer_0(&call, EINVAL);
    341                 async_answer_0(icall, EINVAL);
    342                 return;
    343         }
    344 
    345213        rc = async_data_write_finalize(&call, &pos, size);
    346214        if (rc != EOK) {
    … …  
    355223        }
    356224
    357         rc = srv->ops->window_resize_req(srv->arg, wnd_id, rsztype, &pos,
    358             pos_id);
     225        rc = srv->ops->window_resize_req(srv->arg, wnd_id, rsztype, &pos);
    359226        async_answer_0(icall, rc);
    360227}
    … …  
    399266}
    400267
    401 static void display_window_minimize_srv(display_srv_t *srv, ipc_call_t *icall)
    402 {
    403         sysarg_t wnd_id;
    404         errno_t rc;
    405 
    406         wnd_id = ipc_get_arg1(icall);
    407 
    408         if (srv->ops->window_minimize == NULL) {
    409                 async_answer_0(icall, ENOTSUP);
    410                 return;
    411         }
    412 
    413         rc = srv->ops->window_minimize(srv->arg, wnd_id);
    414         async_answer_0(icall, rc);
    415 }
    416 
    417 static void display_window_maximize_srv(display_srv_t *srv, ipc_call_t *icall)
    418 {
    419         sysarg_t wnd_id;
    420         errno_t rc;
    421 
    422         wnd_id = ipc_get_arg1(icall);
    423 
    424         if (srv->ops->window_maximize == NULL) {
    425                 async_answer_0(icall, ENOTSUP);
    426                 return;
    427         }
    428 
    429         rc = srv->ops->window_maximize(srv->arg, wnd_id);
    430         async_answer_0(icall, rc);
    431 }
    432 
    433 static void display_window_unmaximize_srv(display_srv_t *srv, ipc_call_t *icall)
    434 {
    435         sysarg_t wnd_id;
    436         errno_t rc;
    437 
    438         wnd_id = ipc_get_arg1(icall);
    439 
    440         if (srv->ops->window_unmaximize == NULL) {
    441                 async_answer_0(icall, ENOTSUP);
    442                 return;
    443         }
    444 
    445         rc = srv->ops->window_unmaximize(srv->arg, wnd_id);
    446         async_answer_0(icall, rc);
    447 }
    448 
    449268static void display_window_set_cursor_srv(display_srv_t *srv, ipc_call_t *icall)
    450269{
    … …  
    463282        rc = srv->ops->window_set_cursor(srv->arg, wnd_id, cursor);
    464283        async_answer_0(icall, rc);
    465 }
    466 
    467 static void display_window_set_caption_srv(display_srv_t *srv,
    468     ipc_call_t *icall)
    469 {
    470         sysarg_t wnd_id;
    471         ipc_call_t call;
    472         char *caption;
    473         size_t size;
    474         errno_t rc;
    475 
    476         wnd_id = ipc_get_arg1(icall);
    477 
    478         if (!async_data_write_receive(&call, &size)) {
    479                 async_answer_0(&call, EREFUSED);
    480                 async_answer_0(icall, EREFUSED);
    481                 return;
    482         }
    483 
    484         caption = calloc(size + 1, 1);
    485         if (caption == NULL) {
    486                 async_answer_0(&call, ENOMEM);
    487                 async_answer_0(icall, ENOMEM);
    488                 return;
    489         }
    490 
    491         rc = async_data_write_finalize(&call, caption, size);
    492         if (rc != EOK) {
    493                 free(caption);
    494                 async_answer_0(&call, rc);
    495                 async_answer_0(icall, rc);
    496                 return;
    497         }
    498 
    499         if (srv->ops->window_set_caption == NULL) {
    500                 free(caption);
    501                 async_answer_0(icall, ENOTSUP);
    502                 return;
    503         }
    504 
    505         rc = srv->ops->window_set_caption(srv->arg, wnd_id, caption);
    506         async_answer_0(icall, rc);
    507         free(caption);
    508284}
    509285
    … …  
    529305        /* Transfer event data */
    530306        if (!async_data_read_receive(&call, &size)) {
    531                 async_answer_0(&call, EREFUSED);
    532307                async_answer_0(icall, EREFUSED);
    533308                return;
    … …  
    564339        /* Transfer information */
    565340        if (!async_data_read_receive(&call, &size)) {
    566                 async_answer_0(&call, EREFUSED);
    567341                async_answer_0(icall, EREFUSED);
    568342                return;
    … …  
    625399                        display_window_move_srv(srv, &call);
    626400                        break;
    627                 case DISPLAY_WINDOW_GET_POS:
    628                         display_window_get_pos_srv(srv, &call);
    629                         break;
    630                 case DISPLAY_WINDOW_GET_MAX_RECT:
    631                         display_window_get_max_rect_srv(srv, &call);
    632                         break;
    633401                case DISPLAY_WINDOW_RESIZE_REQ:
    634402                        display_window_resize_req_srv(srv, &call);
    … …  
    637405                        display_window_resize_srv(srv, &call);
    638406                        break;
    639                 case DISPLAY_WINDOW_MINIMIZE:
    640                         display_window_minimize_srv(srv, &call);
    641                         break;
    642                 case DISPLAY_WINDOW_MAXIMIZE:
    643                         display_window_maximize_srv(srv, &call);
    644                         break;
    645                 case DISPLAY_WINDOW_UNMAXIMIZE:
    646                         display_window_unmaximize_srv(srv, &call);
    647                         break;
    648407                case DISPLAY_WINDOW_SET_CURSOR:
    649408                        display_window_set_cursor_srv(srv, &call);
    650                         break;
    651                 case DISPLAY_WINDOW_SET_CAPTION:
    652                         display_window_set_caption_srv(srv, &call);
    653409                        break;
    654410                case DISPLAY_GET_EVENT:
Note: See TracChangeset for help on using the changeset viewer.