source: mainline/uspace/lib/ui/src/window.c@ a72f3b8

Last change on this file since a72f3b8 was 9aa51406, checked in by Jiri Svoboda <jiri@…>, 15 months ago

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