Changeset 06176e1 in mainline


Ignore:
Timestamp:
2022-12-20T12:31:44Z (2 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
Files:
27 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/uidemo/uidemo.c

    rd46ac73 r06176e1  
    609609        ui_wnd_params_init(&params);
    610610        params.caption = "UI Demo";
    611         params.style |= ui_wds_maximize_btn | ui_wds_resizable;
     611        params.style |= ui_wds_minimize_btn | ui_wds_maximize_btn |
     612            ui_wds_resizable;
    612613
    613614        /* FIXME: Auto layout */

  • 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{

  • uspace/srv/hid/display/display.c

    rd46ac73 r06176e1  
    304304                gfx_rect_translate(&wnd->dpos, &wnd->rect, &drect);
    305305
    306                 if (gfx_pix_inside_rect(pos, &drect))
     306                if (gfx_pix_inside_rect(pos, &drect) &&
     307                    ds_window_is_visible(wnd))
    307308                        return wnd;
    308309

  • uspace/srv/hid/display/dsops.c

    rd46ac73 r06176e1  
    5454static errno_t disp_window_resize(void *, sysarg_t, gfx_coord2_t *,
    5555    gfx_rect_t *);
     56static errno_t disp_window_minimize(void *, sysarg_t);
    5657static errno_t disp_window_maximize(void *, sysarg_t);
    5758static errno_t disp_window_unmaximize(void *, sysarg_t);
    … …  
    7071        .window_resize_req = disp_window_resize_req,
    7172        .window_resize = disp_window_resize,
     73        .window_minimize = disp_window_minimize,
    7274        .window_maximize = disp_window_maximize,
    7375        .window_unmaximize = disp_window_unmaximize,
    … …  
    247249}
    248250
     251static errno_t disp_window_minimize(void *arg, sysarg_t wnd_id)
     252{
     253        ds_client_t *client = (ds_client_t *) arg;
     254        ds_window_t *wnd;
     255        errno_t rc;
     256
     257        ds_display_lock(client->display);
     258
     259        wnd = ds_client_find_window(client, wnd_id);
     260        if (wnd == NULL) {
     261                ds_display_unlock(client->display);
     262                return ENOENT;
     263        }
     264
     265        log_msg(LOG_DEFAULT, LVL_DEBUG, "disp_window_maximize()");
     266        rc = ds_window_minimize(wnd);
     267        ds_display_unlock(client->display);
     268        return rc;
     269}
     270
    249271static errno_t disp_window_maximize(void *arg, sysarg_t wnd_id)
    250272{

  • uspace/srv/hid/display/seat.c

    rd46ac73 r06176e1  
    9090void ds_seat_set_focus(ds_seat_t *seat, ds_window_t *wnd)
    9191{
     92        errno_t rc;
     93
    9294        if (wnd == seat->focus) {
    9395                /* Focus is not changing */
    9496                return;
     97        }
     98
     99        if (wnd != NULL) {
     100                rc = ds_window_unminimize(wnd);
     101                if (rc != EOK)
     102                        return;
    95103        }
    96104

  • uspace/srv/hid/display/test/window.c

    rd46ac73 r06176e1  
    261261}
    262262
     263/** Test ds_window_minimize(). */
     264PCUT_TEST(window_minimize)
     265{
     266        ds_display_t *disp;
     267        ds_client_t *client;
     268        ds_seat_t *seat;
     269        ds_window_t *wnd;
     270        display_wnd_params_t params;
     271        errno_t rc;
     272
     273        rc = ds_display_create(NULL, df_none, &disp);
     274        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     275
     276        rc = ds_client_create(disp, NULL, NULL, &client);
     277        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     278
     279        rc = ds_seat_create(disp, &seat);
     280        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     281
     282        display_wnd_params_init(&params);
     283        params.rect.p0.x = params.rect.p0.y = 0;
     284        params.rect.p1.x = params.rect.p1.y = 10;
     285
     286        rc = ds_window_create(client, &params, &wnd);
     287        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     288
     289        rc = ds_window_minimize(wnd);
     290        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     291
     292        PCUT_ASSERT_INT_EQUALS(wndf_minimized, wnd->flags & wndf_minimized);
     293
     294        ds_window_destroy(wnd);
     295        ds_seat_destroy(seat);
     296        ds_client_destroy(client);
     297        ds_display_destroy(disp);
     298}
     299
     300/** Test ds_window_unminimize(). */
     301PCUT_TEST(window_unminimize)
     302{
     303        ds_display_t *disp;
     304        ds_client_t *client;
     305        ds_seat_t *seat;
     306        ds_window_t *wnd;
     307        display_wnd_params_t params;
     308        errno_t rc;
     309
     310        rc = ds_display_create(NULL, df_none, &disp);
     311        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     312
     313        rc = ds_client_create(disp, NULL, NULL, &client);
     314        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     315
     316        rc = ds_seat_create(disp, &seat);
     317        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     318
     319        display_wnd_params_init(&params);
     320        params.flags |= wndf_minimized;
     321        params.rect.p0.x = params.rect.p0.y = 0;
     322        params.rect.p1.x = params.rect.p1.y = 10;
     323
     324        rc = ds_window_create(client, &params, &wnd);
     325        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     326
     327        rc = ds_window_unminimize(wnd);
     328        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     329
     330        PCUT_ASSERT_INT_EQUALS(0, wnd->flags & wndf_minimized);
     331
     332        ds_window_destroy(wnd);
     333        ds_seat_destroy(seat);
     334        ds_client_destroy(client);
     335        ds_display_destroy(disp);
     336}
     337
    263338/** Test ds_window_maximize(). */
    264339PCUT_TEST(window_maximize)
    … …  
    373448        gc = ds_window_get_ctx(wnd);
    374449        PCUT_ASSERT_NOT_NULL(gc);
     450
     451        ds_window_destroy(wnd);
     452        ds_seat_destroy(seat);
     453        ds_client_destroy(client);
     454        ds_display_destroy(disp);
     455}
     456
     457/** Test ds_window_is_visible() */
     458PCUT_TEST(is_visible)
     459{
     460        ds_display_t *disp;
     461        ds_client_t *client;
     462        ds_seat_t *seat;
     463        ds_window_t *wnd;
     464        display_wnd_params_t params;
     465        errno_t rc;
     466
     467        rc = ds_display_create(NULL, df_none, &disp);
     468        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     469
     470        rc = ds_client_create(disp, NULL, NULL, &client);
     471        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     472
     473        rc = ds_seat_create(disp, &seat);
     474        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     475
     476        display_wnd_params_init(&params);
     477        params.rect.p0.x = params.rect.p0.y = 0;
     478        params.rect.p1.x = params.rect.p1.y = 10;
     479
     480        rc = ds_window_create(client, &params, &wnd);
     481        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     482
     483        PCUT_ASSERT_TRUE(ds_window_is_visible(wnd));
     484
     485        wnd->flags |= wndf_minimized;
     486
     487        PCUT_ASSERT_FALSE(ds_window_is_visible(wnd));
    375488
    376489        ds_window_destroy(wnd);

  • uspace/srv/hid/display/window.c

    rd46ac73 r06176e1  
    220220}
    221221
     222/** Determine if window is visible.
     223 *
     224 * @param wnd Window
     225 * @return @c true iff window is visible
     226 */
     227bool ds_window_is_visible(ds_window_t *wnd)
     228{
     229        return (wnd->flags & wndf_minimized) == 0;
     230}
     231
    222232/** Paint a window using its backing bitmap.
    223233 *
    … …  
    233243
    234244        log_msg(LOG_DEFAULT, LVL_DEBUG2, "ds_window_paint");
     245
     246        /* Skip painting the window if not visible */
     247        if (!ds_window_is_visible(wnd))
     248                return EOK;
    235249
    236250        if (rect != NULL) {
    … …  
    808822}
    809823
     824/** Minimize window.
     825 *
     826 * @param wnd Window
     827 * @return EOK on success or an error code
     828 */
     829errno_t ds_window_minimize(ds_window_t *wnd)
     830{
     831        /* If already minimized, do nothing and return success. */
     832        if ((wnd->flags & wndf_minimized) != 0)
     833                return EOK;
     834
     835        wnd->flags |= wndf_minimized;
     836        (void) ds_display_paint(wnd->display, NULL);
     837        return EOK;
     838}
     839
     840/** Unminimize window.
     841 *
     842 * @param wnd Window
     843 * @return EOK on success or an error code
     844 */
     845errno_t ds_window_unminimize(ds_window_t *wnd)
     846{
     847        /* If not minimized, do nothing and return success. */
     848        if ((wnd->flags & wndf_minimized) == 0)
     849                return EOK;
     850
     851        wnd->flags &= ~wndf_minimized;
     852        (void) ds_display_paint(wnd->display, NULL);
     853        return EOK;
     854}
     855
    810856/** Maximize window.
    811857 *

  • uspace/srv/hid/display/window.h

    rd46ac73 r06176e1  
    4141#include <errno.h>
    4242#include <io/pos_event.h>
     43#include <stdbool.h>
    4344#include <types/gfx/context.h>
    4445#include <types/gfx/coord.h>
    … …  
    5556extern void ds_window_bring_to_top(ds_window_t *);
    5657extern gfx_context_t *ds_window_get_ctx(ds_window_t *);
     58extern bool ds_window_is_visible(ds_window_t *);
    5759extern errno_t ds_window_paint(ds_window_t *, gfx_rect_t *);
    5860errno_t ds_window_paint_preview(ds_window_t *, gfx_rect_t *);
    … …  
    6870    gfx_coord2_t *);
    6971extern errno_t ds_window_resize(ds_window_t *, gfx_coord2_t *, gfx_rect_t *);
     72extern errno_t ds_window_minimize(ds_window_t *);
     73extern errno_t ds_window_unminimize(ds_window_t *);
    7074extern errno_t ds_window_maximize(ds_window_t *);
    7175extern errno_t ds_window_unmaximize(ds_window_t *);

  • uspace/srv/hid/display/wmops.c

    rd46ac73 r06176e1  
    4141#include "display.h"
    4242#include "seat.h"
     43#include "window.h"
    4344#include "wmclient.h"
    4445
Note: See TracChangeset for help on using the changeset viewer.