Changeset c0757e1f in mainline for uspace/lib


Ignore:
Timestamp:
2023-04-19T11:13:06Z (3 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
master, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
37087c8
Parents:
ec8ef12
Message:

UI display configuration utility

In addition to the command-line utility 'disp', we introduce its UI
equivalent 'display-cfg'. Currently this allows the user to configure
seats in a very comfortable way.

Location:
uspace/lib
Files:
5 added
21 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/dispcfg/include/dispcfg.h

    rec8ef12 rc0757e1f  
    5151extern errno_t dispcfg_dev_assign(dispcfg_t *, sysarg_t, sysarg_t);
    5252extern errno_t dispcfg_dev_unassign(dispcfg_t *, sysarg_t);
     53extern errno_t dispcfg_get_asgn_dev_list(dispcfg_t *, sysarg_t,
     54    dispcfg_dev_list_t **);
     55extern void dispcfg_free_dev_list(dispcfg_dev_list_t *);
    5356
    5457#endif

  • uspace/lib/dispcfg/include/dispcfg_srv.h

    rec8ef12 rc0757e1f  
    5656        errno_t (*dev_assign)(void *, sysarg_t, sysarg_t);
    5757        errno_t (*dev_unassign)(void *, sysarg_t);
     58        errno_t (*get_asgn_dev_list)(void *, sysarg_t, dispcfg_dev_list_t **);
    5859        errno_t (*get_event)(void *, dispcfg_ev_t *);
    5960};

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

    rec8ef12 rc0757e1f  
    4646        DISPCFG_DEV_ASSIGN,
    4747        DISPCFG_DEV_UNASSIGN,
     48        DISPCFG_GET_ASGN_DEV_LIST,
    4849        DISPCFG_GET_EVENT,
    4950} dispcfg_request_t;

  • uspace/lib/dispcfg/include/types/dispcfg.h

    rec8ef12 rc0757e1f  
    8585} dispcfg_seat_info_t;
    8686
     87/** Assigned device list */
     88typedef struct {
     89        /** Number of devices */
     90        size_t ndevs;
     91        /** ID for each device */
     92        sysarg_t *devs;
     93} dispcfg_dev_list_t;
     94
    8795#endif
    8896

  • uspace/lib/dispcfg/src/dispcfg.c

    rec8ef12 rc0757e1f  
    206206/** Free seat list.
    207207 *
    208  * @param list Display configuration list
     208 * @param list Seat list
    209209 */
    210210void dispcfg_free_seat_list(dispcfg_seat_list_t *list)
    … …  
    277277/** Free seat information.
    278278 *
    279  * @param info Display configuration information
     279 * @param info Seat information
    280280 */
    281281void dispcfg_free_seat_info(dispcfg_seat_info_t *info)
    … …  
    378378        async_exchange_end(exch);
    379379        return rc;
     380}
     381
     382/** Get list of devices assigned to a seat.
     383 *
     384 * @param dispcfg Display configuration
     385 * @param seat_id Seat ID
     386 * @param rlist Place to store pointer to new device list structure
     387 * @return EOK on success or an error code
     388 */
     389errno_t dispcfg_get_asgn_dev_list(dispcfg_t *dispcfg, sysarg_t seat_id,
     390    dispcfg_dev_list_t **rlist)
     391{
     392        async_exch_t *exch;
     393        aid_t req;
     394        ipc_call_t answer;
     395        dispcfg_dev_list_t *list;
     396        sysarg_t ndevs;
     397        sysarg_t *devs;
     398        errno_t rc;
     399
     400        exch = async_exchange_begin(dispcfg->sess);
     401        req = async_send_1(exch, DISPCFG_GET_ASGN_DEV_LIST, seat_id, &answer);
     402
     403        /* Receive device list length */
     404        rc = async_data_read_start(exch, &ndevs, sizeof (ndevs));
     405        if (rc != EOK) {
     406                async_exchange_end(exch);
     407                async_wait_for(req, &rc);
     408                return rc;
     409        }
     410
     411        devs = calloc(ndevs, sizeof(sysarg_t));
     412        if (devs == NULL) {
     413                async_exchange_end(exch);
     414                async_forget(req);
     415                return ENOMEM;
     416        }
     417
     418        /* Receive device list */
     419        rc = async_data_read_start(exch, devs, ndevs * sizeof (sysarg_t));
     420        async_exchange_end(exch);
     421
     422        if (rc != EOK) {
     423                async_forget(req);
     424                return rc;
     425        }
     426
     427        async_wait_for(req, &rc);
     428        if (rc != EOK)
     429                return rc;
     430
     431        list = calloc(1, sizeof(dispcfg_dev_list_t));
     432        if (list == NULL)
     433                return ENOMEM;
     434
     435        list->ndevs = ndevs;
     436        list->devs = devs;
     437        *rlist = list;
     438        return EOK;
     439}
     440
     441/** Free device list.
     442 *
     443 * @param list Device list
     444 */
     445void dispcfg_free_dev_list(dispcfg_dev_list_t *list)
     446{
     447        free(list->devs);
     448        free(list);
    380449}
    381450

  • uspace/lib/dispcfg/src/dispcfg_srv.c

    rec8ef12 rc0757e1f  
    293293}
    294294
     295static void dispcfg_get_asgn_dev_list_srv(dispcfg_srv_t *srv, ipc_call_t *icall)
     296{
     297        sysarg_t seat_id;
     298        ipc_call_t call;
     299        dispcfg_dev_list_t *list = NULL;
     300        size_t size;
     301        errno_t rc;
     302
     303        seat_id = ipc_get_arg1(icall);
     304
     305        if (srv->ops->get_asgn_dev_list == NULL) {
     306                async_answer_0(icall, ENOTSUP);
     307                return;
     308        }
     309
     310        rc = srv->ops->get_asgn_dev_list(srv->arg, seat_id, &list);
     311        if (rc != EOK) {
     312                async_answer_0(icall, rc);
     313                return;
     314        }
     315
     316        /* Send list size */
     317
     318        if (!async_data_read_receive(&call, &size)) {
     319                dispcfg_free_dev_list(list);
     320                async_answer_0(&call, EREFUSED);
     321                async_answer_0(icall, EREFUSED);
     322                return;
     323        }
     324
     325        if (size != sizeof(list->ndevs)) {
     326                dispcfg_free_dev_list(list);
     327                async_answer_0(&call, EINVAL);
     328                async_answer_0(icall, EINVAL);
     329                return;
     330        }
     331
     332        rc = async_data_read_finalize(&call, &list->ndevs, size);
     333        if (rc != EOK) {
     334                dispcfg_free_dev_list(list);
     335                async_answer_0(&call, rc);
     336                async_answer_0(icall, rc);
     337                return;
     338        }
     339
     340        /* Send device list */
     341
     342        if (!async_data_read_receive(&call, &size)) {
     343                dispcfg_free_dev_list(list);
     344                async_answer_0(&call, EREFUSED);
     345                async_answer_0(icall, EREFUSED);
     346                return;
     347        }
     348
     349        if (size != list->ndevs * sizeof(sysarg_t)) {
     350                dispcfg_free_dev_list(list);
     351                async_answer_0(&call, EINVAL);
     352                async_answer_0(icall, EINVAL);
     353                return;
     354        }
     355
     356        rc = async_data_read_finalize(&call, list->devs, size);
     357        if (rc != EOK) {
     358                dispcfg_free_dev_list(list);
     359                async_answer_0(&call, rc);
     360                async_answer_0(icall, rc);
     361                return;
     362        }
     363
     364        async_answer_0(icall, EOK);
     365        dispcfg_free_dev_list(list);
     366}
     367
    295368static void dispcfg_get_event_srv(dispcfg_srv_t *srv, ipc_call_t *icall)
    296369{
    … …  
    372445                case DISPCFG_DEV_UNASSIGN:
    373446                        dispcfg_dev_unassign_srv(srv, &call);
     447                        break;
     448                case DISPCFG_GET_ASGN_DEV_LIST:
     449                        dispcfg_get_asgn_dev_list_srv(srv, &call);
    374450                        break;
    375451                case DISPCFG_GET_EVENT:

  • uspace/lib/dispcfg/test/dispcfg.c

    rec8ef12 rc0757e1f  
    5252static errno_t test_dev_assign(void *, sysarg_t, sysarg_t);
    5353static errno_t test_dev_unassign(void *, sysarg_t);
     54static errno_t test_get_asgn_dev_list(void *, sysarg_t, dispcfg_dev_list_t **);
    5455static errno_t test_get_event(void *, dispcfg_ev_t *);
    5556
    … …  
    6465        .dev_assign = test_dev_assign,
    6566        .dev_unassign = test_dev_unassign,
     67        .get_asgn_dev_list = test_get_asgn_dev_list,
    6668        .get_event = test_get_event
    6769};
    … …  
    102104        bool dev_unassign_called;
    103105        sysarg_t dev_unassign_svc_id;
     106
     107        bool get_asgn_dev_list_called;
     108        sysarg_t get_asgn_dev_list_seat_id;
     109        dispcfg_dev_list_t *get_asgn_dev_list_rlist;
    104110
    105111        bool get_event_called;
    … …  
    604610}
    605611
     612/** dispcfg_get_asgn_dev_list() with server returning error response works */
     613PCUT_TEST(get_asgn_dev_list_failure)
     614{
     615        errno_t rc;
     616        service_id_t sid;
     617        dispcfg_t *dispcfg = NULL;
     618        dispcfg_dev_list_t *list;
     619        sysarg_t seat_id;
     620        test_response_t resp;
     621
     622        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     623
     624        // FIXME This causes this test to be non-reentrant!
     625        rc = loc_server_register(test_dispcfg_server);
     626        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     627
     628        rc = loc_service_register(test_dispcfg_svc, &sid);
     629        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     630
     631        rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
     632        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     633        PCUT_ASSERT_NOT_NULL(dispcfg);
     634
     635        resp.rc = ENOMEM;
     636        resp.get_asgn_dev_list_called = false;
     637        seat_id = 42;
     638
     639        rc = dispcfg_get_asgn_dev_list(dispcfg, seat_id, &list);
     640        PCUT_ASSERT_TRUE(resp.get_asgn_dev_list_called);
     641        PCUT_ASSERT_INT_EQUALS(seat_id, resp.get_asgn_dev_list_seat_id);
     642        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
     643
     644        dispcfg_close(dispcfg);
     645        rc = loc_service_unregister(sid);
     646        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     647}
     648
     649/** dispcfg_get_asgn_dev_list() with server returning success response works */
     650PCUT_TEST(get_asgn_dev_list_success)
     651{
     652        errno_t rc;
     653        service_id_t sid;
     654        dispcfg_t *dispcfg = NULL;
     655        dispcfg_dev_list_t *list;
     656        sysarg_t seat_id;
     657        test_response_t resp;
     658
     659        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     660
     661        // FIXME This causes this test to be non-reentrant!
     662        rc = loc_server_register(test_dispcfg_server);
     663        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     664
     665        rc = loc_service_register(test_dispcfg_svc, &sid);
     666        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     667
     668        rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
     669        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     670        PCUT_ASSERT_NOT_NULL(dispcfg);
     671
     672        resp.rc = EOK;
     673        resp.get_asgn_dev_list_called = false;
     674        resp.get_asgn_dev_list_rlist = calloc(1, sizeof(dispcfg_dev_list_t));
     675        PCUT_ASSERT_NOT_NULL(resp.get_asgn_dev_list_rlist);
     676        resp.get_asgn_dev_list_rlist->ndevs = 2;
     677        resp.get_asgn_dev_list_rlist->devs = calloc(2, sizeof(sysarg_t));
     678        PCUT_ASSERT_NOT_NULL(resp.get_asgn_dev_list_rlist->devs);
     679        resp.get_asgn_dev_list_rlist->devs[0] = 11;
     680        resp.get_asgn_dev_list_rlist->devs[1] = 12;
     681        seat_id = 42;
     682
     683        rc = dispcfg_get_asgn_dev_list(dispcfg, seat_id, &list);
     684        PCUT_ASSERT_TRUE(resp.get_asgn_dev_list_called);
     685        PCUT_ASSERT_INT_EQUALS(seat_id, resp.get_asgn_dev_list_seat_id);
     686        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
     687
     688        PCUT_ASSERT_INT_EQUALS(2, list->ndevs);
     689        PCUT_ASSERT_INT_EQUALS(11, list->devs[0]);
     690        PCUT_ASSERT_INT_EQUALS(12, list->devs[1]);
     691
     692        dispcfg_free_dev_list(list);
     693        dispcfg_close(dispcfg);
     694        rc = loc_service_unregister(sid);
     695        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     696}
     697
    606698/** Window added event can be delivered from server to client callback function */
    607699PCUT_TEST(seat_added_deliver)
    … …  
    808900}
    809901
     902static errno_t test_get_asgn_dev_list(void *arg, sysarg_t seat_id,
     903    dispcfg_dev_list_t **rlist)
     904{
     905        test_response_t *resp = (test_response_t *) arg;
     906
     907        resp->get_asgn_dev_list_called = true;
     908        resp->get_asgn_dev_list_seat_id = seat_id;
     909
     910        if (resp->rc != EOK)
     911                return resp->rc;
     912
     913        *rlist = resp->get_asgn_dev_list_rlist;
     914        return EOK;
     915}
     916
    810917static errno_t test_get_event(void *arg, dispcfg_ev_t *event)
    811918{

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

    rec8ef12 rc0757e1f  
    5454extern const char *ui_entry_get_text(ui_entry_t *);
    5555extern errno_t ui_entry_paint(ui_entry_t *);
     56extern errno_t ui_entry_insert_str(ui_entry_t *, const char *);
    5657extern void ui_entry_activate(ui_entry_t *);
    5758extern void ui_entry_deactivate(ui_entry_t *);

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

    rec8ef12 rc0757e1f  
    4848extern ui_control_t *ui_list_ctl(ui_list_t *);
    4949extern void ui_list_set_cb(ui_list_t *, ui_list_cb_t *, void *);
     50extern void *ui_list_get_cb_arg(ui_list_t *);
    5051extern void ui_list_set_rect(ui_list_t *, gfx_rect_t *);
    5152extern errno_t ui_list_activate(ui_list_t *);
    5253extern void ui_list_deactivate(ui_list_t *);
    5354extern ui_list_entry_t *ui_list_get_cursor(ui_list_t *);
     55extern void ui_list_set_cursor(ui_list_t *, ui_list_entry_t *);
    5456extern void ui_list_entry_attr_init(ui_list_entry_attr_t *);
    5557extern errno_t ui_list_entry_append(ui_list_t *,
    … …  
    5759extern void ui_list_entry_delete(ui_list_entry_t *);
    5860extern void *ui_list_entry_get_arg(ui_list_entry_t *);
     61extern ui_list_t *ui_list_entry_get_list(ui_list_entry_t *);
    5962extern size_t ui_list_entries_cnt(ui_list_t *);
    6063extern errno_t ui_list_sort(ui_list_t *);

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

    rec8ef12 rc0757e1f  
    4343#include <stdbool.h>
    4444#include <types/common.h>
     45#include <types/ui/control.h>
    4546#include <types/ui/tab.h>
    4647#include <types/ui/tabset.h>

  • uspace/lib/ui/meson.build

    rec8ef12 rc0757e1f  
    5252        'src/resource.c',
    5353        'src/scrollbar.c',
     54        'src/selectdialog.c',
    5455        'src/slider.c',
    5556        'src/tab.c',
    … …  
    8586        'test/resource.c',
    8687        'test/scrollbar.c',
     88        'test/selectdialog.c',
    8789        'test/slider.c',
    8890        'test/tab.c',

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

    rec8ef12 rc0757e1f  
    9292} ui_entry_geom_t;
    9393
    94 extern errno_t ui_entry_insert_str(ui_entry_t *, const char *);
    9594extern ui_evclaim_t ui_entry_key_press_ctrl(ui_entry_t *, kbd_event_t *);
    9695extern ui_evclaim_t ui_entry_key_press_shift(ui_entry_t *, kbd_event_t *);

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

    rec8ef12 rc0757e1f  
    103103
    104104extern bool ui_file_list_is_active(ui_file_list_t *);
    105 extern void ui_file_list_entry_delete(ui_file_list_entry_t *);
     105extern void ui_file_list_entry_destroy(ui_file_list_entry_t *);
    106106extern void ui_file_list_clear_entries(ui_file_list_t *);
    107107extern errno_t ui_file_list_sort(ui_file_list_t *);

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

    rec8ef12 rc0757e1f  
    136136extern int ui_list_entry_ptr_cmp(const void *, const void *);
    137137extern size_t ui_list_entry_get_idx(ui_list_entry_t *);
     138extern void ui_list_entry_destroy(ui_list_entry_t *);
    138139
    139140#endif

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

    rec8ef12 rc0757e1f  
    4545        /** Dialog window */
    4646        struct ui_window *window;
    47         /** File name entry */
     47        /** Text entry */
    4848        struct ui_entry *ename;
    4949        /** OK button */

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

    rec8ef12 rc0757e1f  
    4646#include <qsort.h>
    4747#include "../private/filelist.h"
     48#include "../private/list.h"
    4849#include "../private/resource.h"
    4950
    … …  
    290291 * @param entry File list entry
    291292 */
    292 void ui_file_list_entry_delete(ui_file_list_entry_t *entry)
    293 {
    294         ui_list_entry_delete(entry->entry);
     293void ui_file_list_entry_destroy(ui_file_list_entry_t *entry)
     294{
     295        ui_list_entry_destroy(entry->entry);
    295296        free(entry->name);
    296297        free(entry);
    … …  
    307308        entry = ui_file_list_first(flist);
    308309        while (entry != NULL) {
    309                 ui_file_list_entry_delete(entry);
     310                ui_file_list_entry_destroy(entry);
    310311                entry = ui_file_list_first(flist);
    311312        }

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

    rec8ef12 rc0757e1f  
    149149        list->cb = cb;
    150150        list->cb_arg = arg;
     151}
     152
     153/** Get UI list callback argument.
     154 *
     155 * @param list UI list
     156 * @return Callback argument
     157 */
     158void *ui_list_get_cb_arg(ui_list_t *list)
     159{
     160        return list->cb_arg;
    151161}
    152162
    … …  
    701711}
    702712
    703 /** Delete UI list entry.
     713/** Destroy UI list entry.
     714 *
     715 * This is the quick way, but does not update cursor or page position.
    704716 *
    705717 * @param entry UI list entry
    706718 */
    707 void ui_list_entry_delete(ui_list_entry_t *entry)
     719void ui_list_entry_destroy(ui_list_entry_t *entry)
    708720{
    709721        if (entry->list->cursor == entry)
    … …  
    718730}
    719731
     732/** Delete UI list entry.
     733 *
     734 * If required, update cursor and page position and repaint.
     735 *
     736 * @param entry UI list entry
     737 */
     738void ui_list_entry_delete(ui_list_entry_t *entry)
     739{
     740        /* Try to make sure entry does not disappear between cursor and page */
     741        if (entry->list->cursor == entry)
     742                ui_list_cursor_up(entry->list);
     743        if (entry->list->cursor == entry)
     744                ui_list_cursor_down(entry->list);
     745        if (entry->list->page == entry)
     746                ui_list_scroll_up(entry->list);
     747        if (entry->list->page == entry)
     748                ui_list_scroll_down(entry->list);
     749
     750        ui_list_entry_destroy(entry);
     751}
     752
    720753/** Get entry argument.
    721754 *
    … …  
    728761}
    729762
     763/** Get containing list.
     764 *
     765 * @param entry UI list entry
     766 * @return Containing list
     767 */
     768ui_list_t *ui_list_entry_get_list(ui_list_entry_t *entry)
     769{
     770        return entry->list;
     771}
     772
    730773/** Clear UI list entry list.
    731774 *
    … …  
    738781        entry = ui_list_first(list);
    739782        while (entry != NULL) {
    740                 ui_list_entry_delete(entry);
     783                ui_list_entry_destroy(entry);
    741784                entry = ui_list_first(list);
    742785        }
    … …  
    858901{
    859902        return list->cursor;
     903}
     904
     905/** Set new cursor position.
     906 *
     907 * O(N) in list size, use with caution.
     908 *
     909 * @param list UI list
     910 * @param entry New cursor position
     911 */
     912void ui_list_set_cursor(ui_list_t *list, ui_list_entry_t *entry)
     913{
     914        size_t idx;
     915
     916        idx = ui_list_entry_get_idx(entry);
     917        ui_list_cursor_move(list, entry, idx);
    860918}
    861919
    … …  
    912970                                /* Find first page entry (go back rows - 1) */
    913971                                e = entry;
    914                                 for (i = 0; i < rows - 1; i++) {
     972                                for (i = 0; i + 1 < rows; i++) {
    915973                                        e = ui_list_prev(e);
    916974                                }
    … …  
    10981156        ui_list_entry_t *prev;
    10991157
     1158        if (list->page == NULL)
     1159                return;
     1160
    11001161        prev = ui_list_prev(list->page);
    11011162        if (prev == NULL)
    … …  
    11201181        size_t i;
    11211182        size_t rows;
     1183
     1184        if (list->page == NULL)
     1185                return;
    11221186
    11231187        next = ui_list_next(list->page);

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

    rec8ef12 rc0757e1f  
    327327{
    328328        ui_prompt_dialog_t *dialog = (ui_prompt_dialog_t *) arg;
    329         const char *fname;
     329        const char *text;
    330330
    331331        if (event->type == KEY_PRESS &&
    … …  
    334334                        /* Confirm */
    335335                        if (dialog->cb != NULL && dialog->cb->bok != NULL) {
    336                                 fname = ui_entry_get_text(dialog->ename);
    337                                 dialog->cb->bok(dialog, dialog->arg, fname);
     336                                text = ui_entry_get_text(dialog->ename);
     337                                dialog->cb->bok(dialog, dialog->arg, text);
    338338                                return;
    339339                        }
    … …  
    358358{
    359359        ui_prompt_dialog_t *dialog = (ui_prompt_dialog_t *) arg;
    360         const char *fname;
     360        const char *text;
    361361
    362362        if (dialog->cb != NULL && dialog->cb->bok != NULL) {
    363                 fname = ui_entry_get_text(dialog->ename);
    364                 dialog->cb->bok(dialog, dialog->arg, fname);
     363                text = ui_entry_get_text(dialog->ename);
     364                dialog->cb->bok(dialog, dialog->arg, text);
    365365        }
    366366}

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

    rec8ef12 rc0757e1f  
    350350}
    351351
    352 /** ui_file_list_entry_delete() deletes entry */
    353 PCUT_TEST(entry_delete)
     352/** ui_file_list_entry_destroy() destroys entry */
     353PCUT_TEST(entry_destroy)
    354354{
    355355        ui_t *ui;
    … …  
    386386
    387387        entry = ui_file_list_first(flist);
    388         ui_file_list_entry_delete(entry);
     388        ui_file_list_entry_destroy(entry);
    389389
    390390        PCUT_ASSERT_INT_EQUALS(1, ui_list_entries_cnt(flist->list));
    391391
    392392        entry = ui_file_list_first(flist);
    393         ui_file_list_entry_delete(entry);
     393        ui_file_list_entry_destroy(entry);
    394394
    395395        PCUT_ASSERT_INT_EQUALS(0, ui_list_entries_cnt(flist->list));

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

    rec8ef12 rc0757e1f  
    119119}
    120120
     121//XXX
     122PCUT_TEST(get_cb_arg)
     123{
     124}
     125
    121126/** ui_list_entry_height() gives the correct height */
    122127PCUT_TEST(entry_height)
    … …  
    751756}
    752757
     758//XXX TODO
     759PCUT_TEST(set_cursor)
     760{
     761}
     762
    753763/** ui_list_entry_attr_init() initializes entry attribute structure */
    754764PCUT_TEST(entry_attr_init)
    … …  
    902912        ui_window_destroy(window);
    903913        ui_destroy(ui);
     914}
     915
     916//XXX
     917PCUT_TEST(entry_get_list)
     918{
    904919}
    905920

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

    rec8ef12 rc0757e1f  
    5252PCUT_IMPORT(resource);
    5353PCUT_IMPORT(scrollbar);
     54PCUT_IMPORT(select_dialog);
    5455PCUT_IMPORT(slider);
    5556PCUT_IMPORT(tab);
    … …  
    5960PCUT_IMPORT(wdecor);
    6061PCUT_IMPORT(window);
     62
    6163PCUT_MAIN();
Note: See TracChangeset for help on using the changeset viewer.