Changeset 06176e1 in mainline for uspace/lib


Ignore:
Timestamp:
2022-12-20T12:31:44Z (3 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
master, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
4e7b0ad
Parents:
d46ac73
git-author:
Jiri Svoboda <jiri@…> (2022-12-19 18:31:30)
git-committer:
Jiri Svoboda <jiri@…> (2022-12-20 12:31:44)
Message:

Minimizing windows

Location:
uspace/lib
Files:
19 edited

Legend:

Unmodified
Added
Removed

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

    rd46ac73 r06176e1  
    6464        errno_t (*window_get_max_rect)(void *, sysarg_t, gfx_rect_t *);
    6565        errno_t (*window_resize)(void *, sysarg_t, gfx_coord2_t *, gfx_rect_t *);
     66        errno_t (*window_minimize)(void *, sysarg_t);
    6667        errno_t (*window_maximize)(void *, sysarg_t);
    6768        errno_t (*window_unmaximize)(void *, sysarg_t);

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

    rd46ac73 r06176e1  
    6262extern errno_t display_window_resize(display_window_t *,
    6363    gfx_coord2_t *, gfx_rect_t *);
     64extern errno_t display_window_minimize(display_window_t *);
    6465extern errno_t display_window_maximize(display_window_t *);
    6566extern errno_t display_window_unmaximize(display_window_t *);

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

    rd46ac73 r06176e1  
    4242        DISPLAY_WINDOW_CREATE,
    4343        DISPLAY_WINDOW_DESTROY,
     44        DISPLAY_WINDOW_MINIMIZE,
    4445        DISPLAY_WINDOW_MAXIMIZE,
    4546        DISPLAY_WINDOW_MOVE,

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

    rd46ac73 r06176e1  
    4646        /** Set specific initial window position */
    4747        wndf_setpos = 0x4,
     48        /** Window is minimized */
     49        wndf_minimized = 0x8,
    4850        /** Window is maximized */
    49         wndf_maximized = 0x8,
     51        wndf_maximized = 0x10,
    5052        /** Special system window */
    51         wndf_system = 0x10,
     53        wndf_system = 0x20,
    5254        /** Maximized windows should avoid this window */
    53         wndf_avoid = 0x20
     55        wndf_avoid = 0x40
    5456} display_wnd_flags_t;
    5557

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

    rd46ac73 r06176e1  
    391391}
    392392
     393static void display_window_minimize_srv(display_srv_t *srv, ipc_call_t *icall)
     394{
     395        sysarg_t wnd_id;
     396        errno_t rc;
     397
     398        wnd_id = ipc_get_arg1(icall);
     399
     400        if (srv->ops->window_minimize == NULL) {
     401                async_answer_0(icall, ENOTSUP);
     402                return;
     403        }
     404
     405        rc = srv->ops->window_minimize(srv->arg, wnd_id);
     406        async_answer_0(icall, rc);
     407}
     408
    393409static void display_window_maximize_srv(display_srv_t *srv, ipc_call_t *icall)
    394410{
    … …  
    610626                case DISPLAY_WINDOW_RESIZE:
    611627                        display_window_resize_srv(srv, &call);
     628                        break;
     629                case DISPLAY_WINDOW_MINIMIZE:
     630                        display_window_minimize_srv(srv, &call);
    612631                        break;
    613632                case DISPLAY_WINDOW_MAXIMIZE:

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

    rd46ac73 r06176e1  
    508508
    509509        return EOK;
     510}
     511
     512/** Minimize window.
     513 *
     514 * @param window Window
     515 * @return EOK on success or an error code
     516 */
     517errno_t display_window_minimize(display_window_t *window)
     518{
     519        async_exch_t *exch;
     520        errno_t rc;
     521
     522        exch = async_exchange_begin(window->display->sess);
     523        rc = async_req_1_0(exch, DISPLAY_WINDOW_MINIMIZE, window->id);
     524        async_exchange_end(exch);
     525
     526        return rc;
    510527}
    511528

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

    rd46ac73 r06176e1  
    6666static errno_t test_window_resize(void *, sysarg_t, gfx_coord2_t *,
    6767    gfx_rect_t *);
     68static errno_t test_window_minimize(void *, sysarg_t);
    6869static errno_t test_window_maximize(void *, sysarg_t);
    6970static errno_t test_window_unmaximize(void *, sysarg_t);
    … …  
    8485        .window_resize_req = test_window_resize_req,
    8586        .window_resize = test_window_resize,
     87        .window_minimize = test_window_minimize,
    8688        .window_maximize = test_window_maximize,
    8789        .window_unmaximize = test_window_unmaximize,
    … …  
    145147        sysarg_t resize_wnd_id;
    146148
     149        bool window_minimize_called;
    147150        bool window_maximize_called;
    148151        bool window_unmaximize_called;
    … …  
    10501053        PCUT_ASSERT_INT_EQUALS(nrect.p1.x, resp.resize_nbound.p1.x);
    10511054        PCUT_ASSERT_INT_EQUALS(nrect.p1.y, resp.resize_nbound.p1.y);
     1055
     1056        display_window_destroy(wnd);
     1057        display_close(disp);
     1058        rc = loc_service_unregister(sid);
     1059        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1060}
     1061
     1062/** display_window_minimize() with server returning error response works. */
     1063PCUT_TEST(window_minimize_failure)
     1064{
     1065        errno_t rc;
     1066        service_id_t sid;
     1067        display_t *disp = NULL;
     1068        display_wnd_params_t params;
     1069        display_window_t *wnd;
     1070        test_response_t resp;
     1071
     1072        async_set_fallback_port_handler(test_display_conn, &resp);
     1073
     1074        // FIXME This causes this test to be non-reentrant!
     1075        rc = loc_server_register(test_display_server);
     1076        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1077
     1078        rc = loc_service_register(test_display_svc, &sid);
     1079        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1080
     1081        rc = display_open(test_display_svc, &disp);
     1082        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1083        PCUT_ASSERT_NOT_NULL(disp);
     1084
     1085        resp.rc = EOK;
     1086        display_wnd_params_init(&params);
     1087        params.rect.p0.x = 0;
     1088        params.rect.p0.y = 0;
     1089        params.rect.p0.x = 100;
     1090        params.rect.p0.y = 100;
     1091
     1092        rc = display_window_create(disp, &params, &test_display_wnd_cb,
     1093            (void *) &resp, &wnd);
     1094        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1095        PCUT_ASSERT_NOT_NULL(wnd);
     1096
     1097        resp.rc = EIO;
     1098        resp.window_minimize_called = false;
     1099
     1100        rc = display_window_minimize(wnd);
     1101        PCUT_ASSERT_TRUE(resp.window_minimize_called);
     1102        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
     1103
     1104        display_window_destroy(wnd);
     1105        display_close(disp);
     1106        rc = loc_service_unregister(sid);
     1107        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1108}
     1109
     1110/** display_window_minimize() with server returning success response works. */
     1111PCUT_TEST(window_minimize_success)
     1112{
     1113        errno_t rc;
     1114        service_id_t sid;
     1115        display_t *disp = NULL;
     1116        display_wnd_params_t params;
     1117        display_window_t *wnd;
     1118        test_response_t resp;
     1119
     1120        async_set_fallback_port_handler(test_display_conn, &resp);
     1121
     1122        // FIXME This causes this test to be non-reentrant!
     1123        rc = loc_server_register(test_display_server);
     1124        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1125
     1126        rc = loc_service_register(test_display_svc, &sid);
     1127        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1128
     1129        rc = display_open(test_display_svc, &disp);
     1130        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1131        PCUT_ASSERT_NOT_NULL(disp);
     1132
     1133        resp.rc = EOK;
     1134        display_wnd_params_init(&params);
     1135        params.rect.p0.x = 0;
     1136        params.rect.p0.y = 0;
     1137        params.rect.p0.x = 100;
     1138        params.rect.p0.y = 100;
     1139
     1140        rc = display_window_create(disp, &params, &test_display_wnd_cb,
     1141            (void *) &resp, &wnd);
     1142        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1143        PCUT_ASSERT_NOT_NULL(wnd);
     1144
     1145        resp.rc = EOK;
     1146        resp.window_minimize_called = false;
     1147
     1148        rc = display_window_minimize(wnd);
     1149        PCUT_ASSERT_TRUE(resp.window_minimize_called);
     1150        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    10521151
    10531152        display_window_destroy(wnd);
    … …  
    21032202}
    21042203
     2204static errno_t test_window_minimize(void *arg, sysarg_t wnd_id)
     2205{
     2206        test_response_t *resp = (test_response_t *) arg;
     2207
     2208        resp->window_minimize_called = true;
     2209        resp->resize_wnd_id = wnd_id;
     2210        return resp->rc;
     2211}
     2212
    21052213static errno_t test_window_maximize(void *arg, sysarg_t wnd_id)
    21062214{

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

    rd46ac73 r06176e1  
    5151        /** Window has a title bar */
    5252        ui_wds_titlebar = 0x2,
     53        /** Window has a minimize button */
     54        ui_wds_minimize_btn = 0x4,
    5355        /** Window has a maximize button */
    54         ui_wds_maximize_btn = 0x4,
     56        ui_wds_maximize_btn = 0x8,
    5557        /** Window has a close button */
    56         ui_wds_close_btn = 0x8,
     58        ui_wds_close_btn = 0x10,
    5759        /** Window is resizable */
    58         ui_wds_resizable = 0x10,
     60        ui_wds_resizable = 0x20,
    5961        /** Window is decorated (default decoration) */
    6062        ui_wds_decorated = ui_wds_frame | ui_wds_titlebar | ui_wds_close_btn
    … …  
    7880/** Window decoration callbacks */
    7981typedef struct ui_wdecor_cb {
     82        void (*minimize)(ui_wdecor_t *, void *);
    8083        void (*maximize)(ui_wdecor_t *, void *);
    8184        void (*unmaximize)(ui_wdecor_t *, void *);

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

    rd46ac73 r06176e1  
    9393/** Window callbacks */
    9494typedef struct ui_window_cb {
     95        void (*minimize)(ui_window_t *, void *);
    9596        void (*maximize)(ui_window_t *, void *);
    9697        void (*unmaximize)(ui_window_t *, void *);

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

    rd46ac73 r06176e1  
    6565extern errno_t ui_paint_cross(gfx_context_t *, gfx_coord2_t *, gfx_coord_t,
    6666    gfx_coord_t, gfx_coord_t);
     67extern errno_t ui_paint_minicon(ui_resource_t *, gfx_coord2_t *, gfx_coord_t,
     68    gfx_coord_t);
    6769extern errno_t ui_paint_maxicon(ui_resource_t *, gfx_coord2_t *, gfx_coord_t,
    6870    gfx_coord_t);

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

    rd46ac73 r06176e1  
    6565extern void ui_window_set_ctl_cursor(ui_window_t *, ui_stock_cursor_t);
    6666extern errno_t ui_window_paint(ui_window_t *);
     67extern errno_t ui_window_def_minimize(ui_window_t *);
    6768extern errno_t ui_window_def_maximize(ui_window_t *);
    6869extern errno_t ui_window_def_unmaximize(ui_window_t *);

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

    rd46ac73 r06176e1  
    6565        /** Window is maximized */
    6666        bool maximized;
     67        /** Minimize button */
     68        struct ui_pbutton *btn_min;
    6769        /** Maximize button */
    6870        struct ui_pbutton *btn_max;
    … …  
    8284        /** Window caption rectangle */
    8385        gfx_rect_t caption_rect;
     86        /** Minimize button rectangle */
     87        gfx_rect_t btn_min_rect;
    8488        /** Maximize button rectangle */
    8589        gfx_rect_t btn_max_rect;
    … …  
    9094} ui_wdecor_geom_t;
    9195
     96extern void ui_wdecor_minimize(ui_wdecor_t *);
    9297extern void ui_wdecor_maximize(ui_wdecor_t *);
    9398extern void ui_wdecor_unmaximize(ui_wdecor_t *);

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

    rd46ac73 r06176e1  
    112112
    113113extern display_stock_cursor_t wnd_dcursor_from_cursor(ui_stock_cursor_t);
     114extern void ui_window_send_minimize(ui_window_t *);
    114115extern void ui_window_send_maximize(ui_window_t *);
    115116extern void ui_window_send_unmaximize(ui_window_t *);

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

    rd46ac73 r06176e1  
    529529}
    530530
     531/** Paint minimize icon.
     532 *
     533 * @param resource UI resource
     534 * @param pos Center position
     535 * @param w Icon width
     536 * @param h Icon height
     537 * @return EOK on success or an error code
     538 */
     539errno_t ui_paint_minicon(ui_resource_t *resource, gfx_coord2_t *pos,
     540    gfx_coord_t w, gfx_coord_t h)
     541{
     542        gfx_rect_t rect;
     543        errno_t rc;
     544
     545        rc = gfx_set_color(resource->gc, resource->btn_text_color);
     546        if (rc != EOK)
     547                return rc;
     548
     549        rect.p0.x = pos->x - w / 2;
     550        rect.p0.y = pos->y + h / 2 - 2;
     551        rect.p1.x = rect.p0.x + w;
     552        rect.p1.y = rect.p0.y + 2;
     553        rc = gfx_fill_rect(resource->gc, &rect);
     554        if (rc != EOK)
     555                return rc;
     556
     557        return EOK;
     558}
     559
    531560/** Paint maximize icon.
    532561 *

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

    rd46ac73 r06176e1  
    4949#include "../private/wdecor.h"
    5050
     51static void ui_wdecor_btn_min_clicked(ui_pbutton_t *, void *);
     52static errno_t ui_wdecor_btn_min_paint(ui_pbutton_t *, void *,
     53    gfx_coord2_t *);
     54
    5155static void ui_wdecor_btn_max_clicked(ui_pbutton_t *, void *);
    5256static errno_t ui_wdecor_btn_max_paint(ui_pbutton_t *, void *,
    … …  
    5660static errno_t ui_wdecor_btn_close_paint(ui_pbutton_t *, void *,
    5761    gfx_coord2_t *);
     62
     63static ui_pbutton_cb_t ui_wdecor_btn_min_cb = {
     64        .clicked = ui_wdecor_btn_min_clicked
     65};
     66
     67static ui_pbutton_decor_ops_t ui_wdecor_btn_min_decor_ops = {
     68        .paint = ui_wdecor_btn_min_paint
     69};
    5870
    5971static ui_pbutton_cb_t ui_wdecor_btn_max_cb = {
    … …  
    98110        /** Close button cross pen height */
    99111        wdecor_close_cross_h = 1,
     112        /** Minimize icon width */
     113        wdecor_min_w = 10,
     114        /** Minimize icon height */
     115        wdecor_min_h = 10,
    100116        /** Maximize icon width */
    101117        wdecor_max_w = 10,
    … …  
    136152        }
    137153
     154        if ((style & ui_wds_minimize_btn) != 0) {
     155                rc = ui_pbutton_create(resource, "_", &wdecor->btn_min);
     156                if (rc != EOK) {
     157                        ui_wdecor_destroy(wdecor);
     158                        return rc;
     159                }
     160
     161                ui_pbutton_set_cb(wdecor->btn_min, &ui_wdecor_btn_min_cb,
     162                    (void *)wdecor);
     163
     164                ui_pbutton_set_decor_ops(wdecor->btn_min,
     165                    &ui_wdecor_btn_min_decor_ops, (void *)wdecor);
     166        }
     167
    138168        if ((style & ui_wds_maximize_btn) != 0) {
    139169                rc = ui_pbutton_create(resource, "^", &wdecor->btn_max);
    … …  
    180210                return;
    181211
     212        ui_pbutton_destroy(wdecor->btn_min);
    182213        ui_pbutton_destroy(wdecor->btn_max);
    183214        ui_pbutton_destroy(wdecor->btn_close);
    … …  
    211242        ui_wdecor_get_geom(wdecor, &geom);
    212243
     244        if (wdecor->btn_min != NULL)
     245                ui_pbutton_set_rect(wdecor->btn_min, &geom.btn_min_rect);
    213246        if (wdecor->btn_max != NULL)
    214247                ui_pbutton_set_rect(wdecor->btn_max, &geom.btn_max_rect);
    … …  
    362395                        return rc;
    363396
     397                if (wdecor->btn_min != NULL) {
     398                        rc = ui_pbutton_paint(wdecor->btn_min);
     399                        if (rc != EOK)
     400                                return rc;
     401                }
     402
    364403                if (wdecor->btn_max != NULL) {
    365404                        rc = ui_pbutton_paint(wdecor->btn_max);
    … …  
    380419
    381420        return EOK;
     421}
     422
     423/** Send decoration minimize event.
     424 *
     425 * @param wdecor Window decoration
     426 */
     427void ui_wdecor_minimize(ui_wdecor_t *wdecor)
     428{
     429        if (wdecor->cb != NULL && wdecor->cb->minimize != NULL)
     430                wdecor->cb->minimize(wdecor, wdecor->arg);
    382431}
    383432
    … …  
    554603        }
    555604
     605        /* Does window have a minimize button? */
     606        if ((wdecor->style & ui_wds_minimize_btn) != 0) {
     607                if (wdecor->res->textmode == false) {
     608                        geom->btn_min_rect.p0.x = btn_x - 20;
     609                        geom->btn_min_rect.p0.y = btn_y;
     610                        geom->btn_min_rect.p1.x = btn_x;
     611                        geom->btn_min_rect.p1.y = btn_y + 20;
     612
     613                        btn_x -= 20;
     614                } else {
     615                        geom->btn_min_rect.p0.x = btn_x - 3;
     616                        geom->btn_min_rect.p0.y = btn_y;
     617                        geom->btn_min_rect.p1.x = btn_x;
     618                        geom->btn_min_rect.p1.y = btn_y + 1;
     619
     620                        btn_x -= 3;
     621                }
     622        } else {
     623                geom->btn_min_rect.p0.x = 0;
     624                geom->btn_min_rect.p0.y = 0;
     625                geom->btn_min_rect.p1.x = 0;
     626                geom->btn_min_rect.p1.y = 0;
     627        }
     628
    556629        if (wdecor->res->textmode == false)
    557630                cap_hmargin = wdecor_cap_hmargin;
    … …  
    773846        ui_wdecor_get_geom(wdecor, &geom);
    774847
     848        if (wdecor->btn_min != NULL) {
     849                claim = ui_pbutton_pos_event(wdecor->btn_min, event);
     850                if (claim == ui_claimed)
     851                        return ui_claimed;
     852        }
     853
    775854        if (wdecor->btn_max != NULL) {
    776855                claim = ui_pbutton_pos_event(wdecor->btn_max, event);
    … …  
    798877}
    799878
     879/** Window decoration minimize button was clicked.
     880 *
     881 * @param pbutton Minimize button
     882 * @param arg Argument (ui_wdecor_t)
     883 */
     884static void ui_wdecor_btn_min_clicked(ui_pbutton_t *pbutton, void *arg)
     885{
     886        ui_wdecor_t *wdecor = (ui_wdecor_t *) arg;
     887
     888        (void) pbutton;
     889
     890        ui_wdecor_minimize(wdecor);
     891}
     892
    800893/** Window decoration (un)maximize button was clicked.
    801894 *
    802  * @param pbutton Close button
     895 * @param pbutton (Un)maximize button
    803896 * @param arg Argument (ui_wdecor_t)
    804897 */
    … …  
    813906        else
    814907                ui_wdecor_maximize(wdecor);
     908}
     909
     910/** Paint minimize button decoration.
     911 *
     912 * @param pbutton Push button
     913 * @param arg Argument (ui_wdecor_t *)
     914 * @param pos Center position
     915 */
     916static errno_t ui_wdecor_btn_min_paint(ui_pbutton_t *pbutton,
     917    void *arg, gfx_coord2_t *pos)
     918{
     919        ui_wdecor_t *wdecor = (ui_wdecor_t *)arg;
     920        errno_t rc;
     921
     922        rc = ui_paint_minicon(wdecor->res, pos, wdecor_min_w,
     923            wdecor_min_h);
     924
     925        return rc;
    815926}
    816927

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

    rd46ac73 r06176e1  
    7474};
    7575
     76static void wd_minimize(ui_wdecor_t *, void *);
    7677static void wd_maximize(ui_wdecor_t *, void *);
    7778static void wd_unmaximize(ui_wdecor_t *, void *);
    … …  
    8384
    8485static ui_wdecor_cb_t wdecor_cb = {
     86        .minimize = wd_minimize,
    8587        .maximize = wd_maximize,
    8688        .unmaximize = wd_unmaximize,
    … …  
    917919}
    918920
     921/** Window decoration requested window minimization.
     922 *
     923 * @param wdecor Window decoration
     924 * @param arg Argument (window)
     925 */
     926static void wd_minimize(ui_wdecor_t *wdecor, void *arg)
     927{
     928        ui_window_t *window = (ui_window_t *) arg;
     929
     930        ui_window_send_minimize(window);
     931}
     932
    919933/** Window decoration requested window maximization.
    920934 *
    … …  
    10411055}
    10421056
     1057/** Send window minimize event.
     1058 *
     1059 * @param window Window
     1060 */
     1061void ui_window_send_minimize(ui_window_t *window)
     1062{
     1063        if (window->cb != NULL && window->cb->maximize != NULL)
     1064                window->cb->minimize(window, window->arg);
     1065        else
     1066                ui_window_def_minimize(window);
     1067}
     1068
    10431069/** Send window maximize event.
    10441070 *
    … …  
    11311157        else
    11321158                return ui_window_def_unfocus(window);
     1159}
     1160
     1161/** Default window minimize routine.
     1162 *
     1163 * @param window Window
     1164 * @return EOK on success or an error code
     1165 */
     1166errno_t ui_window_def_minimize(ui_window_t *window)
     1167{
     1168        errno_t rc;
     1169
     1170        if (window->dwindow != NULL) {
     1171                rc = display_window_minimize(window->dwindow);
     1172                if (rc != EOK)
     1173                        goto error;
     1174        }
     1175
     1176        return EOK;
     1177error:
     1178        return rc;
    11331179}
    11341180

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

    rd46ac73 r06176e1  
    354354}
    355355
     356/** Paint mimimize icon */
     357PCUT_TEST(minicon)
     358{
     359        errno_t rc;
     360        gfx_context_t *gc = NULL;
     361        ui_resource_t *resource = NULL;
     362        test_gc_t tgc;
     363        gfx_coord2_t center;
     364
     365        memset(&tgc, 0, sizeof(tgc));
     366        rc = gfx_context_new(&ops, &tgc, &gc);
     367        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     368
     369        rc = ui_resource_create(gc, false, &resource);
     370        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     371        PCUT_ASSERT_NOT_NULL(resource);
     372
     373        center.x = 0;
     374        center.y = 0;
     375
     376        rc = ui_paint_minicon(resource, &center, 8, 6);
     377        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     378
     379        ui_resource_destroy(resource);
     380        rc = gfx_context_delete(gc);
     381        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     382}
     383
    356384/** Paint maximize icon */
    357385PCUT_TEST(maxicon)

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

    rd46ac73 r06176e1  
    6262};
    6363
     64static void test_wdecor_minimize(ui_wdecor_t *, void *);
    6465static void test_wdecor_maximize(ui_wdecor_t *, void *);
    6566static void test_wdecor_unmaximize(ui_wdecor_t *, void *);
    … …  
    7172
    7273static ui_wdecor_cb_t test_wdecor_cb = {
     74        .minimize = test_wdecor_minimize,
    7375        .maximize = test_wdecor_maximize,
    7476        .unmaximize = test_wdecor_unmaximize,
    … …  
    100102
    101103typedef struct {
     104        bool minimize;
    102105        bool maximize;
    103106        bool unmaximize;
    … …  
    222225        rc = gfx_context_delete(gc);
    223226        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     227}
     228
     229/** Test ui_wdecor_minimize() */
     230PCUT_TEST(minimize)
     231{
     232        errno_t rc;
     233        ui_wdecor_t *wdecor;
     234        test_cb_resp_t resp;
     235
     236        rc = ui_wdecor_create(NULL, "Hello", ui_wds_none, &wdecor);
     237        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     238
     239        /* Minimize callback with no callbacks set */
     240        ui_wdecor_minimize(wdecor);
     241
     242        /* Minimize callback with minimize callback not implemented */
     243        ui_wdecor_set_cb(wdecor, &dummy_wdecor_cb, NULL);
     244        ui_wdecor_minimize(wdecor);
     245
     246        /* Minimize callback with real callback set */
     247        resp.minimize = false;
     248        ui_wdecor_set_cb(wdecor, &test_wdecor_cb, &resp);
     249        ui_wdecor_minimize(wdecor);
     250        PCUT_ASSERT_TRUE(resp.minimize);
     251
     252        ui_wdecor_destroy(wdecor);
    224253}
    225254
    … …  
    10141043}
    10151044
     1045static void test_wdecor_minimize(ui_wdecor_t *wdecor, void *arg)
     1046{
     1047        test_cb_resp_t *resp = (test_cb_resp_t *) arg;
     1048
     1049        resp->minimize = true;
     1050}
     1051
    10161052static void test_wdecor_maximize(ui_wdecor_t *wdecor, void *arg)
    10171053{

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

    rd46ac73 r06176e1  
    4545PCUT_TEST_SUITE(window);
    4646
     47static void test_window_minimize(ui_window_t *, void *);
    4748static void test_window_maximize(ui_window_t *, void *);
    4849static void test_window_unmaximize(ui_window_t *, void *);
    … …  
    5556
    5657static ui_window_cb_t test_window_cb = {
     58        .minimize = test_window_minimize,
    5759        .maximize = test_window_maximize,
    5860        .unmaximize = test_window_unmaximize,
    … …  
    8082typedef struct {
    8183        errno_t rc;
     84        bool minimize;
    8285        bool maximize;
    8386        bool unmaximize;
    … …  
    537540}
    538541
     542/** ui_window_send_minimize() calls minimize callback set via ui_window_set_cb() */
     543PCUT_TEST(send_minimize)
     544{
     545        errno_t rc;
     546        ui_t *ui = NULL;
     547        ui_wnd_params_t params;
     548        ui_window_t *window = NULL;
     549        test_cb_resp_t resp;
     550
     551        rc = ui_create_disp(NULL, &ui);
     552        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     553
     554        ui_wnd_params_init(&params);
     555        params.caption = "Hello";
     556
     557        rc = ui_window_create(ui, &params, &window);
     558        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     559        PCUT_ASSERT_NOT_NULL(window);
     560
     561        /* Minimize callback with no callbacks set */
     562        ui_window_send_minimize(window);
     563
     564        /* Minimize callback with minimize callback not implemented */
     565        ui_window_set_cb(window, &dummy_window_cb, NULL);
     566        ui_window_send_minimize(window);
     567
     568        /* Minimize callback with real callback set */
     569        resp.minimize = false;
     570        ui_window_set_cb(window, &test_window_cb, &resp);
     571        ui_window_send_minimize(window);
     572        PCUT_ASSERT_TRUE(resp.minimize);
     573
     574        ui_window_destroy(window);
     575        ui_destroy(ui);
     576}
     577
    539578/** ui_window_send_maximize() calls maximize callback set via ui_window_set_cb() */
    540579PCUT_TEST(send_maximize)
    … …  
    849888}
    850889
     890static void test_window_minimize(ui_window_t *window, void *arg)
     891{
     892        test_cb_resp_t *resp = (test_cb_resp_t *) arg;
     893
     894        resp->minimize = true;
     895}
     896
    851897static void test_window_maximize(ui_window_t *window, void *arg)
    852898{
Note: See TracChangeset for help on using the changeset viewer.