Changes in uspace/srv/hid/display/display.c [2ab8ab3:5d380b6] in mainline

File:

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

uspace/srv/hid/display/display.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2019 Jiri Svoboda
+ * Copyright (c) 2023 Jiri Svoboda
  * All rights reserved.
  *
@@ -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 *);
 static void ds_display_invalidate_cb(void *, gfx_rect_t *);
 static void ds_display_update_cb(void *);
+
+static mem_gc_cb_t ds_display_mem_gc_cb = {
+        .invalidate = ds_display_invalidate_cb,
+        .update = ds_display_update_cb
+};
 
 /** Create display.
@@ -91 +97 @@
         fibril_mutex_initialize(&disp->lock);
         list_initialize(&disp->clients);
+        list_initialize(&disp->wmclients);
+        list_initialize(&disp->cfgclients);
         disp->next_wnd_id = 1;
         list_initialize(&disp->ddevs);
+        list_initialize(&disp->idevcfgs);
         list_initialize(&disp->seats);
         list_initialize(&disp->windows);
@@ -109 +118 @@
 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);
@@ -198 +221 @@
 
         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);
 }
 
@@ -241 +343 @@
                 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;
 
@@ -250 +353 @@
 }
 
+/** 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.
  *
@@ -257 +392 @@
 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);
+        }
 }
 
@@ -270 +414 @@
 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);
 }
 
@@ -347 +517 @@
         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;
@@ -364 +534 @@
         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;
@@ -383 +553 @@
 
         seat->display = disp;
+        seat->id = disp->next_seat_id++;
         list_append(&seat->lseats, &disp->seats);
 }
@@ -424 +595 @@
 
         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);
 }
 
@@ -459 +687 @@
                 goto error;
 
-        rc = mem_gc_create(&disp->rect, &alloc,
-            ds_display_invalidate_cb, ds_display_update_cb, (void *) disp,
-            &disp->bbgc);
+        rc = mem_gc_create(&disp->rect, &alloc, &ds_display_mem_gc_cb,
+            (void *) disp, &disp->bbgc);
         if (rc != EOK)
                 goto error;
@@ -489 +716 @@
 {
         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;
@@ -503 +733 @@
                 /* 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;
                 }
@@ -522 +750 @@
         }
 
+        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;
@@ -572 +799 @@
 }
 
+/** 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.
  *
@@ -594 +875 @@
         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;
+        }
 }