uspace/lib/ui/src/window.c

   1 /*
   2  * Copyright (c) 2024 Jiri Svoboda
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * - Redistributions of source code must retain the above copyright
  10  *   notice, this list of conditions and the following disclaimer.
  11  * - Redistributions in binary form must reproduce the above copyright
  12  *   notice, this list of conditions and the following disclaimer in the
  13  *   documentation and/or other materials provided with the distribution.
  14  * - The name of the author may not be used to endorse or promote products
  15  *   derived from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 /** @addtogroup libui
  30  * @{
  31  */
  32 /**
  33  * @file Window
  34  */
  35
  36 #include <congfx/console.h>
  37 #include <display.h>
  38 #include <errno.h>
  39 #include <gfx/bitmap.h>
  40 #include <gfx/context.h>
  41 #include <gfx/cursor.h>
  42 #include <gfx/render.h>
  43 #include <io/kbd_event.h>
  44 #include <io/pos_event.h>
  45 #include <mem.h>
  46 #include <memgfx/memgc.h>
  47 #include <stdlib.h>
  48 #include <ui/control.h>
  49 #include <ui/menubar.h>
  50 #include <ui/menu.h>
  51 #include <ui/menuentry.h>
  52 #include <ui/resource.h>
  53 #include <ui/ui.h>
  54 #include <ui/wdecor.h>
  55 #include <ui/window.h>
  56 #include "../private/control.h"
  57 #include "../private/dummygc.h"
  58 #include "../private/resource.h"
  59 #include "../private/ui.h"
  60 #include "../private/wdecor.h"
  61 #include "../private/window.h"
  62
  63 static void dwnd_close_event(void *);
  64 static void dwnd_focus_event(void *, unsigned);
  65 static void dwnd_kbd_event(void *, kbd_event_t *);
  66 static void dwnd_pos_event(void *, pos_event_t *);
  67 static void dwnd_resize_event(void *, gfx_rect_t *);
  68 static void dwnd_unfocus_event(void *, unsigned);
  69
  70 static display_wnd_cb_t dwnd_cb = {
  71         .close_event = dwnd_close_event,
  72         .focus_event = dwnd_focus_event,
  73         .kbd_event = dwnd_kbd_event,
  74         .pos_event = dwnd_pos_event,
  75         .resize_event = dwnd_resize_event,
  76         .unfocus_event = dwnd_unfocus_event
  77 };
  78
  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 *);
  86 static void wd_close(ui_wdecor_t *, void *);
  87 static void wd_move(ui_wdecor_t *, void *, gfx_coord2_t *, sysarg_t);
  88 static void wd_resize(ui_wdecor_t *, void *, ui_wdecor_rsztype_t,
  89     gfx_coord2_t *, sysarg_t);
  90 static void wd_set_cursor(ui_wdecor_t *, void *, ui_stock_cursor_t);
  91
  92 static 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,
 100         .close = wd_close,
 101         .move = wd_move,
 102         .resize = wd_resize,
 103         .set_cursor = wd_set_cursor
 104 };
 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 *);
 122
 123 static void ui_window_invalidate(void *, gfx_rect_t *);
 124 static void ui_window_update(void *);
 125 static errno_t ui_window_cursor_get_pos(void *, gfx_coord2_t *);
 126 static errno_t ui_window_cursor_set_pos(void *, gfx_coord2_t *);
 127 static errno_t ui_window_cursor_set_visible(void *, bool);
 128
 129 /** Window memory GC callbacks */
 130 static mem_gc_cb_t ui_window_mem_gc_cb = {
 131         .invalidate = ui_window_invalidate,
 132         .update = ui_window_update,
 133         .cursor_get_pos = ui_window_cursor_get_pos,
 134         .cursor_set_pos = ui_window_cursor_set_pos,
 135         .cursor_set_visible = ui_window_cursor_set_visible
 136 };
 137
 138 static void ui_window_app_invalidate(void *, gfx_rect_t *);
 139 static void ui_window_app_update(void *);
 140
 141 /** Application area memory GC callbacks */
 142 static mem_gc_cb_t ui_window_app_mem_gc_cb = {
 143         .invalidate = ui_window_app_invalidate,
 144         .update = ui_window_app_update
 145 };
 146
 147 static void ui_window_expose_cb(void *);
 148
 149 /** Initialize window parameters structure.
 150  *
 151  * Window parameters structure must always be initialized using this function
 152  * first. By default, the window will be decorated. To get a non-decorated
 153  * window, one needs to clear ui_wds_decorated
 154  * (e.g. params->style &= ~ui_wds_decorated).
 155  *
 156  * @param params Window parameters structure
 157  */
 158 void ui_wnd_params_init(ui_wnd_params_t *params)
 159 {
 160         memset(params, 0, sizeof(ui_wnd_params_t));
 161
 162         /* Make window decorated by default. */
 163         params->style = ui_wds_decorated;
 164 }
 165
 166 /** Compute where window should be placed on the screen.
 167  *
 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 params Window parameters
 174  * @param pos Place to store position of top-left corner
 175  */
 176 static void ui_window_place(ui_window_t *window, gfx_rect_t *drect,
 177     ui_wnd_params_t *params, gfx_coord2_t *pos)
 178 {
 179         gfx_coord2_t dims;
 180         gfx_coord2_t below_pos;
 181         gfx_rect_t below_rect;
 182
 183         assert(params->placement != ui_wnd_place_default ||
 184             ui_is_fullscreen(window->ui));
 185
 186         pos->x = 0;
 187         pos->y = 0;
 188
 189         switch (params->placement) {
 190         case ui_wnd_place_default:
 191         case ui_wnd_place_center:
 192                 assert(params->placement != ui_wnd_place_default ||
 193                     ui_is_fullscreen(window->ui));
 194                 /* Center window */
 195                 gfx_rect_dims(&params->rect, &dims);
 196                 pos->x = (drect->p0.x + drect->p1.x) / 2 - dims.x / 2;
 197                 pos->y = (drect->p0.y + drect->p1.y) / 2 - dims.y / 2;
 198                 break;
 199         case ui_wnd_place_top_left:
 200         case ui_wnd_place_full_screen:
 201                 pos->x = drect->p0.x - params->rect.p0.x;
 202                 pos->y = drect->p0.y - params->rect.p0.y;
 203                 break;
 204         case ui_wnd_place_top_right:
 205                 pos->x = drect->p1.x - params->rect.p1.x;
 206                 pos->y = drect->p0.y - params->rect.p0.y;
 207                 break;
 208         case ui_wnd_place_bottom_left:
 209                 pos->x = drect->p0.x - params->rect.p0.x;
 210                 pos->y = drect->p1.y - params->rect.p1.y;
 211                 break;
 212         case ui_wnd_place_bottom_right:
 213                 pos->x = drect->p1.x - params->rect.p1.x;
 214                 pos->y = drect->p1.y - params->rect.p1.y;
 215                 break;
 216         case ui_wnd_place_popup:
 217                 /* Compute rectangle when placed below */
 218                 below_pos.x = params->prect.p0.x;
 219                 below_pos.y = params->prect.p1.y;
 220                 gfx_rect_translate(&below_pos, &params->rect, &below_rect);
 221
 222                 /* Does below_rect fit within the display? */
 223                 if (gfx_rect_is_inside(&below_rect, drect)) {
 224                         /* Place popup window below parent rectangle */
 225                         pos->x = params->prect.p0.x - params->rect.p0.x;
 226                         pos->y = params->prect.p1.y - params->rect.p0.y;
 227                 } else {
 228                         /* Place popup window above parent rectangle */
 229                         pos->x = params->prect.p0.x;
 230                         pos->y = params->prect.p0.y -
 231                             (params->rect.p1.y - params->rect.p0.y);
 232                 }
 233                 break;
 234         }
 235 }
 236
 237 /** Create window's system menu.
 238  *
 239  * @param window Window
 240  * @return EOK on success or an error code
 241  */
 242 static errno_t ui_window_sysmenu_create(ui_window_t *window)
 243 {
 244         errno_t rc;
 245         ui_menu_entry_t *mrestore;
 246         ui_menu_entry_t *mmin;
 247         ui_menu_entry_t *mmax;
 248         ui_menu_entry_t *msep;
 249         ui_menu_entry_t *mclose;
 250
 251         rc = ui_menu_create(window, &window->sysmenu);
 252         if (rc != EOK)
 253                 goto error;
 254
 255         ui_menu_set_cb(window->sysmenu, &wnd_sysmenu_cb, (void *)window);
 256
 257         rc = ui_menu_entry_create(window->sysmenu, "~R~estore",
 258             "", &mrestore);
 259         if (rc != EOK)
 260                 goto error;
 261
 262         if (!window->wdecor->maximized)
 263                 ui_menu_entry_set_disabled(mrestore, true);
 264
 265         ui_menu_entry_set_cb(mrestore, wnd_sysmenu_erestore, (void *)window);
 266
 267         rc = ui_menu_entry_create(window->sysmenu, "Mi~n~imize",
 268             "", &mmin);
 269         if (rc != EOK)
 270                 goto error;
 271
 272         if ((window->wdecor->style & ui_wds_minimize_btn) == 0)
 273                 ui_menu_entry_set_disabled(mmin, true);
 274
 275         ui_menu_entry_set_cb(mmin, wnd_sysmenu_eminimize, (void *)window);
 276
 277         rc = ui_menu_entry_create(window->sysmenu, "Ma~x~imize",
 278             "", &mmax);
 279         if (rc != EOK)
 280                 goto error;
 281
 282         if ((window->wdecor->style & ui_wds_maximize_btn) == 0 ||
 283             window->wdecor->maximized)
 284                 ui_menu_entry_set_disabled(mmax, true);
 285
 286         ui_menu_entry_set_cb(mmax, wnd_sysmenu_emaximize, (void *)window);
 287
 288         rc = ui_menu_entry_sep_create(window->sysmenu, &msep);
 289         if (rc != EOK)
 290                 goto error;
 291
 292         rc = ui_menu_entry_create(window->sysmenu, "~C~lose", "Alt-F4",
 293             &mclose);
 294         if (rc != EOK)
 295                 goto error;
 296
 297         if ((window->wdecor->style & ui_wds_close_btn) == 0)
 298                 ui_menu_entry_set_disabled(mclose, true);
 299
 300         ui_menu_entry_set_cb(mclose, wnd_sysmenu_eclose, (void *)window);
 301
 302         window->sysmenu_restore = mrestore;
 303         window->sysmenu_minimize = mmin;
 304         window->sysmenu_maximize = mmax;
 305
 306         return EOK;
 307 error:
 308         return rc;
 309 }
 310
 311 /** Create new window.
 312  *
 313  * @param ui User interface
 314  * @param params Window parameters
 315  * @param rwindow Place to store pointer to new window
 316  * @return EOK on success or an error code
 317  */
 318 errno_t ui_window_create(ui_t *ui, ui_wnd_params_t *params,
 319     ui_window_t **rwindow)
 320 {
 321         ui_window_t *window;
 322         ui_window_t *pwindow = NULL;
 323         display_info_t info;
 324         gfx_coord2_t scr_dims;
 325         display_wnd_params_t dparams;
 326         gfx_context_t *gc = NULL;
 327         ui_resource_t *res = NULL;
 328         ui_wdecor_t *wdecor = NULL;
 329         dummy_gc_t *dgc = NULL;
 330         gfx_bitmap_params_t bparams;
 331         gfx_bitmap_alloc_t alloc;
 332         gfx_bitmap_t *bmp = NULL;
 333         gfx_coord2_t off;
 334         mem_gc_t *memgc = NULL;
 335         xlate_gc_t *xgc = NULL;
 336         errno_t rc;
 337
 338         window = calloc(1, sizeof(ui_window_t));
 339         if (window == NULL)
 340                 return ENOMEM;
 341
 342         window->ui = ui;
 343
 344         display_wnd_params_init(&dparams);
 345         dparams.rect = params->rect;
 346         dparams.caption = params->caption;
 347         dparams.min_size = params->min_size;
 348
 349         /*
 350          * If idev_id is not specified, use the UI default (probably
 351          * obtained from display specification. This creates the
 352          * main window in the seat specified on the command line.
 353          */
 354         if (params->idev_id != 0)
 355                 dparams.idev_id = params->idev_id;
 356         else
 357                 dparams.idev_id = ui->idev_id;
 358
 359         if ((params->flags & ui_wndf_popup) != 0)
 360                 dparams.flags |= wndf_popup;
 361         if ((params->flags & ui_wndf_nofocus) != 0)
 362                 dparams.flags |= wndf_nofocus;
 363         if ((params->flags & ui_wndf_topmost) != 0)
 364                 dparams.flags |= wndf_topmost;
 365         if ((params->flags & ui_wndf_system) != 0)
 366                 dparams.flags |= wndf_system;
 367         if ((params->flags & ui_wndf_avoid) != 0)
 368                 dparams.flags |= wndf_avoid;
 369
 370         if (ui->display != NULL) {
 371                 if (params->placement != ui_wnd_place_default) {
 372                         rc = display_get_info(ui->display, &info);
 373                         if (rc != EOK)
 374                                 goto error;
 375                 }
 376
 377                 if (params->placement == ui_wnd_place_full_screen) {
 378                         /* Make window the size of the screen */
 379                         gfx_rect_dims(&info.rect, &scr_dims);
 380                         gfx_coord2_add(&dparams.rect.p0, &scr_dims,
 381                             &dparams.rect.p1);
 382                 }
 383
 384                 if (params->placement != ui_wnd_place_default) {
 385                         /* Set initial display window position */
 386                         ui_window_place(window, &info.rect, params,
 387                             &dparams.pos);
 388
 389                         dparams.flags |= wndf_setpos;
 390                 }
 391
 392                 rc = display_window_create(ui->display, &dparams, &dwnd_cb,
 393                     (void *) window, &window->dwindow);
 394                 if (rc != EOK)
 395                         goto error;
 396
 397                 rc = display_window_get_gc(window->dwindow, &gc);
 398                 if (rc != EOK)
 399                         goto error;
 400         } else if (ui->console != NULL) {
 401                 gc = console_gc_get_ctx(ui->cgc);
 402
 403                 if (params->placement == ui_wnd_place_full_screen) {
 404                         /* Make window the size of the screen */
 405                         gfx_rect_dims(&ui->rect, &scr_dims);
 406                         gfx_coord2_add(&dparams.rect.p0, &scr_dims,
 407                             &dparams.rect.p1);
 408                         (void) console_set_caption(ui->console,
 409                             params->caption);
 410                 }
 411         } else {
 412                 /* Needed for unit tests */
 413                 rc = dummygc_create(&dgc);
 414                 if (rc != EOK)
 415                         goto error;
 416
 417                 gc = dummygc_get_ctx(dgc);
 418         }
 419
 420 #ifdef CONFIG_UI_CS_RENDER
 421         /* Create window bitmap */
 422         gfx_bitmap_params_init(&bparams);
 423 #ifndef CONFIG_WIN_DOUBLE_BUF
 424         /* Console does not support direct output */
 425         if (ui->display != NULL)
 426                 bparams.flags |= bmpf_direct_output;
 427 #endif
 428
 429         /* Move rectangle so that top-left corner is 0,0 */
 430         gfx_rect_rtranslate(&dparams.rect.p0, &dparams.rect, &bparams.rect);
 431
 432         rc = gfx_bitmap_create(gc, &bparams, NULL, &bmp);
 433         if (rc != EOK)
 434                 goto error;
 435
 436         /* Create memory GC */
 437         rc = gfx_bitmap_get_alloc(bmp, &alloc);
 438         if (rc != EOK) {
 439                 gfx_bitmap_destroy(window->app_bmp);
 440                 return rc;
 441         }
 442
 443         rc = mem_gc_create(&bparams.rect, &alloc, &ui_window_mem_gc_cb,
 444             (void *) window, &memgc);
 445         if (rc != EOK) {
 446                 gfx_bitmap_destroy(window->app_bmp);
 447                 return rc;
 448         }
 449
 450         window->bmp = bmp;
 451         window->mgc = memgc;
 452         window->gc = mem_gc_get_ctx(memgc);
 453         window->realgc = gc;
 454         (void) off;
 455 #else
 456         /* Server-side rendering */
 457
 458         /* Full-screen mode? */
 459         if (ui->display == NULL) {
 460                 /* Create translating GC to translate window contents */
 461                 off.x = 0;
 462                 off.y = 0;
 463                 rc = xlate_gc_create(&off, gc, &xgc);
 464                 if (rc != EOK)
 465                         goto error;
 466
 467                 window->xgc = xgc;
 468                 window->gc = xlate_gc_get_ctx(xgc);
 469                 window->realgc = gc;
 470         } else {
 471                 window->gc = gc;
 472         }
 473
 474         (void) ui_window_mem_gc_cb;
 475         (void) alloc;
 476         (void) bparams;
 477 #endif
 478         if (ui->display == NULL) {
 479                 ui_window_place(window, &ui->rect, params, &window->dpos);
 480
 481                 if (window->xgc != NULL)
 482                         xlate_gc_set_off(window->xgc, &window->dpos);
 483         }
 484
 485         rc = ui_resource_create(window->gc, ui_is_textmode(ui), &res);
 486         if (rc != EOK)
 487                 goto error;
 488
 489         rc = ui_wdecor_create(res, params->caption, params->style, &wdecor);
 490         if (rc != EOK)
 491                 goto error;
 492
 493         ui_wdecor_set_rect(wdecor, &dparams.rect);
 494         ui_wdecor_set_cb(wdecor, &wdecor_cb, (void *) window);
 495         ui_wdecor_paint(wdecor);
 496
 497         ui_resource_set_expose_cb(res, ui_window_expose_cb, (void *) window);
 498
 499         window->rect = dparams.rect;
 500         window->res = res;
 501         window->wdecor = wdecor;
 502         window->cursor = ui_curs_arrow;
 503         window->placement = params->placement;
 504
 505         rc = ui_window_sysmenu_create(window);
 506         if (rc != EOK)
 507                 goto error;
 508
 509         *rwindow = window;
 510
 511         if (ui_is_fullscreen(ui))
 512                 pwindow = ui_window_get_active(ui);
 513
 514         list_append(&window->lwindows, &ui->windows);
 515
 516         if (ui_is_fullscreen(ui)) {
 517                 /* Send unfocus event to previously active window */
 518                 if (pwindow != NULL)
 519                         ui_window_send_unfocus(pwindow, 0);
 520         }
 521
 522         return EOK;
 523 error:
 524         if (wdecor != NULL)
 525                 ui_wdecor_destroy(wdecor);
 526         if (res != NULL)
 527                 ui_resource_destroy(res);
 528         if (memgc != NULL)
 529                 mem_gc_delete(memgc);
 530         if (xgc != NULL)
 531                 xlate_gc_delete(xgc);
 532         if (bmp != NULL)
 533                 gfx_bitmap_destroy(bmp);
 534         if (dgc != NULL)
 535                 dummygc_destroy(dgc);
 536         free(window);
 537         return rc;
 538 }
 539
 540 /** Destroy window.
 541  *
 542  * @param window Window or @c NULL
 543  */
 544 void ui_window_destroy(ui_window_t *window)
 545 {
 546         ui_t *ui;
 547         ui_window_t *nwindow;
 548
 549         if (window == NULL)
 550                 return;
 551
 552         ui = window->ui;
 553
 554         list_remove(&window->lwindows);
 555         ui_control_destroy(window->control);
 556         ui_menu_destroy(window->sysmenu);
 557         ui_wdecor_destroy(window->wdecor);
 558         ui_resource_destroy(window->res);
 559         if (window->app_mgc != NULL)
 560                 mem_gc_delete(window->app_mgc);
 561         if (window->app_bmp != NULL)
 562                 gfx_bitmap_destroy(window->app_bmp);
 563         if (window->mgc != NULL) {
 564                 mem_gc_delete(window->mgc);
 565                 window->gc = NULL;
 566         }
 567         if (window->bmp != NULL)
 568                 gfx_bitmap_destroy(window->bmp);
 569         if (window->dwindow != NULL)
 570                 display_window_destroy(window->dwindow);
 571
 572         /* Need to repaint if windows are emulated */
 573         if (ui_is_fullscreen(ui)) {
 574                 ui_paint(ui);
 575                 /* Send focus event to newly active window */
 576                 nwindow = ui_window_get_active(ui);
 577                 if (nwindow != NULL)
 578                         ui_window_send_focus(nwindow, 0);
 579         }
 580
 581         if (ui->console != NULL &&
 582             window->placement == ui_wnd_place_full_screen) {
 583                 (void) console_set_caption(ui->console, "");
 584         }
 585
 586         free(window);
 587 }
 588
 589 /** Add control to window.
 590  *
 591  * Only one control can be added to a window. If more than one control
 592  * is added, the results are undefined.
 593  *
 594  * @param window Window
 595  * @param control Control
 596  */
 597 void ui_window_add(ui_window_t *window, ui_control_t *control)
 598 {
 599         assert(window->control == NULL);
 600
 601         window->control = control;
 602         control->elemp = (void *) window;
 603 }
 604
 605 /** Remove control from window.
 606  *
 607  * @param window Window
 608  * @param control Control
 609  */
 610 void ui_window_remove(ui_window_t *window, ui_control_t *control)
 611 {
 612         assert(window->control == control);
 613         assert((ui_window_t *) control->elemp == window);
 614
 615         window->control = NULL;
 616         control->elemp = NULL;
 617 }
 618
 619 /** Get active window (only valid in fullscreen mode).
 620  *
 621  * @param ui User interface
 622  * @return Active window
 623  */
 624 ui_window_t *ui_window_get_active(ui_t *ui)
 625 {
 626         link_t *link;
 627
 628         link = list_last(&ui->windows);
 629         if (link == NULL)
 630                 return NULL;
 631
 632         return list_get_instance(link, ui_window_t, lwindows);
 633 }
 634
 635 /** Resize or (un)maximize window.
 636  *
 637  * @param window Window
 638  * @param rect Rectangle
 639  * @param scop Size change operation
 640  *
 641  * @return EOK on success or an error code
 642  */
 643 errno_t ui_window_size_change(ui_window_t *window, gfx_rect_t *rect,
 644     ui_wnd_sc_op_t scop)
 645 {
 646         gfx_coord2_t offs;
 647         gfx_rect_t nrect;
 648         gfx_rect_t arect;
 649         gfx_bitmap_t *app_bmp = NULL;
 650         gfx_bitmap_t *win_bmp = NULL;
 651         gfx_bitmap_params_t app_params;
 652         gfx_bitmap_params_t win_params;
 653         gfx_bitmap_alloc_t app_alloc;
 654         gfx_bitmap_alloc_t win_alloc;
 655         errno_t rc;
 656
 657         /*
 658          * Move rect so that p0=0,0 - keep window's coordinate system origin
 659          * locked to top-left corner of the window.
 660          */
 661         offs = rect->p0;
 662         gfx_rect_rtranslate(&offs, rect, &nrect);
 663
 664         /* mgc != NULL iff client-side rendering */
 665         if (window->mgc != NULL) {
 666 #ifdef CONFIG_WIN_DOUBLE_BUF
 667                 /*
 668                  * Create new window bitmap in advance. If direct mapping,
 669                  * will need do it after resizing the window.
 670                  */
 671                 assert(window->bmp != NULL);
 672                 gfx_bitmap_params_init(&win_params);
 673                 win_params.rect = nrect;
 674
 675                 rc = gfx_bitmap_create(window->realgc, &win_params, NULL,
 676                     &win_bmp);
 677                 if (rc != EOK)
 678                         goto error;
 679
 680                 rc = gfx_bitmap_get_alloc(win_bmp, &win_alloc);
 681                 if (rc != EOK)
 682                         goto error;
 683 #endif
 684         }
 685
 686         /* Application area GC? */
 687         if (window->app_gc != NULL) {
 688                 /* Resize application bitmap */
 689                 assert(window->app_bmp != NULL);
 690
 691                 gfx_bitmap_params_init(&app_params);
 692
 693                 /*
 694                  * The bitmap will have the same dimensions as the
 695                  * application rectangle, but start at 0,0.
 696                  */
 697                 ui_wdecor_app_from_rect(window->wdecor->style, &nrect, &arect);
 698                 gfx_rect_rtranslate(&arect.p0, &arect, &app_params.rect);
 699
 700                 rc = gfx_bitmap_create(window->gc, &app_params, NULL,
 701                     &app_bmp);
 702                 if (rc != EOK)
 703                         goto error;
 704
 705                 rc = gfx_bitmap_get_alloc(app_bmp, &app_alloc);
 706                 if (rc != EOK)
 707                         goto error;
 708         }
 709
 710         /* dwindow can be NULL in case of unit tests or fullscreen mode */
 711         if (window->dwindow != NULL) {
 712                 switch (scop) {
 713                 case ui_wsc_resize:
 714                         rc = display_window_resize(window->dwindow, &offs,
 715                             &nrect);
 716                         if (rc != EOK)
 717                                 goto error;
 718                         break;
 719                 case ui_wsc_maximize:
 720                         rc = display_window_maximize(window->dwindow);
 721                         if (rc != EOK)
 722                                 goto error;
 723                         break;
 724                 case ui_wsc_unmaximize:
 725                         rc = display_window_unmaximize(window->dwindow);
 726                         if (rc != EOK)
 727                                 goto error;
 728                         break;
 729                 }
 730         }
 731
 732         /* Client side rendering? */
 733         if (window->mgc != NULL) {
 734 #ifndef CONFIG_WIN_DOUBLE_BUF
 735                 /* Window is resized, now we can map the window bitmap again */
 736                 gfx_bitmap_params_init(&win_params);
 737                 win_params.flags |= bmpf_direct_output;
 738                 win_params.rect = nrect;
 739
 740                 rc = gfx_bitmap_create(window->realgc, &win_params, NULL,
 741                     &win_bmp);
 742                 if (rc != EOK)
 743                         goto error;
 744
 745                 rc = gfx_bitmap_get_alloc(win_bmp, &win_alloc);
 746                 if (rc != EOK)
 747                         goto error;
 748 #endif
 749                 mem_gc_retarget(window->mgc, &win_params.rect, &win_alloc);
 750
 751                 gfx_bitmap_destroy(window->bmp);
 752                 window->bmp = win_bmp;
 753         }
 754
 755         window->rect = nrect;
 756         ui_wdecor_set_rect(window->wdecor, &nrect);
 757         ui_wdecor_paint(window->wdecor);
 758         gfx_update(window->gc);
 759
 760         /* Application area GC? */
 761         if (window->app_gc != NULL) {
 762                 mem_gc_retarget(window->app_mgc, &app_params.rect, &app_alloc);
 763
 764                 gfx_bitmap_destroy(window->app_bmp);
 765                 window->app_bmp = app_bmp;
 766         }
 767
 768         return EOK;
 769 error:
 770         if (app_bmp != NULL)
 771                 gfx_bitmap_destroy(app_bmp);
 772         if (win_bmp != NULL)
 773                 gfx_bitmap_destroy(win_bmp);
 774         return rc;
 775 }
 776
 777 /** Resize/move window.
 778  *
 779  * Resize window to the dimensions of @a rect. If @a rect.p0 is not 0,0,
 780  * the top-left corner of the window will move on the screen accordingly.
 781  *
 782  * @param window Window
 783  * @param rect Rectangle
 784  *
 785  * @return EOK on success or an error code
 786  */
 787 errno_t ui_window_resize(ui_window_t *window, gfx_rect_t *rect)
 788 {
 789         return ui_window_size_change(window, rect, ui_wsc_resize);
 790 }
 791
 792 /** Set window callbacks.
 793  *
 794  * @param window Window
 795  * @param cb Window callbacks
 796  * @param arg Callback argument
 797  */
 798 void ui_window_set_cb(ui_window_t *window, ui_window_cb_t *cb, void *arg)
 799 {
 800         window->cb = cb;
 801         window->arg = arg;
 802 }
 803
 804 /** Change window caption.
 805  *
 806  * @param window Window
 807  * @param caption New caption
 808  *
 809  * @return EOK on success or an error code
 810  */
 811 errno_t ui_window_set_caption(ui_window_t *window, const char *caption)
 812 {
 813         errno_t rc;
 814
 815         /* Set console caption if fullscreen window on console */
 816         if (window->ui->console != NULL && window->placement ==
 817             ui_wnd_place_full_screen) {
 818                 rc = console_set_caption(window->ui->console, caption);
 819                 if (rc != EOK)
 820                         return rc;
 821         }
 822
 823         /* Set display window caption if running on display service */
 824         if (window->dwindow != NULL) {
 825                 rc = display_window_set_caption(window->dwindow, caption);
 826                 if (rc != EOK)
 827                         return rc;
 828         }
 829
 830         return ui_wdecor_set_caption(window->wdecor, caption);
 831 }
 832
 833 /** Get window's containing UI.
 834  *
 835  * @param window Window
 836  * @return Containing UI
 837  */
 838 ui_t *ui_window_get_ui(ui_window_t *window)
 839 {
 840         return window->ui;
 841 }
 842
 843 /** Get UI resource from window.
 844  *
 845  * @param window Window
 846  * @return UI resource
 847  */
 848 ui_resource_t *ui_window_get_res(ui_window_t *window)
 849 {
 850         return window->res;
 851 }
 852
 853 /** Get window GC.
 854  *
 855  * @param window Window
 856  * @return GC (relative to window)
 857  */
 858 gfx_context_t *ui_window_get_gc(ui_window_t *window)
 859 {
 860         return window->gc;
 861 }
 862
 863 /** Get window position.
 864  *
 865  * @param window Window
 866  * @param pos Place to store position
 867  * @return EOK on success or an error code
 868  */
 869 errno_t ui_window_get_pos(ui_window_t *window, gfx_coord2_t *pos)
 870 {
 871         errno_t rc;
 872
 873         if (window->dwindow != NULL) {
 874                 rc = display_window_get_pos(window->dwindow, pos);
 875                 if (rc != EOK)
 876                         return rc;
 877         } else {
 878                 *pos = window->dpos;
 879         }
 880
 881         return EOK;
 882 }
 883
 884 /** Get window application area GC
 885  *
 886  * @param window Window
 887  * @param rgc Place to store GC (relative to application area)
 888  * @return EOK on success or an error code
 889  */
 890 errno_t ui_window_get_app_gc(ui_window_t *window, gfx_context_t **rgc)
 891 {
 892         gfx_bitmap_params_t params;
 893         gfx_bitmap_alloc_t alloc;
 894         gfx_rect_t rect;
 895         mem_gc_t *memgc;
 896         errno_t rc;
 897
 898         if (window->app_gc == NULL) {
 899                 assert(window->app_bmp == NULL);
 900
 901                 gfx_bitmap_params_init(&params);
 902
 903                 /*
 904                  * The bitmap will have the same dimensions as the
 905                  * application rectangle, but start at 0,0.
 906                  */
 907                 ui_window_get_app_rect(window, &rect);
 908                 gfx_rect_rtranslate(&rect.p0, &rect, &params.rect);
 909
 910                 rc = gfx_bitmap_create(window->gc, &params, NULL,
 911                     &window->app_bmp);
 912                 if (rc != EOK)
 913                         return rc;
 914
 915                 rc = gfx_bitmap_get_alloc(window->app_bmp, &alloc);
 916                 if (rc != EOK) {
 917                         gfx_bitmap_destroy(window->app_bmp);
 918                         return rc;
 919                 }
 920
 921                 rc = mem_gc_create(&params.rect, &alloc,
 922                     &ui_window_app_mem_gc_cb, (void *) window, &memgc);
 923                 if (rc != EOK) {
 924                         gfx_bitmap_destroy(window->app_bmp);
 925                         return rc;
 926                 }
 927
 928                 window->app_mgc = memgc;
 929                 window->app_gc = mem_gc_get_ctx(memgc);
 930         }
 931
 932         *rgc = window->app_gc;
 933         return EOK;
 934 }
 935
 936 /** Get window application rectangle
 937  *
 938  * @param window Window
 939  * @param rect Place to store application rectangle
 940  */
 941 void ui_window_get_app_rect(ui_window_t *window, gfx_rect_t *rect)
 942 {
 943         ui_wdecor_geom_t geom;
 944
 945         ui_wdecor_get_geom(window->wdecor, &geom);
 946         *rect = geom.app_area_rect;
 947 }
 948
 949 /** Set cursor when pointer is hovering over a control.
 950  *
 951  * @param window Window
 952  * @param cursor Cursor
 953  */
 954 void ui_window_set_ctl_cursor(ui_window_t *window, ui_stock_cursor_t cursor)
 955 {
 956         display_stock_cursor_t dcursor;
 957
 958         dcursor = wnd_dcursor_from_cursor(cursor);
 959
 960         if (window->dwindow != NULL)
 961                 (void) display_window_set_cursor(window->dwindow, dcursor);
 962 }
 963
 964 /** Paint window
 965  *
 966  * @param window Window
 967  * @return EOK on success or an error code
 968  */
 969 errno_t ui_window_paint(ui_window_t *window)
 970 {
 971         return ui_window_send_paint(window);
 972 }
 973
 974 /** Handle window close event. */
 975 static void dwnd_close_event(void *arg)
 976 {
 977         ui_window_t *window = (ui_window_t *) arg;
 978         ui_t *ui = window->ui;
 979
 980         ui_lock(ui);
 981         ui_window_send_close(window);
 982         ui_unlock(ui);
 983 }
 984
 985 /** Handle window focus event. */
 986 static void dwnd_focus_event(void *arg, unsigned nfocus)
 987 {
 988         ui_window_t *window = (ui_window_t *) arg;
 989         ui_t *ui = window->ui;
 990
 991         ui_lock(ui);
 992         (void)nfocus;
 993
 994         if (window->wdecor != NULL) {
 995                 ui_wdecor_set_active(window->wdecor, true);
 996                 ui_wdecor_paint(window->wdecor);
 997         }
 998
 999         ui_window_send_focus(window, nfocus);
1000         ui_unlock(ui);
1001 }
1002
1003 /** Handle window keyboard event */
1004 static void dwnd_kbd_event(void *arg, kbd_event_t *kbd_event)
1005 {
1006         ui_window_t *window = (ui_window_t *) arg;
1007         ui_t *ui = window->ui;
1008
1009         ui_lock(ui);
1010         ui_window_send_kbd(window, kbd_event);
1011         ui_unlock(ui);
1012 }
1013
1014 /** Handle window position event */
1015 static void dwnd_pos_event(void *arg, pos_event_t *event)
1016 {
1017         ui_window_t *window = (ui_window_t *) arg;
1018         ui_t *ui = window->ui;
1019         ui_evclaim_t claim;
1020
1021         /* Make sure we don't process events until fully initialized */
1022         if (window->wdecor == NULL)
1023                 return;
1024
1025         ui_lock(ui);
1026
1027         claim = ui_wdecor_pos_event(window->wdecor, event);
1028         if (claim == ui_claimed) {
1029                 ui_unlock(ui);
1030                 return;
1031         }
1032
1033         ui_window_send_pos(window, event);
1034         ui_unlock(ui);
1035 }
1036
1037 /** Handle window resize event */
1038 static void dwnd_resize_event(void *arg, gfx_rect_t *rect)
1039 {
1040         ui_window_t *window = (ui_window_t *) arg;
1041         ui_t *ui = window->ui;
1042
1043         /* Make sure we don't process events until fully initialized */
1044         if (window->wdecor == NULL)
1045                 return;
1046
1047         if ((window->wdecor->style & ui_wds_resizable) == 0)
1048                 return;
1049
1050         ui_lock(ui);
1051         (void) ui_window_resize(window, rect);
1052         ui_window_send_resize(window);
1053         ui_unlock(ui);
1054 }
1055
1056 /** Handle window unfocus event. */
1057 static void dwnd_unfocus_event(void *arg, unsigned nfocus)
1058 {
1059         ui_window_t *window = (ui_window_t *) arg;
1060         ui_t *ui = window->ui;
1061
1062         ui_lock(ui);
1063
1064         if (window->wdecor != NULL && nfocus == 0) {
1065                 ui_wdecor_set_active(window->wdecor, false);
1066                 ui_wdecor_paint(window->wdecor);
1067         }
1068
1069         ui_window_send_unfocus(window, nfocus);
1070         ui_unlock(ui);
1071 }
1072
1073 /** Window decoration requested opening of system menu.
1074  *
1075  * @param wdecor Window decoration
1076  * @param arg Argument (window)
1077  * @param idev_id Input device ID
1078  */
1079 static void wd_sysmenu_open(ui_wdecor_t *wdecor, void *arg, sysarg_t idev_id)
1080 {
1081         ui_window_t *window = (ui_window_t *) arg;
1082
1083         ui_window_send_sysmenu(window, idev_id);
1084 }
1085
1086 /** Window decoration requested moving left from system menu handle.
1087  *
1088  * @param wdecor Window decoration
1089  * @param arg Argument (window)
1090  * @param idev_id Input device ID
1091  */
1092 static void wd_sysmenu_left(ui_wdecor_t *wdecor, void *arg, sysarg_t idev_id)
1093 {
1094         ui_window_t *window = (ui_window_t *) arg;
1095
1096         if (window->mbar != NULL) {
1097                 ui_wdecor_sysmenu_hdl_set_active(window->wdecor, false);
1098                 ui_menu_close(window->sysmenu);
1099                 ui_menu_bar_select_last(window->mbar, false, idev_id);
1100         }
1101 }
1102
1103 /** Window decoration requested moving right from system menu handle.
1104  *
1105  * @param wdecor Window decoration
1106  * @param arg Argument (window)
1107  * @param idev_id Input device ID
1108  */
1109 static void wd_sysmenu_right(ui_wdecor_t *wdecor, void *arg, sysarg_t idev_id)
1110 {
1111         ui_window_t *window = (ui_window_t *) arg;
1112
1113         if (window->mbar != NULL) {
1114                 ui_wdecor_sysmenu_hdl_set_active(window->wdecor, false);
1115                 ui_menu_close(window->sysmenu);
1116                 ui_menu_bar_select_first(window->mbar, false, idev_id);
1117         }
1118 }
1119
1120 /** Window decoration detected accelerator press from system menu handle.
1121  *
1122  * @param wdecor Window decoration
1123  * @param arg Argument (window)
1124  * @param c Accelerator key
1125  * @param idev_id Input device ID
1126  */
1127 static void wd_sysmenu_accel(ui_wdecor_t *wdecor, void *arg, char32_t c,
1128     sysarg_t idev_id)
1129 {
1130         ui_window_t *window = (ui_window_t *) arg;
1131
1132         if (window->mbar != NULL) {
1133                 ui_wdecor_sysmenu_hdl_set_active(window->wdecor, false);
1134                 ui_menu_close(window->sysmenu);
1135                 ui_menu_bar_press_accel(window->mbar, c, idev_id);
1136         }
1137 }
1138
1139 /** Window decoration requested window minimization.
1140  *
1141  * @param wdecor Window decoration
1142  * @param arg Argument (window)
1143  */
1144 static void wd_minimize(ui_wdecor_t *wdecor, void *arg)
1145 {
1146         ui_window_t *window = (ui_window_t *) arg;
1147
1148         ui_window_send_minimize(window);
1149 }
1150
1151 /** Window decoration requested window maximization.
1152  *
1153  * @param wdecor Window decoration
1154  * @param arg Argument (window)
1155  */
1156 static void wd_maximize(ui_wdecor_t *wdecor, void *arg)
1157 {
1158         ui_window_t *window = (ui_window_t *) arg;
1159
1160         ui_window_send_maximize(window);
1161 }
1162
1163 /** Window decoration requested window unmaximization.
1164  *
1165  * @param wdecor Window decoration
1166  * @param arg Argument (window)
1167  */
1168 static void wd_unmaximize(ui_wdecor_t *wdecor, void *arg)
1169 {
1170         ui_window_t *window = (ui_window_t *) arg;
1171
1172         ui_window_send_unmaximize(window);
1173 }
1174
1175 /** Window decoration requested window closure.
1176  *
1177  * @param wdecor Window decoration
1178  * @param arg Argument (window)
1179  */
1180 static void wd_close(ui_wdecor_t *wdecor, void *arg)
1181 {
1182         ui_window_t *window = (ui_window_t *) arg;
1183
1184         ui_window_send_close(window);
1185 }
1186
1187 /** Window decoration requested window move.
1188  *
1189  * @param wdecor Window decoration
1190  * @param arg Argument (window)
1191  * @param pos Position where the title bar was pressed
1192  * @param pos_id Positioning device ID
1193  */
1194 static void wd_move(ui_wdecor_t *wdecor, void *arg, gfx_coord2_t *pos,
1195     sysarg_t pos_id)
1196 {
1197         ui_window_t *window = (ui_window_t *) arg;
1198
1199         if (window->dwindow != NULL)
1200                 (void) display_window_move_req(window->dwindow, pos, pos_id);
1201 }
1202
1203 /** Window decoration requested window resize.
1204  *
1205  * @param wdecor Window decoration
1206  * @param arg Argument (window)
1207  * @param rsztype Resize type
1208  * @param pos Position where the button was pressed
1209  * @param pos_id Positioning device ID
1210  */
1211 static void wd_resize(ui_wdecor_t *wdecor, void *arg,
1212     ui_wdecor_rsztype_t rsztype, gfx_coord2_t *pos, sysarg_t pos_id)
1213 {
1214         ui_window_t *window = (ui_window_t *) arg;
1215
1216         if (window->dwindow != NULL) {
1217                 (void) display_window_resize_req(window->dwindow,
1218                     (display_wnd_rsztype_t) rsztype, // Same constants in the enums
1219                     pos, pos_id);
1220         }
1221 }
1222
1223 /** Get display stock cursor from UI stock cursor.
1224  *
1225  * @param cursor UI stock cursor
1226  * @return Display stock cursor
1227  */
1228 display_stock_cursor_t wnd_dcursor_from_cursor(ui_stock_cursor_t cursor)
1229 {
1230         display_stock_cursor_t dcursor;
1231
1232         dcursor = dcurs_arrow;
1233
1234         switch (cursor) {
1235         case ui_curs_arrow:
1236                 dcursor = dcurs_arrow;
1237                 break;
1238         case ui_curs_size_ud:
1239                 dcursor = dcurs_size_ud;
1240                 break;
1241         case ui_curs_size_lr:
1242                 dcursor = dcurs_size_lr;
1243                 break;
1244         case ui_curs_size_uldr:
1245                 dcursor = dcurs_size_uldr;
1246                 break;
1247         case ui_curs_size_urdl:
1248                 dcursor = dcurs_size_urdl;
1249                 break;
1250         case ui_curs_ibeam:
1251                 dcursor = dcurs_ibeam;
1252                 break;
1253         }
1254
1255         return dcursor;
1256 }
1257
1258 /** Window decoration requested changing cursor.
1259  *
1260  * @param wdecor Window decoration
1261  * @param arg Argument (window)
1262  * @param cursor Cursor to set
1263  */
1264 static void wd_set_cursor(ui_wdecor_t *wdecor, void *arg,
1265     ui_stock_cursor_t cursor)
1266 {
1267         ui_window_t *window = (ui_window_t *) arg;
1268         display_stock_cursor_t dcursor;
1269
1270         if (cursor == window->cursor)
1271                 return;
1272
1273         dcursor = wnd_dcursor_from_cursor(cursor);
1274
1275         if (window->dwindow != NULL)
1276                 (void) display_window_set_cursor(window->dwindow, dcursor);
1277
1278         window->cursor = cursor;
1279 }
1280
1281 /** Send window sysmenu event.
1282  *
1283  * @param window Window
1284  * @parma idev_id Input device ID
1285  */
1286 void ui_window_send_sysmenu(ui_window_t *window, sysarg_t idev_id)
1287 {
1288         if (window->cb != NULL && window->cb->sysmenu != NULL)
1289                 window->cb->sysmenu(window, window->arg, idev_id);
1290         else
1291                 ui_window_def_sysmenu(window, idev_id);
1292 }
1293
1294 /** Send window minimize event.
1295  *
1296  * @param window Window
1297  */
1298 void ui_window_send_minimize(ui_window_t *window)
1299 {
1300         if (window->cb != NULL && window->cb->minimize != NULL)
1301                 window->cb->minimize(window, window->arg);
1302         else
1303                 ui_window_def_minimize(window);
1304 }
1305
1306 /** Send window maximize event.
1307  *
1308  * @param window Window
1309  */
1310 void ui_window_send_maximize(ui_window_t *window)
1311 {
1312         if (window->cb != NULL && window->cb->maximize != NULL)
1313                 window->cb->maximize(window, window->arg);
1314         else
1315                 ui_window_def_maximize(window);
1316 }
1317
1318 /** Send window unmaximize event.
1319  *
1320  * @param window Window
1321  */
1322 void ui_window_send_unmaximize(ui_window_t *window)
1323 {
1324         if (window->cb != NULL && window->cb->unmaximize != NULL)
1325                 window->cb->unmaximize(window, window->arg);
1326         else
1327                 ui_window_def_unmaximize(window);
1328 }
1329
1330 /** Send window close event.
1331  *
1332  * @param window Window
1333  */
1334 void ui_window_send_close(ui_window_t *window)
1335 {
1336         if (window->cb != NULL && window->cb->close != NULL)
1337                 window->cb->close(window, window->arg);
1338 }
1339
1340 /** Send window focus event.
1341  *
1342  * @param window Window
1343  * @param nfocus New number of foci
1344  */
1345 void ui_window_send_focus(ui_window_t *window, unsigned nfocus)
1346 {
1347         if (window->cb != NULL && window->cb->focus != NULL)
1348                 window->cb->focus(window, window->arg, nfocus);
1349 }
1350
1351 /** Send window keyboard event.
1352  *
1353  * @param window Window
1354  */
1355 void ui_window_send_kbd(ui_window_t *window, kbd_event_t *kbd)
1356 {
1357         if (window->cb != NULL && window->cb->kbd != NULL)
1358                 window->cb->kbd(window, window->arg, kbd);
1359         else
1360                 ui_window_def_kbd(window, kbd);
1361 }
1362
1363 /** Send window paint event.
1364  *
1365  * @param window Window
1366  */
1367 errno_t ui_window_send_paint(ui_window_t *window)
1368 {
1369         if (window->cb != NULL && window->cb->paint != NULL)
1370                 return window->cb->paint(window, window->arg);
1371         else
1372                 return ui_window_def_paint(window);
1373 }
1374
1375 /** Send window position event.
1376  *
1377  * @param window Window
1378  */
1379 void ui_window_send_pos(ui_window_t *window, pos_event_t *pos)
1380 {
1381         if (window->cb != NULL && window->cb->pos != NULL)
1382                 window->cb->pos(window, window->arg, pos);
1383         else
1384                 ui_window_def_pos(window, pos);
1385 }
1386
1387 /** Send window unfocus event.
1388  *
1389  * @param window Window
1390  * @param nfocus Number of remaining foci
1391  */
1392 void ui_window_send_unfocus(ui_window_t *window, unsigned nfocus)
1393 {
1394         if (window->cb != NULL && window->cb->unfocus != NULL)
1395                 window->cb->unfocus(window, window->arg, nfocus);
1396         else
1397                 return ui_window_def_unfocus(window, nfocus);
1398 }
1399
1400 /** Send window resize event.
1401  *
1402  * @param window Window
1403  */
1404 void ui_window_send_resize(ui_window_t *window)
1405 {
1406         if (window->cb != NULL && window->cb->resize != NULL)
1407                 window->cb->resize(window, window->arg);
1408         else
1409                 return ui_window_def_resize(window);
1410 }
1411
1412 /** Default window sysmenu routine.
1413  *
1414  * @param window Window
1415  * @param idev_id Input device ID
1416  * @return EOK on success or an error code
1417  */
1418 errno_t ui_window_def_sysmenu(ui_window_t *window, sysarg_t idev_id)
1419 {
1420         errno_t rc;
1421         ui_wdecor_geom_t geom;
1422
1423         if (ui_menu_is_open(window->sysmenu)) {
1424                 ui_menu_close(window->sysmenu);
1425         } else {
1426                 ui_wdecor_get_geom(window->wdecor, &geom);
1427
1428                 rc = ui_menu_open(window->sysmenu, &geom.title_bar_rect,
1429                     idev_id);
1430                 if (rc != EOK)
1431                         goto error;
1432         }
1433
1434         return EOK;
1435 error:
1436         return rc;
1437 }
1438
1439 /** Default window minimize routine.
1440  *
1441  * @param window Window
1442  * @return EOK on success or an error code
1443  */
1444 errno_t ui_window_def_minimize(ui_window_t *window)
1445 {
1446         errno_t rc;
1447
1448         if (window->dwindow != NULL) {
1449                 rc = display_window_minimize(window->dwindow);
1450                 if (rc != EOK)
1451                         goto error;
1452         }
1453
1454         return EOK;
1455 error:
1456         return rc;
1457 }
1458
1459 /** Default window maximize routine.
1460  *
1461  * @param window Window
1462  * @return EOK on success or an error code
1463  */
1464 errno_t ui_window_def_maximize(ui_window_t *window)
1465 {
1466         errno_t rc;
1467         gfx_rect_t old_rect;
1468         gfx_rect_t rect;
1469
1470         old_rect = window->rect;
1471
1472         if (window->dwindow != NULL) {
1473                 rc = display_window_get_max_rect(window->dwindow, &rect);
1474                 if (rc != EOK)
1475                         return rc;
1476         } else {
1477                 rect = window->ui->rect;
1478         }
1479
1480         ui_wdecor_set_maximized(window->wdecor, true);
1481         ui_menu_entry_set_disabled(window->sysmenu_restore, false);
1482         ui_menu_entry_set_disabled(window->sysmenu_maximize, true);
1483
1484         rc = ui_window_size_change(window, &rect, ui_wsc_maximize);
1485         if (rc != EOK) {
1486                 ui_wdecor_set_maximized(window->wdecor, false);
1487                 return rc;
1488         }
1489
1490         window->normal_rect = old_rect;
1491         (void) ui_window_paint(window);
1492         return EOK;
1493 }
1494
1495 /** Default window unmaximize routine.
1496  *
1497  * @param window Window
1498  * @return EOK on success or an error code
1499  */
1500 errno_t ui_window_def_unmaximize(ui_window_t *window)
1501 {
1502         errno_t rc;
1503
1504         ui_wdecor_set_maximized(window->wdecor, false);
1505         ui_menu_entry_set_disabled(window->sysmenu_restore, true);
1506         ui_menu_entry_set_disabled(window->sysmenu_maximize, false);
1507
1508         rc = ui_window_size_change(window, &window->normal_rect,
1509             ui_wsc_unmaximize);
1510         if (rc != EOK) {
1511                 ui_wdecor_set_maximized(window->wdecor, true);
1512                 printf("ui_window_size_change->error\n");
1513                 return rc;
1514         }
1515
1516         (void) ui_window_paint(window);
1517         return EOK;
1518 }
1519
1520 /** Default window keyboard event routine.
1521  *
1522  * @param window Window
1523  * @return ui_claimed iff event was claimed
1524  */
1525 ui_evclaim_t ui_window_def_kbd(ui_window_t *window, kbd_event_t *kbd)
1526 {
1527         ui_evclaim_t claim;
1528
1529         if (window->control != NULL)
1530                 claim = ui_control_kbd_event(window->control, kbd);
1531         else
1532                 claim = ui_unclaimed;
1533
1534         if (claim == ui_unclaimed)
1535                 return ui_wdecor_kbd_event(window->wdecor, kbd);
1536
1537         return ui_unclaimed;
1538 }
1539
1540 /** Default window paint routine.
1541  *
1542  * @param window Window
1543  * @return EOK on success or an error code
1544  */
1545 errno_t ui_window_def_paint(ui_window_t *window)
1546 {
1547         gfx_rect_t app_rect;
1548         errno_t rc;
1549
1550         rc = gfx_set_color(window->gc, window->res->wnd_face_color);
1551         if (rc != EOK)
1552                 return rc;
1553
1554         ui_window_get_app_rect(window, &app_rect);
1555
1556         rc = gfx_fill_rect(window->gc, &app_rect);
1557         if (rc != EOK)
1558                 return rc;
1559
1560         if (window->control != NULL)
1561                 return ui_control_paint(window->control);
1562
1563         rc = gfx_update(window->res->gc);
1564         if (rc != EOK)
1565                 return rc;
1566
1567         return EOK;
1568 }
1569
1570 /** Default window position event routine.
1571  *
1572  * @param window Window
1573  */
1574 void ui_window_def_pos(ui_window_t *window, pos_event_t *pos)
1575 {
1576         if (window->control != NULL)
1577                 ui_control_pos_event(window->control, pos);
1578 }
1579
1580 /** Default window unfocus routine.
1581  *
1582  * @param window Window
1583  * @param nfocus Number of remaining foci
1584  * @return EOK on success or an error code
1585  */
1586 void ui_window_def_unfocus(ui_window_t *window, unsigned nfocus)
1587 {
1588         if (window->control != NULL)
1589                 ui_control_unfocus(window->control, nfocus);
1590 }
1591
1592 /** Default window resize routine.
1593  *
1594  * @param window Window
1595  * @return EOK on success or an error code
1596  */
1597 void ui_window_def_resize(ui_window_t *window)
1598 {
1599         ui_window_paint(window);
1600 }
1601
1602 /** Handle system menu left event.
1603  *
1604  * @param sysmenu System menu
1605  * @param arg Argument (ui_window_t *)
1606  * @param idev_id Input device ID
1607  */
1608 static void wnd_sysmenu_left(ui_menu_t *sysmenu, void *arg, sysarg_t idev_id)
1609 {
1610         ui_window_t *window = (ui_window_t *)arg;
1611
1612         if (window->mbar != NULL) {
1613                 ui_wdecor_sysmenu_hdl_set_active(window->wdecor, false);
1614                 ui_menu_close(sysmenu);
1615                 ui_menu_bar_select_last(window->mbar, true, idev_id);
1616         }
1617 }
1618
1619 /** Handle system menu right event.
1620  *
1621  * @param sysmenu System menu
1622  * @param arg Argument (ui_window_t *)
1623  * @param idev_id Input device ID
1624  */
1625 static void wnd_sysmenu_right(ui_menu_t *sysmenu, void *arg, sysarg_t idev_id)
1626 {
1627         ui_window_t *window = (ui_window_t *)arg;
1628
1629         if (window->mbar != NULL) {
1630                 ui_wdecor_sysmenu_hdl_set_active(window->wdecor, false);
1631                 ui_menu_close(sysmenu);
1632                 ui_menu_bar_select_first(window->mbar, true, idev_id);
1633         }
1634 }
1635
1636 /** Handle system menu close request event.
1637  *
1638  * @param sysmenu System menu
1639  * @param arg Argument (ui_window_t *)
1640  * @param idev_id Input device ID
1641  */
1642 static void wnd_sysmenu_close_req(ui_menu_t *sysmenu, void *arg)
1643 {
1644         ui_window_t *window = (ui_window_t *)arg;
1645
1646         ui_wdecor_sysmenu_hdl_set_active(window->wdecor, false);
1647         ui_menu_close(sysmenu);
1648 }
1649
1650 /** Handle system menu Restore entry activation.
1651  *
1652  * @param mentry Menu entry
1653  * @param arg Argument (ui_window_t *)
1654  */
1655 static void wnd_sysmenu_erestore(ui_menu_entry_t *mentry, void *arg)
1656 {
1657         ui_window_t *window = (ui_window_t *)arg;
1658
1659         ui_window_send_unmaximize(window);
1660 }
1661
1662 /** Handle system menu Minimize entry activation.
1663  *
1664  * @param mentry Menu entry
1665  * @param arg Argument (ui_window_t *)
1666  */
1667 static void wnd_sysmenu_eminimize(ui_menu_entry_t *mentry, void *arg)
1668 {
1669         ui_window_t *window = (ui_window_t *)arg;
1670
1671         ui_window_send_minimize(window);
1672 }
1673
1674 /** Handle system menu Maximize entry activation.
1675  *
1676  * @param mentry Menu entry
1677  * @param arg Argument (ui_window_t *)
1678  */
1679 static void wnd_sysmenu_emaximize(ui_menu_entry_t *mentry, void *arg)
1680 {
1681         ui_window_t *window = (ui_window_t *)arg;
1682
1683         ui_window_send_maximize(window);
1684 }
1685
1686 /** Handle system menu Close entry activation.
1687  *
1688  * @param mentry Menu entry
1689  * @param arg Argument (ui_window_t *)
1690  */
1691 static void wnd_sysmenu_eclose(ui_menu_entry_t *mentry, void *arg)
1692 {
1693         ui_window_t *window = (ui_window_t *)arg;
1694
1695         ui_window_send_close(window);
1696 }
1697
1698 /** Handle system menu press accelerator key event.
1699  *
1700  * @param sysmenu System menu
1701  * @param arg Argument (ui_window_t *)
1702  * @param idev_id Input device ID
1703  */
1704 static void wnd_sysmenu_press_accel(ui_menu_t *sysmenu, void *arg,
1705     char32_t c, sysarg_t idev_id)
1706 {
1707         (void)sysmenu;
1708         (void)arg;
1709         (void)c;
1710         (void)idev_id;
1711 }
1712
1713 /** Window invalidate callback
1714  *
1715  * @param arg Argument (ui_window_t *)
1716  * @param rect Rectangle to update
1717  */
1718 static void ui_window_invalidate(void *arg, gfx_rect_t *rect)
1719 {
1720         ui_window_t *window = (ui_window_t *) arg;
1721         gfx_rect_t env;
1722
1723         gfx_rect_envelope(&window->dirty_rect, rect, &env);
1724         window->dirty_rect = env;
1725 }
1726
1727 /** Window update callback
1728  *
1729  * @param arg Argument (ui_window_t *)
1730  */
1731 static void ui_window_update(void *arg)
1732 {
1733         ui_window_t *window = (ui_window_t *) arg;
1734
1735         if (!gfx_rect_is_empty(&window->dirty_rect)) {
1736                 (void) gfx_bitmap_render(window->bmp, &window->dirty_rect,
1737                     &window->dpos);
1738         }
1739
1740         window->dirty_rect.p0.x = 0;
1741         window->dirty_rect.p0.y = 0;
1742         window->dirty_rect.p1.x = 0;
1743         window->dirty_rect.p1.y = 0;
1744 }
1745
1746 /** Window cursor get position callback
1747  *
1748  * @param arg Argument (ui_window_t *)
1749  * @param pos Place to store position
1750  */
1751 static errno_t ui_window_cursor_get_pos(void *arg, gfx_coord2_t *pos)
1752 {
1753         ui_window_t *window = (ui_window_t *) arg;
1754         gfx_coord2_t cpos;
1755         errno_t rc;
1756
1757         rc = gfx_cursor_get_pos(window->realgc, &cpos);
1758         if (rc != EOK)
1759                 return rc;
1760
1761         pos->x = cpos.x - window->dpos.x;
1762         pos->y = cpos.y - window->dpos.y;
1763         return EOK;
1764 }
1765
1766 /** Window cursor set position callback
1767  *
1768  * @param arg Argument (ui_window_t *)
1769  * @param pos New position
1770  */
1771 static errno_t ui_window_cursor_set_pos(void *arg, gfx_coord2_t *pos)
1772 {
1773         ui_window_t *window = (ui_window_t *) arg;
1774         gfx_coord2_t cpos;
1775
1776         cpos.x = pos->x + window->dpos.x;
1777         cpos.y = pos->y + window->dpos.y;
1778
1779         return gfx_cursor_set_pos(window->realgc, &cpos);
1780 }
1781
1782 /** Window cursor set visibility callback
1783  *
1784  * @param arg Argument (ui_window_t *)
1785  * @param visible @c true iff cursor is to be made visible
1786  */
1787 static errno_t ui_window_cursor_set_visible(void *arg, bool visible)
1788 {
1789         ui_window_t *window = (ui_window_t *) arg;
1790
1791         return gfx_cursor_set_visible(window->realgc, visible);
1792 }
1793
1794 /** Application area invalidate callback
1795  *
1796  * @param arg Argument (ui_window_t *)
1797  * @param rect Rectangle to update
1798  */
1799 static void ui_window_app_invalidate(void *arg, gfx_rect_t *rect)
1800 {
1801         ui_window_t *window = (ui_window_t *) arg;
1802         gfx_rect_t arect;
1803
1804         ui_window_get_app_rect(window, &arect);
1805
1806         /* Render bitmap rectangle inside the application area */
1807         (void) gfx_bitmap_render(window->app_bmp, rect, &arect.p0);
1808         /*
1809          * TODO Update applications to call gfx_update(), then
1810          * we can defer update to ui_window_app_update().
1811          */
1812         (void) gfx_update(window->res->gc);
1813 }
1814
1815 /** Application area update callback
1816  *
1817  * @param arg Argument (ui_window_t *)
1818  */
1819 static void ui_window_app_update(void *arg)
1820 {
1821         ui_window_t *window = (ui_window_t *) arg;
1822
1823         /*
1824          * Not used since display is updated immediately
1825          * in ui_window_app_invalidate
1826          */
1827         (void) window;
1828 }
1829
1830 /** Window expose callback. */
1831 static void ui_window_expose_cb(void *arg)
1832 {
1833         ui_window_t *window = (ui_window_t *) arg;
1834
1835         ui_window_paint(window);
1836 }
1837
1838 /** @}
1839  */