Changeset 0e6e77f in mainline for uspace/lib/display

Timestamp:

2020-02-28T15:44:55Z (5 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

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

Children:

a8eed5f

Parents:

2a515dcd

git-author:

Jiri Svoboda <jiri@…> (2020-02-26 18:26:13)

git-committer:

Jiri Svoboda <jiri@…> (2020-02-28 15:44:55)

Message:

Window resize by client request

Location:

uspace/lib/display

Files:

• include/disp_srv.h (modified) (2 diffs)
• include/display.h (modified) (2 diffs)
• include/ipc/display.h (modified) (1 diff)
• src/disp_srv.c (modified) (3 diffs)
• src/display.c (modified) (2 diffs)
• test/display.c (modified) (6 diffs)

uspace/lib/display/include/disp_srv.h

@@ -38 +38 @@
 #include <async.h>
 #include <errno.h>
+#include <gfx/coord.h>
 #include "display/wndparams.h"
 #include "types/display/event.h"
@@ -53 +54 @@
         errno_t (*window_create)(void *, display_wnd_params_t *, sysarg_t *);
         errno_t (*window_destroy)(void *, sysarg_t);
+        errno_t (*window_resize)(void *, sysarg_t, gfx_coord2_t *, gfx_rect_t *);
         errno_t (*get_event)(void *, sysarg_t *, display_wnd_ev_t *);
 };

uspace/lib/display/include/display.h

@@ -38 +38 @@
 #include <errno.h>
 #include <gfx/context.h>
+#include <gfx/coord.h>
 #include <stdbool.h>
 #include "display/wndparams.h"
@@ -48 +49 @@
 extern errno_t display_window_destroy(display_window_t *);
 extern errno_t display_window_get_gc(display_window_t *, gfx_context_t **);
+extern errno_t display_window_resize(display_window_t *,
+    gfx_coord2_t *, gfx_rect_t *);
 
 #endif

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

@@ -42 +42 @@
         DISPLAY_WINDOW_CREATE,
         DISPLAY_WINDOW_DESTROY,
+        DISPLAY_WINDOW_RESIZE,
         DISPLAY_GET_EVENT
 } display_request_t;

uspace/lib/display/src/disp_srv.c

@@ -43 +43 @@
 #include <stdlib.h>
 #include <stddef.h>
+#include "../private/params.h"
 
 static void display_callback_create_srv(display_srv_t *srv, ipc_call_t *call)
@@ -108 +109 @@
 }
 
+static void display_window_resize_srv(display_srv_t *srv, ipc_call_t *icall)
+{
+        sysarg_t wnd_id;
+        ipc_call_t call;
+        display_wnd_move_t wmove;
+        size_t size;
+        errno_t rc;
+
+        wnd_id = ipc_get_arg1(icall);
+
+        if (!async_data_write_receive(&call, &size)) {
+                async_answer_0(&call, EREFUSED);
+                async_answer_0(icall, EREFUSED);
+                return;
+        }
+
+        if (size != sizeof(display_wnd_move_t)) {
+                async_answer_0(&call, EINVAL);
+                async_answer_0(icall, EINVAL);
+                return;
+        }
+
+        rc = async_data_write_finalize(&call, &wmove, size);
+        if (rc != EOK) {
+                async_answer_0(&call, rc);
+                async_answer_0(icall, rc);
+                return;
+        }
+
+        if (srv->ops->window_resize == NULL) {
+                async_answer_0(icall, ENOTSUP);
+                return;
+        }
+
+        rc = srv->ops->window_resize(srv->arg, wnd_id, &wmove.offs,
+            &wmove.nrect);
+        async_answer_0(icall, rc);
+}
+
 static void display_get_event_srv(display_srv_t *srv, ipc_call_t *icall)
 {
@@ -175 +215 @@
                 case DISPLAY_WINDOW_DESTROY:
                         display_window_destroy_srv(srv, &call);
+                        break;
+                case DISPLAY_WINDOW_RESIZE:
+                        display_window_resize_srv(srv, &call);
                         break;
                 case DISPLAY_GET_EVENT:

uspace/lib/display/src/display.c

@@ -38 +38 @@
 #include <mem.h>
 #include <stdlib.h>
+#include "../private/params.h"
 
 static errno_t display_callback_create(display_t *);
@@ -237 +238 @@
 
         *rgc = ipc_gc_get_ctx(gc);
+        return EOK;
+}
+
+/** Resize display window.
+ *
+ * It seems resizing windows should be easy with bounding rectangles.
+ * You have an old bounding rectangle and a new bounding rectangle (@a nrect).
+ * Change .p0 and top-left corner moves. Change .p1 and bottom-right corner
+ * moves. Piece of cake!
+ *
+ * There's always a catch, though. By series of resizes and moves .p0 could
+ * drift outside of the range of @c gfx_coord_t. Now what? @a offs to the
+ * rescue! @a offs moves the @em boundaries of the window with respect
+ * to the display, while keeping the @em contents of the window in the
+ * same place (with respect to the display). In other words, @a offs shifts
+ * the window's internal coordinate system.
+ *
+ * A few examples follow:
+ *
+ * Enlarge window by moving bottom-right corner 1 right, 1 down:
+ *
+ *   bound = (0, 0, 10, 10)
+ *   offs  = (0, 0)
+ *   nrect = (0, 0, 11, 11)
+ *
+ * Enlarge window by moving top-left corner, 1 up, 1 left, allowing the
+ * window-relative coordinate of the top-left corner to drift (undesirable)
+ *
+ *   bound = (0, 0, 10, 10)
+ *   offs  = (0, 0)
+ *   nrect = (-1, -1, 10, 10) <- this is the new bounding rectangle
+ *
+ * Enlarge window by moving top-left corner 1 up, 1 left, keeping top-left
+ * corner locked to (0,0) window-relative coordinates (desirable):
+ *
+ *   bound = (0, 0, 10, 10)
+ *   off   = (-1,-1)        <- top-left corner goes 1 up, 1 left
+ *   nrect = (0, 0, 11, 11) <- window still starts at 0,0 window-relative
+ *
+ * @param window Window
+ * @param nrect New bounding rectangle
+ * @param offs
+ * @return EOK on success or an error code. In both cases @a window must
+ *         not be accessed anymore
+ */
+errno_t display_window_resize(display_window_t *window, gfx_coord2_t *offs,
+    gfx_rect_t *nrect)
+{
+        async_exch_t *exch;
+        aid_t req;
+        ipc_call_t answer;
+        display_wnd_move_t wmove;
+        errno_t rc;
+
+        wmove.offs = *offs;
+        wmove.nrect = *nrect;
+
+        exch = async_exchange_begin(window->display->sess);
+        req = async_send_1(exch, DISPLAY_WINDOW_RESIZE, window->id, &answer);
+        rc = async_data_write_start(exch, &wmove, sizeof (display_wnd_move_t));
+        async_exchange_end(exch);
+        if (rc != EOK) {
+                async_forget(req);
+                return rc;
+        }
+
+        async_wait_for(req, &rc);
+        if (rc != EOK)
+                return rc;
+
         return EOK;
 }

uspace/lib/display/test/display.c

@@ -55 +55 @@
 static errno_t test_window_create(void *, display_wnd_params_t *, sysarg_t *);
 static errno_t test_window_destroy(void *, sysarg_t);
+static errno_t test_window_resize(void *, sysarg_t, gfx_coord2_t *,
+    gfx_rect_t *);
 static errno_t test_get_event(void *, sysarg_t *, display_wnd_ev_t *);
 
@@ -62 +64 @@
         .window_create = test_window_create,
         .window_destroy = test_window_destroy,
+        .window_resize = test_window_resize,
         .get_event = test_get_event
 };
@@ -88 +91 @@
         gfx_rect_t create_rect;
         bool window_destroy_called;
+        sysarg_t destroy_wnd_id;
+
+        bool window_resize_called;
+        gfx_coord2_t resize_offs;
+        gfx_rect_t resize_nbound;
+        sysarg_t resize_wnd_id;
+
         bool get_event_called;
         bool set_color_called;
@@ -220 +230 @@
         rc = display_window_destroy(wnd);
         PCUT_ASSERT_TRUE(resp.window_destroy_called);
+        PCUT_ASSERT_INT_EQUALS(wnd->id, resp.destroy_wnd_id);
         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 
@@ -272 +283 @@
         rc = display_window_destroy(wnd);
         PCUT_ASSERT_TRUE(resp.window_destroy_called);
+        PCUT_ASSERT_INT_EQUALS(wnd->id, resp.destroy_wnd_id);
         PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
 
+        display_close(disp);
+        rc = loc_service_unregister(sid);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+}
+
+/** display_window_resize() with server returning error response works. */
+PCUT_TEST(window_resize_failure)
+{
+        errno_t rc;
+        service_id_t sid;
+        display_t *disp = NULL;
+        display_wnd_params_t params;
+        display_window_t *wnd;
+        gfx_coord2_t offs;
+        gfx_rect_t nrect;
+        test_response_t resp;
+
+        async_set_fallback_port_handler(test_display_conn, &resp);
+
+        // FIXME This causes this test to be non-reentrant!
+        rc = loc_server_register(test_display_server);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+
+        rc = loc_service_register(test_display_svc, &sid);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+
+        rc = display_open(test_display_svc, &disp);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+        PCUT_ASSERT_NOT_NULL(disp);
+
+        resp.rc = EOK;
+        display_wnd_params_init(&params);
+        params.rect.p0.x = 0;
+        params.rect.p0.y = 0;
+        params.rect.p0.x = 100;
+        params.rect.p0.y = 100;
+
+        rc = display_window_create(disp, &params, &test_display_wnd_cb,
+            (void *) &resp, &wnd);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+        PCUT_ASSERT_NOT_NULL(wnd);
+
+        resp.rc = EIO;
+        resp.window_resize_called = false;
+        offs.x = 11;
+        offs.y = 12;
+        nrect.p0.x = 13;
+        nrect.p0.y = 14;
+        nrect.p1.x = 15;
+        nrect.p1.y = 16;
+
+        rc = display_window_resize(wnd, &offs, &nrect);
+        PCUT_ASSERT_TRUE(resp.window_resize_called);
+        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
+        PCUT_ASSERT_INT_EQUALS(wnd->id, resp.resize_wnd_id);
+        PCUT_ASSERT_INT_EQUALS(offs.x, resp.resize_offs.x);
+        PCUT_ASSERT_INT_EQUALS(offs.y, resp.resize_offs.y);
+        PCUT_ASSERT_INT_EQUALS(nrect.p0.x, resp.resize_nbound.p0.x);
+        PCUT_ASSERT_INT_EQUALS(nrect.p0.y, resp.resize_nbound.p0.y);
+        PCUT_ASSERT_INT_EQUALS(nrect.p1.x, resp.resize_nbound.p1.x);
+        PCUT_ASSERT_INT_EQUALS(nrect.p1.y, resp.resize_nbound.p1.y);
+
+        display_window_destroy(wnd);
+        display_close(disp);
+        rc = loc_service_unregister(sid);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+}
+
+/** display_window_resize() with server returning success response works. */
+PCUT_TEST(window_resize_success)
+{
+        errno_t rc;
+        service_id_t sid;
+        display_t *disp = NULL;
+        display_wnd_params_t params;
+        display_window_t *wnd;
+        gfx_coord2_t offs;
+        gfx_rect_t nrect;
+        test_response_t resp;
+
+        async_set_fallback_port_handler(test_display_conn, &resp);
+
+        // FIXME This causes this test to be non-reentrant!
+        rc = loc_server_register(test_display_server);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+
+        rc = loc_service_register(test_display_svc, &sid);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+
+        rc = display_open(test_display_svc, &disp);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+        PCUT_ASSERT_NOT_NULL(disp);
+
+        resp.rc = EOK;
+        display_wnd_params_init(&params);
+        params.rect.p0.x = 0;
+        params.rect.p0.y = 0;
+        params.rect.p0.x = 100;
+        params.rect.p0.y = 100;
+
+        rc = display_window_create(disp, &params, &test_display_wnd_cb,
+            (void *) &resp, &wnd);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+        PCUT_ASSERT_NOT_NULL(wnd);
+
+        resp.rc = EOK;
+        resp.window_resize_called = false;
+        offs.x = 11;
+        offs.y = 12;
+        nrect.p0.x = 13;
+        nrect.p0.y = 14;
+        nrect.p1.x = 15;
+        nrect.p1.y = 16;
+
+        rc = display_window_resize(wnd, &offs, &nrect);
+        PCUT_ASSERT_TRUE(resp.window_resize_called);
+        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
+        PCUT_ASSERT_INT_EQUALS(offs.x, resp.resize_offs.x);
+        PCUT_ASSERT_INT_EQUALS(offs.y, resp.resize_offs.y);
+        PCUT_ASSERT_INT_EQUALS(nrect.p0.x, resp.resize_nbound.p0.x);
+        PCUT_ASSERT_INT_EQUALS(nrect.p0.y, resp.resize_nbound.p0.y);
+        PCUT_ASSERT_INT_EQUALS(nrect.p1.x, resp.resize_nbound.p1.x);
+        PCUT_ASSERT_INT_EQUALS(nrect.p1.y, resp.resize_nbound.p1.y);
+
+        display_window_destroy(wnd);
         display_close(disp);
         rc = loc_service_unregister(sid);
@@ -792 +929 @@
 
         resp->window_destroy_called = true;
+        resp->destroy_wnd_id = wnd_id;
+        return resp->rc;
+}
+
+static errno_t test_window_resize(void *arg, sysarg_t wnd_id,
+    gfx_coord2_t *offs, gfx_rect_t *nrect)
+{
+        test_response_t *resp = (test_response_t *) arg;
+
+        resp->window_resize_called = true;
+        resp->resize_wnd_id = wnd_id;
+        resp->resize_offs = *offs;
+        resp->resize_nbound = *nrect;
         return resp->rc;
 }