Changes in uspace/srv/hid/display/window.c [2e0a2e7:0d00e53] in mainline

File:

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

uspace/srv/hid/display/window.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2019 Jiri Svoboda
+ * Copyright (c) 2024 Jiri Svoboda
  * All rights reserved.
  *
@@ -44 +44 @@
 #include <memgfx/memgc.h>
 #include <stdlib.h>
+#include <str.h>
+#include <wndmgt.h>
 #include "client.h"
 #include "display.h"
 #include "seat.h"
 #include "window.h"
-
-static void ds_window_update_cb(void *, gfx_rect_t *);
+#include "wmclient.h"
+
+static void ds_window_invalidate_cb(void *, gfx_rect_t *);
+static void ds_window_update_cb(void *);
 static void ds_window_get_preview_rect(ds_window_t *, gfx_rect_t *);
+
+static mem_gc_cb_t ds_window_mem_gc_cb = {
+        .invalidate = ds_window_invalidate_cb,
+        .update = ds_window_update_cb
+};
 
 /** Create window.
@@ -58 +67 @@
  * @param client Client owning the window
  * @param params Window parameters
- * @param rgc Place to store pointer to new GC.
+ * @param rwnd Place to store pointer to new window.
  *
  * @return EOK on success or an error code
  */
 errno_t ds_window_create(ds_client_t *client, display_wnd_params_t *params,
-    ds_window_t **rgc)
+    ds_window_t **rwnd)
 {
         ds_window_t *wnd = NULL;
+        ds_seat_t *seat;
         gfx_context_t *dgc;
         gfx_coord2_t dims;
@@ -78 +88 @@
         }
 
+        /* Caption */
+        wnd->caption = str_dup(params->caption);
+        if (wnd->caption == NULL) {
+                rc = ENOMEM;
+                goto error;
+        }
+
+        wnd->flags = params->flags;
+
         ds_client_add_window(client, wnd);
         ds_display_add_window(client->display, wnd);
@@ -83 +102 @@
         gfx_bitmap_params_init(&bparams);
         bparams.rect = params->rect;
+
+        /* Allocate window bitmap */
 
         dgc = ds_display_get_gc(wnd->display);
@@ -106 +127 @@
         }
 
-        rc = mem_gc_create(&params->rect, &alloc, ds_window_update_cb,
+        rc = mem_gc_create(&params->rect, &alloc, &ds_window_mem_gc_cb,
             (void *)wnd, &wnd->mgc);
         if (rc != EOK)
@@ -115 +136 @@
         wnd->gc = mem_gc_get_ctx(wnd->mgc);
         wnd->cursor = wnd->display->cursor[dcurs_arrow];
-        *rgc = wnd;
+
+        if ((params->flags & wndf_setpos) != 0) {
+                /* Specific window position */
+                wnd->dpos = params->pos;
+        } else {
+                /* Automatic window placement */
+                wnd->dpos.x = ((wnd->id - 1) & 1) * 400;
+                wnd->dpos.y = ((wnd->id - 1) & 2) / 2 * 300;
+        }
+
+        /* Determine which seat should own the window */
+        if (params->idev_id != 0)
+                seat = ds_display_seat_by_idev(wnd->display, params->idev_id);
+        else
+                seat = ds_display_default_seat(wnd->display);
+
+        /* Is this a popup window? */
+        if ((params->flags & wndf_popup) != 0) {
+                ds_seat_set_popup(seat, wnd);
+        } else {
+                if ((params->flags & wndf_nofocus) == 0)
+                        ds_seat_set_focus(seat, wnd);
+        }
+
+        /* Is this window a panel? */
+        if ((params->flags & wndf_avoid) != 0)
+                ds_display_update_max_rect(wnd->display);
+
+        (void) ds_display_paint(wnd->display, NULL);
+
+        *rwnd = wnd;
         return EOK;
 error:
         if (wnd != NULL) {
+                ds_client_remove_window(wnd);
+                ds_display_remove_window(wnd);
+                if (wnd->mgc != NULL)
+                        mem_gc_delete(wnd->mgc);
                 if (wnd->bitmap != NULL)
                         gfx_bitmap_destroy(wnd->bitmap);
+                if (wnd->caption != NULL)
+                        free(wnd->caption);
                 free(wnd);
         }
@@ -136 +193 @@
 
         disp = wnd->display;
+
+        ds_window_unfocus(wnd);
 
         ds_client_remove_window(wnd);
         ds_display_remove_window(wnd);
 
+        if ((wnd->flags & wndf_avoid) != 0)
+                ds_display_update_max_rect(disp);
+
         mem_gc_delete(wnd->mgc);
 
@@ -145 +207 @@
                 gfx_bitmap_destroy(wnd->bitmap);
 
+        free(wnd->caption);
         free(wnd);
 
@@ -156 +219 @@
 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);
 }
@@ -171 +231 @@
 {
         return wnd->gc;
+}
+
+/** Determine if window is visible.
+ *
+ * @param wnd Window
+ * @return @c true iff window is visible
+ */
+bool ds_window_is_visible(ds_window_t *wnd)
+{
+        return (wnd->flags & wndf_minimized) == 0;
 }
 
@@ -185 +255 @@
         gfx_rect_t crect;
 
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "ds_window_paint");
+        log_msg(LOG_DEFAULT, LVL_DEBUG2, "ds_window_paint");
+
+        /* Skip painting the window if not visible */
+        if (!ds_window_is_visible(wnd))
+                return EOK;
 
         if (rect != NULL) {
@@ -330 +404 @@
         bool newr;
 
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "ds_window_repaint_preview");
+        log_msg(LOG_DEFAULT, LVL_DEBUG2, "ds_window_repaint_preview");
 
         /*
@@ -374 +448 @@
  * @param wnd Window
  * @param pos Position where mouse button was pressed
- */
-static void ds_window_start_move(ds_window_t *wnd, gfx_coord2_t *pos)
+ * @param pos_id Positioning device ID
+ */
+static void ds_window_start_move(ds_window_t *wnd, gfx_coord2_t *pos,
+    sysarg_t pos_id)
 {
         log_msg(LOG_DEFAULT, LVL_DEBUG, "ds_window_start_move (%d, %d)",
@@ -384 +460 @@
 
         wnd->orig_pos = *pos;
+        wnd->orig_pos_id = pos_id;
         wnd->state = dsw_moving;
         wnd->preview_pos = wnd->dpos;
@@ -413 +490 @@
         wnd->dpos = nwpos;
         wnd->state = dsw_idle;
+        wnd->orig_pos_id = 0;
 
         (void) ds_display_paint(wnd->display, NULL);
@@ -428 +506 @@
         gfx_rect_t old_rect;
 
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "ds_window_update_move (%d, %d)",
+        log_msg(LOG_DEFAULT, LVL_DEBUG2, "ds_window_update_move (%d, %d)",
             (int) pos->x, (int) pos->y);
 
@@ -447 +525 @@
  * @param rsztype Resize type (which part of window is being dragged)
  * @param pos Position where mouse button was pressed
+ * @param pos_id Positioning device ID
  */
 static void ds_window_start_resize(ds_window_t *wnd,
-    display_wnd_rsztype_t rsztype, gfx_coord2_t *pos)
+    display_wnd_rsztype_t rsztype, gfx_coord2_t *pos, sysarg_t pos_id)
 {
         ds_seat_t *seat;
@@ -460 +539 @@
                 return;
 
+        /* Determine which seat started the resize */
+        seat = ds_display_seat_by_idev(wnd->display, pos_id);
+        if (seat == NULL)
+                return;
+
         wnd->orig_pos = *pos;
+        wnd->orig_pos_id = pos_id;
         wnd->state = dsw_resizing;
         wnd->rsztype = rsztype;
         wnd->preview_rect = wnd->rect;
 
-        // XXX Need client to tell us which seat started the resize!
-        seat = ds_display_first_seat(wnd->display);
         ctype = display_cursor_from_wrsz(rsztype);
         ds_seat_set_wm_cursor(seat, wnd->display->cursor[ctype]);
@@ -496 +579 @@
         ds_client_post_resize_event(wnd->client, wnd, &nrect);
 
-        // XXX Need to know which seat started the resize!
-        seat = ds_display_first_seat(wnd->display);
-        ds_seat_set_wm_cursor(seat, NULL);
+        /* Determine which seat started the resize */
+        seat = ds_display_seat_by_idev(wnd->display, wnd->orig_pos_id);
+        if (seat != NULL)
+                ds_seat_set_wm_cursor(seat, NULL);
+
+        wnd->orig_pos_id = 0;
 
         (void) ds_display_paint(wnd->display, NULL);
@@ -514 +600 @@
         gfx_rect_t old_rect;
 
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "ds_window_update_resize (%d, %d)",
+        log_msg(LOG_DEFAULT, LVL_DEBUG2, "ds_window_update_resize (%d, %d)",
             (int) pos->x, (int) pos->y);
 
@@ -553 +639 @@
  * @param wnd Window
  * @param event Position event
+ *
+ * @return EOK on success or an error code
  */
 errno_t ds_window_post_pos_event(ds_window_t *wnd, pos_event_t *event)
@@ -558 +646 @@
         pos_event_t tevent;
         gfx_coord2_t pos;
+        sysarg_t pos_id;
         gfx_rect_t drect;
         bool inside;
 
-        log_msg(LOG_DEFAULT, LVL_DEBUG,
+        log_msg(LOG_DEFAULT, LVL_DEBUG2,
             "ds_window_post_pos_event type=%d pos=%d,%d", event->type,
             (int) event->hpos, (int) event->vpos);
@@ -567 +656 @@
         pos.x = event->hpos;
         pos.y = event->vpos;
+        pos_id = event->pos_id;
         gfx_rect_translate(&wnd->dpos, &wnd->rect, &drect);
         inside = gfx_pix_inside_rect(&pos, &drect);
 
-        if (event->type == POS_PRESS && event->btn_num == 2 && inside) {
-                ds_window_start_move(wnd, &pos);
+        if (event->type == POS_PRESS && event->btn_num == 2 && inside &&
+            (wnd->flags & wndf_maximized) == 0) {
+                ds_window_start_move(wnd, &pos, pos_id);
                 return EOK;
         }
 
         if (event->type == POS_RELEASE) {
-                if (wnd->state == dsw_moving) {
+                /* Finish move/resize if they were started by the same seat */
+                if (wnd->state == dsw_moving &&
+                    ds_window_orig_seat(wnd, pos_id)) {
                         ds_window_finish_move(wnd, &pos);
                         return EOK;
                 }
 
-                if (wnd->state == dsw_resizing) {
+                if (wnd->state == dsw_resizing &&
+                    ds_window_orig_seat(wnd, pos_id)) {
                         ds_window_finish_resize(wnd, &pos);
                         return EOK;
@@ -588 +682 @@
 
         if (event->type == POS_UPDATE) {
-                if (wnd->state == dsw_moving) {
+                /* Update move/resize if they were started by the same seat */
+                if (wnd->state == dsw_moving &&
+                    ds_window_orig_seat(wnd, pos_id)) {
                         ds_window_update_move(wnd, &pos);
                         return EOK;
                 }
 
-                if (wnd->state == dsw_resizing) {
+                if (wnd->state == dsw_resizing &&
+                    ds_window_orig_seat(wnd, pos_id)) {
                         ds_window_update_resize(wnd, &pos);
                         return EOK;
@@ -610 +707 @@
  *
  * @param wnd Window
+ * @return EOK on success or an error code
  */
 errno_t ds_window_post_focus_event(ds_window_t *wnd)
 {
+        display_wnd_focus_ev_t efocus;
+        errno_t rc;
+        ds_wmclient_t *wmclient;
+
         log_msg(LOG_DEFAULT, LVL_DEBUG, "ds_window_post_focus_event");
 
-        return ds_client_post_focus_event(wnd->client, wnd);
+        /* Increase focus counter */
+        ++wnd->nfocus;
+        efocus.nfocus = wnd->nfocus;
+
+        rc = ds_client_post_focus_event(wnd->client, wnd, &efocus);
+        if (rc != EOK)
+                return rc;
+
+        /* Notify window managers about window information change */
+        wmclient = ds_display_first_wmclient(wnd->display);
+        while (wmclient != NULL) {
+                ds_wmclient_post_wnd_changed_event(wmclient, wnd->id);
+                wmclient = ds_display_next_wmclient(wmclient);
+        }
+
+        return EOK;
 }
 
@@ -621 +738 @@
  *
  * @param wnd Window
+ * @return EOK on success or an error code
  */
 errno_t ds_window_post_unfocus_event(ds_window_t *wnd)
 {
+        display_wnd_unfocus_ev_t eunfocus;
+        errno_t rc;
+        ds_wmclient_t *wmclient;
+
         log_msg(LOG_DEFAULT, LVL_DEBUG, "ds_window_post_unfocus_event");
 
-        return ds_client_post_unfocus_event(wnd->client, wnd);
+        /* Decrease focus counter */
+        --wnd->nfocus;
+        eunfocus.nfocus = wnd->nfocus;
+
+        rc = ds_client_post_unfocus_event(wnd->client, wnd, &eunfocus);
+        if (rc != EOK)
+                return rc;
+
+        /* Notify window managers about window information change */
+        wmclient = ds_display_first_wmclient(wnd->display);
+        while (wmclient != NULL) {
+                ds_wmclient_post_wnd_changed_event(wmclient, wnd->id);
+                wmclient = ds_display_next_wmclient(wmclient);
+        }
+
+        return EOK;
 }
 
@@ -634 +771 @@
  * @param pos Position where the pointer was when the move started
  *            relative to the window
+ * @param pos_id Positioning device ID
  * @param event Button press event
  */
-void ds_window_move_req(ds_window_t *wnd, gfx_coord2_t *pos)
+void ds_window_move_req(ds_window_t *wnd, gfx_coord2_t *pos, sysarg_t pos_id)
 {
         gfx_coord2_t orig_pos;
@@ -644 +782 @@
 
         gfx_coord2_add(&wnd->dpos, pos, &orig_pos);
-        ds_window_start_move(wnd, &orig_pos);
+        ds_window_start_move(wnd, &orig_pos, pos_id);
 }
 
@@ -655 +793 @@
         wnd->dpos = *dpos;
         (void) ds_display_paint(wnd->display, NULL);
+}
+
+/** Get window position.
+ *
+ * @param wnd Window
+ */
+void ds_window_get_pos(ds_window_t *wnd, gfx_coord2_t *dpos)
+{
+        *dpos = wnd->dpos;
+}
+
+/** Get maximized window rectangle.
+ *
+ * @param wnd Window
+ */
+void ds_window_get_max_rect(ds_window_t *wnd, gfx_rect_t *rect)
+{
+        *rect = wnd->display->max_rect;
 }
 
@@ -663 +819 @@
  * @param pos Position where the pointer was when the resize started
  *            relative to the window
+ * @param pos_id Positioning device ID
  * @param event Button press event
  */
 void ds_window_resize_req(ds_window_t *wnd, display_wnd_rsztype_t rsztype,
-    gfx_coord2_t *pos)
+    gfx_coord2_t *pos, sysarg_t pos_id)
 {
         gfx_coord2_t orig_pos;
 
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "ds_window_resize_req (%d, %d, %d)",
-            (int) rsztype, (int) pos->x, (int) pos->y);
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "ds_window_resize_req (%d, %d, %d, %d)",
+            (int)rsztype, (int)pos->x, (int)pos->y, (int)pos_id);
 
         gfx_coord2_add(&wnd->dpos, pos, &orig_pos);
-        ds_window_start_resize(wnd, rsztype, &orig_pos);
+        ds_window_start_resize(wnd, rsztype, &orig_pos, pos_id);
 }
 
@@ -680 +837 @@
  *
  * @param wnd Window
+ * @return EOK on success or an error code
  */
 errno_t ds_window_resize(ds_window_t *wnd, gfx_coord2_t *offs,
@@ -730 +888 @@
         wnd->rect = *nrect;
 
+        if ((wnd->flags & wndf_avoid) != 0)
+                ds_display_update_max_rect(wnd->display);
+
         (void) ds_display_paint(wnd->display, NULL);
+        return EOK;
+}
+
+/** Minimize window.
+ *
+ * @param wnd Window
+ * @return EOK on success or an error code
+ */
+errno_t ds_window_minimize(ds_window_t *wnd)
+{
+        /* If already minimized, do nothing and return success. */
+        if ((wnd->flags & wndf_minimized) != 0)
+                return EOK;
+
+        ds_window_unfocus(wnd);
+
+        wnd->flags |= wndf_minimized;
+        (void) ds_display_paint(wnd->display, NULL);
+        return EOK;
+}
+
+/** Unminimize window.
+ *
+ * @param wnd Window
+ * @return EOK on success or an error code
+ */
+errno_t ds_window_unminimize(ds_window_t *wnd)
+{
+        /* If not minimized, do nothing and return success. */
+        if ((wnd->flags & wndf_minimized) == 0)
+                return EOK;
+
+        wnd->flags &= ~wndf_minimized;
+        (void) ds_display_paint(wnd->display, NULL);
+        return EOK;
+}
+
+/** Maximize window.
+ *
+ * @param wnd Window
+ * @return EOK on success or an error code
+ */
+errno_t ds_window_maximize(ds_window_t *wnd)
+{
+        gfx_coord2_t old_dpos;
+        gfx_rect_t old_rect;
+        gfx_coord2_t offs;
+        gfx_rect_t max_rect;
+        gfx_rect_t nrect;
+        errno_t rc;
+
+        /* If already maximized, do nothing and return success. */
+        if ((wnd->flags & wndf_maximized) != 0)
+                return EOK;
+
+        /* Remember the old window rectangle and display position */
+        old_rect = wnd->rect;
+        old_dpos = wnd->dpos;
+
+        ds_window_get_max_rect(wnd, &max_rect);
+
+        /* Keep window contents on the same position on the screen */
+        offs.x = max_rect.p0.x - wnd->dpos.x;
+        offs.y = max_rect.p0.y - wnd->dpos.y;
+
+        /* Maximized window's coordinates will start at 0,0 */
+        gfx_rect_rtranslate(&max_rect.p0, &max_rect, &nrect);
+
+        rc = ds_window_resize(wnd, &offs, &nrect);
+        if (rc != EOK)
+                return rc;
+
+        /* Set window flags, remember normal rectangle */
+        wnd->flags |= wndf_maximized;
+        wnd->normal_rect = old_rect;
+        wnd->normal_dpos = old_dpos;
+
+        return EOK;
+}
+
+/** Unmaximize window.
+ *
+ * @param wnd Window
+ * @return EOK on success or an error code
+ */
+errno_t ds_window_unmaximize(ds_window_t *wnd)
+{
+        gfx_coord2_t offs;
+        errno_t rc;
+
+        /* If not maximized, do nothing and return success. */
+        if ((wnd->flags & wndf_maximized) == 0)
+                return EOK;
+
+        /* Keep window contents on the same position on the screen */
+        offs.x = wnd->normal_dpos.x - wnd->dpos.x;
+        offs.y = wnd->normal_dpos.y - wnd->dpos.y;
+
+        rc = ds_window_resize(wnd, &offs, &wnd->normal_rect);
+        if (rc != EOK)
+                return rc;
+
+        /* Clear maximized flag */
+        wnd->flags &= ~wndf_maximized;
+
         return EOK;
 }
@@ -776 +1042 @@
  *
  * @param wnd Window
+ * @param cursor New cursor
  * @return EOK on success, EINVAL if @a cursor is invalid
  */
@@ -789 +1056 @@
 }
 
-/** Window memory GC update callback.
- *
- * This is called by the window's memory GC when a rectangle us updated.
- */
-static void ds_window_update_cb(void *arg, gfx_rect_t *rect)
+/** Set window caption.
+ *
+ * @param wnd Window
+ * @param caption New caption
+ *
+ * @return EOK on success, EINVAL if @a cursor is invalid
+ */
+errno_t ds_window_set_caption(ds_window_t *wnd, const char *caption)
+{
+        char *dcaption;
+        ds_wmclient_t *wmclient;
+
+        dcaption = str_dup(caption);
+        if (dcaption == NULL)
+                return ENOMEM;
+
+        free(wnd->caption);
+        wnd->caption = dcaption;
+
+        /* Notify window managers about window information change */
+        wmclient = ds_display_first_wmclient(wnd->display);
+        while (wmclient != NULL) {
+                ds_wmclient_post_wnd_changed_event(wmclient, wnd->id);
+                wmclient = ds_display_next_wmclient(wmclient);
+        }
+
+        return EOK;
+}
+
+/** Find alternate window with the allowed flags.
+ *
+ * An alternate window is a *different* window that is preferably previous
+ * in the display order and only has the @a allowed flags.
+ *
+ * @param wnd Window
+ * @param allowed_flags Bitmask of flags that the window is allowed to have
+ *
+ * @return Alternate window matching the criteria or @c NULL if there is none
+ */
+ds_window_t *ds_window_find_prev(ds_window_t *wnd,
+    display_wnd_flags_t allowed_flags)
+{
+        ds_window_t *nwnd;
+
+        /* Try preceding windows in display order */
+        nwnd = ds_display_next_window(wnd);
+        while (nwnd != NULL && (nwnd->flags & ~allowed_flags) != 0) {
+                nwnd = ds_display_next_window(nwnd);
+        }
+
+        /* Do we already have a matching window? */
+        if (nwnd != NULL && (nwnd->flags & ~allowed_flags) == 0) {
+                return nwnd;
+        }
+
+        /* Try succeeding windows in display order */
+        nwnd = ds_display_first_window(wnd->display);
+        while (nwnd != NULL && nwnd != wnd &&
+            (nwnd->flags & ~allowed_flags) != 0) {
+                nwnd = ds_display_next_window(nwnd);
+        }
+
+        if (nwnd == wnd)
+                return NULL;
+
+        return nwnd;
+}
+
+/** Find alternate window with the allowed flags.
+ *
+ * An alternate window is a *different* window that is preferably previous
+ * in the display order and only has the @a allowed flags.
+ *
+ * @param wnd Window
+ * @param allowed_flags Bitmask of flags that the window is allowed to have
+ *
+ * @return Alternate window matching the criteria or @c NULL if there is none
+ */
+ds_window_t *ds_window_find_next(ds_window_t *wnd,
+    display_wnd_flags_t allowed_flags)
+{
+        ds_window_t *nwnd;
+
+        /* Try preceding windows in display order */
+        nwnd = ds_display_prev_window(wnd);
+        while (nwnd != NULL && (nwnd->flags & ~allowed_flags) != 0) {
+                nwnd = ds_display_prev_window(nwnd);
+        }
+
+        /* Do we already have a matching window? */
+        if (nwnd != NULL && (nwnd->flags & ~allowed_flags) == 0) {
+                return nwnd;
+        }
+
+        /* Try succeeding windows in display order */
+        nwnd = ds_display_last_window(wnd->display);
+        while (nwnd != NULL && nwnd != wnd &&
+            (nwnd->flags & ~allowed_flags) != 0) {
+                nwnd = ds_display_prev_window(nwnd);
+        }
+
+        if (nwnd == wnd)
+                return NULL;
+
+        return nwnd;
+}
+
+/** Remove focus from window.
+ *
+ * Used to switch focus to another window when closing or minimizing window.
+ *
+ * @param wnd Window
+ */
+void ds_window_unfocus(ds_window_t *wnd)
+{
+        ds_seat_t *seat;
+
+        /* Make sure window is no longer focused in any seat */
+        seat = ds_display_first_seat(wnd->display);
+        while (seat != NULL) {
+                ds_seat_unfocus_wnd(seat, wnd);
+                seat = ds_display_next_seat(seat);
+        }
+}
+
+/** Determine if input device belongs to the same seat as the original device.
+ *
+ * Compare the seat ownning @a idev_id with the seat owning @a wnd->orig_pos_id
+ * (the device that started the window move or resize).
+ *
+ * This is used to make sure that, when two seats focus the same window,
+ * only devices owned by the seat that started the resize or move can
+ * affect it. Otherwise moving the other pointer(s) would disrupt the
+ * resize or move operation.
+ *
+ * @param wnd Window (that is currently being resized or moved)
+ * @param idev_id Input device ID
+ * @return @c true iff idev_id is owned by the same seat as the input
+ *         device that started the resize or move
+ */
+bool ds_window_orig_seat(ds_window_t *wnd, sysarg_t idev_id)
+{
+        ds_seat_t *orig_seat;
+        ds_seat_t *seat;
+
+        /* Window must be in state such that wnd->orig_pos_id is valid */
+        assert(wnd->state == dsw_moving || wnd->state == dsw_resizing);
+
+        orig_seat = ds_display_seat_by_idev(wnd->display, wnd->orig_pos_id);
+        seat = ds_display_seat_by_idev(wnd->display, idev_id);
+
+        return seat == orig_seat;
+}
+
+/** Window memory GC invalidate callback.
+ *
+ * This is called by the window's memory GC when a rectangle is modified.
+ */
+static void ds_window_invalidate_cb(void *arg, gfx_rect_t *rect)
 {
         ds_window_t *wnd = (ds_window_t *)arg;
@@ -806 +1227 @@
 }
 
+/** Window memory GC update callback.
+ *
+ * This is called by the window's memory GC when it is to be updated.
+ */
+static void ds_window_update_cb(void *arg)
+{
+        ds_window_t *wnd = (ds_window_t *)arg;
+
+        (void) wnd;
+}
+
 /** @}
  */