Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    rec50d65e r3d10a2f  
    11/*
    2  * Copyright (c) 2024 Jiri Svoboda
     2 * Copyright (c) 2021 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    4747#include <stdlib.h>
    4848#include <ui/control.h>
    49 #include <ui/menubar.h>
    50 #include <ui/menu.h>
    51 #include <ui/menuentry.h>
    5249#include <ui/resource.h>
    5350#include <ui/ui.h>
    … …  
    6259
    6360static void dwnd_close_event(void *);
    64 static void dwnd_focus_event(void *, unsigned);
     61static void dwnd_focus_event(void *);
    6562static void dwnd_kbd_event(void *, kbd_event_t *);
    6663static void dwnd_pos_event(void *, pos_event_t *);
    6764static void dwnd_resize_event(void *, gfx_rect_t *);
    68 static void dwnd_unfocus_event(void *, unsigned);
     65static void dwnd_unfocus_event(void *);
    6966
    7067static display_wnd_cb_t dwnd_cb = {
    … …  
    7774};
    7875
    79 static void wd_sysmenu_open(ui_wdecor_t *, void *, sysarg_t);
    80 static void wd_sysmenu_left(ui_wdecor_t *, void *, sysarg_t);
    81 static void wd_sysmenu_right(ui_wdecor_t *, void *, sysarg_t);
    82 static void wd_sysmenu_accel(ui_wdecor_t *, void *, char32_t, sysarg_t);
    83 static void wd_minimize(ui_wdecor_t *, void *);
    84 static void wd_maximize(ui_wdecor_t *, void *);
    85 static void wd_unmaximize(ui_wdecor_t *, void *);
    8676static void wd_close(ui_wdecor_t *, void *);
    87 static void wd_move(ui_wdecor_t *, void *, gfx_coord2_t *, sysarg_t);
     77static void wd_move(ui_wdecor_t *, void *, gfx_coord2_t *);
    8878static void wd_resize(ui_wdecor_t *, void *, ui_wdecor_rsztype_t,
    89     gfx_coord2_t *, sysarg_t);
     79    gfx_coord2_t *);
    9080static void wd_set_cursor(ui_wdecor_t *, void *, ui_stock_cursor_t);
    9181
    9282static ui_wdecor_cb_t wdecor_cb = {
    93         .sysmenu_open = wd_sysmenu_open,
    94         .sysmenu_left = wd_sysmenu_left,
    95         .sysmenu_right = wd_sysmenu_right,
    96         .sysmenu_accel = wd_sysmenu_accel,
    97         .minimize = wd_minimize,
    98         .maximize = wd_maximize,
    99         .unmaximize = wd_unmaximize,
    10083        .close = wd_close,
    10184        .move = wd_move,
    … …  
    10386        .set_cursor = wd_set_cursor
    10487};
    105 
    106 static void wnd_sysmenu_left(ui_menu_t *, void *, sysarg_t);
    107 static void wnd_sysmenu_right(ui_menu_t *, void *, sysarg_t);
    108 static void wnd_sysmenu_close_req(ui_menu_t *, void *);
    109 static void wnd_sysmenu_press_accel(ui_menu_t *, void *, char32_t, sysarg_t);
    110 
    111 static ui_menu_cb_t wnd_sysmenu_cb = {
    112         .left = wnd_sysmenu_left,
    113         .right = wnd_sysmenu_right,
    114         .close_req = wnd_sysmenu_close_req,
    115         .press_accel = wnd_sysmenu_press_accel
    116 };
    117 
    118 static void wnd_sysmenu_erestore(ui_menu_entry_t *, void *);
    119 static void wnd_sysmenu_eminimize(ui_menu_entry_t *, void *);
    120 static void wnd_sysmenu_emaximize(ui_menu_entry_t *, void *);
    121 static void wnd_sysmenu_eclose(ui_menu_entry_t *, void *);
    12288
    12389static void ui_window_invalidate(void *, gfx_rect_t *);
    … …  
    178144{
    179145        gfx_coord2_t dims;
    180         gfx_coord2_t below_pos;
    181         gfx_rect_t below_rect;
    182146
    183147        assert(params->placement != ui_wnd_place_default ||
    … …  
    213177                break;
    214178        case ui_wnd_place_popup:
    215                 /* Compute rectangle when placed below */
    216                 below_pos.x = params->prect.p0.x;
    217                 below_pos.y = params->prect.p1.y;
    218                 gfx_rect_translate(&below_pos, &params->rect, &below_rect);
    219 
    220                 /* Does below_rect fit within the display? */
    221                 if (gfx_rect_is_inside(&below_rect, drect)) {
    222                         /* Place popup window below parent rectangle */
    223                         pos->x = params->prect.p0.x - params->rect.p0.x;
    224                         pos->y = params->prect.p1.y - params->rect.p0.y;
    225                 } else {
    226                         /* Place popup window above parent rectangle */
    227                         pos->x = params->prect.p0.x;
    228                         pos->y = params->prect.p0.y -
    229                             (params->rect.p1.y - params->rect.p0.y);
    230                 }
     179                /* Place popup window below parent rectangle */
     180                pos->x = params->prect.p0.x;
     181                pos->y = params->prect.p1.y;
    231182                break;
    232183        }
    233 }
    234 
    235 /** Create window's system menu.
    236  *
    237  * @param window Window
    238  * @return EOK on success or an error code
    239  */
    240 static errno_t ui_window_sysmenu_create(ui_window_t *window)
    241 {
    242         errno_t rc;
    243         ui_menu_entry_t *mrestore;
    244         ui_menu_entry_t *mmin;
    245         ui_menu_entry_t *mmax;
    246         ui_menu_entry_t *msep;
    247         ui_menu_entry_t *mclose;
    248 
    249         rc = ui_menu_create(window, &window->sysmenu);
    250         if (rc != EOK)
    251                 goto error;
    252 
    253         ui_menu_set_cb(window->sysmenu, &wnd_sysmenu_cb, (void *)window);
    254 
    255         rc = ui_menu_entry_create(window->sysmenu, "~R~estore",
    256             "", &mrestore);
    257         if (rc != EOK)
    258                 goto error;
    259 
    260         if (!window->wdecor->maximized)
    261                 ui_menu_entry_set_disabled(mrestore, true);
    262 
    263         ui_menu_entry_set_cb(mrestore, wnd_sysmenu_erestore, (void *)window);
    264 
    265         rc = ui_menu_entry_create(window->sysmenu, "Mi~n~imize",
    266             "", &mmin);
    267         if (rc != EOK)
    268                 goto error;
    269 
    270         if ((window->wdecor->style & ui_wds_minimize_btn) == 0)
    271                 ui_menu_entry_set_disabled(mmin, true);
    272 
    273         ui_menu_entry_set_cb(mmin, wnd_sysmenu_eminimize, (void *)window);
    274 
    275         rc = ui_menu_entry_create(window->sysmenu, "Ma~x~imize",
    276             "", &mmax);
    277         if (rc != EOK)
    278                 goto error;
    279 
    280         if ((window->wdecor->style & ui_wds_maximize_btn) == 0 ||
    281             window->wdecor->maximized)
    282                 ui_menu_entry_set_disabled(mmax, true);
    283 
    284         ui_menu_entry_set_cb(mmax, wnd_sysmenu_emaximize, (void *)window);
    285 
    286         rc = ui_menu_entry_sep_create(window->sysmenu, &msep);
    287         if (rc != EOK)
    288                 goto error;
    289 
    290         rc = ui_menu_entry_create(window->sysmenu, "~C~lose", "Alt-F4",
    291             &mclose);
    292         if (rc != EOK)
    293                 goto error;
    294 
    295         if ((window->wdecor->style & ui_wds_close_btn) == 0)
    296                 ui_menu_entry_set_disabled(mclose, true);
    297 
    298         ui_menu_entry_set_cb(mclose, wnd_sysmenu_eclose, (void *)window);
    299 
    300         window->sysmenu_restore = mrestore;
    301         window->sysmenu_minimize = mmin;
    302         window->sysmenu_maximize = mmax;
    303 
    304         return EOK;
    305 error:
    306         return rc;
    307184}
    308185
    … …  
    318195{
    319196        ui_window_t *window;
    320         ui_window_t *pwindow = NULL;
    321197        display_info_t info;
    322198        gfx_coord2_t scr_dims;
    … …  
    342218        display_wnd_params_init(&dparams);
    343219        dparams.rect = params->rect;
    344         dparams.caption = params->caption;
    345220        /* Only allow making the window larger */
    346221        gfx_rect_dims(&params->rect, &dparams.min_size);
    347222
    348         /*
    349          * If idev_id is not specified, use the UI default (probably
    350          * obtained from display specification. This creates the
    351          * main window in the seat specified on the command line.
    352          */
    353         if (params->idev_id != 0)
    354                 dparams.idev_id = params->idev_id;
    355         else
    356                 dparams.idev_id = ui->idev_id;
    357 
    358223        if ((params->flags & ui_wndf_popup) != 0)
    359224                dparams.flags |= wndf_popup;
    360         if ((params->flags & ui_wndf_topmost) != 0)
    361                 dparams.flags |= wndf_topmost;
    362         if ((params->flags & ui_wndf_system) != 0)
    363                 dparams.flags |= wndf_system;
    364         if ((params->flags & ui_wndf_avoid) != 0)
    365                 dparams.flags |= wndf_avoid;
    366225
    367226        if (ui->display != NULL) {
    … …  
    403262                        gfx_coord2_add(&dparams.rect.p0, &scr_dims,
    404263                            &dparams.rect.p1);
    405                         (void) console_set_caption(ui->console,
    406                             params->caption);
    407264                }
    408265        } else {
    … …  
    498355        window->wdecor = wdecor;
    499356        window->cursor = ui_curs_arrow;
    500         window->placement = params->placement;
    501 
    502         rc = ui_window_sysmenu_create(window);
    503         if (rc != EOK)
    504                 goto error;
    505 
    506357        *rwindow = window;
    507358
    508         if (ui_is_fullscreen(ui))
    509                 pwindow = ui_window_get_active(ui);
    510 
    511359        list_append(&window->lwindows, &ui->windows);
    512 
    513         if (ui_is_fullscreen(ui)) {
    514                 /* Send unfocus event to previously active window */
    515                 if (pwindow != NULL)
    516                         ui_window_send_unfocus(pwindow, 0);
    517         }
    518 
    519360        return EOK;
    520361error:
    … …  
    542383{
    543384        ui_t *ui;
    544         ui_window_t *nwindow;
    545385
    546386        if (window == NULL)
    … …  
    551391        list_remove(&window->lwindows);
    552392        ui_control_destroy(window->control);
    553         ui_menu_destroy(window->sysmenu);
    554393        ui_wdecor_destroy(window->wdecor);
    555394        ui_resource_destroy(window->res);
    556         if (window->app_mgc != NULL)
     395        if (0 && window->app_mgc != NULL)
    557396                mem_gc_delete(window->app_mgc);
    558         if (window->app_bmp != NULL)
     397        if (0 && window->app_bmp != NULL)
    559398                gfx_bitmap_destroy(window->app_bmp);
    560399        if (window->mgc != NULL) {
    … …  
    567406                display_window_destroy(window->dwindow);
    568407
     408        free(window);
     409
    569410        /* Need to repaint if windows are emulated */
    570411        if (ui_is_fullscreen(ui)) {
    571412                ui_paint(ui);
    572                 /* Send focus event to newly active window */
    573                 nwindow = ui_window_get_active(ui);
    574                 if (nwindow != NULL)
    575                         ui_window_send_focus(nwindow, 0);
    576         }
    577 
    578         if (ui->console != NULL &&
    579             window->placement == ui_wnd_place_full_screen) {
    580                 (void) console_set_caption(ui->console, "");
    581         }
    582 
    583         free(window);
     413        }
    584414}
    585415
    … …  
    591421 * @param window Window
    592422 * @param control Control
     423 * @return EOK on success, ENOMEM if out of memory
    593424 */
    594425void ui_window_add(ui_window_t *window, ui_control_t *control)
    … …  
    630461}
    631462
    632 /** Resize or (un)maximize window.
     463/** Resize/move window.
     464 *
     465 * Resize window to the dimensions of @a rect. If @a rect.p0 is not 0,0,
     466 * the top-left corner of the window will move on the screen accordingly.
    633467 *
    634468 * @param window Window
    635469 * @param rect Rectangle
    636  * @param scop Size change operation
    637470 *
    638471 * @return EOK on success or an error code
    639472 */
    640 errno_t ui_window_size_change(ui_window_t *window, gfx_rect_t *rect,
    641     ui_wnd_sc_op_t scop)
     473errno_t ui_window_resize(ui_window_t *window, gfx_rect_t *rect)
    642474{
    643475        gfx_coord2_t offs;
    … …  
    705537        }
    706538
    707         /* dwindow can be NULL in case of unit tests or fullscreen mode */
     539        /* dwindow can be NULL in case of unit tests */
    708540        if (window->dwindow != NULL) {
    709                 switch (scop) {
    710                 case ui_wsc_resize:
    711                         rc = display_window_resize(window->dwindow, &offs,
    712                             &nrect);
    713                         if (rc != EOK)
    714                                 goto error;
    715                         break;
    716                 case ui_wsc_maximize:
    717                         rc = display_window_maximize(window->dwindow);
    718                         if (rc != EOK)
    719                                 goto error;
    720                         break;
    721                 case ui_wsc_unmaximize:
    722                         rc = display_window_unmaximize(window->dwindow);
    723                         if (rc != EOK)
    724                                 goto error;
    725                         break;
    726                 }
     541                rc = display_window_resize(window->dwindow, &offs, &nrect);
     542                if (rc != EOK)
     543                        goto error;
    727544        }
    728545
    … …  
    744561                        goto error;
    745562#endif
     563
    746564                mem_gc_retarget(window->mgc, &win_params.rect, &win_alloc);
    747565
    … …  
    750568        }
    751569
    752         window->rect = nrect;
    753570        ui_wdecor_set_rect(window->wdecor, &nrect);
    754571        ui_wdecor_paint(window->wdecor);
    … …  
    772589}
    773590
    774 /** Resize/move window.
    775  *
    776  * Resize window to the dimensions of @a rect. If @a rect.p0 is not 0,0,
    777  * the top-left corner of the window will move on the screen accordingly.
    778  *
    779  * @param window Window
    780  * @param rect Rectangle
    781  *
    782  * @return EOK on success or an error code
    783  */
    784 errno_t ui_window_resize(ui_window_t *window, gfx_rect_t *rect)
    785 {
    786         return ui_window_size_change(window, rect, ui_wsc_resize);
    787 }
    788 
    789591/** Set window callbacks.
    790592 *
    … …  
    797599        window->cb = cb;
    798600        window->arg = arg;
    799 }
    800 
    801 /** Change window caption.
    802  *
    803  * @param window Window
    804  * @param caption New caption
    805  *
    806  * @return EOK on success or an error code
    807  */
    808 errno_t ui_window_set_caption(ui_window_t *window, const char *caption)
    809 {
    810         errno_t rc;
    811 
    812         /* Set console caption if fullscreen window on console */
    813         if (window->ui->console != NULL && window->placement ==
    814             ui_wnd_place_full_screen) {
    815                 rc = console_set_caption(window->ui->console, caption);
    816                 if (rc != EOK)
    817                         return rc;
    818         }
    819 
    820         /* Set display window caption if running on display service */
    821         if (window->dwindow != NULL) {
    822                 rc = display_window_set_caption(window->dwindow, caption);
    823                 if (rc != EOK)
    824                         return rc;
    825         }
    826 
    827         return ui_wdecor_set_caption(window->wdecor, caption);
    828601}
    829602
    … …  
    973746{
    974747        ui_window_t *window = (ui_window_t *) arg;
    975         ui_t *ui = window->ui;
    976 
    977         ui_lock(ui);
     748
    978749        ui_window_send_close(window);
    979         ui_unlock(ui);
    980750}
    981751
    982752/** Handle window focus event. */
    983 static void dwnd_focus_event(void *arg, unsigned nfocus)
    984 {
    985         ui_window_t *window = (ui_window_t *) arg;
    986         ui_t *ui = window->ui;
    987 
    988         ui_lock(ui);
    989         (void)nfocus;
     753static void dwnd_focus_event(void *arg)
     754{
     755        ui_window_t *window = (ui_window_t *) arg;
    990756
    991757        if (window->wdecor != NULL) {
    … …  
    994760        }
    995761
    996         ui_window_send_focus(window, nfocus);
    997         ui_unlock(ui);
     762        ui_window_send_focus(window);
    998763}
    999764
    … …  
    1002767{
    1003768        ui_window_t *window = (ui_window_t *) arg;
    1004         ui_t *ui = window->ui;
    1005 
    1006         ui_lock(ui);
     769
     770        (void) window;
    1007771        ui_window_send_kbd(window, kbd_event);
    1008         ui_unlock(ui);
    1009772}
    1010773
    … …  
    1013776{
    1014777        ui_window_t *window = (ui_window_t *) arg;
    1015         ui_t *ui = window->ui;
    1016         ui_evclaim_t claim;
    1017778
    1018779        /* Make sure we don't process events until fully initialized */
    … …  
    1020781                return;
    1021782
    1022         ui_lock(ui);
    1023 
    1024         claim = ui_wdecor_pos_event(window->wdecor, event);
    1025         if (claim == ui_claimed) {
    1026                 ui_unlock(ui);
    1027                 return;
    1028         }
    1029 
     783        ui_wdecor_pos_event(window->wdecor, event);
    1030784        ui_window_send_pos(window, event);
    1031         ui_unlock(ui);
    1032785}
    1033786
    … …  
    1036789{
    1037790        ui_window_t *window = (ui_window_t *) arg;
    1038         ui_t *ui = window->ui;
    1039791
    1040792        /* Make sure we don't process events until fully initialized */
    … …  
    1045797                return;
    1046798
    1047         ui_lock(ui);
    1048799        (void) ui_window_resize(window, rect);
    1049800        (void) ui_window_paint(window);
    1050         ui_unlock(ui);
    1051801}
    1052802
    1053803/** Handle window unfocus event. */
    1054 static void dwnd_unfocus_event(void *arg, unsigned nfocus)
    1055 {
    1056         ui_window_t *window = (ui_window_t *) arg;
    1057         ui_t *ui = window->ui;
    1058 
    1059         ui_lock(ui);
    1060 
    1061         if (window->wdecor != NULL && nfocus == 0) {
     804static void dwnd_unfocus_event(void *arg)
     805{
     806        ui_window_t *window = (ui_window_t *) arg;
     807
     808        if (window->wdecor != NULL) {
    1062809                ui_wdecor_set_active(window->wdecor, false);
    1063810                ui_wdecor_paint(window->wdecor);
    1064811        }
    1065812
    1066         ui_window_send_unfocus(window, nfocus);
    1067         ui_unlock(ui);
    1068 }
    1069 
    1070 /** Window decoration requested opening of system menu.
    1071  *
    1072  * @param wdecor Window decoration
    1073  * @param arg Argument (window)
    1074  * @param idev_id Input device ID
    1075  */
    1076 static void wd_sysmenu_open(ui_wdecor_t *wdecor, void *arg, sysarg_t idev_id)
    1077 {
    1078         ui_window_t *window = (ui_window_t *) arg;
    1079 
    1080         ui_window_send_sysmenu(window, idev_id);
    1081 }
    1082 
    1083 /** Window decoration requested moving left from system menu handle.
    1084  *
    1085  * @param wdecor Window decoration
    1086  * @param arg Argument (window)
    1087  * @param idev_id Input device ID
    1088  */
    1089 static void wd_sysmenu_left(ui_wdecor_t *wdecor, void *arg, sysarg_t idev_id)
    1090 {
    1091         ui_window_t *window = (ui_window_t *) arg;
    1092 
    1093         if (window->mbar != NULL) {
    1094                 ui_wdecor_sysmenu_hdl_set_active(window->wdecor, false);
    1095                 ui_menu_close(window->sysmenu);
    1096                 ui_menu_bar_select_last(window->mbar, false, idev_id);
    1097         }
    1098 }
    1099 
    1100 /** Window decoration requested moving right from system menu handle.
    1101  *
    1102  * @param wdecor Window decoration
    1103  * @param arg Argument (window)
    1104  * @param idev_id Input device ID
    1105  */
    1106 static void wd_sysmenu_right(ui_wdecor_t *wdecor, void *arg, sysarg_t idev_id)
    1107 {
    1108         ui_window_t *window = (ui_window_t *) arg;
    1109 
    1110         if (window->mbar != NULL) {
    1111                 ui_wdecor_sysmenu_hdl_set_active(window->wdecor, false);
    1112                 ui_menu_close(window->sysmenu);
    1113                 ui_menu_bar_select_first(window->mbar, false, idev_id);
    1114         }
    1115 }
    1116 
    1117 /** Window decoration detected accelerator press from system menu handle.
    1118  *
    1119  * @param wdecor Window decoration
    1120  * @param arg Argument (window)
    1121  * @param c Accelerator key
    1122  * @param idev_id Input device ID
    1123  */
    1124 static void wd_sysmenu_accel(ui_wdecor_t *wdecor, void *arg, char32_t c,
    1125     sysarg_t idev_id)
    1126 {
    1127         ui_window_t *window = (ui_window_t *) arg;
    1128 
    1129         if (window->mbar != NULL) {
    1130                 ui_wdecor_sysmenu_hdl_set_active(window->wdecor, false);
    1131                 ui_menu_close(window->sysmenu);
    1132                 ui_menu_bar_press_accel(window->mbar, c, idev_id);
    1133         }
    1134 }
    1135 
    1136 /** Window decoration requested window minimization.
    1137  *
    1138  * @param wdecor Window decoration
    1139  * @param arg Argument (window)
    1140  */
    1141 static void wd_minimize(ui_wdecor_t *wdecor, void *arg)
    1142 {
    1143         ui_window_t *window = (ui_window_t *) arg;
    1144 
    1145         ui_window_send_minimize(window);
    1146 }
    1147 
    1148 /** Window decoration requested window maximization.
    1149  *
    1150  * @param wdecor Window decoration
    1151  * @param arg Argument (window)
    1152  */
    1153 static void wd_maximize(ui_wdecor_t *wdecor, void *arg)
    1154 {
    1155         ui_window_t *window = (ui_window_t *) arg;
    1156 
    1157         ui_window_send_maximize(window);
    1158 }
    1159 
    1160 /** Window decoration requested window unmaximization.
    1161  *
    1162  * @param wdecor Window decoration
    1163  * @param arg Argument (window)
    1164  */
    1165 static void wd_unmaximize(ui_wdecor_t *wdecor, void *arg)
    1166 {
    1167         ui_window_t *window = (ui_window_t *) arg;
    1168 
    1169         ui_window_send_unmaximize(window);
     813        ui_window_send_unfocus(window);
    1170814}
    1171815
    … …  
    1187831 * @param arg Argument (window)
    1188832 * @param pos Position where the title bar was pressed
    1189  * @param pos_id Positioning device ID
    1190  */
    1191 static void wd_move(ui_wdecor_t *wdecor, void *arg, gfx_coord2_t *pos,
    1192     sysarg_t pos_id)
     833 */
     834static void wd_move(ui_wdecor_t *wdecor, void *arg, gfx_coord2_t *pos)
    1193835{
    1194836        ui_window_t *window = (ui_window_t *) arg;
    1195837
    1196838        if (window->dwindow != NULL)
    1197                 (void) display_window_move_req(window->dwindow, pos, pos_id);
     839                (void) display_window_move_req(window->dwindow, pos);
    1198840}
    1199841
    … …  
    1204846 * @param rsztype Resize type
    1205847 * @param pos Position where the button was pressed
    1206  * @param pos_id Positioning device ID
    1207848 */
    1208849static void wd_resize(ui_wdecor_t *wdecor, void *arg,
    1209     ui_wdecor_rsztype_t rsztype, gfx_coord2_t *pos, sysarg_t pos_id)
    1210 {
    1211         ui_window_t *window = (ui_window_t *) arg;
    1212 
    1213         if (window->dwindow != NULL) {
    1214                 (void) display_window_resize_req(window->dwindow,
    1215                     (display_wnd_rsztype_t) rsztype, // Same constants in the enums
    1216                     pos, pos_id);
    1217         }
     850    ui_wdecor_rsztype_t rsztype, gfx_coord2_t *pos)
     851{
     852        ui_window_t *window = (ui_window_t *) arg;
     853
     854        if (window->dwindow != NULL)
     855                (void) display_window_resize_req(window->dwindow, rsztype, pos);
    1218856}
    1219857
    … …  
    1276914}
    1277915
    1278 /** Send window sysmenu event.
    1279  *
    1280  * @param window Window
    1281  * @parma idev_id Input device ID
    1282  */
    1283 void ui_window_send_sysmenu(ui_window_t *window, sysarg_t idev_id)
    1284 {
    1285         if (window->cb != NULL && window->cb->sysmenu != NULL)
    1286                 window->cb->sysmenu(window, window->arg, idev_id);
    1287         else
    1288                 ui_window_def_sysmenu(window, idev_id);
    1289 }
    1290 
    1291 /** Send window minimize event.
    1292  *
    1293  * @param window Window
    1294  */
    1295 void ui_window_send_minimize(ui_window_t *window)
    1296 {
    1297         if (window->cb != NULL && window->cb->maximize != NULL)
    1298                 window->cb->minimize(window, window->arg);
    1299         else
    1300                 ui_window_def_minimize(window);
    1301 }
    1302 
    1303 /** Send window maximize event.
    1304  *
    1305  * @param window Window
    1306  */
    1307 void ui_window_send_maximize(ui_window_t *window)
    1308 {
    1309         if (window->cb != NULL && window->cb->maximize != NULL)
    1310                 window->cb->maximize(window, window->arg);
    1311         else
    1312                 ui_window_def_maximize(window);
    1313 }
    1314 
    1315 /** Send window unmaximize event.
    1316  *
    1317  * @param window Window
    1318  */
    1319 void ui_window_send_unmaximize(ui_window_t *window)
    1320 {
    1321         if (window->cb != NULL && window->cb->unmaximize != NULL)
    1322                 window->cb->unmaximize(window, window->arg);
    1323         else
    1324                 ui_window_def_unmaximize(window);
    1325 }
    1326 
    1327916/** Send window close event.
    1328917 *
    … …  
    1338927 *
    1339928 * @param window Window
    1340  * @param nfocus New number of foci
    1341  */
    1342 void ui_window_send_focus(ui_window_t *window, unsigned nfocus)
     929 */
     930void ui_window_send_focus(ui_window_t *window)
    1343931{
    1344932        if (window->cb != NULL && window->cb->focus != NULL)
    1345                 window->cb->focus(window, window->arg, nfocus);
     933                window->cb->focus(window, window->arg);
    1346934}
    1347935
    … …  
    1355943                window->cb->kbd(window, window->arg, kbd);
    1356944        else
    1357                 ui_window_def_kbd(window, kbd);
     945                return ui_window_def_kbd(window, kbd);
    1358946}
    1359947
    … …  
    1385973 *
    1386974 * @param window Window
    1387  * @param nfocus Number of remaining foci
    1388  */
    1389 void ui_window_send_unfocus(ui_window_t *window, unsigned nfocus)
     975 */
     976void ui_window_send_unfocus(ui_window_t *window)
    1390977{
    1391978        if (window->cb != NULL && window->cb->unfocus != NULL)
    1392                 window->cb->unfocus(window, window->arg, nfocus);
     979                window->cb->unfocus(window, window->arg);
    1393980        else
    1394                 return ui_window_def_unfocus(window, nfocus);
    1395 }
    1396 
    1397 /** Default window sysmenu routine.
    1398  *
    1399  * @param window Window
    1400  * @param idev_id Input device ID
    1401  * @return EOK on success or an error code
    1402  */
    1403 errno_t ui_window_def_sysmenu(ui_window_t *window, sysarg_t idev_id)
    1404 {
    1405         errno_t rc;
    1406         ui_wdecor_geom_t geom;
    1407 
    1408         if (ui_menu_is_open(window->sysmenu)) {
    1409                 ui_menu_close(window->sysmenu);
    1410         } else {
    1411                 ui_wdecor_get_geom(window->wdecor, &geom);
    1412 
    1413                 rc = ui_menu_open(window->sysmenu, &geom.title_bar_rect,
    1414                     idev_id);
    1415                 if (rc != EOK)
    1416                         goto error;
    1417         }
    1418 
    1419         return EOK;
    1420 error:
    1421         return rc;
    1422 }
    1423 
    1424 /** Default window minimize routine.
    1425  *
    1426  * @param window Window
    1427  * @return EOK on success or an error code
    1428  */
    1429 errno_t ui_window_def_minimize(ui_window_t *window)
    1430 {
    1431         errno_t rc;
    1432 
    1433         if (window->dwindow != NULL) {
    1434                 rc = display_window_minimize(window->dwindow);
    1435                 if (rc != EOK)
    1436                         goto error;
    1437         }
    1438 
    1439         return EOK;
    1440 error:
    1441         return rc;
    1442 }
    1443 
    1444 /** Default window maximize routine.
    1445  *
    1446  * @param window Window
    1447  * @return EOK on success or an error code
    1448  */
    1449 errno_t ui_window_def_maximize(ui_window_t *window)
    1450 {
    1451         errno_t rc;
    1452         gfx_rect_t old_rect;
    1453         gfx_rect_t rect;
    1454 
    1455         old_rect = window->rect;
    1456 
    1457         if (window->dwindow != NULL) {
    1458                 rc = display_window_get_max_rect(window->dwindow, &rect);
    1459                 if (rc != EOK)
    1460                         return rc;
    1461         } else {
    1462                 rect = window->ui->rect;
    1463         }
    1464 
    1465         ui_wdecor_set_maximized(window->wdecor, true);
    1466         ui_menu_entry_set_disabled(window->sysmenu_restore, false);
    1467         ui_menu_entry_set_disabled(window->sysmenu_maximize, true);
    1468 
    1469         rc = ui_window_size_change(window, &rect, ui_wsc_maximize);
    1470         if (rc != EOK) {
    1471                 ui_wdecor_set_maximized(window->wdecor, false);
    1472                 return rc;
    1473         }
    1474 
    1475         window->normal_rect = old_rect;
    1476         (void) ui_window_paint(window);
    1477         return EOK;
    1478 }
    1479 
    1480 /** Default window unmaximize routine.
    1481  *
    1482  * @param window Window
    1483  * @return EOK on success or an error code
    1484  */
    1485 errno_t ui_window_def_unmaximize(ui_window_t *window)
    1486 {
    1487         errno_t rc;
    1488 
    1489         ui_wdecor_set_maximized(window->wdecor, false);
    1490         ui_menu_entry_set_disabled(window->sysmenu_restore, true);
    1491         ui_menu_entry_set_disabled(window->sysmenu_maximize, false);
    1492 
    1493         rc = ui_window_size_change(window, &window->normal_rect,
    1494             ui_wsc_unmaximize);
    1495         if (rc != EOK) {
    1496                 ui_wdecor_set_maximized(window->wdecor, true);
    1497                 printf("ui_window_size_change->error\n");
    1498                 return rc;
    1499         }
    1500 
    1501         (void) ui_window_paint(window);
    1502         return EOK;
     981                return ui_window_def_unfocus(window);
    1503982}
    1504983
    … …  
    1506985 *
    1507986 * @param window Window
    1508  * @return ui_claimed iff event was claimed
    1509  */
    1510 ui_evclaim_t ui_window_def_kbd(ui_window_t *window, kbd_event_t *kbd)
    1511 {
    1512         ui_evclaim_t claim;
    1513 
     987 */
     988void ui_window_def_kbd(ui_window_t *window, kbd_event_t *kbd)
     989{
    1514990        if (window->control != NULL)
    1515                 claim = ui_control_kbd_event(window->control, kbd);
    1516         else
    1517                 claim = ui_unclaimed;
    1518 
    1519         if (claim == ui_unclaimed)
    1520                 return ui_wdecor_kbd_event(window->wdecor, kbd);
    1521 
    1522         return ui_unclaimed;
     991                ui_control_kbd_event(window->control, kbd);
    1523992}
    1524993
    … …  
    15661035 *
    15671036 * @param window Window
    1568  * @param nfocus Number of remaining foci
    15691037 * @return EOK on success or an error code
    15701038 */
    1571 void ui_window_def_unfocus(ui_window_t *window, unsigned nfocus)
     1039void ui_window_def_unfocus(ui_window_t *window)
    15721040{
    15731041        if (window->control != NULL)
    1574                 ui_control_unfocus(window->control, nfocus);
    1575 }
    1576 
    1577 /** Handle system menu left event.
    1578  *
    1579  * @param sysmenu System menu
    1580  * @param arg Argument (ui_window_t *)
    1581  * @param idev_id Input device ID
    1582  */
    1583 static void wnd_sysmenu_left(ui_menu_t *sysmenu, void *arg, sysarg_t idev_id)
    1584 {
    1585         ui_window_t *window = (ui_window_t *)arg;
    1586 
    1587         if (window->mbar != NULL) {
    1588                 ui_wdecor_sysmenu_hdl_set_active(window->wdecor, false);
    1589                 ui_menu_close(sysmenu);
    1590                 ui_menu_bar_select_last(window->mbar, true, idev_id);
    1591         }
    1592 }
    1593 
    1594 /** Handle system menu right event.
    1595  *
    1596  * @param sysmenu System menu
    1597  * @param arg Argument (ui_window_t *)
    1598  * @param idev_id Input device ID
    1599  */
    1600 static void wnd_sysmenu_right(ui_menu_t *sysmenu, void *arg, sysarg_t idev_id)
    1601 {
    1602         ui_window_t *window = (ui_window_t *)arg;
    1603 
    1604         if (window->mbar != NULL) {
    1605                 ui_wdecor_sysmenu_hdl_set_active(window->wdecor, false);
    1606                 ui_menu_close(sysmenu);
    1607                 ui_menu_bar_select_first(window->mbar, true, idev_id);
    1608         }
    1609 }
    1610 
    1611 /** Handle system menu close request event.
    1612  *
    1613  * @param sysmenu System menu
    1614  * @param arg Argument (ui_window_t *)
    1615  * @param idev_id Input device ID
    1616  */
    1617 static void wnd_sysmenu_close_req(ui_menu_t *sysmenu, void *arg)
    1618 {
    1619         ui_window_t *window = (ui_window_t *)arg;
    1620 
    1621         ui_wdecor_sysmenu_hdl_set_active(window->wdecor, false);
    1622         ui_menu_close(sysmenu);
    1623 }
    1624 
    1625 /** Handle system menu Restore entry activation.
    1626  *
    1627  * @param mentry Menu entry
    1628  * @param arg Argument (ui_window_t *)
    1629  */
    1630 static void wnd_sysmenu_erestore(ui_menu_entry_t *mentry, void *arg)
    1631 {
    1632         ui_window_t *window = (ui_window_t *)arg;
    1633 
    1634         ui_window_send_unmaximize(window);
    1635 }
    1636 
    1637 /** Handle system menu Minimize entry activation.
    1638  *
    1639  * @param mentry Menu entry
    1640  * @param arg Argument (ui_window_t *)
    1641  */
    1642 static void wnd_sysmenu_eminimize(ui_menu_entry_t *mentry, void *arg)
    1643 {
    1644         ui_window_t *window = (ui_window_t *)arg;
    1645 
    1646         ui_window_send_minimize(window);
    1647 }
    1648 
    1649 /** Handle system menu Maximize entry activation.
    1650  *
    1651  * @param mentry Menu entry
    1652  * @param arg Argument (ui_window_t *)
    1653  */
    1654 static void wnd_sysmenu_emaximize(ui_menu_entry_t *mentry, void *arg)
    1655 {
    1656         ui_window_t *window = (ui_window_t *)arg;
    1657 
    1658         ui_window_send_maximize(window);
    1659 }
    1660 
    1661 /** Handle system menu Close entry activation.
    1662  *
    1663  * @param mentry Menu entry
    1664  * @param arg Argument (ui_window_t *)
    1665  */
    1666 static void wnd_sysmenu_eclose(ui_menu_entry_t *mentry, void *arg)
    1667 {
    1668         ui_window_t *window = (ui_window_t *)arg;
    1669 
    1670         ui_window_send_close(window);
    1671 }
    1672 
    1673 /** Handle system menu press accelerator key event.
    1674  *
    1675  * @param sysmenu System menu
    1676  * @param arg Argument (ui_window_t *)
    1677  * @param idev_id Input device ID
    1678  */
    1679 static void wnd_sysmenu_press_accel(ui_menu_t *sysmenu, void *arg,
    1680     char32_t c, sysarg_t idev_id)
    1681 {
    1682         (void)sysmenu;
    1683         (void)arg;
    1684         (void)c;
    1685         (void)idev_id;
     1042                ui_control_unfocus(window->control);
    16861043}
    16871044
Note: See TracChangeset for help on using the changeset viewer.