source: mainline/uspace/lib/termui/src/termui.c

/*
 * Copyright (c) 2024 Jiří Zárevúcky
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <termui.h>

#include <assert.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>

#include "history.h"

struct termui {
        int cols;
        int rows;

        int col;
        int row;

        bool cursor_visible;

        // How much of the screen is in use. Relevant for clrscr.
        int used_rows;

        // Row index of the first screen row in the circular screen buffer.
        int first_row;
        // rows * cols circular buffer of the current virtual screen contents.
        // Does not necessarily correspond to the currently visible text,
        // if scrollback is active.
        termui_cell_t *screen;
        // Set to one if the corresponding row has overflowed into the next row.
        uint8_t *overflow_flags;

        /* Used to remove extra newline when CRLF is placed exactly on row boundary. */
        bool overflow;

        struct history history;

        termui_cell_t style;
        termui_cell_t default_cell;

        termui_scroll_cb_t scroll_cb;
        termui_update_cb_t update_cb;
        termui_refresh_cb_t refresh_cb;
        void *scroll_udata;
        void *update_udata;
        void *refresh_udata;
};

static int _real_row(const termui_t *termui, int row)
{
        row += termui->first_row;
        if (row >= termui->rows)
                row -= termui->rows;

        return row;
}

#define _screen_cell(termui, col, row) \
        ((termui)->screen[(termui)->cols * _real_row((termui), (row)) + (col)])

#define _current_cell(termui) \
        _screen_cell((termui), (termui)->col, (termui)->row)

#define _overflow_flag(termui, row) \
        ((termui)->overflow_flags[_real_row((termui), (row))])

/** Sets current cell style/color.
 */
void termui_set_style(termui_t *termui, termui_cell_t style)
{
        termui->style = style;
}

static void _termui_evict_row(termui_t *termui)
{
        if (termui->used_rows <= 0)
                return;

        bool last = !_overflow_flag(termui, 0);

        for (int col = 0; col < termui->cols; col++)
                _screen_cell(termui, col, 0).cursor = 0;

        /* Append first row of the screen to history. */
        _history_append_row(&termui->history, &_screen_cell(termui, 0, 0), last);

        _overflow_flag(termui, 0) = false;

        /* Clear the row we moved to history. */
        for (int col = 0; col < termui->cols; col++)
                _screen_cell(termui, col, 0) = termui->default_cell;

        termui->used_rows--;

        termui->row--;
        if (termui->row < 0) {
                termui->row = 0;
                termui->col = 0;
        }

        termui->first_row++;
        if (termui->first_row >= termui->rows)
                termui->first_row -= termui->rows;

        assert(termui->first_row < termui->rows);
}

/**
 * Get active screen row. This always points to the primary output buffer,
 * unaffected by viewport shifting. Can be used for modifying the screen
 * directly. For displaying viewport, use termui_force_viewport_update().
 */
termui_cell_t *termui_get_active_row(termui_t *termui, int row)
{
        assert(row >= 0);
        assert(row < termui->rows);

        return &_screen_cell(termui, 0, row);
}

static void _update_active_cells(termui_t *termui, int col, int row, int cells)
{
        int viewport_rows = _history_viewport_rows(&termui->history, termui->rows);
        int active_rows_shown = termui->rows - viewport_rows;

        /* Send update if the cells are visible in viewport. */
        if (termui->update_cb && active_rows_shown > row)
                termui->update_cb(termui->update_udata, col, row + viewport_rows, &_screen_cell(termui, col, row), cells);
}

static void _update_current_cell(termui_t *termui)
{
        _update_active_cells(termui, termui->col, termui->row, 1);
}

static void _cursor_off(termui_t *termui)
{
        if (termui->cursor_visible) {
                _current_cell(termui).cursor = 0;
                _update_current_cell(termui);
        }
}

static void _cursor_on(termui_t *termui)
{
        if (termui->cursor_visible) {
                _current_cell(termui).cursor = 1;
                _update_current_cell(termui);
        }
}

static void _advance_line(termui_t *termui)
{
        if (termui->row + 1 >= termui->rows) {
                size_t old_top = termui->history.viewport_top;

                _termui_evict_row(termui);

                if (old_top != termui->history.viewport_top && termui->refresh_cb)
                        termui->refresh_cb(termui->refresh_udata);

                if (termui->scroll_cb && !_scrollback_active(&termui->history))
                        termui->scroll_cb(termui->scroll_udata, 1);
        }

        if (termui->rows > 1)
                termui->row++;

        if (termui->row >= termui->used_rows)
                termui->used_rows = termui->row + 1;

        assert(termui->row < termui->rows);
}

void termui_put_lf(termui_t *termui)
{
        _cursor_off(termui);
        termui->overflow = false;
        _advance_line(termui);
        _cursor_on(termui);
}

void termui_put_cr(termui_t *termui)
{
        _cursor_off(termui);

        /* CR right after overflow from previous row. */
        if (termui->overflow && termui->row > 0) {
                termui->row--;
                _overflow_flag(termui, termui->row) = 0;
        }

        termui->overflow = false;

        // Set position to start of current line.
        termui->col = 0;

        _cursor_on(termui);
}

/* Combined CR & LF to cut down on cursor update callbacks. */
void termui_put_crlf(termui_t *termui)
{
        _cursor_off(termui);

        /* CR right after overflow from previous row. */
        if (termui->overflow && termui->row > 0) {
                termui->row--;
                _overflow_flag(termui, termui->row) = 0;
        }

        termui->overflow = false;

        // Set position to start of next row.
        _advance_line(termui);
        termui->col = 0;

        _cursor_on(termui);
}

void termui_put_tab(termui_t *termui)
{
        _cursor_off(termui);

        termui->overflow = false;

        int new_col = (termui->col / 8 + 1) * 8;
        if (new_col >= termui->cols)
                new_col = termui->cols - 1;
        termui->col = new_col;

        _cursor_on(termui);
}

void termui_put_backspace(termui_t *termui)
{
        _cursor_off(termui);

        termui->overflow = false;

        if (termui->col == 0) {
                if (termui->row > 0 && _overflow_flag(termui, termui->row - 1)) {
                        termui->row--;
                        termui->col = termui->cols - 1;
                        _overflow_flag(termui, termui->row) = false;
                }
        } else {
                termui->col--;
        }

        _cursor_on(termui);
}

/**
 * Put glyph at current position, and advance column by width, overflowing into
 * next row and scrolling the active screen if necessary.
 *
 * If width > 1, the function makes sure the glyph isn't split by end of row.
 * The following (width - 1) cells are filled with padding cells,
 * and it's the user's responsibility to render this correctly.
 */
void termui_put_glyph(termui_t *termui, uint32_t glyph_idx, int width)
{
        if (termui->row >= termui->used_rows)
                termui->used_rows = termui->row + 1;

        termui_cell_t padding_cell = termui->style;
        padding_cell.padding = 1;
        termui_cell_t cell = termui->style;
        cell.glyph_idx = glyph_idx;

        // FIXME: handle wide glyphs in history correctly after resize

        if (termui->col + width > termui->cols) {
                /* Have to go to next row first. */
                int blanks = termui->cols - termui->col;
                for (int i = 0; i < blanks; i++)
                        _screen_cell(termui, termui->col + i, termui->row) = padding_cell;

                _update_active_cells(termui, termui->col, termui->row, blanks);

                _overflow_flag(termui, termui->row) = 1;
                _advance_line(termui);
                termui->col = 0;
        }

        _current_cell(termui) = cell;
        termui->col++;

        for (int i = 1; i < width; i++) {
                _current_cell(termui) = padding_cell;
                termui->col++;
        }

        if (termui->col < termui->cols) {
                /* The changed cells are all adjacent. */
                if (termui->cursor_visible)
                        _current_cell(termui).cursor = 1;
                _update_active_cells(termui, termui->col - width, termui->row, width + 1);
                termui->overflow = false;
        } else {
                /* Update the written cells and then update cursor on next row. */
                _update_active_cells(termui, termui->col - width, termui->row, width);

                _overflow_flag(termui, termui->row) = 1;
                _advance_line(termui);
                termui->col = 0;
                termui->overflow = true;

                _cursor_on(termui);
        }
}

termui_color_t termui_color_from_rgb(uint8_t r, uint8_t g, uint8_t b)
{
        r = r >> 3;
        g = g >> 3;
        b = b >> 3;

        return 0x8000 | r << 10 | g << 5 | b;
}

void termui_color_to_rgb(const termui_color_t c, uint8_t *r, uint8_t *g, uint8_t *b)
{
        assert((c & 0x8000) != 0);

        /* 15b encoding, bit 15 is set to reserve lower half for other uses. */

        int bb = c & 0x1f;
        int gg = (c >> 5) & 0x1f;
        int rr = (c >> 10) & 0x1f;

        /*
         * 3 extra low order bits are filled from high-order bits to get the full
         * range instead of topping out at 0xf8.
         */
        *r = (rr << 3) | (rr >> 2);
        *g = (gg << 3) | (gg >> 2);
        *b = (bb << 3) | (bb >> 2);

        assert(termui_color_from_rgb(*r, *g, *b) == c);
}

/** Get terminal width.
 */
int termui_get_cols(const termui_t *termui)
{
        return termui->cols;
}

/** Get terminal height.
 */
int termui_get_rows(const termui_t *termui)
{
        return termui->rows;
}

/** Get cursor position
 */
void termui_get_pos(const termui_t *termui, int *col, int *row)
{
        *col = termui->col;
        *row = termui->row;
}

/** Set cursor position.
 */
void termui_set_pos(termui_t *termui, int col, int row)
{
        if (col < 0)
                col = 0;

        if (col >= termui->cols)
                col = termui->cols - 1;

        if (row < 0)
                row = 0;

        if (row >= termui->rows)
                row = termui->rows - 1;

        _cursor_off(termui);

        termui->col = col;
        termui->row = row;

        _cursor_on(termui);
}

/** Clear screen by scrolling out all text currently on screen.
 * Sets position to (0, 0).
 */
void termui_clear_screen(termui_t *termui)
{
        _cursor_off(termui);
        termui_put_crlf(termui);

        int unused_rows = termui->rows - termui->used_rows;

        while (termui->used_rows > 0)
                _termui_evict_row(termui);

        /* Clear out potential garbage left by direct screen access. */
        for (int row = 0; row < unused_rows; row++) {
                for (int col = 0; col < termui->cols; col++) {
                        _screen_cell(termui, col, row) = termui->default_cell;
                }
        }

        termui->row = 0;
        termui->col = 0;

        _cursor_on(termui);

        if (termui->refresh_cb)
                termui->refresh_cb(termui->refresh_udata);
}

/** Erase all text starting at the given row.
 * Erased text is not appended to history.
 * If cursor was in the erased section, it's set to the beginning of it.
 */
void termui_wipe_screen(termui_t *termui, int first_row)
{
        if (first_row >= termui->rows)
                return;

        if (first_row < 0)
                first_row = 0;

        for (int row = first_row; row < termui->rows; row++) {
                for (int col = 0; col < termui->cols; col++)
                        _screen_cell(termui, col, row) = termui->default_cell;

                _overflow_flag(termui, row) = false;
                _update_active_cells(termui, 0, row, termui->cols);
        }

        if (termui->used_rows > first_row)
                termui->used_rows = first_row;

        if (termui->row >= first_row) {
                termui->row = first_row;
                termui->col = 0;
                _cursor_on(termui);
        }
}

void termui_set_scroll_cb(termui_t *termui, termui_scroll_cb_t cb, void *userdata)
{
        termui->scroll_cb = cb;
        termui->scroll_udata = userdata;
}

void termui_set_update_cb(termui_t *termui, termui_update_cb_t cb, void *userdata)
{
        termui->update_cb = cb;
        termui->update_udata = userdata;
}

void termui_set_refresh_cb(termui_t *termui, termui_refresh_cb_t cb, void *userdata)
{
        termui->refresh_cb = cb;
        termui->refresh_udata = userdata;
}

/** Makes update callbacks for all indicated viewport rows.
 * Useful when refreshing the screens or handling a scroll callback.
 */
void termui_force_viewport_update(const termui_t *termui, int first_row, int rows)
{
        assert(first_row >= 0);
        assert(rows >= 0);
        assert(first_row + rows <= termui->rows);

        if (!termui->update_cb)
                return;

        int sb_rows = _history_viewport_rows(&termui->history, termui->rows);
        int updated = _history_iter_rows(&termui->history, first_row, rows, termui->update_cb, termui->update_udata);

        first_row += updated;
        rows -= updated;

        assert(sb_rows <= first_row);

        for (int row = first_row; row < first_row + rows; row++) {
                termui->update_cb(termui->update_udata, 0, row, &_screen_cell(termui, 0, row - sb_rows), termui->cols);
        }
}

bool termui_scrollback_is_active(const termui_t *termui)
{
        return _scrollback_active(&termui->history);
}

termui_t *termui_create(int cols, int rows, size_t history_lines)
{
        /* Prevent numerical overflows. */
        if (cols < 2 || rows < 1 || INT_MAX / cols < rows)
                return NULL;

        int cells = cols * rows;

        termui_t *termui = calloc(1, sizeof(termui_t));
        if (!termui)
                return NULL;

        termui->cols = cols;
        termui->rows = rows;
        termui->history.lines.max_len = history_lines;
        if (history_lines > SIZE_MAX / cols)
                termui->history.cells.max_len = SIZE_MAX;
        else
                termui->history.cells.max_len = history_lines * cols;
        termui->history.cols = cols;

        termui->screen = calloc(cells, sizeof(termui->screen[0]));
        if (!termui->screen) {
                free(termui);
                return NULL;
        }

        termui->overflow_flags = calloc(rows, sizeof(termui->overflow_flags[0]));
        if (!termui->overflow_flags) {
                free(termui->screen);
                free(termui);
                return NULL;
        }

        return termui;
}

void termui_destroy(termui_t *termui)
{
        free(termui->screen);
        free(termui);
}

/** Scrolls the viewport.
 * Negative delta scrolls towards older rows, positive towards newer.
 * Scroll callback is called with the actual number of rows scrolled.
 * No callback is called for rows previously off-screen.
 *
 * @param termui
 * @param delta  Number of rows to scroll.
 */
void termui_history_scroll(termui_t *termui, int delta)
{
        int scrolled = _history_scroll(&termui->history, delta);

        if (scrolled != 0 && termui->scroll_cb)
                termui->scroll_cb(termui->scroll_udata, scrolled);
}

void termui_set_cursor_visibility(termui_t *termui, bool visible)
{
        if (termui->cursor_visible == visible)
                return;

        termui->cursor_visible = visible;

        _current_cell(termui).cursor = visible;
        _update_current_cell(termui);
}

bool termui_get_cursor_visibility(const termui_t *termui)
{
        return termui->cursor_visible;
}

static void _termui_put_cells(termui_t *termui, const termui_cell_t *cells, int n)
{
        while (n > 0) {
                _current_cell(termui) = cells[0];
                cells++;
                n--;

                termui->col++;

                if (termui->col == termui->cols) {
                        _overflow_flag(termui, termui->row) = 1;
                        _advance_line(termui);
                        termui->col = 0;
                        termui->overflow = true;
                } else {
                        termui->overflow = false;
                }
        }

        if (termui->row >= termui->used_rows)
                termui->used_rows = termui->row + 1;
}

/** Resize active screen and scrollback depth.
 */
errno_t termui_resize(termui_t *termui, int cols, int rows, size_t history_lines)
{
        /* Prevent numerical overflows. */
        if (cols < 2 || rows < 1 || INT_MAX / cols < rows)
                return ERANGE;

        int cells = cols * rows;

        termui_cell_t *new_screen = calloc(cells, sizeof(new_screen[0]));
        if (!new_screen)
                return ENOMEM;

        uint8_t *new_flags = calloc(rows, sizeof(new_flags[0]));
        if (!new_flags) {
                free(new_screen);
                return ENOMEM;
        }

        termui_t old_termui = *termui;

        termui->rows = rows;
        termui->cols = cols;
        termui->row = 0;
        termui->col = 0;
        termui->used_rows = 0;
        termui->first_row = 0;
        termui->screen = new_screen;
        termui->overflow_flags = new_flags;
        termui->overflow = false;

        bool cursor_visible = termui->cursor_visible;
        termui->cursor_visible = false;

        termui->history.lines.max_len = history_lines;

        if (history_lines > SIZE_MAX / cols)
                termui->history.cells.max_len = SIZE_MAX;
        else
                termui->history.cells.max_len = history_lines * cols;

        /* Temporarily remove callbacks. */
        termui->scroll_cb = NULL;
        termui->update_cb = NULL;
        termui->refresh_cb = NULL;

        size_t recouped;
        const termui_cell_t *c = _history_reflow(&termui->history, cols, &recouped);

        /* Return piece of the incomplete line in scrollback back to active screen. */
        if (recouped > 0)
                _termui_put_cells(termui, c, recouped);

        /* Mark cursor position. */
        _current_cell(&old_termui).cursor = 1;

        /* Write the contents of old screen into the new one. */
        for (int row = 0; row < old_termui.used_rows; row++) {
                int real_row_offset = _real_row(&old_termui, row) * old_termui.cols;

                if (_overflow_flag(&old_termui, row)) {
                        _termui_put_cells(termui, &old_termui.screen[real_row_offset], old_termui.cols);
                } else {
                        /* Trim trailing blanks. */
                        int len = old_termui.cols;
                        while (len > 0 && _cell_is_empty(old_termui.screen[real_row_offset + len - 1]))
                                len--;

                        _termui_put_cells(termui, &old_termui.screen[real_row_offset], len);

                        /* Mark cursor at the end of row, if any. */
                        if (len < old_termui.cols)
                                _current_cell(termui).cursor = old_termui.screen[real_row_offset + len].cursor;

                        if (row < old_termui.used_rows - 1)
                                termui_put_crlf(termui);
                }
        }

        /* Find cursor */
        int new_col = 0;
        int new_row = 0;
        for (int col = 0; col < termui->cols; col++) {
                for (int row = 0; row < termui->rows; row++) {
                        if (_screen_cell(termui, col, row).cursor) {
                                _screen_cell(termui, col, row).cursor = 0;
                                new_col = col;
                                new_row = row;
                        }
                }
        }

        free(old_termui.screen);
        free(old_termui.overflow_flags);

        termui->col = new_col;
        termui->row = new_row;

        termui->cursor_visible = cursor_visible;
        _cursor_on(termui);

        termui->scroll_cb = old_termui.scroll_cb;
        termui->update_cb = old_termui.update_cb;
        termui->refresh_cb = old_termui.refresh_cb;

        if (termui->refresh_cb)
                termui->refresh_cb(termui->refresh_udata);

        return EOK;
}