Changeset ddb844e in mainline for uspace/lib

Timestamp:

2020-07-03T23:00:34Z (6 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

e79a025

Parents:

edb57bc6 (diff), 1a1c75e (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Resolve merge conflicts

Location:

uspace/lib

Files:

• c/generic/io/visualizer.c (deleted)
• c/generic/io/window.c (deleted)
• c/include/io/kbd_event.h (modified) (1 diff)
• c/include/io/window.h (modified) (2 diffs)
• c/include/ipc/services.h (modified) (1 diff)
• c/meson.build (modified) (1 diff)
• congfx/doc/doxygroups.h (added)
• congfx/include/congfx/console.h (added)
• congfx/include/types/congfx/console.h (added)
• congfx/meson.build (moved) (moved from uspace/lib/graph/meson.build ) (2 diffs)
• congfx/private/console.h (added)
• congfx/src/console.c (added)
• ddev/doc/doxygroups.h (added)
• ddev/include/ddev.h (added)
• ddev/include/ddev/info.h (added)
• ddev/include/ddev_srv.h (moved) (moved from uspace/lib/c/include/io/visualizer.h ) (3 diffs)
• ddev/include/ipc/ddev.h (added)
• ddev/include/types/ddev.h (added)
• ddev/include/types/ddev/info.h (added)
• ddev/meson.build (added)
• ddev/src/ddev.c (added)
• ddev/src/ddev_srv.c (added)
• ddev/src/info.c (added)
• ddev/test/ddev.c (added)
• ddev/test/main.c (added)
• display/doc/doxygroups.h (added)
• display/include/disp_srv.h (added)
• display/include/display.h (added)
• display/include/display/event.h (added)
• display/include/display/info.h (added)
• display/include/display/wndparams.h (added)
• display/include/display/wndresize.h (added)
• display/include/ipc/display.h (moved) (moved from uspace/lib/c/include/ipc/graph.h ) (3 diffs)
• display/include/types/display.h (added)
• display/include/types/display/cursor.h (added)
• display/include/types/display/event.h (added)
• display/include/types/display/info.h (added)
• display/include/types/display/wndparams.h (added)
• display/include/types/display/wndresize.h (added)
• display/meson.build (added)
• display/private/params.h (added)
• display/src/disp_srv.c (added)
• display/src/display.c (added)
• display/src/wndresize.c (added)
• display/test/display.c (added)
• display/test/main.c (added)
• display/test/wndresize.c (added)
• gfx/doc/doxygroups.h (added)
• gfx/include/gfx/bitmap.h (added)
• gfx/include/gfx/color.h (added)
• gfx/include/gfx/context.h (added)
• gfx/include/gfx/coord.h (added)
• gfx/include/gfx/render.h (added)
• gfx/include/types/gfx/bitmap.h (added)
• gfx/include/types/gfx/color.h (added)
• gfx/include/types/gfx/context.h (added)
• gfx/include/types/gfx/coord.h (moved) (moved from uspace/srv/hid/compositor/compositor.h ) (2 diffs)
• gfx/include/types/gfx/ops/context.h (added)
• gfx/meson.build (added)
• gfx/private/bitmap.h (added)
• gfx/private/color.h (added)
• gfx/private/context.h (added)
• gfx/src/bitmap.c (added)
• gfx/src/color.c (added)
• gfx/src/context.c (added)
• gfx/src/coord.c (added)
• gfx/src/render.c (added)
• gfx/test/bitmap.c (added)
• gfx/test/color.c (added)
• gfx/test/coord.c (added)
• gfx/test/main.c (added)
• gfx/test/render.c (added)
• graph/doc/doxygroups.h (deleted)
• graph/graph.c (deleted)
• graph/graph.h (deleted)
• gui/meson.build (modified) (1 diff)
• gui/terminal.c (modified) (1 diff)
• gui/terminal.h (modified) (1 diff)
• gui/window.c (modified) (19 diffs)
• gui/window.h (modified) (7 diffs)
• guigfx/doc/doxygroups.h (added)
• guigfx/include/guigfx/canvas.h (added)
• guigfx/include/types/guigfx/canvas.h (added)
• guigfx/meson.build (moved) (moved from uspace/srv/hid/compositor/meson.build ) (2 diffs)
• guigfx/private/canvas.h (added)
• guigfx/src/canvas.c (added)
• ipcgfx/doc/doxygroups.h (added)
• ipcgfx/include/ipcgfx/client.h (added)
• ipcgfx/include/ipcgfx/ipc/gc.h (added)
• ipcgfx/include/ipcgfx/server.h (added)
• ipcgfx/include/types/ipcgfx/client.h (added)
• ipcgfx/meson.build (added)
• ipcgfx/private/client.h (added)
• ipcgfx/private/server.h (added)
• ipcgfx/src/client.c (added)
• ipcgfx/src/server.c (added)
• ipcgfx/test/ipcgfx.c (added)
• ipcgfx/test/main.c (added)
• memgfx/doc/doxygroups.h (added)
• memgfx/include/memgfx/memgc.h (added)
• memgfx/include/types/memgfx/memgc.h (added)
• memgfx/meson.build (added)
• memgfx/private/memgc.h (added)
• memgfx/src/memgc.c (added)
• memgfx/test/main.c (added)
• memgfx/test/memgfx.c (added)
• meson.build (modified) (5 diffs)

uspace/lib/c/include/io/kbd_event.h

@@ -37 +37 @@
 
 #include <adt/list.h>
+#include <inttypes.h>
 #include <io/keycode.h>
 

uspace/lib/c/include/io/window.h

@@ -36 +36 @@
 #define _LIBC_IO_WINDOW_H_
 
-#include <stdbool.h>
-#include <async.h>
-#include <loc.h>
 #include <io/kbd_event.h>
 #include <io/pos_event.h>
+#include <types/common.h>
 
 typedef enum {
@@ -113 +111 @@
 } window_event_t;
 
-extern errno_t win_register(async_sess_t *, window_flags_t, service_id_t *,
-    service_id_t *);
-
-extern errno_t win_get_event(async_sess_t *, window_event_t *);
-
-extern errno_t win_damage(async_sess_t *, sysarg_t, sysarg_t, sysarg_t, sysarg_t);
-extern errno_t win_grab(async_sess_t *, sysarg_t, sysarg_t);
-extern errno_t win_resize(async_sess_t *, sysarg_t, sysarg_t, sysarg_t, sysarg_t,
-    window_placement_flags_t, void *);
-extern errno_t win_close(async_sess_t *);
-extern errno_t win_close_request(async_sess_t *);
-
 #endif
 

uspace/lib/c/include/ipc/services.h

@@ -54 +54 @@
 #define SERVICE_NAME_CLIPBOARD "clipboard"
 #define SERVICE_NAME_CORECFG  "corecfg"
+#define SERVICE_NAME_DISPLAY  "hid/display"
 #define SERVICE_NAME_DHCP     "net/dhcp"
 #define SERVICE_NAME_DNSR     "net/dnsr"

uspace/lib/c/meson.build

@@ -131 +131 @@
         'generic/io/console.c',
         'generic/io/table.c',
-        'generic/io/visualizer.c',
-        'generic/io/window.c',
         'generic/iplink.c',
         'generic/iplink_srv.c',

uspace/lib/congfx/meson.build

@@ -1 +1 @@
 #
-# Copyright (c) 2011 Petr Koupy
+# Copyright (c) 2019 Jiri Svoboda
 # All rights reserved.
 #
@@ -27 +27 @@
 #
 
-src = files('graph.c')
+deps = [ 'gfx' ]
+src = files(
+        'src/console.c',
+)

uspace/lib/ddev/include/ddev_srv.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2011 Petr Koupy
+ * Copyright (c) 2019 Jiri Svoboda
  * All rights reserved.
  *
@@ -27 +27 @@
  */
 
-/** @addtogroup libc
+/** @addtogroup libdisplay
  * @{
  */
@@ -33 +33 @@
  */
 
-#ifndef _LIBC_IO_VISUALIZER_H_
-#define _LIBC_IO_VISUALIZER_H_
+#ifndef _LIBDDEV_DDEV_SRV_H_
+#define _LIBDDEV_DDEV_SRV_H_
 
 #include <async.h>
-#include <io/mode.h>
+#include <errno.h>
+#include <gfx/context.h>
+#include "types/ddev/info.h"
 
-extern errno_t visualizer_claim(async_sess_t *, sysarg_t);
-extern errno_t visualizer_yield(async_sess_t *);
+typedef struct ddev_ops ddev_ops_t;
 
-extern errno_t visualizer_enumerate_modes(async_sess_t *, vslmode_t *, sysarg_t);
-extern errno_t visualizer_get_default_mode(async_sess_t *, vslmode_t *);
-extern errno_t visualizer_get_current_mode(async_sess_t *, vslmode_t *);
-extern errno_t visualizer_get_mode(async_sess_t *, vslmode_t *, sysarg_t);
-extern errno_t visualizer_set_mode(async_sess_t *, sysarg_t, sysarg_t, void *);
+/** Display device server structure (per client session) */
+typedef struct {
+        async_sess_t *client_sess;
+        ddev_ops_t *ops;
+        void *arg;
+} ddev_srv_t;
 
-extern errno_t visualizer_update_damaged_region(async_sess_t *,
-    sysarg_t, sysarg_t, sysarg_t, sysarg_t, sysarg_t, sysarg_t);
+struct ddev_ops {
+        errno_t (*get_gc)(void *, sysarg_t *, sysarg_t *);
+        errno_t (*get_info)(void *, ddev_info_t *);
+};
 
-extern errno_t visualizer_suspend(async_sess_t *);
-extern errno_t visualizer_wakeup(async_sess_t *);
+extern void ddev_conn(ipc_call_t *, ddev_srv_t *);
+extern void ddev_srv_initialize(ddev_srv_t *);
 
 #endif

uspace/lib/display/include/ipc/display.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2011 Petr Koupy
+ * Copyright (c) 2019 Jiri Svoboda
  * All rights reserved.
  *
@@ -27 +27 @@
  */
 
-/** @addtogroup libc
+/** @addtogroup libdisplay
  * @{
  */
@@ -33 +33 @@
  */
 
-#ifndef _LIBC_IPC_GRAPH_H_
-#define _LIBC_IPC_GRAPH_H_
+#ifndef _LIBC_IPC_DISPLAY_H_
+#define _LIBC_IPC_DISPLAY_H_
 
 #include <ipc/common.h>
 
 typedef enum {
-        VISUALIZER_CLAIM = IPC_FIRST_USER_METHOD,
-        VISUALIZER_YIELD,
-
-        VISUALIZER_ENUMERATE_MODES,
-        VISUALIZER_GET_DEFAULT_MODE,
-        VISUALIZER_GET_CURRENT_MODE,
-        VISUALIZER_GET_MODE,
-        VISUALIZER_SET_MODE,
-
-        VISUALIZER_UPDATE_DAMAGED_REGION,
-
-        VISUALIZER_SUSPEND,
-        VISUALIZER_WAKE_UP,
-} visualizer_request_t;
+        DISPLAY_CALLBACK_CREATE = IPC_FIRST_USER_METHOD,
+        DISPLAY_WINDOW_CREATE,
+        DISPLAY_WINDOW_DESTROY,
+        DISPLAY_WINDOW_MOVE,
+        DISPLAY_WINDOW_MOVE_REQ,
+        DISPLAY_WINDOW_RESIZE,
+        DISPLAY_WINDOW_RESIZE_REQ,
+        DISPLAY_WINDOW_SET_CURSOR,
+        DISPLAY_GET_EVENT,
+        DISPLAY_GET_INFO
+} display_request_t;
 
 typedef enum {
-        VISUALIZER_MODE_CHANGE = IPC_FIRST_USER_METHOD,
-        VISUALIZER_DISCONNECT
-} visualizer_notif_t;
-
-typedef enum {
-        RENDERER_REQ_NONE = IPC_FIRST_USER_METHOD,
-        // TODO: similar interface as provides libsoftrend
-} renderer_request_t;
-
-typedef enum {
-        RENDERER_NOTIF_NONE = IPC_FIRST_USER_METHOD,
-        // TODO: similar interface as provides libsoftrend
-} renderer_notif_t;
+        DISPLAY_EV_PENDING = IPC_FIRST_USER_METHOD
+} display_event_t;
 
 #endif

uspace/lib/gfx/include/types/gfx/coord.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2012 Petr Koupy
+ * Copyright (c) 2019 Jiri Svoboda
  * All rights reserved.
  *
@@ -27 +27 @@
  */
 
-/** @addtogroup compositor
+/** @addtogroup libgfx
  * @{
  */
-/** @file
+/**
+ * @file Graphic coordinates
  */
 
-#ifndef COMPOSITOR_COMPOSITOR_H_
-#define COMPOSITOR_COMPOSITOR_H_
+#ifndef _GFX_TYPES_COORD_H
+#define _GFX_TYPES_COORD_H
 
-typedef native_t desktop_coord_t;
+#include <errno.h>
+#include <stdint.h>
+
+typedef int gfx_coord_t;
 
 typedef struct {
-        desktop_coord_t x;
-        desktop_coord_t y;
-} desktop_point_t;
-
-typedef desktop_point_t desktop_vector_t;
+        gfx_coord_t x;
+        gfx_coord_t y;
+} gfx_coord2_t;
 
 typedef struct {
-        desktop_coord_t x;
-        desktop_coord_t y;
-        desktop_coord_t w;
-        desktop_coord_t h;
-} desktop_rect_t;
-
-/* TODO remove? */
-typedef struct {
-        double x;
-        double y;
-} double_point_t;
-
-typedef double_point_t double_vector_t;
+        gfx_coord2_t p0;
+        gfx_coord2_t p1;
+} gfx_rect_t;
 
 #endif

uspace/lib/gui/meson.build

@@ -27 +27 @@
 #
 
-deps = [ 'draw' , 'softrend' , 'graph' ]
+deps = [ 'draw' , 'softrend', 'display' ]
 src = files(
         'common.c',

uspace/lib/gui/terminal.c

@@ -42 +42 @@
 #include <io/concaps.h>
 #include <io/console.h>
+#include <loc.h>
 #include <task.h>
 #include <adt/list.h>

uspace/lib/gui/terminal.h

@@ -42 +42 @@
 #include <io/chargrid.h>
 #include <io/con_srv.h>
+#include <loc.h>
 #include <adt/list.h>
 #include <adt/prodcons.h>

uspace/lib/gui/window.c

@@ -48 +48 @@
 #include <adt/list.h>
 
-#include <async.h>
 #include <loc.h>
 
@@ -56 +55 @@
 #include <draw/drawctx.h>
 #include <draw/surface.h>
+#include <display.h>
 
 #include "common.h"
@@ -67 +67 @@
 static sysarg_t header_min_width = 40;
 static sysarg_t close_thickness = 20;
+static sysarg_t corner_size = 24;
+static sysarg_t window_initial_size = 1;
 
 static pixel_t color_highlight = PIXEL(255, 255, 255, 255);
@@ -82 +84 @@
 static pixel_t color_caption_focus = PIXEL(255, 255, 255, 255);
 static pixel_t color_caption_unfocus = PIXEL(255, 207, 207, 207);
+
+static void window_close_event(void *);
+static void window_focus_event(void *);
+static void window_kbd_event(void *, kbd_event_t *);
+static void window_pos_event(void *, pos_event_t *);
+static void window_resize_event(void *, gfx_rect_t *);
+static void window_unfocus_event(void *);
+
+static display_wnd_cb_t window_cb = {
+        .close_event = window_close_event,
+        .focus_event = window_focus_event,
+        .kbd_event = window_kbd_event,
+        .pos_event = window_pos_event,
+        .resize_event = window_resize_event,
+        .unfocus_event = window_unfocus_event
+};
+
+static void set_cursor(window_t *window, display_stock_cursor_t cursor)
+{
+        if (cursor != window->cursor) {
+                (void) display_window_set_cursor(window->dwindow, cursor);
+                window->cursor = cursor;
+        }
+}
 
 static void paint_internal(widget_t *widget)
@@ -258 +284 @@
 static void root_handle_position_event(widget_t *widget, pos_event_t event)
 {
+        gfx_coord2_t pos;
+
         if (widget->window->is_decorated) {
                 sysarg_t width = widget->width;
@@ -263 +291 @@
 
                 bool btn_left = (event.btn_num == 1) && (event.type == POS_PRESS);
-                bool btn_right = (event.btn_num == 2) && (event.type == POS_PRESS);
-                bool allowed_button = btn_left || btn_right;
 
                 bool left = (event.hpos < border_thickness);
@@ -270 +296 @@
                 bool top = (event.vpos < border_thickness);
                 bool bottom = (event.vpos >= height - border_thickness);
+                bool edge = left || right || top || bottom;
+
+                bool cleft = (event.hpos < corner_size);
+                bool cright = (event.hpos >= width - corner_size);
+                bool ctop = (event.vpos < corner_size);
+                bool cbottom = (event.vpos >= height - corner_size);
+
                 bool header = (event.hpos >= border_thickness) &&
                     (event.hpos < width - border_thickness) &&
@@ -277 +310 @@
                     (event.hpos >= width - border_thickness - close_thickness);
 
-                if (top && left && allowed_button) {
-                        window_grab_flags_t flags = GF_EMPTY;
-                        flags |= GF_MOVE_X;
-                        flags |= GF_MOVE_Y;
-                        flags |= btn_left ? GF_RESIZE_X : GF_SCALE_X;
-                        flags |= btn_left ? GF_RESIZE_Y : GF_SCALE_Y;
-                        win_grab(widget->window->osess, event.pos_id, flags);
-                } else if (bottom && left && allowed_button) {
-                        window_grab_flags_t flags = GF_EMPTY;
-                        flags |= GF_MOVE_X;
-                        flags |= btn_left ? GF_RESIZE_X : GF_SCALE_X;
-                        flags |= btn_left ? GF_RESIZE_Y : GF_SCALE_Y;
-                        win_grab(widget->window->osess, event.pos_id, flags);
-                } else if (bottom && right && allowed_button) {
-                        window_grab_flags_t flags = GF_EMPTY;
-                        flags |= btn_left ? GF_RESIZE_X : GF_SCALE_X;
-                        flags |= btn_left ? GF_RESIZE_Y : GF_SCALE_Y;
-                        win_grab(widget->window->osess, event.pos_id, flags);
-                } else if (top && right && allowed_button) {
-                        window_grab_flags_t flags = GF_EMPTY;
-                        flags |= GF_MOVE_Y;
-                        flags |= btn_left ? GF_RESIZE_X : GF_SCALE_X;
-                        flags |= btn_left ? GF_RESIZE_Y : GF_SCALE_Y;
-                        win_grab(widget->window->osess, event.pos_id, flags);
-                } else if (top && allowed_button) {
-                        window_grab_flags_t flags = GF_EMPTY;
-                        flags |= GF_MOVE_Y;
-                        flags |= btn_left ? GF_RESIZE_Y : GF_SCALE_Y;
-                        win_grab(widget->window->osess, event.pos_id, flags);
-                } else if (left && allowed_button) {
-                        window_grab_flags_t flags = GF_EMPTY;
-                        flags |= GF_MOVE_X;
-                        flags |= btn_left ? GF_RESIZE_X : GF_SCALE_X;
-                        win_grab(widget->window->osess, event.pos_id, flags);
-                } else if (bottom && allowed_button) {
-                        window_grab_flags_t flags = GF_EMPTY;
-                        flags |= btn_left ? GF_RESIZE_Y : GF_SCALE_Y;
-                        win_grab(widget->window->osess, event.pos_id, flags);
-                } else if (right && allowed_button) {
-                        window_grab_flags_t flags = GF_EMPTY;
-                        flags |= btn_left ? GF_RESIZE_X : GF_SCALE_X;
-                        win_grab(widget->window->osess, event.pos_id, flags);
+                bool isresize = widget->window->is_resizable;
+                display_wnd_rsztype_t rsztype = 0;
+
+                if (edge && ctop && cleft) {
+                        rsztype = display_wr_top_left;
+                } else if (edge && cbottom && cleft) {
+                        rsztype = display_wr_bottom_left;
+                } else if (edge && cbottom && cright) {
+                        rsztype = display_wr_bottom_right;
+                } else if (edge && ctop && cright) {
+                        rsztype = display_wr_top_right;
+                } else if (top) {
+                        rsztype = display_wr_top;
+                } else if (left) {
+                        rsztype = display_wr_left;
+                } else if (bottom) {
+                        rsztype = display_wr_bottom;
+                } else if (right) {
+                        rsztype = display_wr_right;
+                } else {
+                        isresize = false;
+                }
+
+                if (isresize) {
+                        (void) set_cursor(widget->window,
+                            display_cursor_from_wrsz(rsztype));
+                } else {
+                        (void) set_cursor(widget->window, dcurs_arrow);
+                }
+
+                pos.x = event.hpos;
+                pos.y = event.vpos;
+
+                if (isresize && btn_left) {
+                        (void) display_window_resize_req(
+                            widget->window->dwindow, rsztype, &pos);
                 } else if (close && btn_left) {
-                        win_close_request(widget->window->osess);
+                        window_close(widget->window);
                 } else if (header && btn_left) {
-                        window_grab_flags_t flags = GF_EMPTY;
-                        flags |= GF_MOVE_X;
-                        flags |= GF_MOVE_Y;
-                        win_grab(widget->window->osess, event.pos_id, flags);
+                        (void) display_window_move_req(widget->window->dwindow,
+                            &pos);
                 } else {
                         list_foreach(widget->children, link, widget_t, child) {
@@ -370 +395 @@
     sysarg_t width, sysarg_t height, window_placement_flags_t placement_flags)
 {
-        if (width < 2 * border_thickness + header_min_width) {
-                win_damage(win->osess, 0, 0, 0, 0);
-                return;
-        }
-
-        if (height < 2 * border_thickness + header_height) {
-                win_damage(win->osess, 0, 0, 0, 0);
-                return;
-        }
-
-        /* Allocate resources for new surface. */
-        surface_t *new_surface = surface_create(width, height, NULL,
+        gfx_bitmap_params_t params;
+        gfx_bitmap_alloc_t alloc;
+        gfx_bitmap_t *new_bitmap = NULL;
+        gfx_coord2_t offs;
+        gfx_coord2_t dpos;
+        display_info_t dinfo;
+        gfx_rect_t drect;
+        gfx_rect_t nrect;
+        errno_t rc;
+
+        if (width < 2 * border_thickness + header_min_width)
+                return;
+
+        if (height < 2 * border_thickness + header_height)
+                return;
+
+        fibril_mutex_lock(&win->guard);
+
+        /* Deallocate old bitmap. */
+        if (win->bitmap != NULL) {
+                gfx_bitmap_destroy(win->bitmap);
+                win->bitmap = NULL;
+        }
+
+        /* Deallocate old surface. */
+        if (win->surface != NULL) {
+                surface_destroy(win->surface);
+                win->surface = NULL;
+        }
+
+        /* Place window, if appropriate */
+        if (placement_flags != WINDOW_PLACEMENT_ANY) {
+                dpos.x = 0;
+                dpos.y = 0;
+
+                rc = display_get_info(win->display, &dinfo);
+                if (rc != EOK) {
+                        fibril_mutex_unlock(&win->guard);
+                        return;
+                }
+
+                drect = dinfo.rect;
+
+                if (placement_flags & WINDOW_PLACEMENT_LEFT)
+                        dpos.x = drect.p0.x;
+                else if (placement_flags & WINDOW_PLACEMENT_CENTER_X)
+                        dpos.x = (drect.p0.x + drect.p1.x - width) / 2;
+                else
+                        dpos.x = drect.p1.x - width;
+
+                if (placement_flags & WINDOW_PLACEMENT_TOP)
+                        dpos.y = drect.p0.y;
+                else if (placement_flags & WINDOW_PLACEMENT_CENTER_Y)
+                        dpos.y = (drect.p0.y + drect.p1.y - height) / 2;
+                else
+                        dpos.y = drect.p1.y - height;
+
+                (void) display_window_move(win->dwindow, &dpos);
+        }
+
+        /* Resize the display window. */
+        offs.x = offset_x;
+        offs.y = offset_y;
+        nrect.p0.x = 0;
+        nrect.p0.y = 0;
+        nrect.p1.x = width;
+        nrect.p1.y = height;
+
+        rc = display_window_resize(win->dwindow, &offs, &nrect);
+        if (rc != EOK) {
+                fibril_mutex_unlock(&win->guard);
+                return;
+        }
+
+        gfx_bitmap_params_init(&params);
+#ifndef CONFIG_WIN_DOUBLE_BUF
+        params.flags = bmpf_direct_output;
+#else
+        params.flags = 0;
+#endif
+        params.rect.p0.x = 0;
+        params.rect.p0.y = 0;
+        params.rect.p1.x = width;
+        params.rect.p1.y = height;
+
+        rc = gfx_bitmap_create(win->gc, &params, NULL, &new_bitmap);
+        if (rc != EOK) {
+                if (rc == ENOTSUP) {
+                        /* Direct output is not supported */
+                        params.flags &= ~bmpf_direct_output;
+                        rc = gfx_bitmap_create(win->gc, &params, NULL, &new_bitmap);
+                        if (rc != EOK) {
+                                fibril_mutex_unlock(&win->guard);
+                                return;
+                        }
+                }
+        }
+
+        rc = gfx_bitmap_get_alloc(new_bitmap, &alloc);
+        if (rc != EOK) {
+                fibril_mutex_unlock(&win->guard);
+                return;
+        }
+
+        /* Allocate new surface. */
+        surface_t *new_surface = surface_create(width, height, alloc.pixels,
             SURFACE_FLAG_SHARED);
-        if (!new_surface)
-                return;
-
-        /* Switch new and old surface. */
-        fibril_mutex_lock(&win->guard);
-        surface_t *old_surface = win->surface;
+        if (!new_surface) {
+                gfx_bitmap_destroy(new_bitmap);
+                fibril_mutex_unlock(&win->guard);
+                return;
+        }
+
+        /* Switch in new surface and bitmap. */
         win->surface = new_surface;
+        win->bitmap = new_bitmap;
         fibril_mutex_unlock(&win->guard);
 
@@ -402 +523 @@
         fibril_mutex_unlock(&win->guard);
 
-        /* Inform compositor about new surface. */
-        errno_t rc = win_resize(win->osess, offset_x, offset_y, width, height,
-            placement_flags, surface_direct_access(new_surface));
-
-        if (rc != EOK) {
-                /* Rollback to old surface. Reverse all changes. */
-
-                sysarg_t old_width = 0;
-                sysarg_t old_height = 0;
-                if (old_surface)
-                        surface_get_resolution(old_surface, &old_width, &old_height);
-
-                fibril_mutex_lock(&win->guard);
-                new_surface = win->surface;
-                win->surface = old_surface;
-                fibril_mutex_unlock(&win->guard);
-
-                win->root.rearrange(&win->root, 0, 0, old_width, old_height);
-
-                if (win->surface) {
-                        fibril_mutex_lock(&win->guard);
-                        surface_reset_damaged_region(win->surface);
-                        fibril_mutex_unlock(&win->guard);
-                }
-
-                surface_destroy(new_surface);
-        } else {
-                /* Deallocate old surface. */
-                if (old_surface)
-                        surface_destroy(old_surface);
-        }
+        (void) gfx_bitmap_render(win->bitmap, NULL, NULL);
 }
 
@@ -443 +534 @@
 {
         sysarg_t x, y, width, height;
+        gfx_rect_t rect;
         fibril_mutex_lock(&win->guard);
         surface_get_damaged_region(win->surface, &x, &y, &width, &height);
@@ -449 +541 @@
 
         if (width > 0 && height > 0) {
-                /* Notify compositor. */
-                win_damage(win->osess, x, y, width, height);
+                rect.p0.x = x;
+                rect.p0.y = y;
+                rect.p1.x = x + width;
+                rect.p1.y = y + height;
+
+                if (win->bitmap != NULL)
+                        (void) gfx_bitmap_render(win->bitmap, &rect, NULL);
         }
 }
@@ -472 +569 @@
         win->focus = NULL;
 
-        win_close(win->osess);
-        async_hangup(win->isess);
-        async_hangup(win->osess);
+        gfx_bitmap_destroy(win->bitmap);
+
+        /*
+         * XXX Here we should properly destroy the IPC GC. We only have
+         * the generic GC so either it would need to be cast back or
+         * GC needs a virtual destructor.
+         */
+
+        display_window_destroy(win->dwindow);
+        display_close(win->display);
 
         while (!list_empty(&win->events.list)) {
@@ -506 +610 @@
                         break;
                 case ET_POSITION_EVENT:
-                        if (!win->is_focused) {
-                                win->is_focused = true;
-                                handle_refresh(win);
-                        }
                         deliver_position_event(win, event->data.pos);
                         break;
@@ -559 +659 @@
 }
 
-/* Input fetcher from compositor. Runs in own dedicated fibril. */
-static errno_t fetch_input(void *arg)
-{
-        errno_t rc;
-        bool terminate = false;
-        window_t *win = (window_t *) arg;
-
-        while (true) {
-                window_event_t *event = (window_event_t *) malloc(sizeof(window_event_t));
-
-                if (event) {
-                        rc = win_get_event(win->isess, event);
-                        if (rc == EOK) {
-                                terminate = (event->type == ET_WINDOW_CLOSE);
-                                link_initialize(&event->link);
-                                prodcons_produce(&win->events, &event->link);
-                        } else {
-                                free(event);
-                                terminate = true;
-                        }
-                } else {
-                        terminate = true;
-                }
-
-                if (terminate) {
-                        break;
-                }
-        }
-
-        return 0;
-}
-
 window_t *window_open(const char *winreg, const void *data,
     window_flags_t flags, const char *caption)
 {
-        window_t *win = (window_t *) malloc(sizeof(window_t));
+        display_wnd_params_t wparams;
+
+        window_t *win = (window_t *) calloc(1, sizeof(window_t));
         if (!win)
                 return NULL;
@@ -600 +670 @@
         win->is_main = flags & WINDOW_MAIN;
         win->is_decorated = flags & WINDOW_DECORATED;
+        win->is_resizable = flags & WINDOW_RESIZEABLE;
         win->is_focused = true;
         prodcons_initialize(&win->events);
@@ -614 +685 @@
         win->grab = NULL;
         win->focus = NULL;
-        win->surface = NULL;
-
-        service_id_t reg_dsid;
-        errno_t rc = loc_service_get_id(winreg, &reg_dsid, 0);
-        if (rc != EOK) {
+        win->cursor = dcurs_arrow;
+
+        /* Allocate resources for new surface. */
+        win->surface = surface_create(window_initial_size,
+            window_initial_size, NULL, SURFACE_FLAG_SHARED);
+        if (win->surface == NULL) {
                 free(win);
                 return NULL;
         }
 
-        async_sess_t *reg_sess =
-            loc_service_connect(reg_dsid, INTERFACE_COMPOSITOR, 0);
-        if (reg_sess == NULL) {
+        errno_t rc = display_open(winreg, &win->display);
+        if (rc != EOK) {
+                surface_destroy(win->surface);
                 free(win);
                 return NULL;
         }
 
-        service_id_t in_dsid;
-        service_id_t out_dsid;
-        rc = win_register(reg_sess, flags, &in_dsid, &out_dsid);
-        async_hangup(reg_sess);
+        /* Window dimensions are not know at this time */
+        display_wnd_params_init(&wparams);
+        wparams.rect.p0.x = 0;
+        wparams.rect.p0.y = 0;
+        wparams.rect.p1.x = window_initial_size;
+        wparams.rect.p1.y = window_initial_size;
+        wparams.min_size.x = 2 * border_thickness + header_min_width;
+        wparams.min_size.y = 2 * border_thickness + header_height;
+
+        rc = display_window_create(win->display, &wparams, &window_cb,
+            (void *) win, &win->dwindow);
         if (rc != EOK) {
+                display_close(win->display);
+                surface_destroy(win->surface);
                 free(win);
                 return NULL;
         }
 
-        win->osess = loc_service_connect(out_dsid, INTERFACE_COMPOSITOR, 0);
-        if (win->osess == NULL) {
-                free(win);
-                return NULL;
-        }
-
-        win->isess = loc_service_connect(in_dsid, INTERFACE_COMPOSITOR, 0);
-        if (win->isess == NULL) {
-                async_hangup(win->osess);
+        rc = display_window_get_gc(win->dwindow, &win->gc);
+        if (rc != EOK) {
+                display_window_destroy(win->dwindow);
+                display_close(win->display);
+                surface_destroy(win->surface);
                 free(win);
                 return NULL;
@@ -724 +801 @@
 {
         fid_t ev_fid = fibril_create(event_loop, win);
-        fid_t fi_fid = fibril_create(fetch_input, win);
-        if (!ev_fid || !fi_fid) {
+        if (!ev_fid) {
                 return;
         }
         fibril_add_ready(ev_fid);
-        fibril_add_ready(fi_fid);
 }
 
@@ -745 +820 @@
 void window_close(window_t *win)
 {
-        /* Request compositor to init closing cascade. */
-        win_close_request(win->osess);
+        window_event_t *event;
+
+        event = (window_event_t *) calloc(1, sizeof(window_event_t));
+        if (event == NULL)
+                return;
+
+        link_initialize(&event->link);
+        event->type = ET_WINDOW_CLOSE;
+        prodcons_produce(&win->events, &event->link);
+}
+
+static void window_close_event(void *arg)
+{
+        window_t *win = (window_t *) arg;
+
+        window_close(win);
+}
+
+static void window_focus_event(void *arg)
+{
+        window_t *win = (window_t *) arg;
+        window_event_t *event;
+
+        event = (window_event_t *) calloc(1, sizeof(window_event_t));
+        if (event == NULL)
+                return;
+
+        link_initialize(&event->link);
+        event->type = ET_WINDOW_FOCUS;
+        prodcons_produce(&win->events, &event->link);
+}
+
+static void window_kbd_event(void *arg, kbd_event_t *kevent)
+{
+        window_t *win = (window_t *) arg;
+        window_event_t *event;
+
+        event = (window_event_t *) calloc(1, sizeof(window_event_t));
+        if (event == NULL)
+                return;
+
+        link_initialize(&event->link);
+        event->type = ET_KEYBOARD_EVENT;
+        event->data.kbd = *kevent;
+        prodcons_produce(&win->events, &event->link);
+}
+
+static void window_pos_event(void *arg, pos_event_t *pevent)
+{
+        window_t *win = (window_t *) arg;
+        window_event_t *event;
+
+        event = (window_event_t *) calloc(1, sizeof(window_event_t));
+        if (event == NULL)
+                return;
+
+        link_initialize(&event->link);
+        event->type = ET_POSITION_EVENT;
+        event->data.pos = *pevent;
+        prodcons_produce(&win->events, &event->link);
+}
+
+static void window_resize_event(void *arg, gfx_rect_t *nrect)
+{
+        window_t *win = (window_t *) arg;
+        window_event_t *event;
+
+        if (!win->is_resizable)
+                return;
+
+        event = (window_event_t *) calloc(1, sizeof(window_event_t));
+        if (event == NULL)
+                return;
+
+        link_initialize(&event->link);
+        event->type = ET_WINDOW_RESIZE;
+        event->data.resize.offset_x = nrect->p0.x;
+        event->data.resize.offset_y = nrect->p0.y;
+        event->data.resize.width = nrect->p1.x - nrect->p0.x;
+        event->data.resize.height = nrect->p1.y - nrect->p0.y;
+        event->data.resize.placement_flags = WINDOW_PLACEMENT_ANY;
+        prodcons_produce(&win->events, &event->link);
+}
+
+static void window_unfocus_event(void *arg)
+{
+        window_t *win = (window_t *) arg;
+        window_event_t *event;
+
+        event = (window_event_t *) calloc(1, sizeof(window_event_t));
+        if (event == NULL)
+                return;
+
+        link_initialize(&event->link);
+        event->type = ET_WINDOW_UNFOCUS;
+        prodcons_produce(&win->events, &event->link);
 }
 

uspace/lib/gui/window.h

@@ -37 +37 @@
 #define GUI_WINDOW_H_
 
-#include <async.h>
 #include <adt/prodcons.h>
 #include <fibril_synch.h>
@@ -43 +42 @@
 #include <io/window.h>
 #include <draw/surface.h>
+#include <display.h>
+#include <gfx/bitmap.h>
+#include <gfx/context.h>
 
 #include "widget.h"
@@ -50 +52 @@
         bool is_decorated; /**< True if the window decorations should be rendered. */
         bool is_focused; /**< True for the top level window of the desktop. */
+        bool is_resizable; /**< True if window is resizable */
         char *caption; /**< Text title of the window header. */
-        async_sess_t *isess; /**< Input events from compositor. */
-        async_sess_t *osess; /**< Mainly for damage reporting to compositor. */
+        display_t *display; /**< Display service */
+        display_window_t *dwindow; /**< Display window */
+        gfx_context_t *gc; /**< GC of the window */
         prodcons_t events; /**< Queue for window event loop. */
         widget_t root; /**< Decoration widget serving as a root of widget hiearchy. */
@@ -58 +62 @@
         widget_t *focus; /**< Widget owning the keyboard or NULL. */
         fibril_mutex_t guard; /**< Mutex guarding window surface. */
-        surface_t *surface; /**< Window surface shared with compositor. */
+        surface_t *surface; /**< Window surface shared with display server. */
+        gfx_bitmap_t *bitmap; /**< Window bitmap */
+        display_stock_cursor_t cursor; /**< Selected cursor */
 };
 
 /**
- * Allocate all resources for new window and register it in the compositor.
+ * Allocate all resources for new window and register it in the display server.
  * If the window is declared as main, its closure causes termination of the
  * whole application. Note that opened window does not have any surface yet.
@@ -71 +77 @@
 /**
  * Post resize event into event loop. Window negotiates new surface with
- * compositor and asks all widgets in the tree to calculate their new properties
- * and to paint themselves on the new surface (top-bottom order). Should be
- * called also after opening new window to obtain surface.
+ * display server and asks all widgets in the tree to calculate their new
+ * properties and to paint themselves on the new surface (top-bottom order).
+ * Should be called also after opening new window to obtain surface.
  */
 extern void window_resize(window_t *, sysarg_t, sysarg_t, sysarg_t, sysarg_t,
@@ -90 +96 @@
 
 /**
- * Post damage event into event loop. Handler informs compositor to update the
- * window surface on the screen. Should be called by widget after painting
+ * Post damage event into event loop. Handler informs display server to update
+ * the window surface on the screen. Should be called by widget after painting
  * itself or copying its buffer onto window surface.
  */
@@ -120 +126 @@
 
 /**
- * Initiate the closing cascade for the window. First, compositor deallocates
+ * Initiate the closing cascade for the window. First, display sever deallocates
  * output resources, prepares special closing input event for the window and
  * deallocates input resources after the event is dispatched. When window

uspace/lib/guigfx/meson.build

@@ -1 +1 @@
 #
-# Copyright (c) 2012 Petr Koupy
+# Copyright (c) 2019 Jiri Svoboda
 # All rights reserved.
 #
@@ -27 +27 @@
 #
 
-deps = [ 'draw', 'softrend', 'drv', 'compress', 'math' ]
-src = files('compositor.c')
+deps = [ 'gui', 'gfx', 'memgfx' ]
+src = files(
+        'src/canvas.c'
+)

uspace/lib/meson.build

@@ -33 +33 @@
         'c',
         'math',
+        'display',
         'gui',
         'draw',
@@ -39 +40 @@
         'clui',
         'pcm',
-        'hound'
+        'hound',
+        'gfx',
+        'ipcgfx',
+        'display',
 ]
 
@@ -55 +59 @@
         'fmtutil',
         'fs',
-        'graph',
+        'gfx',
         'http',
         'label',
@@ -72 +76 @@
 
         'bithenge',
+        'congfx',
         'draw',
         'drv',
         'ext4',
-        'gui',
         'hound',
+        'ipcgfx',
+        'memgfx',
         'nic',
         'usb',
@@ -86 +92 @@
 
         'ieee80211',
+        'ddev',
+        'display',
+
+        'gui',
+
+        'guigfx',
 ]