Changeset 913add60 in mainline

Timestamp:

2022-10-31T10:53:53Z (19 months ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

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

Children:

1b92d4b

Parents:

7cc30e9

git-author:

Jiri Svoboda <jiri@…> (2022-10-30 10:53:48)

git-committer:

Jiri Svoboda <jiri@…> (2022-10-31 10:53:53)

Message:

Deliver WM events for windows being added and removed

Location:

uspace

Files:

• app/taskbar/taskbar.c (modified) (3 diffs)
• srv/hid/display/client.c (modified) (1 diff)
• srv/hid/display/display.c (modified) (7 diffs)
• srv/hid/display/display.h (modified) (3 diffs)
• srv/hid/display/main.c (modified) (5 diffs)
• srv/hid/display/meson.build (modified) (3 diffs)
• srv/hid/display/test/display.c (modified) (6 diffs)
• srv/hid/display/test/main.c (modified) (1 diff)
• srv/hid/display/test/window.c (modified) (1 diff)
• srv/hid/display/test/wmclient.c (added)
• srv/hid/display/types/display/display.h (modified) (1 diff)
• srv/hid/display/types/display/wmclient.h (added)
• srv/hid/display/window.c (modified) (1 diff)
• srv/hid/display/wmclient.c (added)
• srv/hid/display/wmclient.h (added)
• srv/hid/display/wmops.c (modified) (9 diffs)

uspace/app/taskbar/taskbar.c

@@ -53 +53 @@
 };
 
+static void taskbar_wm_window_added(void *, sysarg_t);
+static void taskbar_wm_window_removed(void *, sysarg_t);
+
+static wndmgt_cb_t taskbar_wndmgt_cb = {
+        .window_added = taskbar_wm_window_added,
+        .window_removed = taskbar_wm_window_removed
+};
+
 /** Window close button was clicked.
  *
@@ -89 +97 @@
 
         if (wndmgt_svc != NULL) {
-                rc = wndmgt_open(wndmgt_svc, NULL, NULL, &taskbar->wndmgt);
+                rc = wndmgt_open(wndmgt_svc, &taskbar_wndmgt_cb,
+                    (void *)taskbar, &taskbar->wndmgt);
                 if (rc != EOK)
                         goto error;
@@ -241 +250 @@
 }
 
+/** Handle WM window added event.
+ *
+ * @param arg Argument (taskbar_t *)
+ * @param wnd_id Window ID
+ */
+static void taskbar_wm_window_added(void *arg, sysarg_t wnd_id)
+{
+        taskbar_t *taskbar = (taskbar_t *)arg;
+
+        printf("wm_window_added: taskbar=%p wnd_id=%zu\n",
+            (void *)taskbar, wnd_id);
+}
+
+/** Handle WM window removed event.
+ *
+ * @param arg Argument (taskbar_t *)
+ * @param wnd_id Window ID
+ */
+static void taskbar_wm_window_removed(void *arg, sysarg_t wnd_id)
+{
+        taskbar_t *taskbar = (taskbar_t *)arg;
+
+        printf("wm_window_removed: taskbar=%p wnd_id=%zu\n",
+            (void *)taskbar, wnd_id);
+}
+
 /** @}
  */

uspace/srv/hid/display/client.c

@@ -181 +181 @@
  * @param ewindow Place to store pointer to window receiving the event
  * @param event Place to store event
- * @return Graphic context
+ * @return EOK on success, ENOENT if event queue is empty
  */
 errno_t ds_client_get_event(ds_client_t *client, ds_window_t **ewindow,

uspace/srv/hid/display/display.c

@@ -45 +45 @@
 #include "cursimg.h"
 #include "cursor.h"
+#include "display.h"
 #include "seat.h"
 #include "window.h"
-#include "display.h"
+#include "wmclient.h"
 
 static gfx_context_t *ds_display_get_unbuf_gc(ds_display_t *);
@@ -96 +97 @@
         fibril_mutex_initialize(&disp->lock);
         list_initialize(&disp->clients);
+        list_initialize(&disp->wmclients);
         disp->next_wnd_id = 1;
         list_initialize(&disp->ddevs);
@@ -115 +117 @@
 {
         assert(list_empty(&disp->clients));
+        assert(list_empty(&disp->wmclients));
         assert(list_empty(&disp->seats));
         /* XXX destroy cursors */
@@ -203 +206 @@
 
         return list_get_instance(link, ds_client_t, lclients);
+}
+
+/** Add WM client to display.
+ *
+ * @param disp Display
+ * @param wmclient WM client
+ */
+void ds_display_add_wmclient(ds_display_t *disp, ds_wmclient_t *wmclient)
+{
+        assert(wmclient->display == NULL);
+        assert(!link_used(&wmclient->lwmclients));
+
+        wmclient->display = disp;
+        list_append(&wmclient->lwmclients, &disp->wmclients);
+}
+
+/** Remove WM client from display.
+ *
+ * @param wmclient WM client
+ */
+void ds_display_remove_wmclient(ds_wmclient_t *wmclient)
+{
+        list_remove(&wmclient->lwmclients);
+        wmclient->display = NULL;
+}
+
+/** Get first WM client in display.
+ *
+ * @param disp Display
+ * @return First WM client or @c NULL if there is none
+ */
+ds_wmclient_t *ds_display_first_wmclient(ds_display_t *disp)
+{
+        link_t *link = list_first(&disp->wmclients);
+
+        if (link == NULL)
+                return NULL;
+
+        return list_get_instance(link, ds_wmclient_t, lwmclients);
+}
+
+/** Get next WM client in display.
+ *
+ * @param wmclient Current WM client
+ * @return Next WM client or @c NULL if there is none
+ */
+ds_wmclient_t *ds_display_next_wmclient(ds_wmclient_t *wmclient)
+{
+        link_t *link = list_next(&wmclient->lwmclients,
+            &wmclient->display->wmclients);
+
+        if (link == NULL)
+                return NULL;
+
+        return list_get_instance(link, ds_wmclient_t, lwmclients);
 }
 
@@ -262 +320 @@
 void ds_display_add_window(ds_display_t *display, ds_window_t *wnd)
 {
+        ds_wmclient_t *wmclient;
+
         assert(wnd->display == NULL);
         assert(!link_used(&wnd->ldwindows));
@@ -267 +327 @@
         wnd->display = display;
         list_prepend(&wnd->ldwindows, &display->windows);
+
+        /* Notify window managers about the new window */
+        wmclient = ds_display_first_wmclient(display);
+        while (wmclient != NULL) {
+                ds_wmclient_post_wnd_added_event(wmclient, wnd->id);
+                wmclient = ds_display_next_wmclient(wmclient);
+        }
 }
 
@@ -275 +342 @@
 void ds_display_remove_window(ds_window_t *wnd)
 {
+        ds_wmclient_t *wmclient;
+        ds_display_t *display;
+
+        display = wnd->display;
+
         list_remove(&wnd->ldwindows);
         wnd->display = NULL;
+
+        /* Notify window managers about the removed window */
+        wmclient = ds_display_first_wmclient(display);
+        while (wmclient != NULL) {
+                ds_wmclient_post_wnd_removed_event(wmclient, wnd->id);
+                wmclient = ds_display_next_wmclient(wmclient);
+        }
+}
+
+/** Move window to top.
+ *
+ * @param display Display
+ * @param wnd Window
+ */
+void ds_display_window_to_top(ds_window_t *wnd)
+{
+        assert(wnd->display != NULL);
+        assert(link_used(&wnd->ldwindows));
+
+        list_remove(&wnd->ldwindows);
+        list_prepend(&wnd->ldwindows, &wnd->display->windows);
 }
 

uspace/srv/hid/display/display.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2019 Jiri Svoboda
+ * Copyright (c) 2022 Jiri Svoboda
  * All rights reserved.
  *
@@ -48 +48 @@
 #include "types/display/ptd_event.h"
 #include "types/display/seat.h"
+#include "types/display/wmclient.h"
 
 extern errno_t ds_display_create(gfx_context_t *, ds_display_flags_t,
@@ -59 +60 @@
 extern ds_client_t *ds_display_first_client(ds_display_t *);
 extern ds_client_t *ds_display_next_client(ds_client_t *);
+extern void ds_display_add_wmclient(ds_display_t *, ds_wmclient_t *);
+extern void ds_display_remove_wmclient(ds_wmclient_t *);
+extern ds_wmclient_t *ds_display_first_wmclient(ds_display_t *);
+extern ds_wmclient_t *ds_display_next_wmclient(ds_wmclient_t *);
 extern ds_window_t *ds_display_find_window(ds_display_t *, ds_wnd_id_t);
 extern ds_window_t *ds_display_window_by_pos(ds_display_t *, gfx_coord2_t *);
 extern void ds_display_add_window(ds_display_t *, ds_window_t *);
 extern void ds_display_remove_window(ds_window_t *);
+extern void ds_display_window_to_top(ds_window_t *);
 extern ds_window_t *ds_display_first_window(ds_display_t *);
 extern ds_window_t *ds_display_last_window(ds_display_t *);

uspace/srv/hid/display/main.c

@@ -56 +56 @@
 #include "seat.h"
 #include "window.h"
+#include "wmclient.h"
 #include "wmops.h"
 
 static void display_client_conn(ipc_call_t *, void *);
 static void display_client_ev_pending(void *);
+static void display_wmclient_ev_pending(void *);
 static void display_gc_conn(ipc_call_t *, void *);
 static void display_wndmgt_conn(ipc_call_t *, void *);
@@ -80 +82 @@
 };
 
+static ds_wmclient_cb_t display_wmclient_cb = {
+        .ev_pending = display_wmclient_ev_pending
+};
+
 static void display_client_ev_pending(void *arg)
 {
@@ -85 +91 @@
 
         display_srv_ev_pending(srv);
+}
+
+static void display_wmclient_ev_pending(void *arg)
+{
+        wndmgt_srv_t *srv = (wndmgt_srv_t *) arg;
+
+        wndmgt_srv_ev_pending(srv);
 }
 
@@ -189 +202 @@
         if (svc_id != 0) {
                 /* Create client object */
+                ds_display_lock(disp);
                 rc = ds_client_create(disp, &display_client_cb, &srv, &client);
+                ds_display_unlock(disp);
                 if (rc != EOK) {
                         async_answer_0(icall, ENOMEM);
@@ -243 +258 @@
 {
         ds_display_t *disp = (ds_display_t *) arg;
+        errno_t rc;
         wndmgt_srv_t srv;
+        ds_wmclient_t *wmclient = NULL;
+
+        /* Create WM client object */
+        ds_display_lock(disp);
+        rc = ds_wmclient_create(disp, &display_wmclient_cb, &srv, &wmclient);
+        ds_display_unlock(disp);
+        if (rc != EOK) {
+                async_answer_0(icall, ENOMEM);
+                return;
+        }
 
         /* Set up protocol structure */
         wndmgt_srv_initialize(&srv);
         srv.ops = &wndmgt_srv_ops;
-        srv.arg = disp;
+        srv.arg = wmclient;
 
         /* Handle connection */
         wndmgt_conn(icall, &srv);
+
+        ds_display_lock(disp);
+        ds_wmclient_destroy(wmclient);
+        ds_display_unlock(disp);
 }
 

uspace/srv/hid/display/meson.build

@@ -42 +42 @@
         'seat.c',
         'window.c',
+        'wmclient.c',
         'wmops.c',
 )
@@ -54 +55 @@
         'seat.c',
         'window.c',
+        'wmclient.c',
         'test/client.c',
         'test/clonegc.c',
@@ -61 +63 @@
         'test/seat.c',
         'test/window.c',
+        'test/wmclient.c',
 )

uspace/srv/hid/display/test/display.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2019 Jiri Svoboda
+ * Copyright (c) 2022 Jiri Svoboda
  * All rights reserved.
  *
@@ -36 +36 @@
 #include "../seat.h"
 #include "../window.h"
+#include "../wmclient.h"
 
 PCUT_INIT;
@@ -47 +48 @@
 };
 
+static void test_ds_wmev_pending(void *);
+
+static ds_wmclient_cb_t test_ds_wmclient_cb = {
+        .ev_pending = test_ds_wmev_pending
+};
+
 static void test_ds_ev_pending(void *arg)
 {
@@ -53 +60 @@
 }
 
+static void test_ds_wmev_pending(void *arg)
+{
+        bool *called_cb = (bool *) arg;
+        *called_cb = true;
+}
+
 /** Display creation and destruction. */
 PCUT_TEST(display_create_destroy)
@@ -86 +99 @@
 
         ds_client_destroy(client);
+        ds_display_destroy(disp);
+}
+
+/** Basic WM client operation. */
+PCUT_TEST(display_wmclient)
+{
+        ds_display_t *disp;
+        ds_wmclient_t *wmclient;
+        ds_wmclient_t *c0, *c1;
+        errno_t rc;
+
+        rc = ds_display_create(NULL, df_none, &disp);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+
+        rc = ds_wmclient_create(disp, &test_ds_wmclient_cb, NULL, &wmclient);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+
+        c0 = ds_display_first_wmclient(disp);
+        PCUT_ASSERT_EQUALS(c0, wmclient);
+
+        c1 = ds_display_next_wmclient(c0);
+        PCUT_ASSERT_NULL(c1);
+
+        ds_wmclient_destroy(wmclient);
         ds_display_destroy(disp);
 }
@@ -150 +187 @@
         wnd = ds_display_find_window(disp, w0->id + 1);
         PCUT_ASSERT_NULL(wnd);
+
+        ds_window_destroy(w0);
+        ds_window_destroy(w1);
+        ds_seat_destroy(seat);
+        ds_client_destroy(client);
+        ds_display_destroy(disp);
+}
+
+/** Test ds_display_window_to_top() */
+PCUT_TEST(display_window_to_top)
+{
+        ds_display_t *disp;
+        ds_client_t *client;
+        ds_seat_t *seat;
+        ds_window_t *w0;
+        ds_window_t *w1;
+        display_wnd_params_t params;
+        bool called_cb = false;
+        errno_t rc;
+
+        rc = ds_display_create(NULL, df_none, &disp);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+
+        rc = ds_client_create(disp, &test_ds_client_cb, &called_cb, &client);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+
+        rc = ds_seat_create(disp, &seat);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+
+        display_wnd_params_init(&params);
+        params.rect.p0.x = params.rect.p0.y = 0;
+        params.rect.p1.x = params.rect.p1.y = 100;
+
+        rc = ds_window_create(client, &params, &w0);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+
+        rc = ds_window_create(client, &params, &w1);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+
+        PCUT_ASSERT_EQUALS(w1, ds_display_first_window(disp));
+        ds_display_window_to_top(w0);
+        PCUT_ASSERT_EQUALS(w0, ds_display_first_window(disp));
 
         ds_window_destroy(w0);

uspace/srv/hid/display/test/main.c

@@ -37 +37 @@
 PCUT_IMPORT(seat);
 PCUT_IMPORT(window);
+PCUT_IMPORT(wmclient);
 
 PCUT_MAIN();

uspace/srv/hid/display/test/window.c

@@ -51 +51 @@
 };
 
+/** Test creating and destroying window */
+PCUT_TEST(create_destroy)
+{
+        ds_display_t *disp;
+        ds_client_t *client;
+        ds_seat_t *seat;
+        ds_window_t *wnd;
+        display_wnd_params_t params;
+        errno_t rc;
+
+        rc = ds_display_create(NULL, df_none, &disp);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+
+        rc = ds_client_create(disp, NULL, NULL, &client);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+
+        rc = ds_seat_create(disp, &seat);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+
+        display_wnd_params_init(&params);
+        params.rect.p0.x = params.rect.p0.y = 0;
+        params.rect.p1.x = params.rect.p1.y = 10;
+
+        rc = ds_window_create(client, &params, &wnd);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+
+        ds_window_destroy(wnd);
+        ds_seat_destroy(seat);
+        ds_client_destroy(client);
+        ds_display_destroy(disp);
+}
+
+/** Test ds_window_bring_to_top() brings window to top */
+PCUT_TEST(bring_to_top)
+{
+        ds_display_t *disp;
+        ds_client_t *client;
+        ds_seat_t *seat;
+        ds_window_t *w1;
+        ds_window_t *w2;
+        display_wnd_params_t params;
+        errno_t rc;
+
+        rc = ds_display_create(NULL, df_none, &disp);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+
+        rc = ds_client_create(disp, NULL, NULL, &client);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+
+        rc = ds_seat_create(disp, &seat);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+
+        display_wnd_params_init(&params);
+        params.rect.p0.x = params.rect.p0.y = 0;
+        params.rect.p1.x = params.rect.p1.y = 10;
+
+        rc = ds_window_create(client, &params, &w1);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+
+        rc = ds_window_create(client, &params, &w2);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+
+        /* w2 should be on the top */
+        PCUT_ASSERT_EQUALS(w2, ds_display_first_window(disp));
+
+        /* Bring w1 to top */
+        ds_window_bring_to_top(w1);
+
+        /* Now w1 should be on the top */
+        PCUT_ASSERT_EQUALS(w1, ds_display_first_window(disp));
+
+        ds_window_destroy(w1);
+        ds_window_destroy(w2);
+        ds_seat_destroy(seat);
+        ds_client_destroy(client);
+        ds_display_destroy(disp);
+}
+
 /** Test ds_window_resize(). */
 PCUT_TEST(window_resize)

uspace/srv/hid/display/types/display/display.h

@@ -62 +62 @@
         /** Clients (of ds_client_t) */
         list_t clients;
+        /** WM clients (of ds_wmclient_t) */
+        list_t wmclients;
 
         /** Next ID to assign to a window.

uspace/srv/hid/display/window.c

@@ -197 +197 @@
 void ds_window_bring_to_top(ds_window_t *wnd)
 {
-        ds_display_t *disp = wnd->display;
-
-        ds_display_remove_window(wnd);
-        ds_display_add_window(disp, wnd);
+        ds_display_window_to_top(wnd);
         (void) ds_display_paint(wnd->display, NULL);
 }

uspace/srv/hid/display/wmops.c

@@ -40 +40 @@
 #include <wndmgt_srv.h>
 #include "display.h"
+#include "wmclient.h"
 
 static errno_t dispwm_get_window_list(void *, wndmgt_window_list_t **);
@@ -55 +56 @@
 };
 
+/** Get window list.
+ *
+ * @param arg Argument (WM client)
+ * @param rlist Place to store pointer to new list
+ * @return EOK on success or an error code
+ */
 static errno_t dispwm_get_window_list(void *arg, wndmgt_window_list_t **rlist)
 {
+        ds_wmclient_t *wmclient = (ds_wmclient_t *)arg;
         wndmgt_window_list_t *list;
-        ds_display_t *disp = (ds_display_t *)arg;
         ds_window_t *wnd;
         unsigned i;
@@ -68 +75 @@
                 return ENOMEM;
 
+        ds_display_lock(wmclient->display);
+
         /* Count the number of windows */
         list->nwindows = 0;
-        wnd = ds_display_first_window(disp);
+        wnd = ds_display_first_window(wmclient->display);
         while (wnd != NULL) {
                 ++list->nwindows;
@@ -79 +88 @@
         list->windows = calloc(list->nwindows, sizeof(sysarg_t));
         if (list->windows == NULL) {
+                ds_display_unlock(wmclient->display);
                 free(list);
                 return ENOMEM;
@@ -85 +95 @@
         /* Fill in window IDs */
         i = 0;
-        wnd = ds_display_first_window(disp);
+        wnd = ds_display_first_window(wmclient->display);
         while (wnd != NULL) {
                 list->windows[i++] = wnd->id;
@@ -91 +101 @@
         }
 
+        ds_display_unlock(wmclient->display);
         *rlist = list;
         return EOK;
 }
 
+/** Get window information.
+ *
+ * @param arg Argument (WM client)
+ * @param wnd_id Window ID
+ * @param rinfo Place to store pointer to new window information structure
+ * @return EOK on success or an error code
+ */
 static errno_t dispwm_get_window_info(void *arg, sysarg_t wnd_id,
     wndmgt_window_info_t **rinfo)
 {
-        ds_display_t *disp = (ds_display_t *)arg;
+        ds_wmclient_t *wmclient = (ds_wmclient_t *)arg;
         ds_window_t *wnd;
         wndmgt_window_info_t *info;
@@ -104 +122 @@
         log_msg(LOG_DEFAULT, LVL_DEBUG, "dispwm_get_window_info()");
 
-        wnd = ds_display_find_window(disp, wnd_id);
-        if (wnd == NULL)
+        ds_display_lock(wmclient->display);
+        wnd = ds_display_find_window(wmclient->display, wnd_id);
+        if (wnd == NULL) {
+                ds_display_unlock(wmclient->display);
                 return ENOENT;
+        }
 
         info = calloc(1, sizeof(wndmgt_window_info_t));
-        if (info == NULL)
+        if (info == NULL) {
+                ds_display_unlock(wmclient->display);
                 return ENOMEM;
+        }
 
         info->caption = str_dup(wnd->caption);
         if (info->caption == NULL) {
+                ds_display_unlock(wmclient->display);
                 free(info);
                 return ENOMEM;
         }
 
+        ds_display_unlock(wmclient->display);
         *rinfo = info;
         return EOK;
 }
 
+/** Activate window.
+ *
+ * @param arg Argument (WM client)
+ * @param wnd_id Window ID
+ * @return EOK on success or an error code
+ */
 static errno_t dispwm_activate_window(void *arg, sysarg_t wnd_id)
 {
@@ -130 +161 @@
 }
 
+/** Close window.
+ *
+ * @param arg Argument (WM client)
+ * @param wnd_id Window ID
+ * @return EOK on success or an error code
+ */
 static errno_t dispwm_close_window(void *arg, sysarg_t wnd_id)
 {
@@ -138 +175 @@
 }
 
+/** Get window management event.
+ *
+ * @param arg Argument (WM client)
+ * @param ev Place to store event
+ * @return EOK on success, ENOENT if there are no events
+ */
 static errno_t dispwm_get_event(void *arg, wndmgt_ev_t *ev)
 {
-        return ENOTSUP;
+        ds_wmclient_t *wmclient = (ds_wmclient_t *)arg;
+        errno_t rc;
+
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "dispwm_get_event()");
+
+        ds_display_lock(wmclient->display);
+        rc = ds_wmclient_get_event(wmclient, ev);
+        ds_display_unlock(wmclient->display);
+        return rc;
 }