Changes in uspace/lib/ui/src/ui.c [d55ab823:26edcd6] in mainline

File:

• uspace/lib/ui/src/ui.c (modified) (8 diffs)

uspace/lib/ui/src/ui.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2020 Jiri Svoboda
+ * Copyright (c) 2026 Jiri Svoboda
  * All rights reserved.
  *
@@ -34 +34 @@
  */
 
+#include <adt/list.h>
+#include <ctype.h>
 #include <display.h>
 #include <errno.h>
 #include <fibril.h>
+#include <fibril_synch.h>
+#include <gfx/color.h>
+#include <gfx/cursor.h>
+#include <gfx/render.h>
+#include <io/console.h>
+#include <stdbool.h>
 #include <stdlib.h>
+#include <str.h>
 #include <task.h>
+#include <types/common.h>
+#include <ui/clickmatic.h>
 #include <ui/ui.h>
+#include <ui/wdecor.h>
+#include <ui/window.h>
+#include "../private/wdecor.h"
+#include "../private/window.h"
 #include "../private/ui.h"
 
+/** Parse output specification.
+ *
+ * Output specification has the form <proto>@<service> where proto is
+ * eiher 'disp' for display service, 'cons' for console, 'null'
+ * for dummy output. Service is a location ID service name (e.g. hid/display).
+ *
+ * @param ospec Output specification
+ * @param ws Place to store window system type (protocol)
+ * @param osvc Place to store pointer to output service name
+ * @param ridev_id Place to store input device ID
+ * @return EOK on success, EINVAL if syntax is invalid, ENOMEM if out of
+ *         memory
+ */
+static errno_t ui_ospec_parse(const char *ospec, ui_winsys_t *ws,
+    char **osvc, sysarg_t *ridev_id)
+{
+        const char *cp;
+        const char *qm;
+        const char *endptr;
+        uint64_t idev_id;
+        errno_t rc;
+
+        *ridev_id = 0;
+
+        cp = ospec;
+        while (isalpha(*cp))
+                ++cp;
+
+        /* Window system / protocol */
+        if (*cp == '@') {
+                if (str_lcmp(ospec, "disp@", str_length("disp@")) == 0) {
+                        *ws = ui_ws_display;
+                } else if (str_lcmp(ospec, "cons@", str_length("cons@")) == 0) {
+                        *ws = ui_ws_console;
+                } else if (str_lcmp(ospec, "null@", str_length("null@")) == 0) {
+                        *ws = ui_ws_null;
+                } else if (str_lcmp(ospec, "@", str_length("@")) == 0) {
+                        *ws = ui_ws_any;
+                } else {
+                        *ws = ui_ws_unknown;
+                }
+
+                ++cp;
+        } else {
+                *ws = ui_ws_display;
+        }
+
+        /* Output service is the part before question mark */
+        qm = str_chr(cp, '?');
+        if (qm != NULL) {
+                *osvc = str_ndup(cp, qm - cp);
+        } else {
+                /* No question mark */
+                *osvc = str_dup(cp);
+        }
+
+        if (*osvc == NULL)
+                return ENOMEM;
+
+        if (qm != NULL) {
+                /* The part after the question mark */
+                cp = qm + 1;
+
+                /* Input device ID parameter */
+                if (str_lcmp(cp, "idev=", str_length("idev=")) == 0) {
+                        cp += str_length("idev=");
+
+                        rc = str_uint64_t(cp, &endptr, 10, false, &idev_id);
+                        if (rc != EOK)
+                                goto error;
+
+                        *ridev_id = idev_id;
+                        cp = endptr;
+                }
+        }
+
+        if (*cp != '\0') {
+                rc = EINVAL;
+                goto error;
+        }
+
+        return EOK;
+error:
+        free(*osvc);
+        *osvc = NULL;
+        return rc;
+}
+
 /** Create new user interface.
  *
  * @param ospec Output specification or @c UI_DISPLAY_DEFAULT to use
- *              the default output
+ *              the default display service, UI_CONSOLE_DEFAULT to use
+ *              the default console service, UI_DISPLAY_NULL to use
+ *              dummy output.
  * @param rui Place to store pointer to new UI
  * @return EOK on success or an error code
@@ -53 +158 @@
         errno_t rc;
         display_t *display;
+        console_ctrl_t *console;
+        console_gc_t *cgc;
+        ui_winsys_t ws;
+        char *osvc;
+        sysarg_t cols;
+        sysarg_t rows;
+        sysarg_t idev_id;
         ui_t *ui;
 
-        rc = display_open(ospec, &display);
+        rc = ui_ospec_parse(ospec, &ws, &osvc, &idev_id);
         if (rc != EOK)
                 return rc;
 
-        rc = ui_create_disp(display, &ui);
+        if (ws == ui_ws_display || ws == ui_ws_any) {
+                rc = display_open((str_cmp(osvc, "") != 0) ? osvc :
+                    DISPLAY_DEFAULT, &display);
+                if (rc != EOK)
+                        goto disp_fail;
+
+                rc = ui_create_disp(display, &ui);
+                if (rc != EOK) {
+                        display_close(display);
+                        goto disp_fail;
+                }
+
+                free(osvc);
+                ui->myoutput = true;
+                ui->idev_id = idev_id;
+                *rui = ui;
+                return EOK;
+        }
+
+disp_fail:
+        if (ws == ui_ws_console || ws == ui_ws_any) {
+                console = console_init(stdin, stdout);
+                if (console == NULL)
+                        goto cons_fail;
+
+                rc = console_get_size(console, &cols, &rows);
+                if (rc != EOK) {
+                        console_done(console);
+                        goto cons_fail;
+                }
+
+                console_cursor_visibility(console, false);
+
+                /* ws == ui_ws_console */
+                rc = ui_create_cons(console, &ui);
+                if (rc != EOK) {
+                        console_done(console);
+                        goto cons_fail;
+                }
+
+                rc = console_gc_create(console, NULL, &cgc);
+                if (rc != EOK) {
+                        ui_destroy(ui);
+                        console_done(console);
+                        goto cons_fail;
+                }
+
+                free(osvc);
+
+                ui->cgc = cgc;
+                ui->rect.p0.x = 0;
+                ui->rect.p0.y = 0;
+                ui->rect.p1.x = cols;
+                ui->rect.p1.y = rows;
+
+                (void) ui_paint(ui);
+                ui->myoutput = true;
+                *rui = ui;
+                return EOK;
+        }
+
+cons_fail:
+        if (ws == ui_ws_null) {
+                free(osvc);
+                rc = ui_create_disp(NULL, &ui);
+                if (rc != EOK)
+                        return rc;
+
+                ui->myoutput = true;
+                *rui = ui;
+                return EOK;
+        }
+
+        free(osvc);
+        return EINVAL;
+}
+
+/** Create new user interface using console service.
+ *
+ * @param rui Place to store pointer to new UI
+ * @return EOK on success or an error code
+ */
+errno_t ui_create_cons(console_ctrl_t *console, ui_t **rui)
+{
+        ui_t *ui;
+        errno_t rc;
+
+        ui = calloc(1, sizeof(ui_t));
+        if (ui == NULL)
+                return ENOMEM;
+
+        rc = ui_clickmatic_create(ui, &ui->clickmatic);
         if (rc != EOK) {
-                display_close(display);
-                return rc;
-        }
-
-        ui->display = display;
-        ui->myoutput = true;
+                free(ui);
+                return rc;
+        }
+
+        ui->console = console;
+        list_initialize(&ui->windows);
+        fibril_mutex_initialize(&ui->lock);
         *rui = ui;
         return EOK;
@@ -80 +284 @@
 {
         ui_t *ui;
+        errno_t rc;
 
         ui = calloc(1, sizeof(ui_t));
@@ -85 +290 @@
                 return ENOMEM;
 
+        rc = ui_clickmatic_create(ui, &ui->clickmatic);
+        if (rc != EOK) {
+                free(ui);
+                return rc;
+        }
+
         ui->display = disp;
+        list_initialize(&ui->windows);
+        fibril_mutex_initialize(&ui->lock);
         *rui = ui;
         return EOK;
@@ -99 +312 @@
                 return;
 
-        if (ui->myoutput)
-                display_close(ui->display);
+        if (ui->myoutput) {
+                if (ui->cgc != NULL)
+                        console_gc_delete(ui->cgc);
+                if (ui->console != NULL) {
+                        console_cursor_visibility(ui->console, true);
+                        console_done(ui->console);
+                }
+                if (ui->display != NULL)
+                        display_close(ui->display);
+        }
+
         free(ui);
+}
+
+/** Resize UI after screen size change.
+ *
+ * @param ui UI
+ * @param rect New screen rectangle.
+ */
+static void ui_resize(ui_t *ui, gfx_rect_t *rect)
+{
+        ui_window_t *wnd;
+
+        ui->rect = *rect;
+
+        /* Reposition/resize windows */
+        wnd = ui_window_first(ui);
+        while (wnd != NULL) {
+                ui_window_update_placement(wnd);
+                wnd = ui_window_next(wnd);
+        }
+
+        /*
+         * XXX Resizing cleared console GC so we need to repaint the
+         * background.
+         */
+        (void)ui_paint(ui);
+}
+
+static void ui_cons_event_process(ui_t *ui, cons_event_t *event)
+{
+        ui_window_t *awnd;
+        ui_evclaim_t claim;
+        pos_event_t pos;
+        sysarg_t cols, rows;
+        gfx_rect_t rect;
+        errno_t rc;
+
+        awnd = ui_window_get_active(ui);
+        if (awnd == NULL)
+                return;
+
+        switch (event->type) {
+        case CEV_KEY:
+                ui_lock(ui);
+                ui_window_send_kbd(awnd, &event->ev.key);
+                ui_unlock(ui);
+                break;
+        case CEV_POS:
+                pos = event->ev.pos;
+                /* Translate event to window-relative coordinates */
+                pos.hpos -= awnd->dpos.x;
+                pos.vpos -= awnd->dpos.y;
+
+                claim = ui_wdecor_pos_event(awnd->wdecor, &pos);
+                /* Note: If event is claimed, awnd might not be valid anymore */
+                if (claim == ui_unclaimed) {
+                        ui_lock(ui);
+                        ui_window_send_pos(awnd, &pos);
+                        ui_unlock(ui);
+                }
+
+                break;
+        case CEV_RESIZE:
+                rc = console_gc_resize(ui->cgc);
+                if (rc != EOK) {
+                        /* XXX No good way to recover. */
+                        console_done(ui->console);
+                        exit(1);
+                }
+
+                rc = console_get_size(ui->console, &cols, &rows);
+                if (rc != EOK) {
+                        /* XXX No good way to recover. */
+                        console_done(ui->console);
+                        exit(1);
+                }
+
+                ui_lock(ui);
+
+                rect.p0.x = 0;
+                rect.p0.y = 0;
+                rect.p1.x = cols;
+                rect.p1.y = rows;
+
+                ui_resize(ui, &rect);
+                ui_unlock(ui);
+                break;
+        }
 }
 
@@ -113 +422 @@
 void ui_run(ui_t *ui)
 {
-        task_retval(0);
-
-        while (!ui->quit)
-                fibril_usleep(100000);
+        cons_event_t event;
+        usec_t timeout;
+        errno_t rc;
+
+        /* Only return command prompt if we are running in a separate window */
+        if (ui->display != NULL)
+                task_retval(0);
+
+        while (!ui->quit) {
+                if (ui->console != NULL) {
+                        timeout = 100000;
+                        rc = console_get_event_timeout(ui->console,
+                            &event, &timeout);
+
+                        /* Do we actually have an event? */
+                        if (rc == EOK) {
+                                ui_cons_event_process(ui, &event);
+                        } else if (rc != ETIMEOUT) {
+                                /* Error, quit */
+                                break;
+                        }
+                } else {
+                        fibril_usleep(100000);
+                }
+        }
+}
+
+/** Repaint UI (only used in fullscreen mode).
+ *
+ * This is used when an area is exposed in fullscreen mode.
+ *
+ * @param ui UI
+ * @return @c EOK on success or an error code
+ */
+errno_t ui_paint(ui_t *ui)
+{
+        errno_t rc;
+        gfx_context_t *gc;
+        ui_window_t *wnd;
+        gfx_color_t *color = NULL;
+
+        /* In case of null output */
+        if (ui->cgc == NULL)
+                return EOK;
+
+        gc = console_gc_get_ctx(ui->cgc);
+
+        rc = gfx_color_new_ega(0x11, &color);
+        if (rc != EOK)
+                return rc;
+
+        rc = gfx_set_color(gc, color);
+        if (rc != EOK) {
+                gfx_color_delete(color);
+                return rc;
+        }
+
+        rc = gfx_fill_rect(gc, &ui->rect);
+        if (rc != EOK) {
+                gfx_color_delete(color);
+                return rc;
+        }
+
+        gfx_color_delete(color);
+
+        /* Repaint all windows */
+        wnd = ui_window_first(ui);
+        while (wnd != NULL) {
+                rc = ui_wdecor_paint(wnd->wdecor);
+                if (rc != EOK)
+                        return rc;
+
+                rc = ui_window_paint(wnd);
+                if (rc != EOK)
+                        return rc;
+
+                wnd = ui_window_next(wnd);
+        }
+
+        return EOK;
+}
+
+/** Free up console for other users.
+ *
+ * Release console resources for another application (that the current
+ * task is starting). After the other application finishes, resume
+ * operation with ui_resume(). No calls to UI must happen inbetween
+ * and no events must be processed (i.e. the calling function must not
+ * return control to UI.
+ *
+ * @param ui UI
+ * @return EOK on success or an error code
+ */
+errno_t ui_suspend(ui_t *ui)
+{
+        errno_t rc;
+
+        assert(!ui->suspended);
+
+        if (ui->cgc == NULL) {
+                ui->suspended = true;
+                return EOK;
+        }
+
+        (void) console_set_caption(ui->console, "");
+        rc = console_gc_suspend(ui->cgc);
+        if (rc != EOK)
+                return rc;
+
+        ui->suspended = true;
+        return EOK;
+}
+
+/** Resume suspended UI.
+ *
+ * Reclaim console resources (after child application has finished running)
+ * and restore UI operation previously suspended by calling ui_suspend().
+ *
+ * @param ui UI
+ * @return EOK on success or an error code
+ */
+errno_t ui_resume(ui_t *ui)
+{
+        errno_t rc;
+        ui_window_t *awnd;
+        sysarg_t col;
+        sysarg_t row;
+        cons_event_t ev;
+
+        assert(ui->suspended);
+
+        if (ui->cgc == NULL) {
+                ui->suspended = false;
+                return EOK;
+        }
+
+        rc = console_get_pos(ui->console, &col, &row);
+        if (rc != EOK)
+                return rc;
+
+        /*
+         * Here's a little heuristic to help determine if we need
+         * to pause before returning to the UI. If we are in the
+         * top-left corner, chances are the screen is empty and
+         * there is no need to pause.
+         */
+        if (col != 0 || row != 0) {
+                printf("Press any key or button to continue...\n");
+
+                while (true) {
+                        rc = console_get_event(ui->console, &ev);
+                        if (rc != EOK)
+                                return EIO;
+
+                        if (ev.type == CEV_KEY && ev.ev.key.type == KEY_PRESS)
+                                break;
+
+                        if (ev.type == CEV_POS && ev.ev.pos.type == POS_PRESS)
+                                break;
+                }
+        }
+
+        rc = console_gc_resume(ui->cgc);
+        if (rc != EOK)
+                return rc;
+
+        ui->suspended = false;
+
+        awnd = ui_window_get_active(ui);
+        if (awnd != NULL)
+                (void) console_set_caption(ui->console, awnd->wdecor->caption);
+
+        rc = gfx_cursor_set_visible(console_gc_get_ctx(ui->cgc), false);
+        if (rc != EOK)
+                return rc;
+
+        return EOK;
+}
+
+/** Determine if UI is suspended.
+ *
+ * @param ui UI
+ * @return @c true iff UI is suspended
+ */
+bool ui_is_suspended(ui_t *ui)
+{
+        return ui->suspended;
+}
+
+/** Lock UI.
+ *
+ * Block UI from calling window callbacks. @c ui_lock() and @c ui_unlock()
+ * must be used when accessing UI resources from a fibril (as opposed to
+ * from a window callback).
+ *
+ * @param ui UI
+ */
+void ui_lock(ui_t *ui)
+{
+        if (ui->display != NULL)
+                display_lock(ui->display);
+        fibril_mutex_lock(&ui->lock);
+}
+
+/** Unlock UI.
+ *
+ * Allow UI to call window callbacks. @c ui_lock() and @c ui_unlock()
+ * must be used when accessing window resources from a fibril (as opposed to
+ * from a window callback).
+ *
+ * @param ui UI
+ */
+void ui_unlock(ui_t *ui)
+{
+        fibril_mutex_unlock(&ui->lock);
+        if (ui->display != NULL)
+                display_unlock(ui->display);
 }
 
@@ -132 +654 @@
 }
 
+/** Determine if we are running in text mode.
+ *
+ * @param ui User interface
+ * @return @c true iff we are running in text mode
+ */
+bool ui_is_textmode(ui_t *ui)
+{
+        /*
+         * XXX Currently console is always text and display is always
+         * graphics, but this need not always be true.
+         */
+        return (ui->console != NULL);
+}
+
+/** Determine if we are emulating windows.
+ *
+ * @param ui User interface
+ * @return @c true iff we are running in text mode
+ */
+bool ui_is_fullscreen(ui_t *ui)
+{
+        return (ui->display == NULL);
+}
+
+/** Get UI screen rectangle.
+ *
+ * @param ui User interface
+ * @param rect Place to store bounding rectangle
+ */
+errno_t ui_get_rect(ui_t *ui, gfx_rect_t *rect)
+{
+        display_info_t info;
+        sysarg_t cols, rows;
+        errno_t rc;
+
+        if (ui->display != NULL) {
+                rc = display_get_info(ui->display, &info);
+                if (rc != EOK)
+                        return rc;
+
+                *rect = info.rect;
+        } else if (ui->console != NULL) {
+                rc = console_get_size(ui->console, &cols, &rows);
+                if (rc != EOK)
+                        return rc;
+
+                rect->p0.x = 0;
+                rect->p0.y = 0;
+                rect->p1.x = cols;
+                rect->p1.y = rows;
+        } else {
+                return ENOTSUP;
+        }
+
+        return EOK;
+}
+
+/** Get clickmatic from UI.
+ *
+ * @pararm ui UI
+ * @return Clickmatic
+ */
+ui_clickmatic_t *ui_get_clickmatic(ui_t *ui)
+{
+        return ui->clickmatic;
+}
+
 /** @}
  */