Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    rb979ffb r1215db9  
    11/*
    2  * Copyright (c) 2026 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
    173  * @param wrect Window rectangle
    174  * @param prect Parent rectangle for popup placement or @c NULL
    175  * @param placement Window placement
     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
    176139 * @param params Window parameters
    177140 * @param pos Place to store position of top-left corner
    178141 */
    179 static void ui_window_place(ui_window_t *window, gfx_rect_t *drect,
    180     gfx_rect_t *wrect, gfx_rect_t *prect, ui_wnd_placement_t placement,
    181     gfx_coord2_t *pos)
    182 {
    183         gfx_coord2_t dims;
    184         gfx_coord2_t below_pos;
    185         gfx_rect_t below_rect;
    186 
    187         assert(placement != ui_wnd_place_default ||
    188             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);
    189146
    190147        pos->x = 0;
    191148        pos->y = 0;
    192149
    193         switch (placement) {
     150        switch (params->placement) {
    194151        case ui_wnd_place_default:
    195         case ui_wnd_place_center:
    196                 assert(placement != ui_wnd_place_default ||
    197                     ui_is_fullscreen(window->ui));
    198                 /* Center window */
    199                 gfx_rect_dims(wrect, &dims);
    200                 pos->x = (drect->p0.x + drect->p1.x) / 2 - dims.x / 2;
    201                 pos->y = (drect->p0.y + drect->p1.y) / 2 - dims.y / 2;
    202                 break;
     152                assert(false);
    203153        case ui_wnd_place_top_left:
    204154        case ui_wnd_place_full_screen:
    205                 pos->x = drect->p0.x - wrect->p0.x;
    206                 pos->y = drect->p0.y - wrect->p0.y;
     155                pos->x = info->rect.p0.x - params->rect.p0.x;
     156                pos->y = info->rect.p0.y - params->rect.p0.y;
    207157                break;
    208158        case ui_wnd_place_top_right:
    209                 pos->x = drect->p1.x - wrect->p1.x;
    210                 pos->y = drect->p0.y - wrect->p0.y;
     159                pos->x = info->rect.p1.x - params->rect.p1.x;
     160                pos->y = info->rect.p0.y - params->rect.p0.y;
    211161                break;
    212162        case ui_wnd_place_bottom_left:
    213                 pos->x = drect->p0.x - wrect->p0.x;
    214                 pos->y = drect->p1.y - wrect->p1.y;
     163                pos->x = info->rect.p0.x - params->rect.p0.x;
     164                pos->y = info->rect.p1.y - params->rect.p1.y;
    215165                break;
    216166        case ui_wnd_place_bottom_right:
    217                 pos->x = drect->p1.x - wrect->p1.x;
    218                 pos->y = drect->p1.y - wrect->p1.y;
     167                pos->x = info->rect.p1.x - params->rect.p1.x;
     168                pos->y = info->rect.p1.y - params->rect.p1.y;
    219169                break;
    220170        case ui_wnd_place_popup:
    221                 /* Compute rectangle when placed below */
    222                 below_pos.x = prect->p0.x;
    223                 below_pos.y = prect->p1.y;
    224                 gfx_rect_translate(&below_pos, wrect, &below_rect);
    225 
    226                 /* Does below_rect fit within the display? */
    227                 if (gfx_rect_is_inside(&below_rect, drect)) {
    228                         /* Place popup window below parent rectangle */
    229                         pos->x = prect->p0.x - wrect->p0.x;
    230                         pos->y = prect->p1.y - wrect->p0.y;
    231                 } else {
    232                         /* Place popup window above parent rectangle */
    233                         pos->x = prect->p0.x;
    234                         pos->y = prect->p0.y -
    235                             (wrect->p1.y - wrect->p0.y);
    236                 }
     171                /* Place popup window below parent rectangle */
     172                pos->x = params->prect.p0.x;
     173                pos->y = params->prect.p1.y;
    237174                break;
    238175        }
    239 }
    240 
    241 static void ui_window_set_dpos(ui_window_t *window, gfx_coord2_t *dpos)
    242 {
    243         window->dpos = *dpos;
    244         if (window->xgc != NULL)
    245                 xlate_gc_set_off(window->xgc, &window->dpos);
    246 }
    247 
    248 /** Create window's system menu.
    249  *
    250  * @param window Window
    251  * @return EOK on success or an error code
    252  */
    253 static errno_t ui_window_sysmenu_create(ui_window_t *window)
    254 {
    255         errno_t rc;
    256         ui_menu_entry_t *mrestore;
    257         ui_menu_entry_t *mmin;
    258         ui_menu_entry_t *mmax;
    259         ui_menu_entry_t *msep;
    260         ui_menu_entry_t *mclose;
    261 
    262         rc = ui_menu_create(window, &window->sysmenu);
    263         if (rc != EOK)
    264                 goto error;
    265 
    266         ui_menu_set_cb(window->sysmenu, &wnd_sysmenu_cb, (void *)window);
    267 
    268         rc = ui_menu_entry_create(window->sysmenu, "~R~estore",
    269             "", &mrestore);
    270         if (rc != EOK)
    271                 goto error;
    272 
    273         if (!window->wdecor->maximized)
    274                 ui_menu_entry_set_disabled(mrestore, true);
    275 
    276         ui_menu_entry_set_cb(mrestore, wnd_sysmenu_erestore, (void *)window);
    277 
    278         rc = ui_menu_entry_create(window->sysmenu, "Mi~n~imize",
    279             "", &mmin);
    280         if (rc != EOK)
    281                 goto error;
    282 
    283         if ((window->wdecor->style & ui_wds_minimize_btn) == 0)
    284                 ui_menu_entry_set_disabled(mmin, true);
    285 
    286         ui_menu_entry_set_cb(mmin, wnd_sysmenu_eminimize, (void *)window);
    287 
    288         rc = ui_menu_entry_create(window->sysmenu, "Ma~x~imize",
    289             "", &mmax);
    290         if (rc != EOK)
    291                 goto error;
    292 
    293         if ((window->wdecor->style & ui_wds_maximize_btn) == 0 ||
    294             window->wdecor->maximized)
    295                 ui_menu_entry_set_disabled(mmax, true);
    296 
    297         ui_menu_entry_set_cb(mmax, wnd_sysmenu_emaximize, (void *)window);
    298 
    299         rc = ui_menu_entry_sep_create(window->sysmenu, &msep);
    300         if (rc != EOK)
    301                 goto error;
    302 
    303         rc = ui_menu_entry_create(window->sysmenu, "~C~lose", "Alt-F4",
    304             &mclose);
    305         if (rc != EOK)
    306                 goto error;
    307 
    308         if ((window->wdecor->style & ui_wds_close_btn) == 0)
    309                 ui_menu_entry_set_disabled(mclose, true);
    310 
    311         ui_menu_entry_set_cb(mclose, wnd_sysmenu_eclose, (void *)window);
    312 
    313         window->sysmenu_restore = mrestore;
    314         window->sysmenu_minimize = mmin;
    315         window->sysmenu_maximize = mmax;
    316 
    317         return EOK;
    318 error:
    319         return rc;
    320176}
    321177
    … …  
    331187{
    332188        ui_window_t *window;
    333         ui_window_t *pwindow = NULL;
    334189        display_info_t info;
    335190        gfx_coord2_t scr_dims;
    … …  
    342197        gfx_bitmap_alloc_t alloc;
    343198        gfx_bitmap_t *bmp = NULL;
    344         gfx_coord2_t off;
    345199        mem_gc_t *memgc = NULL;
    346         xlate_gc_t *xgc = NULL;
    347         gfx_coord2_t dpos;
    348200        errno_t rc;
    349201
    … …  
    352204                return ENOMEM;
    353205
    354         window->ui = ui;
    355 
    356206        display_wnd_params_init(&dparams);
    357207        dparams.rect = params->rect;
    358         dparams.caption = params->caption;
    359         dparams.min_size = params->min_size;
    360 
    361         /*
    362          * If idev_id is not specified, use the UI default (probably
    363          * obtained from display specification. This creates the
    364          * main window in the seat specified on the command line.
    365          */
    366         if (params->idev_id != 0)
    367                 dparams.idev_id = params->idev_id;
    368         else
    369                 dparams.idev_id = ui->idev_id;
     208        /* Only allow making the window larger */
     209        gfx_rect_dims(&params->rect, &dparams.min_size);
    370210
    371211        if ((params->flags & ui_wndf_popup) != 0)
    372212                dparams.flags |= wndf_popup;
    373         if ((params->flags & ui_wndf_nofocus) != 0)
    374                 dparams.flags |= wndf_nofocus;
    375         if ((params->flags & ui_wndf_topmost) != 0)
    376                 dparams.flags |= wndf_topmost;
    377         if ((params->flags & ui_wndf_system) != 0)
    378                 dparams.flags |= wndf_system;
    379         if ((params->flags & ui_wndf_avoid) != 0)
    380                 dparams.flags |= wndf_avoid;
    381213
    382214        if (ui->display != NULL) {
    … …  
    396228                if (params->placement != ui_wnd_place_default) {
    397229                        /* Set initial display window position */
    398                         ui_window_place(window, &info.rect, &params->rect,
    399                             &params->prect, params->placement, &dparams.pos);
     230                        ui_window_place(window, ui->display, &info,
     231                            params, &dparams.pos);
    400232
    401233                        dparams.flags |= wndf_setpos;
    … …  
    412244        } else if (ui->console != NULL) {
    413245                gc = console_gc_get_ctx(ui->cgc);
    414 
    415                 if (params->placement == ui_wnd_place_full_screen) {
    416                         /* Make window the size of the screen */
    417                         gfx_rect_dims(&ui->rect, &scr_dims);
    418                         gfx_coord2_add(&dparams.rect.p0, &scr_dims,
    419                             &dparams.rect.p1);
    420                         (void) console_set_caption(ui->console,
    421                             params->caption);
    422                 }
    423246        } else {
    424247                /* Needed for unit tests */
    … …  
    440263
    441264        /* Move rectangle so that top-left corner is 0,0 */
    442         gfx_rect_rtranslate(&dparams.rect.p0, &dparams.rect, &bparams.rect);
     265        gfx_rect_rtranslate(&params->rect.p0, &params->rect, &bparams.rect);
    443266
    444267        rc = gfx_bitmap_create(gc, &bparams, NULL, &bmp);
    … …  
    464287        window->gc = mem_gc_get_ctx(memgc);
    465288        window->realgc = gc;
    466         (void) off;
    467289#else
    468         /* Server-side rendering */
    469 
    470         /* Full-screen mode? */
    471         if (ui->display == NULL) {
    472                 /* Create translating GC to translate window contents */
    473                 off.x = 0;
    474                 off.y = 0;
    475                 rc = xlate_gc_create(&off, gc, &xgc);
    476                 if (rc != EOK)
    477                         goto error;
    478 
    479                 window->xgc = xgc;
    480                 window->gc = xlate_gc_get_ctx(xgc);
    481                 window->realgc = gc;
    482         } else {
    483                 window->gc = gc;
    484         }
    485 
    486290        (void) ui_window_mem_gc_cb;
    487291        (void) alloc;
    488292        (void) bparams;
     293        window->gc = gc;
    489294#endif
    490         if (ui->display == NULL) {
    491                 ui_window_place(window, &ui->rect, &params->rect, &params->prect,
    492                     params->placement, &dpos);
    493                 ui_window_set_dpos(window, &dpos);
    494         }
    495295
    496296        rc = ui_resource_create(window->gc, ui_is_textmode(ui), &res);
    … …  
    508308        ui_resource_set_expose_cb(res, ui_window_expose_cb, (void *) window);
    509309
     310        window->ui = ui;
    510311        window->rect = dparams.rect;
     312
    511313        window->res = res;
    512314        window->wdecor = wdecor;
    513315        window->cursor = ui_curs_arrow;
    514         window->placement = params->placement;
    515 
    516         rc = ui_window_sysmenu_create(window);
    517         if (rc != EOK)
    518                 goto error;
    519 
    520316        *rwindow = window;
    521317
    522         if (ui_is_fullscreen(ui))
    523                 pwindow = ui_window_get_active(ui);
    524 
    525318        list_append(&window->lwindows, &ui->windows);
    526 
    527         if (ui_is_fullscreen(ui)) {
    528                 /* Send unfocus event to previously active window */
    529                 if (pwindow != NULL)
    530                         ui_window_send_unfocus(pwindow, 0);
    531         }
    532 
    533319        return EOK;
    534320error:
    … …  
    539325        if (memgc != NULL)
    540326                mem_gc_delete(memgc);
    541         if (xgc != NULL)
    542                 xlate_gc_delete(xgc);
    543327        if (bmp != NULL)
    544328                gfx_bitmap_destroy(bmp);
    … …  
    549333}
    550334
    551 /** Update window placement after screen resize (only in fullscreen UI).
    552  *
    553  * @param window UI window
    554  */
    555 void ui_window_update_placement(ui_window_t *window)
    556 {
    557         if (window->placement == ui_wnd_place_full_screen ||
    558             (window->flags & uiwf_maximized) != 0) {
    559                 /* Update size of fullscreen or maximized window. */
    560                 (void)ui_window_resize(window, &window->ui->rect);
    561                 ui_window_send_resize(window);
    562         }
    563 }
    564 
    565335/** Destroy window.
    566336 *
    … …  
    570340{
    571341        ui_t *ui;
    572         ui_window_t *nwindow;
    573342
    574343        if (window == NULL)
    … …  
    579348        list_remove(&window->lwindows);
    580349        ui_control_destroy(window->control);
    581         ui_menu_destroy(window->sysmenu);
    582350        ui_wdecor_destroy(window->wdecor);
    583351        ui_resource_destroy(window->res);
    584         if (window->app_mgc != NULL)
     352        if (0 && window->app_mgc != NULL)
    585353                mem_gc_delete(window->app_mgc);
    586         if (window->app_bmp != NULL)
     354        if (0 && window->app_bmp != NULL)
    587355                gfx_bitmap_destroy(window->app_bmp);
    588356        if (window->mgc != NULL) {
    … …  
    592360        if (window->bmp != NULL)
    593361                gfx_bitmap_destroy(window->bmp);
     362        gfx_context_delete(window->gc);
    594363        if (window->dwindow != NULL)
    595364                display_window_destroy(window->dwindow);
    596365
     366        free(window);
     367
    597368        /* Need to repaint if windows are emulated */
    598369        if (ui_is_fullscreen(ui)) {
    599                 (void)ui_paint(ui);
    600                 /* Send focus event to newly active window */
    601                 nwindow = ui_window_get_active(ui);
    602                 if (nwindow != NULL)
    603                         ui_window_send_focus(nwindow, 0);
    604         }
    605 
    606         if (ui->console != NULL &&
    607             window->placement == ui_wnd_place_full_screen) {
    608                 (void) console_set_caption(ui->console, "");
    609         }
    610 
    611         free(window);
     370                ui_paint(ui);
     371        }
    612372}
    613373
    … …  
    619379 * @param window Window
    620380 * @param control Control
     381 * @return EOK on success, ENOMEM if out of memory
    621382 */
    622383void ui_window_add(ui_window_t *window, ui_control_t *control)
    … …  
    640401        window->control = NULL;
    641402        control->elemp = NULL;
    642 }
    643 
    644 /** Get first (lowermost) window (only valid in fullscreen mode).
    645  *
    646  * @param ui User interface
    647  * @return First window
    648  */
    649 ui_window_t *ui_window_first(ui_t *ui)
    650 {
    651         link_t *link;
    652 
    653         link = list_first(&ui->windows);
    654         if (link == NULL)
    655                 return NULL;
    656 
    657         return list_get_instance(link, ui_window_t, lwindows);
    658 }
    659 
    660 /** Get next window (only valid in fullscreen mode).
    661  *
    662  * @param cur Current window
    663  * @return First window
    664  */
    665 ui_window_t *ui_window_next(ui_window_t *cur)
    666 {
    667         link_t *link;
    668 
    669         link = list_next(&cur->lwindows, &cur->ui->windows);
    670         if (link == NULL)
    671                 return NULL;
    672 
    673         return list_get_instance(link, ui_window_t, lwindows);
    674403}
    675404
    … …  
    690419}
    691420
    692 /** 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.
    693425 *
    694426 * @param window Window
    695427 * @param rect Rectangle
    696  * @param scop Size change operation
    697428 *
    698429 * @return EOK on success or an error code
    699430 */
    700 errno_t ui_window_size_change(ui_window_t *window, gfx_rect_t *rect,
    701     ui_wnd_sc_op_t scop)
     431errno_t ui_window_resize(ui_window_t *window, gfx_rect_t *rect)
    702432{
    703433        gfx_coord2_t offs;
    … …  
    710440        gfx_bitmap_alloc_t app_alloc;
    711441        gfx_bitmap_alloc_t win_alloc;
    712         gfx_coord2_t dpos;
    713442        errno_t rc;
    714443
    … …  
    766495        }
    767496
    768         /* dwindow can be NULL in case of unit tests or fullscreen mode */
     497        /* dwindow can be NULL in case of unit tests */
    769498        if (window->dwindow != NULL) {
    770                 switch (scop) {
    771                 case ui_wsc_resize:
    772                         rc = display_window_resize(window->dwindow, &offs,
    773                             &nrect);
    774                         if (rc != EOK)
    775                                 goto error;
    776                         break;
    777                 case ui_wsc_maximize:
    778                         rc = display_window_maximize(window->dwindow);
    779                         if (rc != EOK)
    780                                 goto error;
    781                         break;
    782                 case ui_wsc_unmaximize:
    783                         rc = display_window_unmaximize(window->dwindow);
    784                         if (rc != EOK)
    785                                 goto error;
    786                         break;
    787                 }
    788         } else {
    789                 /* fullscreen mode or unit tests */
    790                 switch (scop) {
    791                 case ui_wsc_resize:
    792                         break;
    793                 case ui_wsc_maximize:
    794                         window->normal_dpos = window->dpos;
    795                         dpos.x = 0;
    796                         dpos.y = 0;
    797                         ui_window_set_dpos(window, &dpos);
    798                         break;
    799                 case ui_wsc_unmaximize:
    800                         ui_window_set_dpos(window, &window->normal_dpos);
    801                         break;
    802                 }
     499                rc = display_window_resize(window->dwindow, &offs, &nrect);
     500                if (rc != EOK)
     501                        goto error;
    803502        }
    804503
    … …  
    808507                /* Window is resized, now we can map the window bitmap again */
    809508                gfx_bitmap_params_init(&win_params);
    810                 if (window->ui->display != NULL)
    811                         win_params.flags |= bmpf_direct_output;
     509                win_params.flags |= bmpf_direct_output;
    812510                win_params.rect = nrect;
    813511
    … …  
    821519                        goto error;
    822520#endif
     521
    823522                mem_gc_retarget(window->mgc, &win_params.rect, &win_alloc);
    824523
    … …  
    827526        }
    828527
    829         window->rect = nrect;
    830528        ui_wdecor_set_rect(window->wdecor, &nrect);
    831529        ui_wdecor_paint(window->wdecor);
    … …  
    838536                gfx_bitmap_destroy(window->app_bmp);
    839537                window->app_bmp = app_bmp;
    840         }
    841 
    842         switch (scop) {
    843         case ui_wsc_resize:
    844                 break;
    845         case ui_wsc_maximize:
    846                 window->flags |= uiwf_maximized;
    847                 break;
    848         case ui_wsc_unmaximize:
    849                 window->flags &= ~uiwf_maximized;
    850                 break;
    851538        }
    852539
    … …  
    860547}
    861548
    862 /** Resize/move window.
    863  *
    864  * Resize window to the dimensions of @a rect. If @a rect.p0 is not 0,0,
    865  * the top-left corner of the window will move on the screen accordingly.
    866  *
    867  * @param window Window
    868  * @param rect Rectangle
    869  *
    870  * @return EOK on success or an error code
    871  */
    872 errno_t ui_window_resize(ui_window_t *window, gfx_rect_t *rect)
    873 {
    874         errno_t rc;
    875 
    876         rc = ui_window_size_change(window, rect, ui_wsc_resize);
    877         if (rc != EOK)
    878                 return rc;
    879 
    880         /* Need to repaint UI if windows are emulated */
    881         if (ui_is_fullscreen(window->ui))
    882                 (void)ui_paint(window->ui);
    883 
    884         return EOK;
    885 }
    886 
    887549/** Set window callbacks.
    888550 *
    … …  
    895557        window->cb = cb;
    896558        window->arg = arg;
    897 }
    898 
    899 /** Change window caption.
    900  *
    901  * @param window Window
    902  * @param caption New caption
    903  *
    904  * @return EOK on success or an error code
    905  */
    906 errno_t ui_window_set_caption(ui_window_t *window, const char *caption)
    907 {
    908         errno_t rc;
    909 
    910         /* Set console caption if fullscreen window on console */
    911         if (window->ui->console != NULL && window->placement ==
    912             ui_wnd_place_full_screen) {
    913                 rc = console_set_caption(window->ui->console, caption);
    914                 if (rc != EOK)
    915                         return rc;
    916         }
    917 
    918         /* Set display window caption if running on display service */
    919         if (window->dwindow != NULL) {
    920                 rc = display_window_set_caption(window->dwindow, caption);
    921                 if (rc != EOK)
    922                         return rc;
    923         }
    924 
    925         return ui_wdecor_set_caption(window->wdecor, caption);
    926 }
    927 
    928 /** Get window's containing UI.
    929  *
    930  * @param window Window
    931  * @return Containing UI
    932  */
    933 ui_t *ui_window_get_ui(ui_window_t *window)
    934 {
    935         return window->ui;
    936559}
    937560
    … …  
    971594                        return rc;
    972595        } else {
    973                 *pos = window->dpos;
     596                pos->x = 0;
     597                pos->y = 0;
    974598        }
    975599
    … …  
    1071695{
    1072696        ui_window_t *window = (ui_window_t *) arg;
    1073         ui_t *ui = window->ui;
    1074 
    1075         fibril_mutex_lock(&ui->lock);
     697
    1076698        ui_window_send_close(window);
    1077         fibril_mutex_unlock(&ui->lock);
    1078699}
    1079700
    1080701/** Handle window focus event. */
    1081 static void dwnd_focus_event(void *arg, unsigned nfocus)
    1082 {
    1083         ui_window_t *window = (ui_window_t *) arg;
    1084         ui_t *ui = window->ui;
    1085 
    1086         fibril_mutex_lock(&ui->lock);
    1087         (void)nfocus;
     702static void dwnd_focus_event(void *arg)
     703{
     704        ui_window_t *window = (ui_window_t *) arg;
    1088705
    1089706        if (window->wdecor != NULL) {
    … …  
    1092709        }
    1093710
    1094         ui_window_send_focus(window, nfocus);
    1095         fibril_mutex_unlock(&ui->lock);
     711        ui_window_send_focus(window);
    1096712}
    1097713
    … …  
    1100716{
    1101717        ui_window_t *window = (ui_window_t *) arg;
    1102         ui_t *ui = window->ui;
    1103 
    1104         fibril_mutex_lock(&ui->lock);
     718
     719        (void) window;
    1105720        ui_window_send_kbd(window, kbd_event);
    1106         fibril_mutex_unlock(&ui->lock);
    1107721}
    1108722
    … …  
    1111725{
    1112726        ui_window_t *window = (ui_window_t *) arg;
    1113         ui_t *ui = window->ui;
    1114         ui_evclaim_t claim;
    1115727
    1116728        /* Make sure we don't process events until fully initialized */
    … …  
    1118730                return;
    1119731
    1120         fibril_mutex_lock(&ui->lock);
    1121 
    1122         claim = ui_wdecor_pos_event(window->wdecor, event);
    1123         if (claim == ui_claimed) {
    1124                 fibril_mutex_unlock(&ui->lock);
    1125                 return;
    1126         }
    1127 
     732        ui_wdecor_pos_event(window->wdecor, event);
    1128733        ui_window_send_pos(window, event);
    1129         fibril_mutex_unlock(&ui->lock);
    1130734}
    1131735
    … …  
    1134738{
    1135739        ui_window_t *window = (ui_window_t *) arg;
    1136         ui_t *ui = window->ui;
    1137740
    1138741        /* Make sure we don't process events until fully initialized */
    … …  
    1143746                return;
    1144747
    1145         fibril_mutex_lock(&ui->lock);
    1146748        (void) ui_window_resize(window, rect);
    1147         ui_window_send_resize(window);
    1148         fibril_mutex_unlock(&ui->lock);
     749        (void) ui_window_paint(window);
    1149750}
    1150751
    1151752/** Handle window unfocus event. */
    1152 static void dwnd_unfocus_event(void *arg, unsigned nfocus)
    1153 {
    1154         ui_window_t *window = (ui_window_t *) arg;
    1155         ui_t *ui = window->ui;
    1156 
    1157         fibril_mutex_lock(&ui->lock);
    1158 
    1159         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) {
    1160758                ui_wdecor_set_active(window->wdecor, false);
    1161759                ui_wdecor_paint(window->wdecor);
    1162760        }
    1163761
    1164         ui_window_send_unfocus(window, nfocus);
    1165         fibril_mutex_unlock(&ui->lock);
    1166 }
    1167 
    1168 /** Window decoration requested opening of system menu.
    1169  *
    1170  * @param wdecor Window decoration
    1171  * @param arg Argument (window)
    1172  * @param idev_id Input device ID
    1173  */
    1174 static void wd_sysmenu_open(ui_wdecor_t *wdecor, void *arg, sysarg_t idev_id)
    1175 {
    1176         ui_window_t *window = (ui_window_t *) arg;
    1177 
    1178         ui_window_send_sysmenu(window, idev_id);
    1179 }
    1180 
    1181 /** Window decoration requested moving left from system menu handle.
    1182  *
    1183  * @param wdecor Window decoration
    1184  * @param arg Argument (window)
    1185  * @param idev_id Input device ID
    1186  */
    1187 static void wd_sysmenu_left(ui_wdecor_t *wdecor, void *arg, sysarg_t idev_id)
    1188 {
    1189         ui_window_t *window = (ui_window_t *) arg;
    1190 
    1191         if (window->mbar != NULL) {
    1192                 ui_wdecor_sysmenu_hdl_set_active(window->wdecor, false);
    1193                 ui_menu_close(window->sysmenu);
    1194                 ui_menu_bar_select_last(window->mbar, false, idev_id);
    1195         }
    1196 }
    1197 
    1198 /** Window decoration requested moving right from system menu handle.
    1199  *
    1200  * @param wdecor Window decoration
    1201  * @param arg Argument (window)
    1202  * @param idev_id Input device ID
    1203  */
    1204 static void wd_sysmenu_right(ui_wdecor_t *wdecor, void *arg, sysarg_t idev_id)
    1205 {
    1206         ui_window_t *window = (ui_window_t *) arg;
    1207 
    1208         if (window->mbar != NULL) {
    1209                 ui_wdecor_sysmenu_hdl_set_active(window->wdecor, false);
    1210                 ui_menu_close(window->sysmenu);
    1211                 ui_menu_bar_select_first(window->mbar, false, idev_id);
    1212         }
    1213 }
    1214 
    1215 /** Window decoration detected accelerator press from system menu handle.
    1216  *
    1217  * @param wdecor Window decoration
    1218  * @param arg Argument (window)
    1219  * @param c Accelerator key
    1220  * @param idev_id Input device ID
    1221  */
    1222 static void wd_sysmenu_accel(ui_wdecor_t *wdecor, void *arg, char32_t c,
    1223     sysarg_t idev_id)
    1224 {
    1225         ui_window_t *window = (ui_window_t *) arg;
    1226 
    1227         if (window->mbar != NULL) {
    1228                 ui_wdecor_sysmenu_hdl_set_active(window->wdecor, false);
    1229                 ui_menu_close(window->sysmenu);
    1230                 ui_menu_bar_press_accel(window->mbar, c, idev_id);
    1231         }
    1232 }
    1233 
    1234 /** Window decoration requested window minimization.
    1235  *
    1236  * @param wdecor Window decoration
    1237  * @param arg Argument (window)
    1238  */
    1239 static void wd_minimize(ui_wdecor_t *wdecor, void *arg)
    1240 {
    1241         ui_window_t *window = (ui_window_t *) arg;
    1242 
    1243         ui_window_send_minimize(window);
    1244 }
    1245 
    1246 /** Window decoration requested window maximization.
    1247  *
    1248  * @param wdecor Window decoration
    1249  * @param arg Argument (window)
    1250  */
    1251 static void wd_maximize(ui_wdecor_t *wdecor, void *arg)
    1252 {
    1253         ui_window_t *window = (ui_window_t *) arg;
    1254 
    1255         ui_window_send_maximize(window);
    1256 }
    1257 
    1258 /** Window decoration requested window unmaximization.
    1259  *
    1260  * @param wdecor Window decoration
    1261  * @param arg Argument (window)
    1262  */
    1263 static void wd_unmaximize(ui_wdecor_t *wdecor, void *arg)
    1264 {
    1265         ui_window_t *window = (ui_window_t *) arg;
    1266 
    1267         ui_window_send_unmaximize(window);
     762        ui_window_send_unfocus(window);
    1268763}
    1269764
    … …  
    1285780 * @param arg Argument (window)
    1286781 * @param pos Position where the title bar was pressed
    1287  * @param pos_id Positioning device ID
    1288  */
    1289 static void wd_move(ui_wdecor_t *wdecor, void *arg, gfx_coord2_t *pos,
    1290     sysarg_t pos_id)
     782 */
     783static void wd_move(ui_wdecor_t *wdecor, void *arg, gfx_coord2_t *pos)
    1291784{
    1292785        ui_window_t *window = (ui_window_t *) arg;
    1293786
    1294787        if (window->dwindow != NULL)
    1295                 (void) display_window_move_req(window->dwindow, pos, pos_id);
     788                (void) display_window_move_req(window->dwindow, pos);
    1296789}
    1297790
    … …  
    1302795 * @param rsztype Resize type
    1303796 * @param pos Position where the button was pressed
    1304  * @param pos_id Positioning device ID
    1305797 */
    1306798static void wd_resize(ui_wdecor_t *wdecor, void *arg,
    1307     ui_wdecor_rsztype_t rsztype, gfx_coord2_t *pos, sysarg_t pos_id)
    1308 {
    1309         ui_window_t *window = (ui_window_t *) arg;
    1310 
    1311         if (window->dwindow != NULL) {
    1312                 (void) display_window_resize_req(window->dwindow,
    1313                     (display_wnd_rsztype_t) rsztype, // Same constants in the enums
    1314                     pos, pos_id);
    1315         }
     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);
    1316805}
    1317806
    … …  
    1374863}
    1375864
    1376 /** Send window sysmenu event.
    1377  *
    1378  * @param window Window
    1379  * @parma idev_id Input device ID
    1380  */
    1381 void ui_window_send_sysmenu(ui_window_t *window, sysarg_t idev_id)
    1382 {
    1383         if (window->cb != NULL && window->cb->sysmenu != NULL)
    1384                 window->cb->sysmenu(window, window->arg, idev_id);
    1385         else
    1386                 ui_window_def_sysmenu(window, idev_id);
    1387 }
    1388 
    1389 /** Send window minimize event.
    1390  *
    1391  * @param window Window
    1392  */
    1393 void ui_window_send_minimize(ui_window_t *window)
    1394 {
    1395         if (window->cb != NULL && window->cb->minimize != NULL)
    1396                 window->cb->minimize(window, window->arg);
    1397         else
    1398                 ui_window_def_minimize(window);
    1399 }
    1400 
    1401 /** Send window maximize event.
    1402  *
    1403  * @param window Window
    1404  */
    1405 void ui_window_send_maximize(ui_window_t *window)
    1406 {
    1407         if (window->cb != NULL && window->cb->maximize != NULL)
    1408                 window->cb->maximize(window, window->arg);
    1409         else
    1410                 ui_window_def_maximize(window);
    1411 }
    1412 
    1413 /** Send window unmaximize event.
    1414  *
    1415  * @param window Window
    1416  */
    1417 void ui_window_send_unmaximize(ui_window_t *window)
    1418 {
    1419         if (window->cb != NULL && window->cb->unmaximize != NULL)
    1420                 window->cb->unmaximize(window, window->arg);
    1421         else
    1422                 ui_window_def_unmaximize(window);
    1423 }
    1424 
    1425865/** Send window close event.
    1426866 *
    … …  
    1436876 *
    1437877 * @param window Window
    1438  * @param nfocus New number of foci
    1439  */
    1440 void ui_window_send_focus(ui_window_t *window, unsigned nfocus)
     878 */
     879void ui_window_send_focus(ui_window_t *window)
    1441880{
    1442881        if (window->cb != NULL && window->cb->focus != NULL)
    1443                 window->cb->focus(window, window->arg, nfocus);
     882                window->cb->focus(window, window->arg);
    1444883}
    1445884
    … …  
    1453892                window->cb->kbd(window, window->arg, kbd);
    1454893        else
    1455                 ui_window_def_kbd(window, kbd);
     894                return ui_window_def_kbd(window, kbd);
    1456895}
    1457896
    … …  
    1483922 *
    1484923 * @param window Window
    1485  * @param nfocus Number of remaining foci
    1486  */
    1487 void ui_window_send_unfocus(ui_window_t *window, unsigned nfocus)
     924 */
     925void ui_window_send_unfocus(ui_window_t *window)
    1488926{
    1489927        if (window->cb != NULL && window->cb->unfocus != NULL)
    1490                 window->cb->unfocus(window, window->arg, nfocus);
     928                window->cb->unfocus(window, window->arg);
    1491929        else
    1492                 return ui_window_def_unfocus(window, nfocus);
    1493 }
    1494 
    1495 /** Send window resize event.
    1496  *
    1497  * @param window Window
    1498  */
    1499 void ui_window_send_resize(ui_window_t *window)
    1500 {
    1501         if (window->cb != NULL && window->cb->resize != NULL)
    1502                 window->cb->resize(window, window->arg);
    1503         else
    1504                 return ui_window_def_resize(window);
    1505 }
    1506 
    1507 /** Default window sysmenu routine.
    1508  *
    1509  * @param window Window
    1510  * @param idev_id Input device ID
    1511  * @return EOK on success or an error code
    1512  */
    1513 errno_t ui_window_def_sysmenu(ui_window_t *window, sysarg_t idev_id)
    1514 {
    1515         errno_t rc;
    1516         ui_wdecor_geom_t geom;
    1517 
    1518         if (ui_menu_is_open(window->sysmenu)) {
    1519                 ui_menu_close(window->sysmenu);
    1520         } else {
    1521                 ui_wdecor_get_geom(window->wdecor, &geom);
    1522 
    1523                 rc = ui_menu_open(window->sysmenu, &geom.title_bar_rect,
    1524                     idev_id);
    1525                 if (rc != EOK)
    1526                         goto error;
    1527         }
    1528 
    1529         return EOK;
    1530 error:
    1531         return rc;
    1532 }
    1533 
    1534 /** Default window minimize routine.
    1535  *
    1536  * @param window Window
    1537  * @return EOK on success or an error code
    1538  */
    1539 errno_t ui_window_def_minimize(ui_window_t *window)
    1540 {
    1541         errno_t rc;
    1542 
    1543         if (window->dwindow != NULL) {
    1544                 rc = display_window_minimize(window->dwindow);
    1545                 if (rc != EOK)
    1546                         goto error;
    1547         }
    1548 
    1549         return EOK;
    1550 error:
    1551         return rc;
    1552 }
    1553 
    1554 /** Default window maximize routine.
    1555  *
    1556  * @param window Window
    1557  * @return EOK on success or an error code
    1558  */
    1559 errno_t ui_window_def_maximize(ui_window_t *window)
    1560 {
    1561         errno_t rc;
    1562         gfx_rect_t old_rect;
    1563         gfx_rect_t rect;
    1564 
    1565         old_rect = window->rect;
    1566 
    1567         if (window->dwindow != NULL) {
    1568                 rc = display_window_get_max_rect(window->dwindow, &rect);
    1569                 if (rc != EOK)
    1570                         return rc;
    1571         } else {
    1572                 rect = window->ui->rect;
    1573         }
    1574 
    1575         ui_wdecor_set_maximized(window->wdecor, true);
    1576         ui_menu_entry_set_disabled(window->sysmenu_restore, false);
    1577         ui_menu_entry_set_disabled(window->sysmenu_maximize, true);
    1578 
    1579         rc = ui_window_size_change(window, &rect, ui_wsc_maximize);
    1580         if (rc != EOK) {
    1581                 ui_wdecor_set_maximized(window->wdecor, false);
    1582                 return rc;
    1583         }
    1584 
    1585         window->normal_rect = old_rect;
    1586         ui_window_send_resize(window);
    1587 
    1588         /* Need to repaint UI if windows are emulated */
    1589         if (ui_is_fullscreen(window->ui))
    1590                 (void)ui_paint(window->ui);
    1591 
    1592         return EOK;
    1593 }
    1594 
    1595 /** Default window unmaximize routine.
    1596  *
    1597  * @param window Window
    1598  * @return EOK on success or an error code
    1599  */
    1600 errno_t ui_window_def_unmaximize(ui_window_t *window)
    1601 {
    1602         errno_t rc;
    1603 
    1604         ui_wdecor_set_maximized(window->wdecor, false);
    1605         ui_menu_entry_set_disabled(window->sysmenu_restore, true);
    1606         ui_menu_entry_set_disabled(window->sysmenu_maximize, false);
    1607 
    1608         rc = ui_window_size_change(window, &window->normal_rect,
    1609             ui_wsc_unmaximize);
    1610         if (rc != EOK) {
    1611                 ui_wdecor_set_maximized(window->wdecor, true);
    1612                 printf("ui_window_size_change->error\n");
    1613                 return rc;
    1614         }
    1615 
    1616         ui_window_send_resize(window);
    1617 
    1618         /* Need to repaint UI if windows are emulated */
    1619         if (ui_is_fullscreen(window->ui))
    1620                 (void)ui_paint(window->ui);
    1621 
    1622         return EOK;
     930                return ui_window_def_unfocus(window);
    1623931}
    1624932
    … …  
    1626934 *
    1627935 * @param window Window
    1628  * @return ui_claimed iff event was claimed
    1629  */
    1630 ui_evclaim_t ui_window_def_kbd(ui_window_t *window, kbd_event_t *kbd)
    1631 {
    1632         ui_evclaim_t claim;
    1633 
     936 */
     937void ui_window_def_kbd(ui_window_t *window, kbd_event_t *kbd)
     938{
    1634939        if (window->control != NULL)
    1635                 claim = ui_control_kbd_event(window->control, kbd);
    1636         else
    1637                 claim = ui_unclaimed;
    1638 
    1639         if (claim == ui_unclaimed)
    1640                 return ui_wdecor_kbd_event(window->wdecor, kbd);
    1641 
    1642         return ui_unclaimed;
     940                ui_control_kbd_event(window->control, kbd);
    1643941}
    1644942
    … …  
    1686984 *
    1687985 * @param window Window
    1688  * @param nfocus Number of remaining foci
    1689986 * @return EOK on success or an error code
    1690987 */
    1691 void ui_window_def_unfocus(ui_window_t *window, unsigned nfocus)
     988void ui_window_def_unfocus(ui_window_t *window)
    1692989{
    1693990        if (window->control != NULL)
    1694                 ui_control_unfocus(window->control, nfocus);
    1695 }
    1696 
    1697 /** Default window resize routine.
    1698  *
    1699  * @param window Window
    1700  * @return EOK on success or an error code
    1701  */
    1702 void ui_window_def_resize(ui_window_t *window)
    1703 {
    1704         ui_window_paint(window);
    1705 }
    1706 
    1707 /** Handle system menu left event.
    1708  *
    1709  * @param sysmenu System menu
    1710  * @param arg Argument (ui_window_t *)
    1711  * @param idev_id Input device ID
    1712  */
    1713 static void wnd_sysmenu_left(ui_menu_t *sysmenu, void *arg, sysarg_t idev_id)
    1714 {
    1715         ui_window_t *window = (ui_window_t *)arg;
    1716 
    1717         if (window->mbar != NULL) {
    1718                 ui_wdecor_sysmenu_hdl_set_active(window->wdecor, false);
    1719                 ui_menu_close(sysmenu);
    1720                 ui_menu_bar_select_last(window->mbar, true, idev_id);
    1721         }
    1722 }
    1723 
    1724 /** Handle system menu right event.
    1725  *
    1726  * @param sysmenu System menu
    1727  * @param arg Argument (ui_window_t *)
    1728  * @param idev_id Input device ID
    1729  */
    1730 static void wnd_sysmenu_right(ui_menu_t *sysmenu, void *arg, sysarg_t idev_id)
    1731 {
    1732         ui_window_t *window = (ui_window_t *)arg;
    1733 
    1734         if (window->mbar != NULL) {
    1735                 ui_wdecor_sysmenu_hdl_set_active(window->wdecor, false);
    1736                 ui_menu_close(sysmenu);
    1737                 ui_menu_bar_select_first(window->mbar, true, idev_id);
    1738         }
    1739 }
    1740 
    1741 /** Handle system menu close request event.
    1742  *
    1743  * @param sysmenu System menu
    1744  * @param arg Argument (ui_window_t *)
    1745  * @param idev_id Input device ID
    1746  */
    1747 static void wnd_sysmenu_close_req(ui_menu_t *sysmenu, void *arg)
    1748 {
    1749         ui_window_t *window = (ui_window_t *)arg;
    1750 
    1751         ui_wdecor_sysmenu_hdl_set_active(window->wdecor, false);
    1752         ui_menu_close(sysmenu);
    1753 }
    1754 
    1755 /** Handle system menu Restore entry activation.
    1756  *
    1757  * @param mentry Menu entry
    1758  * @param arg Argument (ui_window_t *)
    1759  */
    1760 static void wnd_sysmenu_erestore(ui_menu_entry_t *mentry, void *arg)
    1761 {
    1762         ui_window_t *window = (ui_window_t *)arg;
    1763 
    1764         ui_window_send_unmaximize(window);
    1765 }
    1766 
    1767 /** Handle system menu Minimize entry activation.
    1768  *
    1769  * @param mentry Menu entry
    1770  * @param arg Argument (ui_window_t *)
    1771  */
    1772 static void wnd_sysmenu_eminimize(ui_menu_entry_t *mentry, void *arg)
    1773 {
    1774         ui_window_t *window = (ui_window_t *)arg;
    1775 
    1776         ui_window_send_minimize(window);
    1777 }
    1778 
    1779 /** Handle system menu Maximize entry activation.
    1780  *
    1781  * @param mentry Menu entry
    1782  * @param arg Argument (ui_window_t *)
    1783  */
    1784 static void wnd_sysmenu_emaximize(ui_menu_entry_t *mentry, void *arg)
    1785 {
    1786         ui_window_t *window = (ui_window_t *)arg;
    1787 
    1788         ui_window_send_maximize(window);
    1789 }
    1790 
    1791 /** Handle system menu Close entry activation.
    1792  *
    1793  * @param mentry Menu entry
    1794  * @param arg Argument (ui_window_t *)
    1795  */
    1796 static void wnd_sysmenu_eclose(ui_menu_entry_t *mentry, void *arg)
    1797 {
    1798         ui_window_t *window = (ui_window_t *)arg;
    1799 
    1800         ui_window_send_close(window);
    1801 }
    1802 
    1803 /** Handle system menu press accelerator key event.
    1804  *
    1805  * @param sysmenu System menu
    1806  * @param arg Argument (ui_window_t *)
    1807  * @param idev_id Input device ID
    1808  */
    1809 static void wnd_sysmenu_press_accel(ui_menu_t *sysmenu, void *arg,
    1810     char32_t c, sysarg_t idev_id)
    1811 {
    1812         (void)sysmenu;
    1813         (void)arg;
    1814         (void)c;
    1815         (void)idev_id;
     991                ui_control_unfocus(window->control);
    1816992}
    1817993
    … …  
    18381014        ui_window_t *window = (ui_window_t *) arg;
    18391015
    1840         if (!gfx_rect_is_empty(&window->dirty_rect)) {
    1841                 (void) gfx_bitmap_render(window->bmp, &window->dirty_rect,
    1842                     &window->dpos);
    1843         }
     1016        if (!gfx_rect_is_empty(&window->dirty_rect))
     1017                (void) gfx_bitmap_render(window->bmp, &window->dirty_rect, NULL);
    18441018
    18451019        window->dirty_rect.p0.x = 0;
    … …  
    18571031{
    18581032        ui_window_t *window = (ui_window_t *) arg;
    1859         gfx_coord2_t cpos;
    1860         errno_t rc;
    1861 
    1862         rc = gfx_cursor_get_pos(window->realgc, &cpos);
    1863         if (rc != EOK)
    1864                 return rc;
    1865 
    1866         pos->x = cpos.x - window->dpos.x;
    1867         pos->y = cpos.y - window->dpos.y;
    1868         return EOK;
     1033
     1034        return gfx_cursor_get_pos(window->realgc, pos);
    18691035}
    18701036
    … …  
    18771043{
    18781044        ui_window_t *window = (ui_window_t *) arg;
    1879         gfx_coord2_t cpos;
    1880 
    1881         cpos.x = pos->x + window->dpos.x;
    1882         cpos.y = pos->y + window->dpos.y;
    1883 
    1884         return gfx_cursor_set_pos(window->realgc, &cpos);
     1045
     1046        return gfx_cursor_set_pos(window->realgc, pos);
    18851047}
    18861048
Note: See TracChangeset for help on using the changeset viewer.