Changes in uspace/lib/ui/src/window.c [1215db9:b979ffb] in mainline

File:

• uspace/lib/ui/src/window.c (modified) (49 diffs)

uspace/lib/ui/src/window.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2021 Jiri Svoboda
+ * Copyright (c) 2026 Jiri Svoboda
  * All rights reserved.
  *
@@ -47 +47 @@
 #include <stdlib.h>
 #include <ui/control.h>
+#include <ui/menubar.h>
+#include <ui/menu.h>
+#include <ui/menuentry.h>
 #include <ui/resource.h>
 #include <ui/ui.h>
@@ -59 +62 @@
 
 static void dwnd_close_event(void *);
-static void dwnd_focus_event(void *);
+static void dwnd_focus_event(void *, unsigned);
 static void dwnd_kbd_event(void *, kbd_event_t *);
 static void dwnd_pos_event(void *, pos_event_t *);
 static void dwnd_resize_event(void *, gfx_rect_t *);
-static void dwnd_unfocus_event(void *);
+static void dwnd_unfocus_event(void *, unsigned);
 
 static display_wnd_cb_t dwnd_cb = {
@@ -74 +77 @@
 };
 
+static void wd_sysmenu_open(ui_wdecor_t *, void *, sysarg_t);
+static void wd_sysmenu_left(ui_wdecor_t *, void *, sysarg_t);
+static void wd_sysmenu_right(ui_wdecor_t *, void *, sysarg_t);
+static void wd_sysmenu_accel(ui_wdecor_t *, void *, char32_t, sysarg_t);
+static void wd_minimize(ui_wdecor_t *, void *);
+static void wd_maximize(ui_wdecor_t *, void *);
+static void wd_unmaximize(ui_wdecor_t *, void *);
 static void wd_close(ui_wdecor_t *, void *);
-static void wd_move(ui_wdecor_t *, void *, gfx_coord2_t *);
+static void wd_move(ui_wdecor_t *, void *, gfx_coord2_t *, sysarg_t);
 static void wd_resize(ui_wdecor_t *, void *, ui_wdecor_rsztype_t,
-    gfx_coord2_t *);
+    gfx_coord2_t *, sysarg_t);
 static void wd_set_cursor(ui_wdecor_t *, void *, ui_stock_cursor_t);
 
 static ui_wdecor_cb_t wdecor_cb = {
+        .sysmenu_open = wd_sysmenu_open,
+        .sysmenu_left = wd_sysmenu_left,
+        .sysmenu_right = wd_sysmenu_right,
+        .sysmenu_accel = wd_sysmenu_accel,
+        .minimize = wd_minimize,
+        .maximize = wd_maximize,
+        .unmaximize = wd_unmaximize,
         .close = wd_close,
         .move = wd_move,
@@ -86 +103 @@
         .set_cursor = wd_set_cursor
 };
+
+static void wnd_sysmenu_left(ui_menu_t *, void *, sysarg_t);
+static void wnd_sysmenu_right(ui_menu_t *, void *, sysarg_t);
+static void wnd_sysmenu_close_req(ui_menu_t *, void *);
+static void wnd_sysmenu_press_accel(ui_menu_t *, void *, char32_t, sysarg_t);
+
+static ui_menu_cb_t wnd_sysmenu_cb = {
+        .left = wnd_sysmenu_left,
+        .right = wnd_sysmenu_right,
+        .close_req = wnd_sysmenu_close_req,
+        .press_accel = wnd_sysmenu_press_accel
+};
+
+static void wnd_sysmenu_erestore(ui_menu_entry_t *, void *);
+static void wnd_sysmenu_eminimize(ui_menu_entry_t *, void *);
+static void wnd_sysmenu_emaximize(ui_menu_entry_t *, void *);
+static void wnd_sysmenu_eclose(ui_menu_entry_t *, void *);
 
 static void ui_window_invalidate(void *, gfx_rect_t *);
@@ -132 +166 @@
 /** Compute where window should be placed on the screen.
  *
- * This only applies to windows that do not use default placement.
- *
- * @param window Window
- * @param display Display
- * @param info Display info
+ * This only applies to windows that do not use default placement or
+ * if we are running in full-screen mode.
+ *
+ * @param window Window
+ * @param drect Display rectangle
+ * @param wrect Window rectangle
+ * @param prect Parent rectangle for popup placement or @c NULL
+ * @param placement Window placement
  * @param params Window parameters
  * @param pos Place to store position of top-left corner
  */
-static void ui_window_place(ui_window_t *window, display_t *display,
-    display_info_t *info, ui_wnd_params_t *params, gfx_coord2_t *pos)
-{
-        assert(params->placement != ui_wnd_place_default);
+static void ui_window_place(ui_window_t *window, gfx_rect_t *drect,
+    gfx_rect_t *wrect, gfx_rect_t *prect, ui_wnd_placement_t placement,
+    gfx_coord2_t *pos)
+{
+        gfx_coord2_t dims;
+        gfx_coord2_t below_pos;
+        gfx_rect_t below_rect;
+
+        assert(placement != ui_wnd_place_default ||
+            ui_is_fullscreen(window->ui));
 
         pos->x = 0;
         pos->y = 0;
 
-        switch (params->placement) {
+        switch (placement) {
         case ui_wnd_place_default:
-                assert(false);
+        case ui_wnd_place_center:
+                assert(placement != ui_wnd_place_default ||
+                    ui_is_fullscreen(window->ui));
+                /* Center window */
+                gfx_rect_dims(wrect, &dims);
+                pos->x = (drect->p0.x + drect->p1.x) / 2 - dims.x / 2;
+                pos->y = (drect->p0.y + drect->p1.y) / 2 - dims.y / 2;
+                break;
         case ui_wnd_place_top_left:
         case ui_wnd_place_full_screen:
-                pos->x = info->rect.p0.x - params->rect.p0.x;
-                pos->y = info->rect.p0.y - params->rect.p0.y;
+                pos->x = drect->p0.x - wrect->p0.x;
+                pos->y = drect->p0.y - wrect->p0.y;
                 break;
         case ui_wnd_place_top_right:
-                pos->x = info->rect.p1.x - params->rect.p1.x;
-                pos->y = info->rect.p0.y - params->rect.p0.y;
+                pos->x = drect->p1.x - wrect->p1.x;
+                pos->y = drect->p0.y - wrect->p0.y;
                 break;
         case ui_wnd_place_bottom_left:
-                pos->x = info->rect.p0.x - params->rect.p0.x;
-                pos->y = info->rect.p1.y - params->rect.p1.y;
+                pos->x = drect->p0.x - wrect->p0.x;
+                pos->y = drect->p1.y - wrect->p1.y;
                 break;
         case ui_wnd_place_bottom_right:
-                pos->x = info->rect.p1.x - params->rect.p1.x;
-                pos->y = info->rect.p1.y - params->rect.p1.y;
+                pos->x = drect->p1.x - wrect->p1.x;
+                pos->y = drect->p1.y - wrect->p1.y;
                 break;
         case ui_wnd_place_popup:
-                /* Place popup window below parent rectangle */
-                pos->x = params->prect.p0.x;
-                pos->y = params->prect.p1.y;
+                /* Compute rectangle when placed below */
+                below_pos.x = prect->p0.x;
+                below_pos.y = prect->p1.y;
+                gfx_rect_translate(&below_pos, wrect, &below_rect);
+
+                /* Does below_rect fit within the display? */
+                if (gfx_rect_is_inside(&below_rect, drect)) {
+                        /* Place popup window below parent rectangle */
+                        pos->x = prect->p0.x - wrect->p0.x;
+                        pos->y = prect->p1.y - wrect->p0.y;
+                } else {
+                        /* Place popup window above parent rectangle */
+                        pos->x = prect->p0.x;
+                        pos->y = prect->p0.y -
+                            (wrect->p1.y - wrect->p0.y);
+                }
                 break;
         }
+}
+
+static void ui_window_set_dpos(ui_window_t *window, gfx_coord2_t *dpos)
+{
+        window->dpos = *dpos;
+        if (window->xgc != NULL)
+                xlate_gc_set_off(window->xgc, &window->dpos);
+}
+
+/** Create window's system menu.
+ *
+ * @param window Window
+ * @return EOK on success or an error code
+ */
+static errno_t ui_window_sysmenu_create(ui_window_t *window)
+{
+        errno_t rc;
+        ui_menu_entry_t *mrestore;
+        ui_menu_entry_t *mmin;
+        ui_menu_entry_t *mmax;
+        ui_menu_entry_t *msep;
+        ui_menu_entry_t *mclose;
+
+        rc = ui_menu_create(window, &window->sysmenu);
+        if (rc != EOK)
+                goto error;
+
+        ui_menu_set_cb(window->sysmenu, &wnd_sysmenu_cb, (void *)window);
+
+        rc = ui_menu_entry_create(window->sysmenu, "~R~estore",
+            "", &mrestore);
+        if (rc != EOK)
+                goto error;
+
+        if (!window->wdecor->maximized)
+                ui_menu_entry_set_disabled(mrestore, true);
+
+        ui_menu_entry_set_cb(mrestore, wnd_sysmenu_erestore, (void *)window);
+
+        rc = ui_menu_entry_create(window->sysmenu, "Mi~n~imize",
+            "", &mmin);
+        if (rc != EOK)
+                goto error;
+
+        if ((window->wdecor->style & ui_wds_minimize_btn) == 0)
+                ui_menu_entry_set_disabled(mmin, true);
+
+        ui_menu_entry_set_cb(mmin, wnd_sysmenu_eminimize, (void *)window);
+
+        rc = ui_menu_entry_create(window->sysmenu, "Ma~x~imize",
+            "", &mmax);
+        if (rc != EOK)
+                goto error;
+
+        if ((window->wdecor->style & ui_wds_maximize_btn) == 0 ||
+            window->wdecor->maximized)
+                ui_menu_entry_set_disabled(mmax, true);
+
+        ui_menu_entry_set_cb(mmax, wnd_sysmenu_emaximize, (void *)window);
+
+        rc = ui_menu_entry_sep_create(window->sysmenu, &msep);
+        if (rc != EOK)
+                goto error;
+
+        rc = ui_menu_entry_create(window->sysmenu, "~C~lose", "Alt-F4",
+            &mclose);
+        if (rc != EOK)
+                goto error;
+
+        if ((window->wdecor->style & ui_wds_close_btn) == 0)
+                ui_menu_entry_set_disabled(mclose, true);
+
+        ui_menu_entry_set_cb(mclose, wnd_sysmenu_eclose, (void *)window);
+
+        window->sysmenu_restore = mrestore;
+        window->sysmenu_minimize = mmin;
+        window->sysmenu_maximize = mmax;
+
+        return EOK;
+error:
+        return rc;
 }
 
@@ -187 +331 @@
 {
         ui_window_t *window;
+        ui_window_t *pwindow = NULL;
         display_info_t info;
         gfx_coord2_t scr_dims;
@@ -197 +342 @@
         gfx_bitmap_alloc_t alloc;
         gfx_bitmap_t *bmp = NULL;
+        gfx_coord2_t off;
         mem_gc_t *memgc = NULL;
+        xlate_gc_t *xgc = NULL;
+        gfx_coord2_t dpos;
         errno_t rc;
 
@@ -204 +352 @@
                 return ENOMEM;
 
+        window->ui = ui;
+
         display_wnd_params_init(&dparams);
         dparams.rect = params->rect;
-        /* Only allow making the window larger */
-        gfx_rect_dims(&params->rect, &dparams.min_size);
+        dparams.caption = params->caption;
+        dparams.min_size = params->min_size;
+
+        /*
+         * If idev_id is not specified, use the UI default (probably
+         * obtained from display specification. This creates the
+         * main window in the seat specified on the command line.
+         */
+        if (params->idev_id != 0)
+                dparams.idev_id = params->idev_id;
+        else
+                dparams.idev_id = ui->idev_id;
 
         if ((params->flags & ui_wndf_popup) != 0)
                 dparams.flags |= wndf_popup;
+        if ((params->flags & ui_wndf_nofocus) != 0)
+                dparams.flags |= wndf_nofocus;
+        if ((params->flags & ui_wndf_topmost) != 0)
+                dparams.flags |= wndf_topmost;
+        if ((params->flags & ui_wndf_system) != 0)
+                dparams.flags |= wndf_system;
+        if ((params->flags & ui_wndf_avoid) != 0)
+                dparams.flags |= wndf_avoid;
 
         if (ui->display != NULL) {
@@ -228 +396 @@
                 if (params->placement != ui_wnd_place_default) {
                         /* Set initial display window position */
-                        ui_window_place(window, ui->display, &info,
-                            params, &dparams.pos);
+                        ui_window_place(window, &info.rect, &params->rect,
+                            &params->prect, params->placement, &dparams.pos);
 
                         dparams.flags |= wndf_setpos;
@@ -244 +412 @@
         } else if (ui->console != NULL) {
                 gc = console_gc_get_ctx(ui->cgc);
+
+                if (params->placement == ui_wnd_place_full_screen) {
+                        /* Make window the size of the screen */
+                        gfx_rect_dims(&ui->rect, &scr_dims);
+                        gfx_coord2_add(&dparams.rect.p0, &scr_dims,
+                            &dparams.rect.p1);
+                        (void) console_set_caption(ui->console,
+                            params->caption);
+                }
         } else {
                 /* Needed for unit tests */
@@ -263 +440 @@
 
         /* Move rectangle so that top-left corner is 0,0 */
-        gfx_rect_rtranslate(&params->rect.p0, &params->rect, &bparams.rect);
+        gfx_rect_rtranslate(&dparams.rect.p0, &dparams.rect, &bparams.rect);
 
         rc = gfx_bitmap_create(gc, &bparams, NULL, &bmp);
@@ -287 +464 @@
         window->gc = mem_gc_get_ctx(memgc);
         window->realgc = gc;
+        (void) off;
 #else
+        /* Server-side rendering */
+
+        /* Full-screen mode? */
+        if (ui->display == NULL) {
+                /* Create translating GC to translate window contents */
+                off.x = 0;
+                off.y = 0;
+                rc = xlate_gc_create(&off, gc, &xgc);
+                if (rc != EOK)
+                        goto error;
+
+                window->xgc = xgc;
+                window->gc = xlate_gc_get_ctx(xgc);
+                window->realgc = gc;
+        } else {
+                window->gc = gc;
+        }
+
         (void) ui_window_mem_gc_cb;
         (void) alloc;
         (void) bparams;
-        window->gc = gc;
 #endif
+        if (ui->display == NULL) {
+                ui_window_place(window, &ui->rect, &params->rect, &params->prect,
+                    params->placement, &dpos);
+                ui_window_set_dpos(window, &dpos);
+        }
 
         rc = ui_resource_create(window->gc, ui_is_textmode(ui), &res);
@@ -308 +508 @@
         ui_resource_set_expose_cb(res, ui_window_expose_cb, (void *) window);
 
-        window->ui = ui;
         window->rect = dparams.rect;
-
         window->res = res;
         window->wdecor = wdecor;
         window->cursor = ui_curs_arrow;
+        window->placement = params->placement;
+
+        rc = ui_window_sysmenu_create(window);
+        if (rc != EOK)
+                goto error;
+
         *rwindow = window;
 
+        if (ui_is_fullscreen(ui))
+                pwindow = ui_window_get_active(ui);
+
         list_append(&window->lwindows, &ui->windows);
+
+        if (ui_is_fullscreen(ui)) {
+                /* Send unfocus event to previously active window */
+                if (pwindow != NULL)
+                        ui_window_send_unfocus(pwindow, 0);
+        }
+
         return EOK;
 error:
@@ -325 +539 @@
         if (memgc != NULL)
                 mem_gc_delete(memgc);
+        if (xgc != NULL)
+                xlate_gc_delete(xgc);
         if (bmp != NULL)
                 gfx_bitmap_destroy(bmp);
@@ -333 +549 @@
 }
 
+/** Update window placement after screen resize (only in fullscreen UI).
+ *
+ * @param window UI window
+ */
+void ui_window_update_placement(ui_window_t *window)
+{
+        if (window->placement == ui_wnd_place_full_screen ||
+            (window->flags & uiwf_maximized) != 0) {
+                /* Update size of fullscreen or maximized window. */
+                (void)ui_window_resize(window, &window->ui->rect);
+                ui_window_send_resize(window);
+        }
+}
+
 /** Destroy window.
  *
@@ -340 +570 @@
 {
         ui_t *ui;
+        ui_window_t *nwindow;
 
         if (window == NULL)
@@ -348 +579 @@
         list_remove(&window->lwindows);
         ui_control_destroy(window->control);
+        ui_menu_destroy(window->sysmenu);
         ui_wdecor_destroy(window->wdecor);
         ui_resource_destroy(window->res);
-        if (0 && window->app_mgc != NULL)
+        if (window->app_mgc != NULL)
                 mem_gc_delete(window->app_mgc);
-        if (0 && window->app_bmp != NULL)
+        if (window->app_bmp != NULL)
                 gfx_bitmap_destroy(window->app_bmp);
         if (window->mgc != NULL) {
@@ -360 +592 @@
         if (window->bmp != NULL)
                 gfx_bitmap_destroy(window->bmp);
-        gfx_context_delete(window->gc);
         if (window->dwindow != NULL)
                 display_window_destroy(window->dwindow);
 
-        free(window);
-
         /* Need to repaint if windows are emulated */
         if (ui_is_fullscreen(ui)) {
-                ui_paint(ui);
-        }
+                (void)ui_paint(ui);
+                /* Send focus event to newly active window */
+                nwindow = ui_window_get_active(ui);
+                if (nwindow != NULL)
+                        ui_window_send_focus(nwindow, 0);
+        }
+
+        if (ui->console != NULL &&
+            window->placement == ui_wnd_place_full_screen) {
+                (void) console_set_caption(ui->console, "");
+        }
+
+        free(window);
 }
 
@@ -379 +619 @@
  * @param window Window
  * @param control Control
- * @return EOK on success, ENOMEM if out of memory
  */
 void ui_window_add(ui_window_t *window, ui_control_t *control)
@@ -401 +640 @@
         window->control = NULL;
         control->elemp = NULL;
+}
+
+/** Get first (lowermost) window (only valid in fullscreen mode).
+ *
+ * @param ui User interface
+ * @return First window
+ */
+ui_window_t *ui_window_first(ui_t *ui)
+{
+        link_t *link;
+
+        link = list_first(&ui->windows);
+        if (link == NULL)
+                return NULL;
+
+        return list_get_instance(link, ui_window_t, lwindows);
+}
+
+/** Get next window (only valid in fullscreen mode).
+ *
+ * @param cur Current window
+ * @return First window
+ */
+ui_window_t *ui_window_next(ui_window_t *cur)
+{
+        link_t *link;
+
+        link = list_next(&cur->lwindows, &cur->ui->windows);
+        if (link == NULL)
+                return NULL;
+
+        return list_get_instance(link, ui_window_t, lwindows);
 }
 
@@ -419 +690 @@
 }
 
-/** Resize/move window.
- *
- * Resize window to the dimensions of @a rect. If @a rect.p0 is not 0,0,
- * the top-left corner of the window will move on the screen accordingly.
+/** Resize or (un)maximize window.
  *
  * @param window Window
  * @param rect Rectangle
+ * @param scop Size change operation
  *
  * @return EOK on success or an error code
  */
-errno_t ui_window_resize(ui_window_t *window, gfx_rect_t *rect)
+errno_t ui_window_size_change(ui_window_t *window, gfx_rect_t *rect,
+    ui_wnd_sc_op_t scop)
 {
         gfx_coord2_t offs;
@@ -440 +710 @@
         gfx_bitmap_alloc_t app_alloc;
         gfx_bitmap_alloc_t win_alloc;
+        gfx_coord2_t dpos;
         errno_t rc;
 
@@ -495 +766 @@
         }
 
-        /* dwindow can be NULL in case of unit tests */
+        /* dwindow can be NULL in case of unit tests or fullscreen mode */
         if (window->dwindow != NULL) {
-                rc = display_window_resize(window->dwindow, &offs, &nrect);
-                if (rc != EOK)
-                        goto error;
+                switch (scop) {
+                case ui_wsc_resize:
+                        rc = display_window_resize(window->dwindow, &offs,
+                            &nrect);
+                        if (rc != EOK)
+                                goto error;
+                        break;
+                case ui_wsc_maximize:
+                        rc = display_window_maximize(window->dwindow);
+                        if (rc != EOK)
+                                goto error;
+                        break;
+                case ui_wsc_unmaximize:
+                        rc = display_window_unmaximize(window->dwindow);
+                        if (rc != EOK)
+                                goto error;
+                        break;
+                }
+        } else {
+                /* fullscreen mode or unit tests */
+                switch (scop) {
+                case ui_wsc_resize:
+                        break;
+                case ui_wsc_maximize:
+                        window->normal_dpos = window->dpos;
+                        dpos.x = 0;
+                        dpos.y = 0;
+                        ui_window_set_dpos(window, &dpos);
+                        break;
+                case ui_wsc_unmaximize:
+                        ui_window_set_dpos(window, &window->normal_dpos);
+                        break;
+                }
         }
 
@@ -507 +808 @@
                 /* Window is resized, now we can map the window bitmap again */
                 gfx_bitmap_params_init(&win_params);
-                win_params.flags |= bmpf_direct_output;
+                if (window->ui->display != NULL)
+                        win_params.flags |= bmpf_direct_output;
                 win_params.rect = nrect;
 
@@ -519 +821 @@
                         goto error;
 #endif
-
                 mem_gc_retarget(window->mgc, &win_params.rect, &win_alloc);
 
@@ -526 +827 @@
         }
 
+        window->rect = nrect;
         ui_wdecor_set_rect(window->wdecor, &nrect);
         ui_wdecor_paint(window->wdecor);
@@ -536 +838 @@
                 gfx_bitmap_destroy(window->app_bmp);
                 window->app_bmp = app_bmp;
+        }
+
+        switch (scop) {
+        case ui_wsc_resize:
+                break;
+        case ui_wsc_maximize:
+                window->flags |= uiwf_maximized;
+                break;
+        case ui_wsc_unmaximize:
+                window->flags &= ~uiwf_maximized;
+                break;
         }
 
@@ -547 +860 @@
 }
 
+/** Resize/move window.
+ *
+ * Resize window to the dimensions of @a rect. If @a rect.p0 is not 0,0,
+ * the top-left corner of the window will move on the screen accordingly.
+ *
+ * @param window Window
+ * @param rect Rectangle
+ *
+ * @return EOK on success or an error code
+ */
+errno_t ui_window_resize(ui_window_t *window, gfx_rect_t *rect)
+{
+        errno_t rc;
+
+        rc = ui_window_size_change(window, rect, ui_wsc_resize);
+        if (rc != EOK)
+                return rc;
+
+        /* Need to repaint UI if windows are emulated */
+        if (ui_is_fullscreen(window->ui))
+                (void)ui_paint(window->ui);
+
+        return EOK;
+}
+
 /** Set window callbacks.
  *
@@ -557 +895 @@
         window->cb = cb;
         window->arg = arg;
+}
+
+/** Change window caption.
+ *
+ * @param window Window
+ * @param caption New caption
+ *
+ * @return EOK on success or an error code
+ */
+errno_t ui_window_set_caption(ui_window_t *window, const char *caption)
+{
+        errno_t rc;
+
+        /* Set console caption if fullscreen window on console */
+        if (window->ui->console != NULL && window->placement ==
+            ui_wnd_place_full_screen) {
+                rc = console_set_caption(window->ui->console, caption);
+                if (rc != EOK)
+                        return rc;
+        }
+
+        /* Set display window caption if running on display service */
+        if (window->dwindow != NULL) {
+                rc = display_window_set_caption(window->dwindow, caption);
+                if (rc != EOK)
+                        return rc;
+        }
+
+        return ui_wdecor_set_caption(window->wdecor, caption);
+}
+
+/** Get window's containing UI.
+ *
+ * @param window Window
+ * @return Containing UI
+ */
+ui_t *ui_window_get_ui(ui_window_t *window)
+{
+        return window->ui;
 }
 
@@ -594 +971 @@
                         return rc;
         } else {
-                pos->x = 0;
-                pos->y = 0;
+                *pos = window->dpos;
         }
 
@@ -695 +1071 @@
 {
         ui_window_t *window = (ui_window_t *) arg;
-
+        ui_t *ui = window->ui;
+
+        fibril_mutex_lock(&ui->lock);
         ui_window_send_close(window);
+        fibril_mutex_unlock(&ui->lock);
 }
 
 /** Handle window focus event. */
-static void dwnd_focus_event(void *arg)
-{
-        ui_window_t *window = (ui_window_t *) arg;
+static void dwnd_focus_event(void *arg, unsigned nfocus)
+{
+        ui_window_t *window = (ui_window_t *) arg;
+        ui_t *ui = window->ui;
+
+        fibril_mutex_lock(&ui->lock);
+        (void)nfocus;
 
         if (window->wdecor != NULL) {
@@ -709 +1092 @@
         }
 
-        ui_window_send_focus(window);
+        ui_window_send_focus(window, nfocus);
+        fibril_mutex_unlock(&ui->lock);
 }
 
@@ -716 +1100 @@
 {
         ui_window_t *window = (ui_window_t *) arg;
-
-        (void) window;
+        ui_t *ui = window->ui;
+
+        fibril_mutex_lock(&ui->lock);
         ui_window_send_kbd(window, kbd_event);
+        fibril_mutex_unlock(&ui->lock);
 }
 
@@ -725 +1111 @@
 {
         ui_window_t *window = (ui_window_t *) arg;
+        ui_t *ui = window->ui;
+        ui_evclaim_t claim;
 
         /* Make sure we don't process events until fully initialized */
@@ -730 +1118 @@
                 return;
 
-        ui_wdecor_pos_event(window->wdecor, event);
+        fibril_mutex_lock(&ui->lock);
+
+        claim = ui_wdecor_pos_event(window->wdecor, event);
+        if (claim == ui_claimed) {
+                fibril_mutex_unlock(&ui->lock);
+                return;
+        }
+
         ui_window_send_pos(window, event);
+        fibril_mutex_unlock(&ui->lock);
 }
 
@@ -738 +1134 @@
 {
         ui_window_t *window = (ui_window_t *) arg;
+        ui_t *ui = window->ui;
 
         /* Make sure we don't process events until fully initialized */
@@ -746 +1143 @@
                 return;
 
+        fibril_mutex_lock(&ui->lock);
         (void) ui_window_resize(window, rect);
-        (void) ui_window_paint(window);
+        ui_window_send_resize(window);
+        fibril_mutex_unlock(&ui->lock);
 }
 
 /** Handle window unfocus event. */
-static void dwnd_unfocus_event(void *arg)
-{
-        ui_window_t *window = (ui_window_t *) arg;
-
-        if (window->wdecor != NULL) {
+static void dwnd_unfocus_event(void *arg, unsigned nfocus)
+{
+        ui_window_t *window = (ui_window_t *) arg;
+        ui_t *ui = window->ui;
+
+        fibril_mutex_lock(&ui->lock);
+
+        if (window->wdecor != NULL && nfocus == 0) {
                 ui_wdecor_set_active(window->wdecor, false);
                 ui_wdecor_paint(window->wdecor);
         }
 
-        ui_window_send_unfocus(window);
+        ui_window_send_unfocus(window, nfocus);
+        fibril_mutex_unlock(&ui->lock);
+}
+
+/** Window decoration requested opening of system menu.
+ *
+ * @param wdecor Window decoration
+ * @param arg Argument (window)
+ * @param idev_id Input device ID
+ */
+static void wd_sysmenu_open(ui_wdecor_t *wdecor, void *arg, sysarg_t idev_id)
+{
+        ui_window_t *window = (ui_window_t *) arg;
+
+        ui_window_send_sysmenu(window, idev_id);
+}
+
+/** Window decoration requested moving left from system menu handle.
+ *
+ * @param wdecor Window decoration
+ * @param arg Argument (window)
+ * @param idev_id Input device ID
+ */
+static void wd_sysmenu_left(ui_wdecor_t *wdecor, void *arg, sysarg_t idev_id)
+{
+        ui_window_t *window = (ui_window_t *) arg;
+
+        if (window->mbar != NULL) {
+                ui_wdecor_sysmenu_hdl_set_active(window->wdecor, false);
+                ui_menu_close(window->sysmenu);
+                ui_menu_bar_select_last(window->mbar, false, idev_id);
+        }
+}
+
+/** Window decoration requested moving right from system menu handle.
+ *
+ * @param wdecor Window decoration
+ * @param arg Argument (window)
+ * @param idev_id Input device ID
+ */
+static void wd_sysmenu_right(ui_wdecor_t *wdecor, void *arg, sysarg_t idev_id)
+{
+        ui_window_t *window = (ui_window_t *) arg;
+
+        if (window->mbar != NULL) {
+                ui_wdecor_sysmenu_hdl_set_active(window->wdecor, false);
+                ui_menu_close(window->sysmenu);
+                ui_menu_bar_select_first(window->mbar, false, idev_id);
+        }
+}
+
+/** Window decoration detected accelerator press from system menu handle.
+ *
+ * @param wdecor Window decoration
+ * @param arg Argument (window)
+ * @param c Accelerator key
+ * @param idev_id Input device ID
+ */
+static void wd_sysmenu_accel(ui_wdecor_t *wdecor, void *arg, char32_t c,
+    sysarg_t idev_id)
+{
+        ui_window_t *window = (ui_window_t *) arg;
+
+        if (window->mbar != NULL) {
+                ui_wdecor_sysmenu_hdl_set_active(window->wdecor, false);
+                ui_menu_close(window->sysmenu);
+                ui_menu_bar_press_accel(window->mbar, c, idev_id);
+        }
+}
+
+/** Window decoration requested window minimization.
+ *
+ * @param wdecor Window decoration
+ * @param arg Argument (window)
+ */
+static void wd_minimize(ui_wdecor_t *wdecor, void *arg)
+{
+        ui_window_t *window = (ui_window_t *) arg;
+
+        ui_window_send_minimize(window);
+}
+
+/** Window decoration requested window maximization.
+ *
+ * @param wdecor Window decoration
+ * @param arg Argument (window)
+ */
+static void wd_maximize(ui_wdecor_t *wdecor, void *arg)
+{
+        ui_window_t *window = (ui_window_t *) arg;
+
+        ui_window_send_maximize(window);
+}
+
+/** Window decoration requested window unmaximization.
+ *
+ * @param wdecor Window decoration
+ * @param arg Argument (window)
+ */
+static void wd_unmaximize(ui_wdecor_t *wdecor, void *arg)
+{
+        ui_window_t *window = (ui_window_t *) arg;
+
+        ui_window_send_unmaximize(window);
 }
 
@@ -780 +1285 @@
  * @param arg Argument (window)
  * @param pos Position where the title bar was pressed
- */
-static void wd_move(ui_wdecor_t *wdecor, void *arg, gfx_coord2_t *pos)
+ * @param pos_id Positioning device ID
+ */
+static void wd_move(ui_wdecor_t *wdecor, void *arg, gfx_coord2_t *pos,
+    sysarg_t pos_id)
 {
         ui_window_t *window = (ui_window_t *) arg;
 
         if (window->dwindow != NULL)
-                (void) display_window_move_req(window->dwindow, pos);
+                (void) display_window_move_req(window->dwindow, pos, pos_id);
 }
 
@@ -795 +1302 @@
  * @param rsztype Resize type
  * @param pos Position where the button was pressed
+ * @param pos_id Positioning device ID
  */
 static void wd_resize(ui_wdecor_t *wdecor, void *arg,
-    ui_wdecor_rsztype_t rsztype, gfx_coord2_t *pos)
-{
-        ui_window_t *window = (ui_window_t *) arg;
-
-        if (window->dwindow != NULL)
-                (void) display_window_resize_req(window->dwindow, rsztype, pos);
+    ui_wdecor_rsztype_t rsztype, gfx_coord2_t *pos, sysarg_t pos_id)
+{
+        ui_window_t *window = (ui_window_t *) arg;
+
+        if (window->dwindow != NULL) {
+                (void) display_window_resize_req(window->dwindow,
+                    (display_wnd_rsztype_t) rsztype, // Same constants in the enums
+                    pos, pos_id);
+        }
 }
 
@@ -863 +1374 @@
 }
 
+/** Send window sysmenu event.
+ *
+ * @param window Window
+ * @parma idev_id Input device ID
+ */
+void ui_window_send_sysmenu(ui_window_t *window, sysarg_t idev_id)
+{
+        if (window->cb != NULL && window->cb->sysmenu != NULL)
+                window->cb->sysmenu(window, window->arg, idev_id);
+        else
+                ui_window_def_sysmenu(window, idev_id);
+}
+
+/** Send window minimize event.
+ *
+ * @param window Window
+ */
+void ui_window_send_minimize(ui_window_t *window)
+{
+        if (window->cb != NULL && window->cb->minimize != NULL)
+                window->cb->minimize(window, window->arg);
+        else
+                ui_window_def_minimize(window);
+}
+
+/** Send window maximize event.
+ *
+ * @param window Window
+ */
+void ui_window_send_maximize(ui_window_t *window)
+{
+        if (window->cb != NULL && window->cb->maximize != NULL)
+                window->cb->maximize(window, window->arg);
+        else
+                ui_window_def_maximize(window);
+}
+
+/** Send window unmaximize event.
+ *
+ * @param window Window
+ */
+void ui_window_send_unmaximize(ui_window_t *window)
+{
+        if (window->cb != NULL && window->cb->unmaximize != NULL)
+                window->cb->unmaximize(window, window->arg);
+        else
+                ui_window_def_unmaximize(window);
+}
+
 /** Send window close event.
  *
@@ -876 +1436 @@
  *
  * @param window Window
- */
-void ui_window_send_focus(ui_window_t *window)
+ * @param nfocus New number of foci
+ */
+void ui_window_send_focus(ui_window_t *window, unsigned nfocus)
 {
         if (window->cb != NULL && window->cb->focus != NULL)
-                window->cb->focus(window, window->arg);
+                window->cb->focus(window, window->arg, nfocus);
 }
 
@@ -892 +1453 @@
                 window->cb->kbd(window, window->arg, kbd);
         else
-                return ui_window_def_kbd(window, kbd);
+                ui_window_def_kbd(window, kbd);
 }
 
@@ -922 +1483 @@
  *
  * @param window Window
- */
-void ui_window_send_unfocus(ui_window_t *window)
+ * @param nfocus Number of remaining foci
+ */
+void ui_window_send_unfocus(ui_window_t *window, unsigned nfocus)
 {
         if (window->cb != NULL && window->cb->unfocus != NULL)
-                window->cb->unfocus(window, window->arg);
+                window->cb->unfocus(window, window->arg, nfocus);
         else
-                return ui_window_def_unfocus(window);
+                return ui_window_def_unfocus(window, nfocus);
+}
+
+/** Send window resize event.
+ *
+ * @param window Window
+ */
+void ui_window_send_resize(ui_window_t *window)
+{
+        if (window->cb != NULL && window->cb->resize != NULL)
+                window->cb->resize(window, window->arg);
+        else
+                return ui_window_def_resize(window);
+}
+
+/** Default window sysmenu routine.
+ *
+ * @param window Window
+ * @param idev_id Input device ID
+ * @return EOK on success or an error code
+ */
+errno_t ui_window_def_sysmenu(ui_window_t *window, sysarg_t idev_id)
+{
+        errno_t rc;
+        ui_wdecor_geom_t geom;
+
+        if (ui_menu_is_open(window->sysmenu)) {
+                ui_menu_close(window->sysmenu);
+        } else {
+                ui_wdecor_get_geom(window->wdecor, &geom);
+
+                rc = ui_menu_open(window->sysmenu, &geom.title_bar_rect,
+                    idev_id);
+                if (rc != EOK)
+                        goto error;
+        }
+
+        return EOK;
+error:
+        return rc;
+}
+
+/** Default window minimize routine.
+ *
+ * @param window Window
+ * @return EOK on success or an error code
+ */
+errno_t ui_window_def_minimize(ui_window_t *window)
+{
+        errno_t rc;
+
+        if (window->dwindow != NULL) {
+                rc = display_window_minimize(window->dwindow);
+                if (rc != EOK)
+                        goto error;
+        }
+
+        return EOK;
+error:
+        return rc;
+}
+
+/** Default window maximize routine.
+ *
+ * @param window Window
+ * @return EOK on success or an error code
+ */
+errno_t ui_window_def_maximize(ui_window_t *window)
+{
+        errno_t rc;
+        gfx_rect_t old_rect;
+        gfx_rect_t rect;
+
+        old_rect = window->rect;
+
+        if (window->dwindow != NULL) {
+                rc = display_window_get_max_rect(window->dwindow, &rect);
+                if (rc != EOK)
+                        return rc;
+        } else {
+                rect = window->ui->rect;
+        }
+
+        ui_wdecor_set_maximized(window->wdecor, true);
+        ui_menu_entry_set_disabled(window->sysmenu_restore, false);
+        ui_menu_entry_set_disabled(window->sysmenu_maximize, true);
+
+        rc = ui_window_size_change(window, &rect, ui_wsc_maximize);
+        if (rc != EOK) {
+                ui_wdecor_set_maximized(window->wdecor, false);
+                return rc;
+        }
+
+        window->normal_rect = old_rect;
+        ui_window_send_resize(window);
+
+        /* Need to repaint UI if windows are emulated */
+        if (ui_is_fullscreen(window->ui))
+                (void)ui_paint(window->ui);
+
+        return EOK;
+}
+
+/** Default window unmaximize routine.
+ *
+ * @param window Window
+ * @return EOK on success or an error code
+ */
+errno_t ui_window_def_unmaximize(ui_window_t *window)
+{
+        errno_t rc;
+
+        ui_wdecor_set_maximized(window->wdecor, false);
+        ui_menu_entry_set_disabled(window->sysmenu_restore, true);
+        ui_menu_entry_set_disabled(window->sysmenu_maximize, false);
+
+        rc = ui_window_size_change(window, &window->normal_rect,
+            ui_wsc_unmaximize);
+        if (rc != EOK) {
+                ui_wdecor_set_maximized(window->wdecor, true);
+                printf("ui_window_size_change->error\n");
+                return rc;
+        }
+
+        ui_window_send_resize(window);
+
+        /* Need to repaint UI if windows are emulated */
+        if (ui_is_fullscreen(window->ui))
+                (void)ui_paint(window->ui);
+
+        return EOK;
 }
 
@@ -934 +1626 @@
  *
  * @param window Window
- */
-void ui_window_def_kbd(ui_window_t *window, kbd_event_t *kbd)
-{
+ * @return ui_claimed iff event was claimed
+ */
+ui_evclaim_t ui_window_def_kbd(ui_window_t *window, kbd_event_t *kbd)
+{
+        ui_evclaim_t claim;
+
         if (window->control != NULL)
-                ui_control_kbd_event(window->control, kbd);
+                claim = ui_control_kbd_event(window->control, kbd);
+        else
+                claim = ui_unclaimed;
+
+        if (claim == ui_unclaimed)
+                return ui_wdecor_kbd_event(window->wdecor, kbd);
+
+        return ui_unclaimed;
 }
 
@@ -984 +1686 @@
  *
  * @param window Window
+ * @param nfocus Number of remaining foci
  * @return EOK on success or an error code
  */
-void ui_window_def_unfocus(ui_window_t *window)
+void ui_window_def_unfocus(ui_window_t *window, unsigned nfocus)
 {
         if (window->control != NULL)
-                ui_control_unfocus(window->control);
+                ui_control_unfocus(window->control, nfocus);
+}
+
+/** Default window resize routine.
+ *
+ * @param window Window
+ * @return EOK on success or an error code
+ */
+void ui_window_def_resize(ui_window_t *window)
+{
+        ui_window_paint(window);
+}
+
+/** Handle system menu left event.
+ *
+ * @param sysmenu System menu
+ * @param arg Argument (ui_window_t *)
+ * @param idev_id Input device ID
+ */
+static void wnd_sysmenu_left(ui_menu_t *sysmenu, void *arg, sysarg_t idev_id)
+{
+        ui_window_t *window = (ui_window_t *)arg;
+
+        if (window->mbar != NULL) {
+                ui_wdecor_sysmenu_hdl_set_active(window->wdecor, false);
+                ui_menu_close(sysmenu);
+                ui_menu_bar_select_last(window->mbar, true, idev_id);
+        }
+}
+
+/** Handle system menu right event.
+ *
+ * @param sysmenu System menu
+ * @param arg Argument (ui_window_t *)
+ * @param idev_id Input device ID
+ */
+static void wnd_sysmenu_right(ui_menu_t *sysmenu, void *arg, sysarg_t idev_id)
+{
+        ui_window_t *window = (ui_window_t *)arg;
+
+        if (window->mbar != NULL) {
+                ui_wdecor_sysmenu_hdl_set_active(window->wdecor, false);
+                ui_menu_close(sysmenu);
+                ui_menu_bar_select_first(window->mbar, true, idev_id);
+        }
+}
+
+/** Handle system menu close request event.
+ *
+ * @param sysmenu System menu
+ * @param arg Argument (ui_window_t *)
+ * @param idev_id Input device ID
+ */
+static void wnd_sysmenu_close_req(ui_menu_t *sysmenu, void *arg)
+{
+        ui_window_t *window = (ui_window_t *)arg;
+
+        ui_wdecor_sysmenu_hdl_set_active(window->wdecor, false);
+        ui_menu_close(sysmenu);
+}
+
+/** Handle system menu Restore entry activation.
+ *
+ * @param mentry Menu entry
+ * @param arg Argument (ui_window_t *)
+ */
+static void wnd_sysmenu_erestore(ui_menu_entry_t *mentry, void *arg)
+{
+        ui_window_t *window = (ui_window_t *)arg;
+
+        ui_window_send_unmaximize(window);
+}
+
+/** Handle system menu Minimize entry activation.
+ *
+ * @param mentry Menu entry
+ * @param arg Argument (ui_window_t *)
+ */
+static void wnd_sysmenu_eminimize(ui_menu_entry_t *mentry, void *arg)
+{
+        ui_window_t *window = (ui_window_t *)arg;
+
+        ui_window_send_minimize(window);
+}
+
+/** Handle system menu Maximize entry activation.
+ *
+ * @param mentry Menu entry
+ * @param arg Argument (ui_window_t *)
+ */
+static void wnd_sysmenu_emaximize(ui_menu_entry_t *mentry, void *arg)
+{
+        ui_window_t *window = (ui_window_t *)arg;
+
+        ui_window_send_maximize(window);
+}
+
+/** Handle system menu Close entry activation.
+ *
+ * @param mentry Menu entry
+ * @param arg Argument (ui_window_t *)
+ */
+static void wnd_sysmenu_eclose(ui_menu_entry_t *mentry, void *arg)
+{
+        ui_window_t *window = (ui_window_t *)arg;
+
+        ui_window_send_close(window);
+}
+
+/** Handle system menu press accelerator key event.
+ *
+ * @param sysmenu System menu
+ * @param arg Argument (ui_window_t *)
+ * @param idev_id Input device ID
+ */
+static void wnd_sysmenu_press_accel(ui_menu_t *sysmenu, void *arg,
+    char32_t c, sysarg_t idev_id)
+{
+        (void)sysmenu;
+        (void)arg;
+        (void)c;
+        (void)idev_id;
 }
 
@@ -1014 +1838 @@
         ui_window_t *window = (ui_window_t *) arg;
 
-        if (!gfx_rect_is_empty(&window->dirty_rect))
-                (void) gfx_bitmap_render(window->bmp, &window->dirty_rect, NULL);
+        if (!gfx_rect_is_empty(&window->dirty_rect)) {
+                (void) gfx_bitmap_render(window->bmp, &window->dirty_rect,
+                    &window->dpos);
+        }
 
         window->dirty_rect.p0.x = 0;
@@ -1031 +1857 @@
 {
         ui_window_t *window = (ui_window_t *) arg;
-
-        return gfx_cursor_get_pos(window->realgc, pos);
+        gfx_coord2_t cpos;
+        errno_t rc;
+
+        rc = gfx_cursor_get_pos(window->realgc, &cpos);
+        if (rc != EOK)
+                return rc;
+
+        pos->x = cpos.x - window->dpos.x;
+        pos->y = cpos.y - window->dpos.y;
+        return EOK;
 }
 
@@ -1043 +1877 @@
 {
         ui_window_t *window = (ui_window_t *) arg;
-
-        return gfx_cursor_set_pos(window->realgc, pos);
+        gfx_coord2_t cpos;
+
+        cpos.x = pos->x + window->dpos.x;
+        cpos.y = pos->y + window->dpos.y;
+
+        return gfx_cursor_set_pos(window->realgc, &cpos);
 }