Changes in uspace/srv/hid/console/console.c [28a5ebd:5d1ff11] in mainline

File:

• uspace/srv/hid/console/console.c (modified) (20 diffs)

uspace/srv/hid/console/console.c

@@ -1 +1 @@
 /*
+ * Copyright (c) 2021 Jiri Svoboda
  * Copyright (c) 2011 Martin Decky
  * All rights reserved.
@@ -62 +63 @@
 typedef struct {
         atomic_flag refcnt;      /**< Connection reference count */
-        prodcons_t input_pc;  /**< Incoming keyboard events */
+        prodcons_t input_pc;  /**< Incoming console events */
 
         /**
@@ -79 +80 @@
         console_caps_t ccaps;  /**< Console capabilities */
 
+        sysarg_t ucols;         /**< Number of columns in user buffer */
+        sysarg_t urows;         /**< Number of rows in user buffer */
+        charfield_t *ubuf;      /**< User buffer */
+
         chargrid_t *frontbuf;    /**< Front buffer */
         frontbuf_handle_t fbid;  /**< Front buffer handle */
@@ -94 +99 @@
 static sysarg_t cols;
 static sysarg_t rows;
+
+/** Mouse pointer X coordinate */
+static int pointer_x;
+/** Mouse pointer Y coordinate */
+static int pointer_y;
+/** Character under mouse cursor */
+static charfield_t pointer_bg;
+
+static int mouse_scale_x = 4;
+static int mouse_scale_y = 8;
 
 /** Array of data for virtual consoles */
@@ -135 +150 @@
 static void cons_set_cursor_visibility(con_srv_t *, bool);
 static errno_t cons_get_event(con_srv_t *, cons_event_t *);
+static errno_t cons_map(con_srv_t *, sysarg_t, sysarg_t, charfield_t **);
+static void cons_unmap(con_srv_t *);
+static void cons_buf_update(con_srv_t *, sysarg_t, sysarg_t, sysarg_t,
+    sysarg_t);
 
 static con_ops_t con_ops = {
@@ -151 +170 @@
         .set_rgb_color = cons_set_rgb_color,
         .set_cursor_visibility = cons_set_cursor_visibility,
-        .get_event = cons_get_event
+        .get_event = cons_get_event,
+        .map = cons_map,
+        .unmap = cons_unmap,
+        .update = cons_buf_update
 };
+
+static void pointer_draw(void);
+static void pointer_undraw(void);
 
 static console_t *srv_to_console(con_srv_t *srv)
@@ -219 +244 @@
 
         fibril_mutex_lock(&switch_mtx);
+        pointer_undraw();
 
         if (cons == active_console) {
@@ -227 +253 @@
         active_console = cons;
 
+        pointer_draw();
         fibril_mutex_unlock(&switch_mtx);
 
         cons_damage(cons);
+}
+
+/** Draw mouse pointer. */
+static void pointer_draw(void)
+{
+        charfield_t *ch;
+        int col, row;
+
+        /* Downscale coordinates to text resolution */
+        col = pointer_x / mouse_scale_x;
+        row = pointer_y / mouse_scale_y;
+
+        /* Make sure they are in range */
+        if (col < 0 || row < 0 || col >= (int)cols || row >= (int)rows)
+                return;
+
+        ch = chargrid_charfield_at(active_console->frontbuf, col, row);
+
+        /*
+         * Store background attributes for undrawing the pointer.
+         * This is necessary as styles cannot be inverted with
+         * round trip (unlike RGB or INDEX)
+         */
+        pointer_bg = *ch;
+
+        /* In general the color should be a one's complement of the background */
+        if (ch->attrs.type == CHAR_ATTR_INDEX) {
+                ch->attrs.val.index.bgcolor ^= 0xf;
+                ch->attrs.val.index.fgcolor ^= 0xf;
+        } else if (ch->attrs.type == CHAR_ATTR_RGB) {
+                ch->attrs.val.rgb.fgcolor ^= 0xffffff;
+                ch->attrs.val.rgb.bgcolor ^= 0xffffff;
+        } else if (ch->attrs.type == CHAR_ATTR_STYLE) {
+                /* Don't have a proper inverse for each style */
+                if (ch->attrs.val.style == STYLE_INVERTED)
+                        ch->attrs.val.style = STYLE_NORMAL;
+                else
+                        ch->attrs.val.style = STYLE_INVERTED;
+        }
+
+        /* Make sure the cell gets updated */
+        ch->flags |= CHAR_FLAG_DIRTY;
+}
+
+/** Undraw mouse pointer. */
+static void pointer_undraw(void)
+{
+        charfield_t *ch;
+        int col, row;
+
+        col = pointer_x / mouse_scale_x;
+        row = pointer_y / mouse_scale_y;
+        if (col < 0 || row < 0 || col >= (int)cols || row >= (int)rows)
+                return;
+
+        ch = chargrid_charfield_at(active_console->frontbuf, col, row);
+        *ch = pointer_bg;
+        ch->flags |= CHAR_FLAG_DIRTY;
+}
+
+/** Queue console event.
+ *
+ * @param cons Console
+ * @param ev Console event
+ */
+static void console_queue_cons_event(console_t *cons, cons_event_t *ev)
+{
+        /* Got key press/release event */
+        cons_event_t *event =
+            (cons_event_t *) malloc(sizeof(cons_event_t));
+        if (event == NULL)
+                return;
+
+        *event = *ev;
+        link_initialize(&event->link);
+
+        prodcons_produce(&cons->input_pc, &event->link);
 }
 
@@ -252 +356 @@
     keymod_t mods, char32_t c)
 {
+        cons_event_t event;
+
         if ((key >= KC_F1) && (key <= KC_F1 + CONSOLE_COUNT) &&
             ((mods & KM_CTRL) == 0)) {
@@ -257 +363 @@
         } else {
                 /* Got key press/release event */
-                kbd_event_t *event =
-                    (kbd_event_t *) malloc(sizeof(kbd_event_t));
-                if (event == NULL) {
-                        return ENOMEM;
-                }
-
-                link_initialize(&event->link);
-                event->type = type;
-                event->key = key;
-                event->mods = mods;
-                event->c = c;
-
-                prodcons_produce(&active_console->input_pc,
-                    &event->link);
-        }
-
-        return EOK;
+                event.type = CEV_KEY;
+
+                event.ev.key.type = type;
+                event.ev.key.key = key;
+                event.ev.key.mods = mods;
+                event.ev.key.c = c;
+
+                console_queue_cons_event(active_console, &event);
+        }
+
+        return EOK;
+}
+
+/** Update pointer position.
+ *
+ * @param new_x New X coordinate (in pixels)
+ * @param new_y New Y coordinate (in pixels)
+ */
+static void pointer_update(int new_x, int new_y)
+{
+        bool upd_pointer;
+
+        /* Make sure coordinates are in range */
+
+        if (new_x < 0)
+                new_x = 0;
+        if (new_x >= (int)cols * mouse_scale_x)
+                new_x = cols * mouse_scale_x - 1;
+        if (new_y < 0)
+                new_y = 0;
+        if (new_y >= (int)rows * mouse_scale_y)
+                new_y = rows * mouse_scale_y - 1;
+
+        /* Determine if pointer moved to a different character cell */
+        upd_pointer = (new_x / mouse_scale_x != pointer_x / mouse_scale_x) ||
+            (new_y / mouse_scale_y != pointer_y / mouse_scale_y);
+
+        if (upd_pointer)
+                pointer_undraw();
+
+        /* Store new pointer position */
+        pointer_x = new_x;
+        pointer_y = new_y;
+
+        if (upd_pointer) {
+                pointer_draw();
+                cons_update(active_console);
+        }
 }
 
 static errno_t input_ev_move(input_t *input, int dx, int dy)
 {
+        pointer_update(pointer_x + dx, pointer_y + dy);
         return EOK;
 }
@@ -284 +422 @@
     unsigned max_x, unsigned max_y)
 {
+        pointer_update(mouse_scale_x * cols * x / max_x, mouse_scale_y * rows * y / max_y);
         return EOK;
 }
@@ -289 +428 @@
 static errno_t input_ev_button(input_t *input, int bnum, int bpress)
 {
+        cons_event_t event;
+
+        event.type = CEV_POS;
+        event.ev.pos.type = bpress ? POS_PRESS : POS_RELEASE;
+        event.ev.pos.btn_num = bnum;
+        event.ev.pos.hpos = pointer_x / mouse_scale_x;
+        event.ev.pos.vpos = pointer_y / mouse_scale_y;
+
+        console_queue_cons_event(active_console, &event);
         return EOK;
 }
@@ -298 +446 @@
 
         fibril_mutex_lock(&cons->mtx);
+        pointer_undraw();
 
         switch (ch) {
@@ -315 +464 @@
         }
 
+        pointer_draw();
         fibril_mutex_unlock(&cons->mtx);
 
@@ -324 +474 @@
 {
         fibril_mutex_lock(&cons->mtx);
+        pointer_undraw();
         chargrid_set_cursor_visibility(cons->frontbuf, visible);
+        pointer_draw();
         fibril_mutex_unlock(&cons->mtx);
 
@@ -367 +519 @@
                 if (pos < size) {
                         link_t *link = prodcons_consume(&cons->input_pc);
-                        kbd_event_t *event = list_get_instance(link, kbd_event_t, link);
+                        cons_event_t *event = list_get_instance(link,
+                            cons_event_t, link);
 
                         /* Accept key presses of printable chars only. */
-                        if ((event->type == KEY_PRESS) && (event->c != 0)) {
-                                char32_t tmp[2] = { event->c, 0 };
+                        if (event->type == CEV_KEY && event->ev.key.type == KEY_PRESS &&
+                            (event->ev.key.c != 0)) {
+                                char32_t tmp[2] = { event->ev.key.c, 0 };
                                 wstr_to_str(cons->char_remains, UTF8_CHAR_BUFFER_SIZE, tmp);
                                 cons->char_remains_len = str_size(cons->char_remains);
@@ -408 +562 @@
 
         fibril_mutex_lock(&cons->mtx);
+        pointer_undraw();
         chargrid_clear(cons->frontbuf);
+        pointer_draw();
         fibril_mutex_unlock(&cons->mtx);
 
@@ -419 +575 @@
 
         fibril_mutex_lock(&cons->mtx);
+        pointer_undraw();
         chargrid_set_cursor(cons->frontbuf, col, row);
+        pointer_draw();
         fibril_mutex_unlock(&cons->mtx);
 
@@ -499 +657 @@
         console_t *cons = srv_to_console(srv);
         link_t *link = prodcons_consume(&cons->input_pc);
-        kbd_event_t *kevent = list_get_instance(link, kbd_event_t, link);
-
-        event->type = CEV_KEY;
-        event->ev.key = *kevent;
-
-        free(kevent);
-        return EOK;
+        cons_event_t *cevent = list_get_instance(link, cons_event_t, link);
+
+        *event = *cevent;
+        free(cevent);
+        return EOK;
+}
+
+/** Create shared buffer for efficient rendering.
+ *
+ * @param srv Console server
+ * @param cols Number of columns in buffer
+ * @param rows Number of rows in buffer
+ * @param rbuf Place to store pointer to new sharable buffer
+ *
+ * @return EOK on sucess or an error code
+ */
+static errno_t cons_map(con_srv_t *srv, sysarg_t cols, sysarg_t rows,
+    charfield_t **rbuf)
+{
+        console_t *cons = srv_to_console(srv);
+        void *buf;
+
+        fibril_mutex_lock(&cons->mtx);
+
+        if (cons->ubuf != NULL) {
+                fibril_mutex_unlock(&cons->mtx);
+                return EBUSY;
+        }
+
+        buf = as_area_create(AS_AREA_ANY, cols * rows * sizeof(charfield_t),
+            AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE, AS_AREA_UNPAGED);
+        if (buf == AS_MAP_FAILED) {
+                fibril_mutex_unlock(&cons->mtx);
+                return ENOMEM;
+        }
+
+        cons->ucols = cols;
+        cons->urows = rows;
+        cons->ubuf = buf;
+        fibril_mutex_unlock(&cons->mtx);
+
+        *rbuf = buf;
+        return EOK;
+}
+
+/** Delete shared buffer.
+ *
+ * @param srv Console server
+ */
+static void cons_unmap(con_srv_t *srv)
+{
+        console_t *cons = srv_to_console(srv);
+        void *buf;
+
+        fibril_mutex_lock(&cons->mtx);
+
+        buf = cons->ubuf;
+        cons->ubuf = NULL;
+
+        if (buf != NULL)
+                as_area_destroy(buf);
+
+        fibril_mutex_unlock(&cons->mtx);
+}
+
+/** Update area of console from shared buffer.
+ *
+ * @param srv Console server
+ * @param c0 Column coordinate of top-left corner (inclusive)
+ * @param r0 Row coordinate of top-left corner (inclusive)
+ * @param c1 Column coordinate of bottom-right corner (exclusive)
+ * @param r1 Row coordinate of bottom-right corner (exclusive)
+ */
+static void cons_buf_update(con_srv_t *srv, sysarg_t c0, sysarg_t r0,
+    sysarg_t c1, sysarg_t r1)
+{
+        console_t *cons = srv_to_console(srv);
+        charfield_t *ch;
+        sysarg_t col, row;
+
+        fibril_mutex_lock(&cons->mtx);
+
+        if (cons->ubuf == NULL) {
+                fibril_mutex_unlock(&cons->mtx);
+                return;
+        }
+
+        /* Make sure we have meaningful coordinates, within bounds */
+
+        if (c1 > cons->ucols)
+                c1 = cons->ucols;
+        if (c1 > cons->cols)
+                c1 = cons->cols;
+        if (c0 >= c1) {
+                fibril_mutex_unlock(&cons->mtx);
+                return;
+        }
+        if (r1 > cons->urows)
+                r1 = cons->urows;
+        if (r1 > cons->rows)
+                r1 = cons->rows;
+        if (r0 >= r1) {
+                fibril_mutex_unlock(&cons->mtx);
+                return;
+        }
+
+        /* Update front buffer from user buffer */
+
+        pointer_undraw();
+
+        for (row = r0; row < r1; row++) {
+                for (col = c0; col < c1; col++) {
+                        ch = chargrid_charfield_at(cons->frontbuf, col, row);
+                        *ch = cons->ubuf[row * cons->ucols + col];
+                }
+        }
+
+        pointer_draw();
+        fibril_mutex_unlock(&cons->mtx);
+
+        /* Update console */
+        cons_update(cons);
 }
 
@@ -649 +922 @@
 
                 input_activate(input);
+                active = true;
+                cons_damage(active_console);
         }