Changes in uspace/srv/hid/display/display.c [1215db9:e90019d] in mainline

File:

• uspace/srv/hid/display/display.c (modified) (18 diffs)

uspace/srv/hid/display/display.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2021 Jiri Svoboda
+ * Copyright (c) 2024 Jiri Svoboda
  * All rights reserved.
  *
@@ -41 +41 @@
 #include <memgfx/memgc.h>
 #include <stdlib.h>
+#include <str.h>
 #include "client.h"
 #include "clonegc.h"
 #include "cursimg.h"
 #include "cursor.h"
+#include "display.h"
+#include "idevcfg.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 +99 @@
         fibril_mutex_initialize(&disp->lock);
         list_initialize(&disp->clients);
+        list_initialize(&disp->wmclients);
+        list_initialize(&disp->cfgclients);
         disp->next_wnd_id = 1;
+        disp->next_seat_id = 1;
         list_initialize(&disp->ddevs);
+        list_initialize(&disp->idevcfgs);
         list_initialize(&disp->seats);
         list_initialize(&disp->windows);
@@ -114 +121 @@
 void ds_display_destroy(ds_display_t *disp)
 {
+        int i;
+
         assert(list_empty(&disp->clients));
+        assert(list_empty(&disp->wmclients));
+        assert(list_empty(&disp->cfgclients));
         assert(list_empty(&disp->seats));
-        /* XXX destroy cursors */
+        assert(list_empty(&disp->ddevs));
+        assert(list_empty(&disp->idevcfgs));
+        assert(list_empty(&disp->seats));
+        assert(list_empty(&disp->windows));
+
+        /* Destroy cursors */
+        for (i = 0; i < dcurs_limit; i++) {
+                ds_cursor_destroy(disp->cursor[i]);
+                disp->cursor[i] = NULL;
+        }
+
         gfx_color_delete(disp->bg_color);
         free(disp);
 }
 
+/** Load display configuration from SIF file.
+ *
+ * @param display Display
+ * @param cfgpath Configuration file path
+ *
+ * @return EOK on success or an error code
+ */
+errno_t ds_display_load_cfg(ds_display_t *display, const char *cfgpath)
+{
+        sif_doc_t *doc = NULL;
+        sif_node_t *rnode;
+        sif_node_t *ndisplay;
+        sif_node_t *nseats;
+        sif_node_t *nseat;
+        ds_seat_t *seat;
+        sif_node_t *nidevcfgs;
+        sif_node_t *nidevcfg;
+        const char *ntype;
+        ds_idevcfg_t *idevcfg;
+        errno_t rc;
+
+        rc = sif_load(cfgpath, &doc);
+        if (rc != EOK)
+                goto error;
+
+        rnode = sif_get_root(doc);
+        ndisplay = sif_node_first_child(rnode);
+        ntype = sif_node_get_type(ndisplay);
+        if (str_cmp(ntype, "display") != 0) {
+                rc = EIO;
+                goto error;
+        }
+
+        nseats = sif_node_first_child(ndisplay);
+        ntype = sif_node_get_type(nseats);
+        if (str_cmp(ntype, "seats") != 0) {
+                rc = EIO;
+                goto error;
+        }
+
+        /* Load individual seats */
+        nseat = sif_node_first_child(nseats);
+        while (nseat != NULL) {
+                ntype = sif_node_get_type(nseat);
+                if (str_cmp(ntype, "seat") != 0) {
+                        rc = EIO;
+                        goto error;
+                }
+
+                rc = ds_seat_load(display, nseat, &seat);
+                if (rc != EOK)
+                        goto error;
+
+                (void)seat;
+                nseat = sif_node_next_child(nseat);
+        }
+
+        nidevcfgs = sif_node_next_child(nseats);
+        ntype = sif_node_get_type(nidevcfgs);
+        if (str_cmp(ntype, "idevcfgs") != 0) {
+                rc = EIO;
+                goto error;
+        }
+
+        /* Load individual input device configuration entries */
+        nidevcfg = sif_node_first_child(nidevcfgs);
+        while (nidevcfg != NULL) {
+                ntype = sif_node_get_type(nidevcfg);
+                if (str_cmp(ntype, "idevcfg") != 0) {
+                        rc = EIO;
+                        goto error;
+                }
+
+                /*
+                 * Load device configuration entry. If the device
+                 * is not currently connected (ENOENT), skip it.
+                 */
+                rc = ds_idevcfg_load(display, nidevcfg, &idevcfg);
+                if (rc != EOK && rc != ENOENT)
+                        goto error;
+
+                (void)idevcfg;
+                nidevcfg = sif_node_next_child(nidevcfg);
+        }
+
+        sif_delete(doc);
+        return EOK;
+error:
+        if (doc != NULL)
+                sif_delete(doc);
+
+        seat = ds_display_first_seat(display);
+        while (seat != NULL) {
+                ds_seat_destroy(seat);
+                seat = ds_display_first_seat(display);
+        }
+        return rc;
+}
+
+/** Save display configuration to SIF file.
+ *
+ * @param display Display
+ * @param cfgpath Configuration file path
+ *
+ * @return EOK on success or an error code
+ */
+errno_t ds_display_save_cfg(ds_display_t *display, const char *cfgpath)
+{
+        sif_doc_t *doc = NULL;
+        sif_node_t *rnode;
+        sif_node_t *ndisplay;
+        sif_node_t *nseats;
+        sif_node_t *nseat;
+        ds_seat_t *seat;
+        sif_node_t *nidevcfgs;
+        sif_node_t *nidevcfg;
+        ds_idevcfg_t *idevcfg;
+        errno_t rc;
+
+        rc = sif_new(&doc);
+        if (rc != EOK)
+                goto error;
+
+        rnode = sif_get_root(doc);
+        rc = sif_node_append_child(rnode, "display", &ndisplay);
+        if (rc != EOK)
+                goto error;
+
+        rc = sif_node_append_child(ndisplay, "seats", &nseats);
+        if (rc != EOK)
+                goto error;
+
+        /* Save individual seats */
+        seat = ds_display_first_seat(display);
+        while (seat != NULL) {
+                rc = sif_node_append_child(nseats, "seat", &nseat);
+                if (rc != EOK)
+                        goto error;
+
+                rc = ds_seat_save(seat, nseat);
+                if (rc != EOK)
+                        goto error;
+
+                seat = ds_display_next_seat(seat);
+        }
+
+        rc = sif_node_append_child(ndisplay, "idevcfgs", &nidevcfgs);
+        if (rc != EOK)
+                goto error;
+
+        /* Save individual input device configuration entries */
+        idevcfg = ds_display_first_idevcfg(display);
+        while (idevcfg != NULL) {
+                rc = sif_node_append_child(nidevcfgs, "idevcfg", &nidevcfg);
+                if (rc != EOK)
+                        goto error;
+
+                rc = ds_idevcfg_save(idevcfg, nidevcfg);
+                if (rc != EOK)
+                        goto error;
+
+                idevcfg = ds_display_next_idevcfg(idevcfg);
+        }
+
+        rc = sif_save(doc, cfgpath);
+        if (rc != EOK)
+                goto error;
+
+        sif_delete(doc);
+        return EOK;
+error:
+        if (doc != NULL)
+                sif_delete(doc);
+        return rc;
+}
+
 /** Lock display.
  *
@@ -203 +400 @@
 
         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;
+}
+
+/** Add CFG client to display.
+ *
+ * @param disp Display
+ * @param cfgclient CFG client
+ */
+void ds_display_add_cfgclient(ds_display_t *disp, ds_cfgclient_t *cfgclient)
+{
+        assert(cfgclient->display == NULL);
+        assert(!link_used(&cfgclient->lcfgclients));
+
+        cfgclient->display = disp;
+        list_append(&cfgclient->lcfgclients, &disp->cfgclients);
+}
+
+/** Remove CFG client from display.
+ *
+ * @param cfgclient CFG client
+ */
+void ds_display_remove_cfgclient(ds_cfgclient_t *cfgclient)
+{
+        list_remove(&cfgclient->lcfgclients);
+        cfgclient->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);
 }
 
@@ -246 +522 @@
                 gfx_rect_translate(&wnd->dpos, &wnd->rect, &drect);
 
-                if (gfx_pix_inside_rect(pos, &drect))
+                if (gfx_pix_inside_rect(pos, &drect) &&
+                    ds_window_is_visible(wnd))
                         return wnd;
 
@@ -255 +532 @@
 }
 
+/** Add window to window list.
+ *
+ * Topmost windows are enlisted before any other window. Non-topmost
+ * windows are enlisted before any other non-topmost window.
+ *
+ * @param display Display
+ * @param wnd Window
+ */
+void ds_display_enlist_window(ds_display_t *display, ds_window_t *wnd)
+{
+        ds_window_t *w;
+
+        assert(wnd->display == display);
+        assert(!link_used(&wnd->ldwindows));
+
+        if ((wnd->flags & wndf_topmost) == 0) {
+                /* Find the first non-topmost window */
+                w = ds_display_first_window(display);
+                while (w != NULL && (w->flags & wndf_topmost) != 0)
+                        w = ds_display_next_window(w);
+
+                if (w != NULL)
+                        list_insert_before(&wnd->ldwindows, &w->ldwindows);
+                else
+                        list_append(&wnd->ldwindows, &display->windows);
+        } else {
+                /* Insert at the beginning */
+                list_prepend(&wnd->ldwindows, &display->windows);
+        }
+
+}
+
 /** Add window to display.
  *
@@ -262 +571 @@
 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));
 
         wnd->display = display;
-        list_prepend(&wnd->ldwindows, &display->windows);
+        ds_display_enlist_window(display, wnd);
+
+        /* 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 +593 @@
 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);
+        ds_display_enlist_window(wnd->display, wnd);
 }
 
@@ -352 +696 @@
         ds_seat_t *seat;
 
-        // TODO Determine which seat the event belongs to
-        seat = ds_display_first_seat(display);
+        /* Determine which seat the event belongs to */
+        seat = ds_display_seat_by_idev(display, event->kbd_id);
         if (seat == NULL)
                 return EOK;
@@ -369 +713 @@
         ds_seat_t *seat;
 
-        // TODO Determine which seat the event belongs to
-        seat = ds_display_first_seat(display);
+        /* Determine which seat the event belongs to */
+        seat = ds_display_seat_by_idev(display, event->pos_id);
         if (seat == NULL)
                 return EOK;
@@ -388 +732 @@
 
         seat->display = disp;
+        seat->id = disp->next_seat_id++;
         list_append(&seat->lseats, &disp->seats);
 }
@@ -429 +774 @@
 
         return list_get_instance(link, ds_seat_t, lseats);
+}
+
+/** Get default seat in display.
+ *
+ * @param disp Display
+ * @return First seat or @c NULL if there is none
+ */
+ds_seat_t *ds_display_default_seat(ds_display_t *disp)
+{
+        /* XXX Probably not the best solution */
+        return ds_display_first_seat(disp);
+}
+
+/** Find seat by ID.
+ *
+ * @param display Display
+ * @param id Seat ID
+ */
+ds_seat_t *ds_display_find_seat(ds_display_t *display, ds_seat_id_t id)
+{
+        ds_seat_t *seat;
+
+        seat = ds_display_first_seat(display);
+        while (seat != NULL) {
+                if (seat->id == id)
+                        return seat;
+
+                seat = ds_display_next_seat(seat);
+        }
+
+        return NULL;
+}
+
+/** Get seat which owns the specified input device.
+ *
+ * @param disp Display
+ * @param idev_id Input device ID
+ * @return Seat which owns device with ID @a idev_id or @c NULL if not found
+ */
+ds_seat_t *ds_display_seat_by_idev(ds_display_t *disp, ds_idev_id_t idev_id)
+{
+        ds_idevcfg_t *idevcfg;
+
+        /*
+         * Find input device configuration entry that maps this input device
+         * to a seat.
+         */
+        idevcfg = ds_display_first_idevcfg(disp);
+        while (idevcfg != NULL) {
+                if (idevcfg->svc_id == idev_id)
+                        return idevcfg->seat;
+
+                idevcfg = ds_display_next_idevcfg(idevcfg);
+        }
+
+        /* If none was found, return the default seat */
+        return ds_display_default_seat(disp);
 }
 
@@ -493 +895 @@
 {
         errno_t rc;
+        gfx_rect_t old_disp_rect;
 
         assert(ddev->display == NULL);
         assert(!link_used(&ddev->lddevs));
+
+        old_disp_rect = disp->rect;
 
         ddev->display = disp;
@@ -507 +912 @@
                 /* Create cloning GC */
                 rc = ds_clonegc_create(ddev->gc, &disp->fbgc);
-                if (rc != EOK) {
-                        // XXX Remove output
-                        return ENOMEM;
-                }
+                if (rc != EOK)
+                        goto error;
 
                 /* Allocate backbuffer */
                 rc = ds_display_alloc_backbuf(disp);
                 if (rc != EOK) {
-                        // XXX Remove output
-                        // XXX Delete clone GC
+                        ds_clonegc_delete(disp->fbgc);
+                        disp->fbgc = NULL;
                         goto error;
                 }
@@ -526 +929 @@
         }
 
+        ds_display_update_max_rect(disp);
+
         return EOK;
 error:
-        disp->rect.p0.x = 0;
-        disp->rect.p0.y = 0;
-        disp->rect.p1.x = 0;
-        disp->rect.p1.y = 0;
+        disp->rect = old_disp_rect;
         list_remove(&ddev->lddevs);
         return rc;
@@ -576 +978 @@
 }
 
+/** Add input device configuration entry to display.
+ *
+ * @param disp Display
+ * @param idevcfg Input device configuration
+ */
+void ds_display_add_idevcfg(ds_display_t *disp, ds_idevcfg_t *idevcfg)
+{
+        assert(idevcfg->display == NULL);
+        assert(!link_used(&idevcfg->ldispidcfgs));
+
+        idevcfg->display = disp;
+        list_append(&idevcfg->ldispidcfgs, &disp->idevcfgs);
+}
+
+/** Remove input device configuration entry from display.
+ *
+ * @param idevcfg Input device configuration entry
+ */
+void ds_display_remove_idevcfg(ds_idevcfg_t *idevcfg)
+{
+        list_remove(&idevcfg->ldispidcfgs);
+        idevcfg->display = NULL;
+}
+
+/** Get first input device configuration entry in display.
+ *
+ * @param disp Display
+ * @return First input device configuration entry or @c NULL if there is none
+ */
+ds_idevcfg_t *ds_display_first_idevcfg(ds_display_t *disp)
+{
+        link_t *link = list_first(&disp->idevcfgs);
+
+        if (link == NULL)
+                return NULL;
+
+        return list_get_instance(link, ds_idevcfg_t, ldispidcfgs);
+}
+
+/** Get next input device configuration entry in display.
+ *
+ * @param idevcfg Current input device configuration entry
+ * @return Next input device configuration entry or @c NULL if there is none
+ */
+ds_idevcfg_t *ds_display_next_idevcfg(ds_idevcfg_t *idevcfg)
+{
+        link_t *link = list_next(&idevcfg->ldispidcfgs, &idevcfg->display->idevcfgs);
+
+        if (link == NULL)
+                return NULL;
+
+        return list_get_instance(link, ds_idevcfg_t, ldispidcfgs);
+}
+
 /** Add cursor to display.
  *
@@ -598 +1054 @@
         list_remove(&cursor->ldisplay);
         cursor->display = NULL;
+}
+
+/** Update display maximize rectangle.
+ *
+ * Recalculate the maximize rectangle (the rectangle used for maximized
+ * windows).
+ *
+ * @param display Display
+ */
+void ds_display_update_max_rect(ds_display_t *display)
+{
+        ds_window_t *wnd;
+        gfx_rect_t max_rect;
+        gfx_rect_t drect;
+
+        /* Start with the entire display */
+        max_rect = display->rect;
+
+        wnd = ds_display_first_window(display);
+        while (wnd != NULL) {
+                /* Should maximized windows avoid this window? */
+                if ((wnd->flags & wndf_avoid) != 0) {
+                        /* Window bounding rectangle on display */
+                        gfx_rect_translate(&wnd->dpos, &wnd->rect, &drect);
+
+                        /* Crop maximized rectangle */
+                        ds_display_crop_max_rect(&drect, &max_rect);
+                }
+
+                wnd = ds_display_next_window(wnd);
+        }
+
+        /* Update the maximize rectangle */
+        display->max_rect = max_rect;
+}
+
+/** Crop maximize rectangle.
+ *
+ * Use the avoid rectangle @a arect to crop off maximization rectangle
+ * @a mrect. If @a arect covers the top, bottom, left or right part
+ * of @a mrect, it will be cropped off. Otherwise there will be
+ * no effect.
+ *
+ * @param arect Avoid rectangle
+ * @param mrect Maximize rectangle to be modified
+ */
+void ds_display_crop_max_rect(gfx_rect_t *arect, gfx_rect_t *mrect)
+{
+        if (arect->p0.x == mrect->p0.x && arect->p0.y == mrect->p0.y &&
+            arect->p1.x == mrect->p1.x) {
+                /* Cropp off top part */
+                mrect->p0.y = arect->p1.y;
+        } else if (arect->p0.x == mrect->p0.x && arect->p1.x == mrect->p1.x &&
+            arect->p1.y == mrect->p1.y) {
+                /* Cropp off bottom part */
+                mrect->p1.y = arect->p0.y;
+        } else if (arect->p0.x == mrect->p0.x && arect->p0.y == mrect->p0.y &&
+            arect->p1.y == mrect->p1.y) {
+                /* Cropp off left part */
+                mrect->p0.x = arect->p1.x;
+        } else if (arect->p0.y == mrect->p0.y && arect->p1.x == mrect->p1.x &&
+            arect->p1.y == mrect->p1.y) {
+                /* Cropp off right part */
+                mrect->p1.x = arect->p0.x;
+        }
 }