Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r8279aab r1215db9  
    11/*
    2  * Copyright (c) 2025 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 *);
    … …  
    166132/** Compute where window should be placed on the screen.
    167133 *
    168  * This only applies to windows that do not use default placement or
    169  * if we are running in full-screen mode.
    170  *
    171  * @param window Window
    172  * @param drect Display rectangle
     134 * This only applies to windows that do not use default placement.
     135 *
     136 * @param window Window
     137 * @param display Display
     138 * @param info Display info
    173139 * @param params Window parameters
    174140 * @param pos Place to store position of top-left corner
    175141 */
    176 static void ui_window_place(ui_window_t *window, gfx_rect_t *drect,
    177     ui_wnd_params_t *params, gfx_coord2_t *pos)
    178 {
    179         gfx_coord2_t dims;
    180         gfx_coord2_t below_pos;
    181         gfx_rect_t below_rect;
    182 
    183         assert(params->placement != ui_wnd_place_default ||
    184             ui_is_fullscreen(window->ui));
     142static void ui_window_place(ui_window_t *window, display_t *display,
     143    display_info_t *info, ui_wnd_params_t *params, gfx_coord2_t *pos)
     144{
     145        assert(params->placement != ui_wnd_place_default);
    185146
    186147        pos->x = 0;
    … …  
    189150        switch (params->placement) {
    190151        case ui_wnd_place_default:
    191         case ui_wnd_place_center:
    192                 assert(params->placement != ui_wnd_place_default ||
    193                     ui_is_fullscreen(window->ui));
    194                 /* Center window */
    195                 gfx_rect_dims(&params->rect, &dims);
    196                 pos->x = (drect->p0.x + drect->p1.x) / 2 - dims.x / 2;
    197                 pos->y = (drect->p0.y + drect->p1.y) / 2 - dims.y / 2;
    198                 break;
     152                assert(false);
    199153        case ui_wnd_place_top_left:
    200154        case ui_wnd_place_full_screen:
    201                 pos->x = drect->p0.x - params->rect.p0.x;
    202                 pos->y = drect->p0.y - params->rect.p0.y;
     155                pos->x = info->rect.p0.x - params->rect.p0.x;
     156                pos->y = info->rect.p0.y - params->rect.p0.y;
    203157                break;
    204158        case ui_wnd_place_top_right:
    205                 pos->x = drect->p1.x - params->rect.p1.x;
    206                 pos->y = drect->p0.y - params->rect.p0.y;
     159                pos->x = info->rect.p1.x - params->rect.p1.x;
     160                pos->y = info->rect.p0.y - params->rect.p0.y;
    207161                break;
    208162        case ui_wnd_place_bottom_left:
    209                 pos->x = drect->p0.x - params->rect.p0.x;
    210                 pos->y = drect->p1.y - params->rect.p1.y;
     163                pos->x = info->rect.p0.x - params->rect.p0.x;
     164                pos->y = info->rect.p1.y - params->rect.p1.y;
    211165                break;
    212166        case ui_wnd_place_bottom_right:
    213                 pos->x = drect->p1.x - params->rect.p1.x;
    214                 pos->y = drect->p1.y - params->rect.p1.y;
     167                pos->x = info->rect.p1.x - params->rect.p1.x;
     168                pos->y = info->rect.p1.y - params->rect.p1.y;
    215169                break;
    216170        case ui_wnd_place_popup:
    217                 /* Compute rectangle when placed below */
    218                 below_pos.x = params->prect.p0.x;
    219                 below_pos.y = params->prect.p1.y;
    220                 gfx_rect_translate(&below_pos, &params->rect, &below_rect);
    221 
    222                 /* Does below_rect fit within the display? */
    223                 if (gfx_rect_is_inside(&below_rect, drect)) {
    224                         /* Place popup window below parent rectangle */
    225                         pos->x = params->prect.p0.x - params->rect.p0.x;
    226                         pos->y = params->prect.p1.y - params->rect.p0.y;
    227                 } else {
    228                         /* Place popup window above parent rectangle */
    229                         pos->x = params->prect.p0.x;
    230                         pos->y = params->prect.p0.y -
    231                             (params->rect.p1.y - params->rect.p0.y);
    232                 }
     171                /* Place popup window below parent rectangle */
     172                pos->x = params->prect.p0.x;
     173                pos->y = params->prect.p1.y;
    233174                break;
    234175        }
    235 }
    236 
    237 /** Create window's system menu.
    238  *
    239  * @param window Window
    240  * @return EOK on success or an error code
    241  */
    242 static errno_t ui_window_sysmenu_create(ui_window_t *window)
    243 {
    244         errno_t rc;
    245         ui_menu_entry_t *mrestore;
    246         ui_menu_entry_t *mmin;
    247         ui_menu_entry_t *mmax;
    248         ui_menu_entry_t *msep;
    249         ui_menu_entry_t *mclose;
    250 
    251         rc = ui_menu_create(window, &window->sysmenu);
    252         if (rc != EOK)
    253                 goto error;
    254 
    255         ui_menu_set_cb(window->sysmenu, &wnd_sysmenu_cb, (void *)window);
    256 
    257         rc = ui_menu_entry_create(window->sysmenu, "~R~estore",
    258             "", &mrestore);
    259         if (rc != EOK)
    260                 goto error;
    261 
    262         if (!window->wdecor->maximized)
    263                 ui_menu_entry_set_disabled(mrestore, true);
    264 
    265         ui_menu_entry_set_cb(mrestore, wnd_sysmenu_erestore, (void *)window);
    266 
    267         rc = ui_menu_entry_create(window->sysmenu, "Mi~n~imize",
    268             "", &mmin);
    269         if (rc != EOK)
    270                 goto error;
    271 
    272         if ((window->wdecor->style & ui_wds_minimize_btn) == 0)
    273                 ui_menu_entry_set_disabled(mmin, true);
    274 
    275         ui_menu_entry_set_cb(mmin, wnd_sysmenu_eminimize, (void *)window);
    276 
    277         rc = ui_menu_entry_create(window->sysmenu, "Ma~x~imize",
    278             "", &mmax);
    279         if (rc != EOK)
    280                 goto error;
    281 
    282         if ((window->wdecor->style & ui_wds_maximize_btn) == 0 ||
    283             window->wdecor->maximized)
    284                 ui_menu_entry_set_disabled(mmax, true);
    285 
    286         ui_menu_entry_set_cb(mmax, wnd_sysmenu_emaximize, (void *)window);
    287 
    288         rc = ui_menu_entry_sep_create(window->sysmenu, &msep);
    289         if (rc != EOK)
    290                 goto error;
    291 
    292         rc = ui_menu_entry_create(window->sysmenu, "~C~lose", "Alt-F4",
    293             &mclose);
    294         if (rc != EOK)
    295                 goto error;
    296 
    297         if ((window->wdecor->style & ui_wds_close_btn) == 0)
    298                 ui_menu_entry_set_disabled(mclose, true);
    299 
    300         ui_menu_entry_set_cb(mclose, wnd_sysmenu_eclose, (void *)window);
    301 
    302         window->sysmenu_restore = mrestore;
    303         window->sysmenu_minimize = mmin;
    304         window->sysmenu_maximize = mmax;
    305 
    306         return EOK;
    307 error:
    308         return rc;
    309176}
    310177
    … …  
    320187{
    321188        ui_window_t *window;
    322         ui_window_t *pwindow = NULL;
    323189        display_info_t info;
    324190        gfx_coord2_t scr_dims;
    … …  
    331197        gfx_bitmap_alloc_t alloc;
    332198        gfx_bitmap_t *bmp = NULL;
    333         gfx_coord2_t off;
    334199        mem_gc_t *memgc = NULL;
    335         xlate_gc_t *xgc = NULL;
    336200        errno_t rc;
    337201
    … …  
    340204                return ENOMEM;
    341205
    342         window->ui = ui;
    343 
    344206        display_wnd_params_init(&dparams);
    345207        dparams.rect = params->rect;
    346         dparams.caption = params->caption;
    347         dparams.min_size = params->min_size;
    348 
    349         /*
    350          * If idev_id is not specified, use the UI default (probably
    351          * obtained from display specification. This creates the
    352          * main window in the seat specified on the command line.
    353          */
    354         if (params->idev_id != 0)
    355                 dparams.idev_id = params->idev_id;
    356         else
    357                 dparams.idev_id = ui->idev_id;
     208        /* Only allow making the window larger */
     209        gfx_rect_dims(&params->rect, &dparams.min_size);
    358210
    359211        if ((params->flags & ui_wndf_popup) != 0)
    360212                dparams.flags |= wndf_popup;
    361         if ((params->flags & ui_wndf_nofocus) != 0)
    362                 dparams.flags |= wndf_nofocus;
    363         if ((params->flags & ui_wndf_topmost) != 0)
    364                 dparams.flags |= wndf_topmost;
    365         if ((params->flags & ui_wndf_system) != 0)
    366                 dparams.flags |= wndf_system;
    367         if ((params->flags & ui_wndf_avoid) != 0)
    368                 dparams.flags |= wndf_avoid;
    369213
    370214        if (ui->display != NULL) {
    … …  
    384228                if (params->placement != ui_wnd_place_default) {
    385229                        /* Set initial display window position */
    386                         ui_window_place(window, &info.rect, params,
    387                             &dparams.pos);
     230                        ui_window_place(window, ui->display, &info,
     231                            params, &dparams.pos);
    388232
    389233                        dparams.flags |= wndf_setpos;
    … …  
    400244        } else if (ui->console != NULL) {
    401245                gc = console_gc_get_ctx(ui->cgc);
    402 
    403                 if (params->placement == ui_wnd_place_full_screen) {
    404                         /* Make window the size of the screen */
    405                         gfx_rect_dims(&ui->rect, &scr_dims);
    406                         gfx_coord2_add(&dparams.rect.p0, &scr_dims,
    407                             &dparams.rect.p1);
    408                         (void) console_set_caption(ui->console,
    409                             params->caption);
    410                 }
    411246        } else {
    412247                /* Needed for unit tests */
    … …  
    428263
    429264        /* Move rectangle so that top-left corner is 0,0 */
    430         gfx_rect_rtranslate(&dparams.rect.p0, &dparams.rect, &bparams.rect);
     265        gfx_rect_rtranslate(&params->rect.p0, &params->rect, &bparams.rect);
    431266
    432267        rc = gfx_bitmap_create(gc, &bparams, NULL, &bmp);
    … …  
    452287        window->gc = mem_gc_get_ctx(memgc);
    453288        window->realgc = gc;
    454         (void) off;
    455289#else
    456         /* Server-side rendering */
    457 
    458         /* Full-screen mode? */
    459         if (ui->display == NULL) {
    460                 /* Create translating GC to translate window contents */
    461                 off.x = 0;
    462                 off.y = 0;
    463                 rc = xlate_gc_create(&off, gc, &xgc);
    464                 if (rc != EOK)
    465                         goto error;
    466 
    467                 window->xgc = xgc;
    468                 window->gc = xlate_gc_get_ctx(xgc);
    469                 window->realgc = gc;
    470         } else {
    471                 window->gc = gc;
    472         }
    473 
    474290        (void) ui_window_mem_gc_cb;
    475291        (void) alloc;
    476292        (void) bparams;
     293        window->gc = gc;
    477294#endif
    478         if (ui->display == NULL) {
    479                 ui_window_place(window, &ui->rect, params, &window->dpos);
    480 
    481                 if (window->xgc != NULL)
    482                         xlate_gc_set_off(window->xgc, &window->dpos);
    483         }
    484295
    485296        rc = ui_resource_create(window->gc, ui_is_textmode(ui), &res);
    … …  
    497308        ui_resource_set_expose_cb(res, ui_window_expose_cb, (void *) window);
    498309
     310        window->ui = ui;
    499311        window->rect = dparams.rect;
     312
    500313        window->res = res;
    501314        window->wdecor = wdecor;
    502315        window->cursor = ui_curs_arrow;
    503         window->placement = params->placement;
    504 
    505         rc = ui_window_sysmenu_create(window);
    506         if (rc != EOK)
    507                 goto error;
    508 
    509316        *rwindow = window;
    510317
    511         if (ui_is_fullscreen(ui))
    512                 pwindow = ui_window_get_active(ui);
    513 
    514318        list_append(&window->lwindows, &ui->windows);
    515 
    516         if (ui_is_fullscreen(ui)) {
    517                 /* Send unfocus event to previously active window */
    518                 if (pwindow != NULL)
    519                         ui_window_send_unfocus(pwindow, 0);
    520         }
    521 
    522319        return EOK;
    523320error:
    … …  
    528325        if (memgc != NULL)
    529326                mem_gc_delete(memgc);
    530         if (xgc != NULL)
    531                 xlate_gc_delete(xgc);
    532327        if (bmp != NULL)
    533328                gfx_bitmap_destroy(bmp);
    … …  
    545340{
    546341        ui_t *ui;
    547         ui_window_t *nwindow;
    548342
    549343        if (window == NULL)
    … …  
    554348        list_remove(&window->lwindows);
    555349        ui_control_destroy(window->control);
    556         ui_menu_destroy(window->sysmenu);
    557350        ui_wdecor_destroy(window->wdecor);
    558351        ui_resource_destroy(window->res);
    559         if (window->app_mgc != NULL)
     352        if (0 && window->app_mgc != NULL)
    560353                mem_gc_delete(window->app_mgc);
    561         if (window->app_bmp != NULL)
     354        if (0 && window->app_bmp != NULL)
    562355                gfx_bitmap_destroy(window->app_bmp);
    563356        if (window->mgc != NULL) {
    … …  
    567360        if (window->bmp != NULL)
    568361                gfx_bitmap_destroy(window->bmp);
     362        gfx_context_delete(window->gc);
    569363        if (window->dwindow != NULL)
    570364                display_window_destroy(window->dwindow);
     365
     366        free(window);
    571367
    572368        /* Need to repaint if windows are emulated */
    573369        if (ui_is_fullscreen(ui)) {
    574370                ui_paint(ui);
    575                 /* Send focus event to newly active window */
    576                 nwindow = ui_window_get_active(ui);
    577                 if (nwindow != NULL)
    578                         ui_window_send_focus(nwindow, 0);
    579         }
    580 
    581         if (ui->console != NULL &&
    582             window->placement == ui_wnd_place_full_screen) {
    583                 (void) console_set_caption(ui->console, "");
    584         }
    585 
    586         free(window);
     371        }
    587372}
    588373
    … …  
    594379 * @param window Window
    595380 * @param control Control
     381 * @return EOK on success, ENOMEM if out of memory
    596382 */
    597383void ui_window_add(ui_window_t *window, ui_control_t *control)
    … …  
    633419}
    634420
    635 /** Resize or (un)maximize window.
     421/** Resize/move window.
     422 *
     423 * Resize window to the dimensions of @a rect. If @a rect.p0 is not 0,0,
     424 * the top-left corner of the window will move on the screen accordingly.
    636425 *
    637426 * @param window Window
    638427 * @param rect Rectangle
    639  * @param scop Size change operation
    640428 *
    641429 * @return EOK on success or an error code
    642430 */
    643 errno_t ui_window_size_change(ui_window_t *window, gfx_rect_t *rect,
    644     ui_wnd_sc_op_t scop)
     431errno_t ui_window_resize(ui_window_t *window, gfx_rect_t *rect)
    645432{
    646433        gfx_coord2_t offs;
    … …  
    708495        }
    709496
    710         /* dwindow can be NULL in case of unit tests or fullscreen mode */
     497        /* dwindow can be NULL in case of unit tests */
    711498        if (window->dwindow != NULL) {
    712                 switch (scop) {
    713                 case ui_wsc_resize:
    714                         rc = display_window_resize(window->dwindow, &offs,
    715                             &nrect);
    716                         if (rc != EOK)
    717                                 goto error;
    718                         break;
    719                 case ui_wsc_maximize:
    720                         rc = display_window_maximize(window->dwindow);
    721                         if (rc != EOK)
    722                                 goto error;
    723                         break;
    724                 case ui_wsc_unmaximize:
    725                         rc = display_window_unmaximize(window->dwindow);
    726                         if (rc != EOK)
    727                                 goto error;
    728                         break;
    729                 }
     499                rc = display_window_resize(window->dwindow, &offs, &nrect);
     500                if (rc != EOK)
     501                        goto error;
    730502        }
    731503
    … …  
    747519                        goto error;
    748520#endif
     521
    749522                mem_gc_retarget(window->mgc, &win_params.rect, &win_alloc);
    750523
    … …  
    753526        }
    754527
    755         window->rect = nrect;
    756528        ui_wdecor_set_rect(window->wdecor, &nrect);
    757529        ui_wdecor_paint(window->wdecor);
    … …  
    775547}
    776548
    777 /** Resize/move window.
    778  *
    779  * Resize window to the dimensions of @a rect. If @a rect.p0 is not 0,0,
    780  * the top-left corner of the window will move on the screen accordingly.
    781  *
    782  * @param window Window
    783  * @param rect Rectangle
    784  *
    785  * @return EOK on success or an error code
    786  */
    787 errno_t ui_window_resize(ui_window_t *window, gfx_rect_t *rect)
    788 {
    789         return ui_window_size_change(window, rect, ui_wsc_resize);
    790 }
    791 
    792549/** Set window callbacks.
    793550 *
    … …  
    800557        window->cb = cb;
    801558        window->arg = arg;
    802 }
    803 
    804 /** Change window caption.
    805  *
    806  * @param window Window
    807  * @param caption New caption
    808  *
    809  * @return EOK on success or an error code
    810  */
    811 errno_t ui_window_set_caption(ui_window_t *window, const char *caption)
    812 {
    813         errno_t rc;
    814 
    815         /* Set console caption if fullscreen window on console */
    816         if (window->ui->console != NULL && window->placement ==
    817             ui_wnd_place_full_screen) {
    818                 rc = console_set_caption(window->ui->console, caption);
    819                 if (rc != EOK)
    820                         return rc;
    821         }
    822 
    823         /* Set display window caption if running on display service */
    824         if (window->dwindow != NULL) {
    825                 rc = display_window_set_caption(window->dwindow, caption);
    826                 if (rc != EOK)
    827                         return rc;
    828         }
    829 
    830         return ui_wdecor_set_caption(window->wdecor, caption);
    831 }
    832 
    833 /** Get window's containing UI.
    834  *
    835  * @param window Window
    836  * @return Containing UI
    837  */
    838 ui_t *ui_window_get_ui(ui_window_t *window)
    839 {
    840         return window->ui;
    841559}
    842560
    … …  
    876594                        return rc;
    877595        } else {
    878                 *pos = window->dpos;
     596                pos->x = 0;
     597                pos->y = 0;
    879598        }
    880599
    … …  
    976695{
    977696        ui_window_t *window = (ui_window_t *) arg;
    978         ui_t *ui = window->ui;
    979 
    980         fibril_mutex_lock(&ui->lock);
     697
    981698        ui_window_send_close(window);
    982         fibril_mutex_unlock(&ui->lock);
    983699}
    984700
    985701/** Handle window focus event. */
    986 static void dwnd_focus_event(void *arg, unsigned nfocus)
    987 {
    988         ui_window_t *window = (ui_window_t *) arg;
    989         ui_t *ui = window->ui;
    990 
    991         fibril_mutex_lock(&ui->lock);
    992         (void)nfocus;
     702static void dwnd_focus_event(void *arg)
     703{
     704        ui_window_t *window = (ui_window_t *) arg;
    993705
    994706        if (window->wdecor != NULL) {
    … …  
    997709        }
    998710
    999         ui_window_send_focus(window, nfocus);
    1000         fibril_mutex_unlock(&ui->lock);
     711        ui_window_send_focus(window);
    1001712}
    1002713
    … …  
    1005716{
    1006717        ui_window_t *window = (ui_window_t *) arg;
    1007         ui_t *ui = window->ui;
    1008 
    1009         fibril_mutex_lock(&ui->lock);
     718
     719        (void) window;
    1010720        ui_window_send_kbd(window, kbd_event);
    1011         fibril_mutex_unlock(&ui->lock);
    1012721}
    1013722
    … …  
    1016725{
    1017726        ui_window_t *window = (ui_window_t *) arg;
    1018         ui_t *ui = window->ui;
    1019         ui_evclaim_t claim;
    1020727
    1021728        /* Make sure we don't process events until fully initialized */
    … …  
    1023730                return;
    1024731
    1025         fibril_mutex_lock(&ui->lock);
    1026 
    1027         claim = ui_wdecor_pos_event(window->wdecor, event);
    1028         if (claim == ui_claimed) {
    1029                 fibril_mutex_unlock(&ui->lock);
    1030                 return;
    1031         }
    1032 
     732        ui_wdecor_pos_event(window->wdecor, event);
    1033733        ui_window_send_pos(window, event);
    1034         fibril_mutex_unlock(&ui->lock);
    1035734}
    1036735
    … …  
    1039738{
    1040739        ui_window_t *window = (ui_window_t *) arg;
    1041         ui_t *ui = window->ui;
    1042740
    1043741        /* Make sure we don't process events until fully initialized */
    … …  
    1048746                return;
    1049747
    1050         fibril_mutex_lock(&ui->lock);
    1051748        (void) ui_window_resize(window, rect);
    1052         ui_window_send_resize(window);
    1053         fibril_mutex_unlock(&ui->lock);
     749        (void) ui_window_paint(window);
    1054750}
    1055751
    1056752/** Handle window unfocus event. */
    1057 static void dwnd_unfocus_event(void *arg, unsigned nfocus)
    1058 {
    1059         ui_window_t *window = (ui_window_t *) arg;
    1060         ui_t *ui = window->ui;
    1061 
    1062         fibril_mutex_lock(&ui->lock);
    1063 
    1064         if (window->wdecor != NULL && nfocus == 0) {
     753static void dwnd_unfocus_event(void *arg)
     754{
     755        ui_window_t *window = (ui_window_t *) arg;
     756
     757        if (window->wdecor != NULL) {
    1065758                ui_wdecor_set_active(window->wdecor, false);
    1066759                ui_wdecor_paint(window->wdecor);
    1067760        }
    1068761
    1069         ui_window_send_unfocus(window, nfocus);
    1070         fibril_mutex_unlock(&ui->lock);
    1071 }
    1072 
    1073 /** Window decoration requested opening of system menu.
    1074  *
    1075  * @param wdecor Window decoration
    1076  * @param arg Argument (window)
    1077  * @param idev_id Input device ID
    1078  */
    1079 static void wd_sysmenu_open(ui_wdecor_t *wdecor, void *arg, sysarg_t idev_id)
    1080 {
    1081         ui_window_t *window = (ui_window_t *) arg;
    1082 
    1083         ui_window_send_sysmenu(window, idev_id);
    1084 }
    1085 
    1086 /** Window decoration requested moving left from system menu handle.
    1087  *
    1088  * @param wdecor Window decoration
    1089  * @param arg Argument (window)
    1090  * @param idev_id Input device ID
    1091  */
    1092 static void wd_sysmenu_left(ui_wdecor_t *wdecor, void *arg, sysarg_t idev_id)
    1093 {
    1094         ui_window_t *window = (ui_window_t *) arg;
    1095 
    1096         if (window->mbar != NULL) {
    1097                 ui_wdecor_sysmenu_hdl_set_active(window->wdecor, false);
    1098                 ui_menu_close(window->sysmenu);
    1099                 ui_menu_bar_select_last(window->mbar, false, idev_id);
    1100         }
    1101 }
    1102 
    1103 /** Window decoration requested moving right from system menu handle.
    1104  *
    1105  * @param wdecor Window decoration
    1106  * @param arg Argument (window)
    1107  * @param idev_id Input device ID
    1108  */
    1109 static void wd_sysmenu_right(ui_wdecor_t *wdecor, void *arg, sysarg_t idev_id)
    1110 {
    1111         ui_window_t *window = (ui_window_t *) arg;
    1112 
    1113         if (window->mbar != NULL) {
    1114                 ui_wdecor_sysmenu_hdl_set_active(window->wdecor, false);
    1115                 ui_menu_close(window->sysmenu);
    1116                 ui_menu_bar_select_first(window->mbar, false, idev_id);
    1117         }
    1118 }
    1119 
    1120 /** Window decoration detected accelerator press from system menu handle.
    1121  *
    1122  * @param wdecor Window decoration
    1123  * @param arg Argument (window)
    1124  * @param c Accelerator key
    1125  * @param idev_id Input device ID
    1126  */
    1127 static void wd_sysmenu_accel(ui_wdecor_t *wdecor, void *arg, char32_t c,
    1128     sysarg_t idev_id)
    1129 {
    1130         ui_window_t *window = (ui_window_t *) arg;
    1131 
    1132         if (window->mbar != NULL) {
    1133                 ui_wdecor_sysmenu_hdl_set_active(window->wdecor, false);
    1134                 ui_menu_close(window->sysmenu);
    1135                 ui_menu_bar_press_accel(window->mbar, c, idev_id);
    1136         }
    1137 }
    1138 
    1139 /** Window decoration requested window minimization.
    1140  *
    1141  * @param wdecor Window decoration
    1142  * @param arg Argument (window)
    1143  */
    1144 static void wd_minimize(ui_wdecor_t *wdecor, void *arg)
    1145 {
    1146         ui_window_t *window = (ui_window_t *) arg;
    1147 
    1148         ui_window_send_minimize(window);
    1149 }
    1150 
    1151 /** Window decoration requested window maximization.
    1152  *
    1153  * @param wdecor Window decoration
    1154  * @param arg Argument (window)
    1155  */
    1156 static void wd_maximize(ui_wdecor_t *wdecor, void *arg)
    1157 {
    1158         ui_window_t *window = (ui_window_t *) arg;
    1159 
    1160         ui_window_send_maximize(window);
    1161 }
    1162 
    1163 /** Window decoration requested window unmaximization.
    1164  *
    1165  * @param wdecor Window decoration
    1166  * @param arg Argument (window)
    1167  */
    1168 static void wd_unmaximize(ui_wdecor_t *wdecor, void *arg)
    1169 {
    1170         ui_window_t *window = (ui_window_t *) arg;
    1171 
    1172         ui_window_send_unmaximize(window);
     762        ui_window_send_unfocus(window);
    1173763}
    1174764
    … …  
    1190780 * @param arg Argument (window)
    1191781 * @param pos Position where the title bar was pressed
    1192  * @param pos_id Positioning device ID
    1193  */
    1194 static void wd_move(ui_wdecor_t *wdecor, void *arg, gfx_coord2_t *pos,
    1195     sysarg_t pos_id)
     782 */
     783static void wd_move(ui_wdecor_t *wdecor, void *arg, gfx_coord2_t *pos)
    1196784{
    1197785        ui_window_t *window = (ui_window_t *) arg;
    1198786
    1199787        if (window->dwindow != NULL)
    1200                 (void) display_window_move_req(window->dwindow, pos, pos_id);
     788                (void) display_window_move_req(window->dwindow, pos);
    1201789}
    1202790
    … …  
    1207795 * @param rsztype Resize type
    1208796 * @param pos Position where the button was pressed
    1209  * @param pos_id Positioning device ID
    1210797 */
    1211798static void wd_resize(ui_wdecor_t *wdecor, void *arg,
    1212     ui_wdecor_rsztype_t rsztype, gfx_coord2_t *pos, sysarg_t pos_id)
    1213 {
    1214         ui_window_t *window = (ui_window_t *) arg;
    1215 
    1216         if (window->dwindow != NULL) {
    1217                 (void) display_window_resize_req(window->dwindow,
    1218                     (display_wnd_rsztype_t) rsztype, // Same constants in the enums
    1219                     pos, pos_id);
    1220         }
     799    ui_wdecor_rsztype_t rsztype, gfx_coord2_t *pos)
     800{
     801        ui_window_t *window = (ui_window_t *) arg;
     802
     803        if (window->dwindow != NULL)
     804                (void) display_window_resize_req(window->dwindow, rsztype, pos);
    1221805}
    1222806
    … …  
    1279863}
    1280864
    1281 /** Send window sysmenu event.
    1282  *
    1283  * @param window Window
    1284  * @parma idev_id Input device ID
    1285  */
    1286 void ui_window_send_sysmenu(ui_window_t *window, sysarg_t idev_id)
    1287 {
    1288         if (window->cb != NULL && window->cb->sysmenu != NULL)
    1289                 window->cb->sysmenu(window, window->arg, idev_id);
    1290         else
    1291                 ui_window_def_sysmenu(window, idev_id);
    1292 }
    1293 
    1294 /** Send window minimize event.
    1295  *
    1296  * @param window Window
    1297  */
    1298 void ui_window_send_minimize(ui_window_t *window)
    1299 {
    1300         if (window->cb != NULL && window->cb->minimize != NULL)
    1301                 window->cb->minimize(window, window->arg);
    1302         else
    1303                 ui_window_def_minimize(window);
    1304 }
    1305 
    1306 /** Send window maximize event.
    1307  *
    1308  * @param window Window
    1309  */
    1310 void ui_window_send_maximize(ui_window_t *window)
    1311 {
    1312         if (window->cb != NULL && window->cb->maximize != NULL)
    1313                 window->cb->maximize(window, window->arg);
    1314         else
    1315                 ui_window_def_maximize(window);
    1316 }
    1317 
    1318 /** Send window unmaximize event.
    1319  *
    1320  * @param window Window
    1321  */
    1322 void ui_window_send_unmaximize(ui_window_t *window)
    1323 {
    1324         if (window->cb != NULL && window->cb->unmaximize != NULL)
    1325                 window->cb->unmaximize(window, window->arg);
    1326         else
    1327                 ui_window_def_unmaximize(window);
    1328 }
    1329 
    1330865/** Send window close event.
    1331866 *
    … …  
    1341876 *
    1342877 * @param window Window
    1343  * @param nfocus New number of foci
    1344  */
    1345 void ui_window_send_focus(ui_window_t *window, unsigned nfocus)
     878 */
     879void ui_window_send_focus(ui_window_t *window)
    1346880{
    1347881        if (window->cb != NULL && window->cb->focus != NULL)
    1348                 window->cb->focus(window, window->arg, nfocus);
     882                window->cb->focus(window, window->arg);
    1349883}
    1350884
    … …  
    1358892                window->cb->kbd(window, window->arg, kbd);
    1359893        else
    1360                 ui_window_def_kbd(window, kbd);
     894                return ui_window_def_kbd(window, kbd);
    1361895}
    1362896
    … …  
    1388922 *
    1389923 * @param window Window
    1390  * @param nfocus Number of remaining foci
    1391  */
    1392 void ui_window_send_unfocus(ui_window_t *window, unsigned nfocus)
     924 */
     925void ui_window_send_unfocus(ui_window_t *window)
    1393926{
    1394927        if (window->cb != NULL && window->cb->unfocus != NULL)
    1395                 window->cb->unfocus(window, window->arg, nfocus);
     928                window->cb->unfocus(window, window->arg);
    1396929        else
    1397                 return ui_window_def_unfocus(window, nfocus);
    1398 }
    1399 
    1400 /** Send window resize event.
    1401  *
    1402  * @param window Window
    1403  */
    1404 void ui_window_send_resize(ui_window_t *window)
    1405 {
    1406         if (window->cb != NULL && window->cb->resize != NULL)
    1407                 window->cb->resize(window, window->arg);
    1408         else
    1409                 return ui_window_def_resize(window);
    1410 }
    1411 
    1412 /** Default window sysmenu routine.
    1413  *
    1414  * @param window Window
    1415  * @param idev_id Input device ID
    1416  * @return EOK on success or an error code
    1417  */
    1418 errno_t ui_window_def_sysmenu(ui_window_t *window, sysarg_t idev_id)
    1419 {
    1420         errno_t rc;
    1421         ui_wdecor_geom_t geom;
    1422 
    1423         if (ui_menu_is_open(window->sysmenu)) {
    1424                 ui_menu_close(window->sysmenu);
    1425         } else {
    1426                 ui_wdecor_get_geom(window->wdecor, &geom);
    1427 
    1428                 rc = ui_menu_open(window->sysmenu, &geom.title_bar_rect,
    1429                     idev_id);
    1430                 if (rc != EOK)
    1431                         goto error;
    1432         }
    1433 
    1434         return EOK;
    1435 error:
    1436         return rc;
    1437 }
    1438 
    1439 /** Default window minimize routine.
    1440  *
    1441  * @param window Window
    1442  * @return EOK on success or an error code
    1443  */
    1444 errno_t ui_window_def_minimize(ui_window_t *window)
    1445 {
    1446         errno_t rc;
    1447 
    1448         if (window->dwindow != NULL) {
    1449                 rc = display_window_minimize(window->dwindow);
    1450                 if (rc != EOK)
    1451                         goto error;
    1452         }
    1453 
    1454         return EOK;
    1455 error:
    1456         return rc;
    1457 }
    1458 
    1459 /** Default window maximize routine.
    1460  *
    1461  * @param window Window
    1462  * @return EOK on success or an error code
    1463  */
    1464 errno_t ui_window_def_maximize(ui_window_t *window)
    1465 {
    1466         errno_t rc;
    1467         gfx_rect_t old_rect;
    1468         gfx_rect_t rect;
    1469 
    1470         old_rect = window->rect;
    1471 
    1472         if (window->dwindow != NULL) {
    1473                 rc = display_window_get_max_rect(window->dwindow, &rect);
    1474                 if (rc != EOK)
    1475                         return rc;
    1476         } else {
    1477                 rect = window->ui->rect;
    1478         }
    1479 
    1480         ui_wdecor_set_maximized(window->wdecor, true);
    1481         ui_menu_entry_set_disabled(window->sysmenu_restore, false);
    1482         ui_menu_entry_set_disabled(window->sysmenu_maximize, true);
    1483 
    1484         rc = ui_window_size_change(window, &rect, ui_wsc_maximize);
    1485         if (rc != EOK) {
    1486                 ui_wdecor_set_maximized(window->wdecor, false);
    1487                 return rc;
    1488         }
    1489 
    1490         window->normal_rect = old_rect;
    1491         (void) ui_window_paint(window);
    1492         return EOK;
    1493 }
    1494 
    1495 /** Default window unmaximize routine.
    1496  *
    1497  * @param window Window
    1498  * @return EOK on success or an error code
    1499  */
    1500 errno_t ui_window_def_unmaximize(ui_window_t *window)
    1501 {
    1502         errno_t rc;
    1503 
    1504         ui_wdecor_set_maximized(window->wdecor, false);
    1505         ui_menu_entry_set_disabled(window->sysmenu_restore, true);
    1506         ui_menu_entry_set_disabled(window->sysmenu_maximize, false);
    1507 
    1508         rc = ui_window_size_change(window, &window->normal_rect,
    1509             ui_wsc_unmaximize);
    1510         if (rc != EOK) {
    1511                 ui_wdecor_set_maximized(window->wdecor, true);
    1512                 printf("ui_window_size_change->error\n");
    1513                 return rc;
    1514         }
    1515 
    1516         (void) ui_window_paint(window);
    1517         return EOK;
     930                return ui_window_def_unfocus(window);
    1518931}
    1519932
    … …  
    1521934 *
    1522935 * @param window Window
    1523  * @return ui_claimed iff event was claimed
    1524  */
    1525 ui_evclaim_t ui_window_def_kbd(ui_window_t *window, kbd_event_t *kbd)
    1526 {
    1527         ui_evclaim_t claim;
    1528 
     936 */
     937void ui_window_def_kbd(ui_window_t *window, kbd_event_t *kbd)
     938{
    1529939        if (window->control != NULL)
    1530                 claim = ui_control_kbd_event(window->control, kbd);
    1531         else
    1532                 claim = ui_unclaimed;
    1533 
    1534         if (claim == ui_unclaimed)
    1535                 return ui_wdecor_kbd_event(window->wdecor, kbd);
    1536 
    1537         return ui_unclaimed;
     940                ui_control_kbd_event(window->control, kbd);
    1538941}
    1539942
    … …  
    1581984 *
    1582985 * @param window Window
    1583  * @param nfocus Number of remaining foci
    1584986 * @return EOK on success or an error code
    1585987 */
    1586 void ui_window_def_unfocus(ui_window_t *window, unsigned nfocus)
     988void ui_window_def_unfocus(ui_window_t *window)
    1587989{
    1588990        if (window->control != NULL)
    1589                 ui_control_unfocus(window->control, nfocus);
    1590 }
    1591 
    1592 /** Default window resize routine.
    1593  *
    1594  * @param window Window
    1595  * @return EOK on success or an error code
    1596  */
    1597 void ui_window_def_resize(ui_window_t *window)
    1598 {
    1599         ui_window_paint(window);
    1600 }
    1601 
    1602 /** Handle system menu left event.
    1603  *
    1604  * @param sysmenu System menu
    1605  * @param arg Argument (ui_window_t *)
    1606  * @param idev_id Input device ID
    1607  */
    1608 static void wnd_sysmenu_left(ui_menu_t *sysmenu, void *arg, sysarg_t idev_id)
    1609 {
    1610         ui_window_t *window = (ui_window_t *)arg;
    1611 
    1612         if (window->mbar != NULL) {
    1613                 ui_wdecor_sysmenu_hdl_set_active(window->wdecor, false);
    1614                 ui_menu_close(sysmenu);
    1615                 ui_menu_bar_select_last(window->mbar, true, idev_id);
    1616         }
    1617 }
    1618 
    1619 /** Handle system menu right event.
    1620  *
    1621  * @param sysmenu System menu
    1622  * @param arg Argument (ui_window_t *)
    1623  * @param idev_id Input device ID
    1624  */
    1625 static void wnd_sysmenu_right(ui_menu_t *sysmenu, void *arg, sysarg_t idev_id)
    1626 {
    1627         ui_window_t *window = (ui_window_t *)arg;
    1628 
    1629         if (window->mbar != NULL) {
    1630                 ui_wdecor_sysmenu_hdl_set_active(window->wdecor, false);
    1631                 ui_menu_close(sysmenu);
    1632                 ui_menu_bar_select_first(window->mbar, true, idev_id);
    1633         }
    1634 }
    1635 
    1636 /** Handle system menu close request event.
    1637  *
    1638  * @param sysmenu System menu
    1639  * @param arg Argument (ui_window_t *)
    1640  * @param idev_id Input device ID
    1641  */
    1642 static void wnd_sysmenu_close_req(ui_menu_t *sysmenu, void *arg)
    1643 {
    1644         ui_window_t *window = (ui_window_t *)arg;
    1645 
    1646         ui_wdecor_sysmenu_hdl_set_active(window->wdecor, false);
    1647         ui_menu_close(sysmenu);
    1648 }
    1649 
    1650 /** Handle system menu Restore entry activation.
    1651  *
    1652  * @param mentry Menu entry
    1653  * @param arg Argument (ui_window_t *)
    1654  */
    1655 static void wnd_sysmenu_erestore(ui_menu_entry_t *mentry, void *arg)
    1656 {
    1657         ui_window_t *window = (ui_window_t *)arg;
    1658 
    1659         ui_window_send_unmaximize(window);
    1660 }
    1661 
    1662 /** Handle system menu Minimize entry activation.
    1663  *
    1664  * @param mentry Menu entry
    1665  * @param arg Argument (ui_window_t *)
    1666  */
    1667 static void wnd_sysmenu_eminimize(ui_menu_entry_t *mentry, void *arg)
    1668 {
    1669         ui_window_t *window = (ui_window_t *)arg;
    1670 
    1671         ui_window_send_minimize(window);
    1672 }
    1673 
    1674 /** Handle system menu Maximize entry activation.
    1675  *
    1676  * @param mentry Menu entry
    1677  * @param arg Argument (ui_window_t *)
    1678  */
    1679 static void wnd_sysmenu_emaximize(ui_menu_entry_t *mentry, void *arg)
    1680 {
    1681         ui_window_t *window = (ui_window_t *)arg;
    1682 
    1683         ui_window_send_maximize(window);
    1684 }
    1685 
    1686 /** Handle system menu Close entry activation.
    1687  *
    1688  * @param mentry Menu entry
    1689  * @param arg Argument (ui_window_t *)
    1690  */
    1691 static void wnd_sysmenu_eclose(ui_menu_entry_t *mentry, void *arg)
    1692 {
    1693         ui_window_t *window = (ui_window_t *)arg;
    1694 
    1695         ui_window_send_close(window);
    1696 }
    1697 
    1698 /** Handle system menu press accelerator key event.
    1699  *
    1700  * @param sysmenu System menu
    1701  * @param arg Argument (ui_window_t *)
    1702  * @param idev_id Input device ID
    1703  */
    1704 static void wnd_sysmenu_press_accel(ui_menu_t *sysmenu, void *arg,
    1705     char32_t c, sysarg_t idev_id)
    1706 {
    1707         (void)sysmenu;
    1708         (void)arg;
    1709         (void)c;
    1710         (void)idev_id;
     991                ui_control_unfocus(window->control);
    1711992}
    1712993
    … …  
    17331014        ui_window_t *window = (ui_window_t *) arg;
    17341015
    1735         if (!gfx_rect_is_empty(&window->dirty_rect)) {
    1736                 (void) gfx_bitmap_render(window->bmp, &window->dirty_rect,
    1737                     &window->dpos);
    1738         }
     1016        if (!gfx_rect_is_empty(&window->dirty_rect))
     1017                (void) gfx_bitmap_render(window->bmp, &window->dirty_rect, NULL);
    17391018
    17401019        window->dirty_rect.p0.x = 0;
    … …  
    17521031{
    17531032        ui_window_t *window = (ui_window_t *) arg;
    1754         gfx_coord2_t cpos;
    1755         errno_t rc;
    1756 
    1757         rc = gfx_cursor_get_pos(window->realgc, &cpos);
    1758         if (rc != EOK)
    1759                 return rc;
    1760 
    1761         pos->x = cpos.x - window->dpos.x;
    1762         pos->y = cpos.y - window->dpos.y;
    1763         return EOK;
     1033
     1034        return gfx_cursor_get_pos(window->realgc, pos);
    17641035}
    17651036
    … …  
    17721043{
    17731044        ui_window_t *window = (ui_window_t *) arg;
    1774         gfx_coord2_t cpos;
    1775 
    1776         cpos.x = pos->x + window->dpos.x;
    1777         cpos.y = pos->y + window->dpos.y;
    1778 
    1779         return gfx_cursor_set_pos(window->realgc, &cpos);
     1045
     1046        return gfx_cursor_set_pos(window->realgc, pos);
    17801047}
    17811048
Note: See TracChangeset for help on using the changeset viewer.