Changeset 806d761 in mainline


Ignore:
Timestamp:
2024-02-07T23:44:59Z (3 months ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
master
Children:
242e3c3
Parents:
74cb6610
Message:

Start menu should have 'open in terminal' functionality

Makes it easier for the user and if we are running in console mode,
we correctly start the application, instead of failing to start a
terminal.

Location:
uspace
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/taskbar-cfg/smeedit.c

    r74cb6610 r806d761  
    11/*
    2  * Copyright (c) 2023 Jiri Svoboda
     2 * Copyright (c) 2024 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    3636#include <stdio.h>
    3737#include <stdlib.h>
     38#include <ui/checkbox.h>
    3839#include <ui/fixed.h>
    3940#include <ui/resource.h>
    … …  
    9495        const char *cmd;
    9596        const char *caption;
     97        bool terminal;
    9698        errno_t rc;
    9799
    … …  
    101103                cmd = smenu_entry_get_cmd(smentry->entry);
    102104                caption = smenu_entry_get_caption(smentry->entry);
     105                terminal = smenu_entry_get_terminal(smentry->entry);
    103106        } else {
    104107                cmd = "";
    105108                caption = "";
     109                terminal = false;
    106110        }
    107111
    … …  
    122126                params.rect.p0.y = 0;
    123127                params.rect.p1.x = 50;
    124                 params.rect.p1.y = 12;
     128                params.rect.p1.y = 13;
    125129        } else {
    126130                params.rect.p0.x = 0;
    127131                params.rect.p0.y = 0;
    128132                params.rect.p1.x = 370;
    129                 params.rect.p1.y = 200;
     133                params.rect.p1.y = 230;
    130134        }
    131135
    … …  
    255259        }
    256260
     261        /* Start in terminal checkbox */
     262
     263        rc = ui_checkbox_create(res, "Start in terminal", &smee->cbterminal);
     264        if (rc != EOK)
     265                goto error;
     266
     267        /* FIXME: Auto layout */
     268        if (ui_is_textmode(ui)) {
     269                rect.p0.x = 3;
     270                rect.p0.y = 8;
     271                rect.p1.x = 6;
     272                rect.p1.y = 9;
     273        } else {
     274                rect.p0.x = 10;
     275                rect.p0.y = 155;
     276                rect.p1.x = 360;
     277                rect.p1.y = 170;
     278        }
     279
     280        ui_checkbox_set_rect(smee->cbterminal, &rect);
     281        ui_checkbox_set_checked(smee->cbterminal, terminal);
     282
     283        rc = ui_fixed_add(smee->fixed, ui_checkbox_ctl(smee->cbterminal));
     284        if (rc != EOK) {
     285                printf("Error adding control to layout.\n");
     286                goto error;
     287        }
     288
    257289        /* OK button */
    258290
    … …  
    264296        if (ui_is_textmode(ui)) {
    265297                rect.p0.x = 23;
    266                 rect.p0.y = 9;
     298                rect.p0.y = 10;
    267299                rect.p1.x = 35;
    268                 rect.p1.y = 10;
     300                rect.p1.y = 11;
    269301        } else {
    270302                rect.p0.x = 190;
    271                 rect.p0.y = 155;
     303                rect.p0.y = 190;
    272304                rect.p1.x = 270;
    273                 rect.p1.y = 180;
     305                rect.p1.y = 215;
    274306        }
    275307
    … …  
    293325        if (ui_is_textmode(ui)) {
    294326                rect.p0.x = 36;
    295                 rect.p0.y = 9;
     327                rect.p0.y = 10;
    296328                rect.p1.x = 48;
    297                 rect.p1.y = 10;
     329                rect.p1.y = 11;
    298330        } else {
    299331                rect.p0.x = 280;
    300                 rect.p0.y = 155;
     332                rect.p0.y = 190;
    301333                rect.p1.x = 360;
    302                 rect.p1.y = 180;
     334                rect.p1.y = 215;
    303335        }
    304336
    … …  
    349381        const char *cmd;
    350382        const char *caption;
     383        bool terminal;
    351384        errno_t rc;
    352385
    … …  
    356389        cmd = ui_entry_get_text(smee->ecmd);
    357390        caption = ui_entry_get_text(smee->ecaption);
     391        terminal = ui_checkbox_get_checked(smee->cbterminal);
    358392
    359393        if (smee->smentry == NULL) {
    360394                /* Create new entry */
    361395                rc = smenu_entry_create(smee->startmenu->tbarcfg->tbarcfg,
    362                     caption, cmd, &entry);
     396                    caption, cmd, terminal, &entry);
    363397                if (rc != EOK)
    364398                        return;
    … …  
    379413                        return;
    380414
     415                smenu_entry_set_terminal(smee->smentry->entry, terminal);
     416                if (rc != EOK)
     417                        return;
     418
    381419                (void)smenu_entry_save(smee->smentry->entry);
    382420                startmenu_entry_update(smee->smentry);

  • uspace/app/taskbar-cfg/types/smeedit.h

    r74cb6610 r806d761  
    11/*
    2  * Copyright (c) 2023 Jiri Svoboda
     2 * Copyright (c) 2024 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    3737#define TYPES_SMEEDIT_H
    3838
     39#include <ui/checkbox.h>
    3940#include <ui/fixed.h>
    4041#include <ui/label.h>
    … …  
    6162        /** Command entry */
    6263        ui_entry_t *ecmd;
    63         /** OK buttion */
     64        /** Start in terminal checkbox */
     65        ui_checkbox_t *cbterminal;
     66        /** OK button */
    6467        ui_pbutton_t *bok;
    6568        /** Cancel button */

  • uspace/app/taskbar/taskbar.sif

    r74cb6610 r806d761  
    1 [sif](){[entries](){[entry]([caption]=[~N~avigator][cmd]=[/app/terminal -c /app/nav]){}[entry]([caption]=[Text ~E~ditor][cmd]=[/app/terminal -c /app/edit]){}[entry]([caption]=[~T~erminal][cmd]=[/app/terminal]){}[entry]([caption]=[~C~alculator][cmd]=[/app/calculator]){}[entry]([caption]=[~U~I Demo][cmd]=[/app/uidemo]){}[entry]([caption]=[~G~FX Demo][cmd]=[/app/gfxdemo ui]){}}}
     1[sif](){[entries](){[entry]([caption]=[~N~avigator][cmd]=[/app/nav][terminal]=[y]){}[entry]([caption]=[Text ~E~ditor][cmd]=[/app/edit][terminal]=[y]){}[entry]([caption]=[~T~erminal][cmd]=[/app/terminal][terminal]=[n]){}[entry]([caption]=[~C~alculator][cmd]=[/app/calculator][terminal]=[n]){}[entry]([caption]=[~U~I Demo][cmd]=[/app/uidemo][terminal]=[n]){}[entry]([caption]=[~G~FX Demo][cmd]=[/app/gfxdemo ui][terminal]=[n]){}}}

  • uspace/app/taskbar/tbsmenu.c

    r74cb6610 r806d761  
    11/*
    2  * Copyright (c) 2023 Jiri Svoboda
     2 * Copyright (c) 2024 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    131131        const char *caption;
    132132        const char *cmd;
     133        bool terminal;
    133134        errno_t rc;
    134135
    … …  
    141142                caption = smenu_entry_get_caption(sme);
    142143                cmd = smenu_entry_get_cmd(sme);
    143 
    144                 rc = tbsmenu_add(tbsmenu, caption, cmd, &tentry);
     144                terminal = smenu_entry_get_terminal(sme);
     145
     146                rc = tbsmenu_add(tbsmenu, caption, cmd, terminal, &tentry);
    145147                if (rc != EOK)
    146148                        goto error;
    … …  
    226228 * @param caption Caption
    227229 * @param cmd Command to run
     230 * @param terminal Start in terminal
    228231 * @param entry Start menu entry
    229232 * @return @c EOK on success or an error code
    230233 */
    231234errno_t tbsmenu_add(tbsmenu_t *tbsmenu, const char *caption,
    232     const char *cmd, tbsmenu_entry_t **rentry)
     235    const char *cmd, bool terminal, tbsmenu_entry_t **rentry)
    233236{
    234237        errno_t rc;
    … …  
    250253                goto error;
    251254        }
     255
     256        entry->terminal = terminal;
    252257
    253258        rc = ui_menu_entry_create(tbsmenu->smenu, caption, "", &entry->mentry);
    … …  
    438443        }
    439444
     445        cmd->argv[cnt] = NULL;
     446
    440447        return EOK;
    441448}
    … …  
    465472        int retval;
    466473        bool suspended;
     474        int i;
     475        int cnt;
     476        char **cp;
     477        const char **targv = NULL;
    467478        errno_t rc;
    468479        ui_t *ui;
    … …  
    482493        suspended = true;
    483494
    484         rc = task_spawnv(&id, &wait, cmd.argv[0], (const char *const *)
    485             cmd.argv);
    486         if (rc != EOK)
    487                 goto error;
     495        /* Don't start in terminal if not running in a window */
     496        if (entry->terminal && !ui_is_fullscreen(ui)) {
     497                cnt = 0;
     498                cp = cmd.argv;
     499                while (*cp != NULL) {
     500                        ++cnt;
     501                        ++cp;
     502                }
     503
     504                targv = calloc(cnt + 3, sizeof(char **));
     505                if (targv == NULL)
     506                        goto error;
     507
     508                targv[0] = "/app/terminal";
     509                targv[1] = "-c";
     510
     511                for (i = 0; i <= cnt; i++) {
     512                        if (cmd.argv[i] != NULL)
     513                                printf(" - '%s'\n", cmd.argv[i]);
     514                        else
     515                                printf(" - NULL\n");
     516
     517                        targv[2 + i] = cmd.argv[i];
     518                }
     519
     520                rc = task_spawnv(&id, &wait, targv[0], targv);
     521                if (rc != EOK)
     522                        goto error;
     523
     524                free(targv);
     525                targv = NULL;
     526        } else {
     527                rc = task_spawnv(&id, &wait, cmd.argv[0], (const char *const *)
     528                    cmd.argv);
     529                if (rc != EOK)
     530                        goto error;
     531        }
    488532
    489533        rc = task_wait(&wait, &texit, &retval);
    … …  
    499543        return EOK;
    500544error:
     545        if (targv != NULL)
     546                free(targv);
    501547        tbsmenu_cmd_fini(&cmd);
    502548        if (suspended)

  • uspace/app/taskbar/tbsmenu.h

    r74cb6610 r806d761  
    11/*
    2  * Copyright (c) 2023 Jiri Svoboda
     2 * Copyright (c) 2024 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    5353extern bool tbsmenu_is_open(tbsmenu_t *);
    5454extern void tbsmenu_destroy(tbsmenu_t *);
    55 extern errno_t tbsmenu_add(tbsmenu_t *, const char *, const char *,
     55extern errno_t tbsmenu_add(tbsmenu_t *, const char *, const char *, bool,
    5656    tbsmenu_entry_t **);
    5757extern void tbsmenu_remove(tbsmenu_t *, tbsmenu_entry_t *, bool);

  • uspace/app/taskbar/types/tbsmenu.h

    r74cb6610 r806d761  
    11/*
    2  * Copyright (c) 2023 Jiri Svoboda
     2 * Copyright (c) 2024 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    4646#include <ui/window.h>
    4747
    48 /** Taskbar window list entry */
     48/** Taskbar start menu entry */
    4949typedef struct {
    5050        /** Containing start menu */
    … …  
    5858        /** Command to run */
    5959        char *cmd;
     60        /** Start in terminal */
     61        bool terminal;
    6062} tbsmenu_entry_t;
    6163

  • uspace/lib/tbarcfg/include/tbarcfg/tbarcfg.h

    r74cb6610 r806d761  
    11/*
    2  * Copyright (c) 2023 Jiri Svoboda
     2 * Copyright (c) 2024 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    3939#include <errno.h>
    4040#include <sif.h>
     41#include <stdbool.h>
    4142#include <types/tbarcfg/tbarcfg.h>
    4243
    … …  
    4849extern const char *smenu_entry_get_caption(smenu_entry_t *);
    4950extern const char *smenu_entry_get_cmd(smenu_entry_t *);
     51extern bool smenu_entry_get_terminal(smenu_entry_t *);
    5052extern errno_t smenu_entry_set_caption(smenu_entry_t *, const char *);
    5153extern errno_t smenu_entry_set_cmd(smenu_entry_t *, const char *);
     54extern void smenu_entry_set_terminal(smenu_entry_t *, bool);
    5255extern errno_t smenu_entry_save(smenu_entry_t *);
    5356extern errno_t smenu_entry_create(tbarcfg_t *, const char *, const char *,
    54     smenu_entry_t **);
     57    bool, smenu_entry_t **);
    5558extern errno_t smenu_entry_destroy(smenu_entry_t *);
    5659

  • uspace/lib/tbarcfg/private/tbarcfg.h

    r74cb6610 r806d761  
    11/*
    2  * Copyright (c) 2023 Jiri Svoboda
     2 * Copyright (c) 2024 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    4040#include <adt/list.h>
    4141#include <sif.h>
     42#include <stdbool.h>
    4243#include <types/tbarcfg/tbarcfg.h>
    4344
    … …  
    6465        /** Command to run */
    6566        char *cmd;
     67        /** Start in terminal */
     68        bool terminal;
    6669};
    6770
    6871extern errno_t smenu_entry_new(tbarcfg_t *, sif_node_t *, const char *,
    69     const char *, smenu_entry_t **);
     72    const char *, bool, smenu_entry_t **);
    7073extern void smenu_entry_delete(smenu_entry_t *);
    7174

  • uspace/lib/tbarcfg/src/tbarcfg.c

    r74cb6610 r806d761  
    11/*
    2  * Copyright (c) 2023 Jiri Svoboda
     2 * Copyright (c) 2024 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    101101 * @return EOK on success or an error code
    102102 */
     103#include <stdio.h>
    103104errno_t tbarcfg_open(const char *repopath, tbarcfg_t **rtbcfg)
    104105{
    … …  
    110111        const char *caption;
    111112        const char *cmd;
     113        const char *terminal = NULL;
    112114        errno_t rc;
    113115
    … …  
    154156                }
    155157
    156                 rc = smenu_entry_new(tbcfg, nentry, caption, cmd, NULL);
     158                terminal = sif_node_get_attr(nentry, "terminal");
     159                if (terminal == NULL)
     160                        terminal = "n";
     161
     162                printf("terminal=%s\n", terminal);
     163
     164                rc = smenu_entry_new(tbcfg, nentry, caption, cmd,
     165                    str_cmp(terminal, "y") == 0, NULL);
    157166                if (rc != EOK)
    158167                        goto error;
    … …  
    233242/** Get start menu entry command.
    234243 *
    235  * @param entr Start menu entry
     244 * @param entry Start menu entry
    236245 * @return Command to run
    237246 */
    … …  
    239248{
    240249        return entry->cmd;
     250}
     251
     252/** Get start menu start in terminal flag.
     253 *
     254 * @param entry Start menu entry
     255 * @return Start in terminal flag
     256 */
     257bool smenu_entry_get_terminal(smenu_entry_t *entry)
     258{
     259        return entry->terminal;
    241260}
    242261
    … …  
    285304}
    286305
     306/** Set start menu entry start in terminal flag.
     307 *
     308 * Note: To make the change visible to others and persistent,
     309 * you must call @c smenu_entry_save()
     310 *
     311 * @param entry Start menu entry
     312 * @param terminal Start in terminal flag
     313 */
     314void smenu_entry_set_terminal(smenu_entry_t *entry, bool terminal)
     315{
     316        entry->terminal = terminal;
     317}
     318
    287319/** Save any changes to start menu entry.
    288320 *
    … …  
    303335
    304336        rc = sif_node_set_attr(trans, entry->nentry, "caption", entry->caption);
     337        if (rc != EOK)
     338                goto error;
     339
     340        rc = sif_node_set_attr(trans, entry->nentry, "terminal",
     341            entry->terminal ? "y" : "n");
    305342        if (rc != EOK)
    306343                goto error;
    … …  
    325362 * @param caption Caption
    326363 * @param cmd Command to run
     364 * @param terminal Start in terminal
    327365 * @param rentry Place to store pointer to new entry or @c NULL
    328366 */
    329367errno_t smenu_entry_new(tbarcfg_t *smenu, sif_node_t *nentry,
    330     const char *caption, const char *cmd, smenu_entry_t **rentry)
     368    const char *caption, const char *cmd, bool terminal, smenu_entry_t **rentry)
    331369{
    332370        smenu_entry_t *entry;
    … …  
    352390                goto error;
    353391        }
     392
     393        entry->terminal = terminal;
    354394
    355395        entry->smenu = smenu;
    … …  
    391431 * @param caption Caption
    392432 * @param cmd Command to run
     433 * @param terminal Start in terminal
    393434 * @param rentry Place to store pointer to new entry or @c NULL
    394435 */
    395436errno_t smenu_entry_create(tbarcfg_t *smenu, const char *caption,
    396     const char *cmd, smenu_entry_t **rentry)
     437    const char *cmd, bool terminal, smenu_entry_t **rentry)
    397438{
    398439        sif_node_t *nentry;
    … …  
    418459                goto error;
    419460
    420         rc = smenu_entry_new(smenu, nentry, caption, cmd, &entry);
     461        rc = sif_node_set_attr(trans, nentry, "terminal", terminal ? "y" : "n");
     462        if (rc != EOK)
     463                goto error;
     464
     465        rc = smenu_entry_new(smenu, nentry, caption, cmd, terminal ? "y" : "n",
     466            &entry);
    421467        if (rc != EOK)
    422468                goto error;

  • uspace/lib/tbarcfg/test/tbarcfg.c

    r74cb6610 r806d761  
    11/*
    2  * Copyright (c) 2023 Jiri Svoboda
     2 * Copyright (c) 2024 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    7676        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    7777
    78         rc = smenu_entry_create(tbcfg, "A", "a", &e1);
     78        rc = smenu_entry_create(tbcfg, "A", "a", false, &e1);
    7979        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    8080        PCUT_ASSERT_NOT_NULL(e1);
    8181
    82         rc = smenu_entry_create(tbcfg, "B", "b", &e2);
     82        rc = smenu_entry_create(tbcfg, "B", "b", false, &e2);
    8383        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    8484        PCUT_ASSERT_NOT_NULL(e2);
    8585
    8686        /* Create entry without getting a pointer to it */
    87         rc = smenu_entry_create(tbcfg, "C", "c", NULL);
     87        rc = smenu_entry_create(tbcfg, "C", "c", false, NULL);
    8888        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    8989
    … …  
    102102
    103103/** Getting menu entry properties */
    104 PCUT_TEST(get_caption_cmd)
     104PCUT_TEST(get_caption_cmd_term)
    105105{
    106106        errno_t rc;
    … …  
    110110        const char *caption;
    111111        const char *cmd;
    112 
    113         p = tmpnam(fname);
    114         PCUT_ASSERT_NOT_NULL(p);
    115 
    116         rc = tbarcfg_create(fname, &tbcfg);
    117         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    118 
    119         rc = smenu_entry_create(tbcfg, "A", "a", &e);
     112        bool terminal;
     113
     114        p = tmpnam(fname);
     115        PCUT_ASSERT_NOT_NULL(p);
     116
     117        rc = tbarcfg_create(fname, &tbcfg);
     118        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     119
     120        rc = smenu_entry_create(tbcfg, "A", "a", false, &e);
    120121        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    121122
    … …  
    124125        cmd = smenu_entry_get_cmd(e);
    125126        PCUT_ASSERT_STR_EQUALS("a", cmd);
     127        terminal = smenu_entry_get_terminal(e);
     128        PCUT_ASSERT_FALSE(terminal);
    126129
    127130        tbarcfg_close(tbcfg);
    … …  
    130133
    131134/** Setting menu entry properties */
    132 PCUT_TEST(set_caption_cmd)
     135PCUT_TEST(set_caption_cmd_term)
    133136{
    134137        errno_t rc;
    … …  
    138141        const char *caption;
    139142        const char *cmd;
    140 
    141         p = tmpnam(fname);
    142         PCUT_ASSERT_NOT_NULL(p);
    143 
    144         rc = tbarcfg_create(fname, &tbcfg);
    145         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    146 
    147         rc = smenu_entry_create(tbcfg, "A", "a", &e);
     143        bool terminal;
     144
     145        p = tmpnam(fname);
     146        PCUT_ASSERT_NOT_NULL(p);
     147
     148        rc = tbarcfg_create(fname, &tbcfg);
     149        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     150
     151        rc = smenu_entry_create(tbcfg, "A", "a", false, &e);
    148152        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    149153
    … …  
    152156        cmd = smenu_entry_get_cmd(e);
    153157        PCUT_ASSERT_STR_EQUALS("a", cmd);
     158        terminal = smenu_entry_get_terminal(e);
     159        PCUT_ASSERT_FALSE(terminal);
    154160
    155161        /* Set properties */
    … …  
    158164        rc = smenu_entry_set_cmd(e, "b");
    159165        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     166        smenu_entry_set_terminal(e, true);
    160167
    161168        rc = smenu_entry_save(e);
    … …  
    167174        cmd = smenu_entry_get_cmd(e);
    168175        PCUT_ASSERT_STR_EQUALS("b", cmd);
     176        terminal = smenu_entry_get_terminal(e);
     177        PCUT_ASSERT_TRUE(terminal);
    169178
    170179        tbarcfg_close(tbcfg);
    … …  
    197206        const char *caption;
    198207        const char *cmd;
    199 
    200         p = tmpnam(fname);
    201         PCUT_ASSERT_NOT_NULL(p);
    202 
    203         rc = tbarcfg_create(fname, &tbcfg);
    204         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    205 
    206         rc = smenu_entry_create(tbcfg, "A", "a", &e);
     208        bool terminal;
     209
     210        p = tmpnam(fname);
     211        PCUT_ASSERT_NOT_NULL(p);
     212
     213        rc = tbarcfg_create(fname, &tbcfg);
     214        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     215
     216        rc = smenu_entry_create(tbcfg, "A", "a", false, &e);
    207217        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    208218        PCUT_ASSERT_NOT_NULL(e);
    … …  
    212222        cmd = smenu_entry_get_cmd(e);
    213223        PCUT_ASSERT_STR_EQUALS("a", cmd);
     224        terminal = smenu_entry_get_terminal(e);
     225        PCUT_ASSERT_FALSE(terminal);
     226
     227        smenu_entry_destroy(e);
     228
     229        rc = smenu_entry_create(tbcfg, "B", "b", true, &e);
     230        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     231        PCUT_ASSERT_NOT_NULL(e);
     232
     233        caption = smenu_entry_get_caption(e);
     234        PCUT_ASSERT_STR_EQUALS("B", caption);
     235        cmd = smenu_entry_get_cmd(e);
     236        PCUT_ASSERT_STR_EQUALS("b", cmd);
     237        terminal = smenu_entry_get_terminal(e);
     238        PCUT_ASSERT_TRUE(terminal);
     239
     240        smenu_entry_destroy(e);
    214241
    215242        tbarcfg_close(tbcfg);
    … …  
    231258        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    232259
    233         rc = smenu_entry_create(tbcfg, "A", "a", &e);
     260        rc = smenu_entry_create(tbcfg, "A", "a", false, &e);
    234261        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    235262

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

    r74cb6610 r806d761  
    11/*
    2  * Copyright (c) 2020 Jiri Svoboda
     2 * Copyright (c) 2024 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    5252extern void ui_checkbox_set_cb(ui_checkbox_t *, ui_checkbox_cb_t *, void *);
    5353extern void ui_checkbox_set_rect(ui_checkbox_t *, gfx_rect_t *);
     54extern bool ui_checkbox_get_checked(ui_checkbox_t *);
     55extern void ui_checkbox_set_checked(ui_checkbox_t *, bool);
    5456extern errno_t ui_checkbox_paint(ui_checkbox_t *);
    5557extern void ui_checkbox_press(ui_checkbox_t *);

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

    r74cb6610 r806d761  
    11/*
    2  * Copyright (c) 2022 Jiri Svoboda
     2 * Copyright (c) 2024 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    139139}
    140140
    141 /** Set button rectangle.
    142  *
    143  * @param checkbox Button
    144  * @param rect New button rectangle
     141/** Set check box rectangle.
     142 *
     143 * @param checkbox Check box
     144 * @param rect New check box rectangle
    145145 */
    146146void ui_checkbox_set_rect(ui_checkbox_t *checkbox, gfx_rect_t *rect)
    147147{
    148148        checkbox->rect = *rect;
     149}
     150
     151/** Return if check box is checked.
     152 *
     153 * @param checkbox Check box
     154 * @return @c true iff check box is checked
     155 */
     156bool ui_checkbox_get_checked(ui_checkbox_t *checkbox)
     157{
     158        return checkbox->checked;
     159}
     160
     161/** Set check box checked state.
     162 *
     163 * @param checkbox Check box
     164 * @param checked @c true iff checkbox should be checked
     165 */
     166void ui_checkbox_set_checked(ui_checkbox_t *checkbox, bool checked)
     167{
     168        checkbox->checked = checked;
    149169}
    150170

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

    r74cb6610 r806d761  
    11/*
    2  * Copyright (c) 2021 Jiri Svoboda
     2 * Copyright (c) 2024 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    151151}
    152152
     153/** Get check box checked returns internal field */
     154PCUT_TEST(get_checked)
     155{
     156        ui_checkbox_t *checkbox;
     157        errno_t rc;
     158
     159        rc = ui_checkbox_create(NULL, "Hello", &checkbox);
     160        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     161
     162        checkbox->checked = false;
     163        PCUT_ASSERT_FALSE(ui_checkbox_get_checked(checkbox));
     164        checkbox->checked = true;
     165        PCUT_ASSERT_TRUE(ui_checkbox_get_checked(checkbox));
     166
     167        ui_checkbox_destroy(checkbox);
     168}
     169
     170/** Set check box checked sets internal field */
     171PCUT_TEST(set_checked)
     172{
     173        ui_checkbox_t *checkbox;
     174        errno_t rc;
     175
     176        rc = ui_checkbox_create(NULL, "Hello", &checkbox);
     177        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     178
     179        ui_checkbox_set_checked(checkbox, true);
     180        PCUT_ASSERT_TRUE(checkbox->checked);
     181        ui_checkbox_set_checked(checkbox, false);
     182        PCUT_ASSERT_FALSE(checkbox->checked);
     183
     184        ui_checkbox_destroy(checkbox);
     185}
     186
    153187/** Paint check box in graphics mode */
    154188PCUT_TEST(paint_gfx)
Note: See TracChangeset for help on using the changeset viewer.