diff options
Diffstat (limited to 'ui-terminal-vt100.c')
| -rw-r--r-- | ui-terminal-vt100.c | 211 |
1 files changed, 211 insertions, 0 deletions
diff --git a/ui-terminal-vt100.c b/ui-terminal-vt100.c new file mode 100644 index 0000000..8a73bb7 --- /dev/null +++ b/ui-terminal-vt100.c @@ -0,0 +1,211 @@ +/* This file is included from ui-terminal.c + * + * The goal is *not* to reimplement curses. Instead we aim to provide the + * simplest possible drawing backend for VT-100 compatible terminals. + * This is useful for debugging and fuzzing purposes as well as for environments + * with no curses support. + * + * Currently no attempt is made to optimize terminal output. The amount of + * flickering will depend on the smartness of your terminal emulator. + * + * The following terminal escape sequences are used: + * + * - CSI ? 1049 h Save cursor and use Alternate Screen Buffer (DECSET) + * - CSI ? 1049 l Use Normal Screen Buffer and restore cursor (DECRST) + * - CSI ? 25 l Hide Cursor (DECTCEM) + * - CSI ? 25 h Show Cursor (DECTCEM) + * - CSI 2 J Erase in Display (ED) + * - CSI row ; column H Cursor Position (CUP) + * - CSI ... m Character Attributes (SGR) + * - CSI 0 m Normal + * - CSI 1 m Bold + * - CSI 3 m Italicized + * - CSI 4 m Underlined + * - CSI 5 m Blink + * - CSI 7 m Inverse + * - CSI 22 m Normal (not bold) + * - CSI 23 m Not italicized + * - CSI 24 m Not underlined + * - CSI 25 m Not blinking + * - CSI 27 m Not inverse + * - CSI 30-37,39 Set foreground color + * - CSI 38 ; 2 ; R ; G ; B m Set RGB foreground color + * - CSI 40-47,49 Set background color + * - CSI 48 ; 2 ; R ; G ; B m Set RGB background color + * + * See http://invisible-island.net/xterm/ctlseqs/ctlseqs.txt + * for further information. + */ +#include <stdio.h> +#include "buffer.h" + +#define ui_term_backend_init ui_vt100_init +#define ui_term_backend_blit ui_vt100_blit +#define ui_term_backend_clear ui_vt100_clear +#define ui_term_backend_colors ui_vt100_colors +#define ui_term_backend_resize ui_vt100_resize +#define ui_term_backend_save ui_vt100_save +#define ui_term_backend_restore ui_vt100_restore +#define ui_term_backend_suspend ui_vt100_suspend +#define ui_term_backend_resume ui_vt100_resume +#define ui_term_backend_new ui_vt100_new +#define ui_term_backend_free ui_vt100_free + +#define CELL_COLOR_BLACK (CellColor){ .index = 0 } +#define CELL_COLOR_RED (CellColor){ .index = 1 } +#define CELL_COLOR_GREEN (CellColor){ .index = 2 } +#define CELL_COLOR_YELLOW (CellColor){ .index = 3 } +#define CELL_COLOR_BLUE (CellColor){ .index = 4 } +#define CELL_COLOR_MAGENTA (CellColor){ .index = 5 } +#define CELL_COLOR_CYAN (CellColor){ .index = 6 } +#define CELL_COLOR_WHITE (CellColor){ .index = 7 } +#define CELL_COLOR_DEFAULT (CellColor){ .index = 9 } + +#define CELL_ATTR_NORMAL 0 +#define CELL_ATTR_UNDERLINE (1 << 0) +#define CELL_ATTR_REVERSE (1 << 1) +#define CELL_ATTR_BLINK (1 << 2) +#define CELL_ATTR_BOLD (1 << 3) +#define CELL_ATTR_ITALIC (1 << 4) + +typedef struct { + UiTerm uiterm; + Buffer buf; +} UiVt100; + +static CellColor color_rgb(UiTerm *ui, uint8_t r, uint8_t g, uint8_t b) { + return (CellColor){ .r = r, .g = g, .b = b, .index = (uint8_t)-1 }; +} + +static CellColor color_terminal(UiTerm *ui, uint8_t index) { + return (CellColor){ .r = 0, .g = 0, .b = 0, .index = index }; +} + + +static void output(const char *data, size_t len) { + fwrite(data, len, 1, stderr); + fflush(stderr); +} + +static void output_literal(const char *data) { + output(data, strlen(data)); +} + +static void screen_alternate(bool alternate) { + output_literal(alternate ? "\x1b[?1049h" : "\x1b[0m" "\x1b[?1049l"); +} + +static void cursor_visible(bool visible) { + output_literal(visible ? "\x1b[?25h" : "\x1b[?25l"); +} + +static void ui_vt100_blit(UiTerm *tui) { + Buffer *buf = &((UiVt100*)tui)->buf; + buffer_clear(buf); + CellAttr attr = CELL_ATTR_NORMAL; + CellColor fg = CELL_COLOR_DEFAULT, bg = CELL_COLOR_DEFAULT; + int w = tui->width, h = tui->height; + Cell *cell = tui->cells; + /* erase screen, reposition cursor, reset attributes */ + buffer_append0(buf, "\x1b[2J" "\x1b[H" "\x1b[0m"); + for (int y = 0; y < h; y++) { + for (int x = 0; x < w; x++) { + CellStyle *style = &cell->style; + if (style->attr != attr) { + + static struct { + CellAttr attr; + char on[4], off[4]; + } cell_attrs[] = { + { CELL_ATTR_BOLD, "1", "22" }, + { CELL_ATTR_ITALIC, "3", "23" }, + { CELL_ATTR_UNDERLINE, "4", "24" }, + { CELL_ATTR_BLINK, "5", "25" }, + { CELL_ATTR_REVERSE, "7", "27" }, + }; + + for (size_t i = 0; i < LENGTH(cell_attrs); i++) { + CellAttr a = cell_attrs[i].attr; + if ((style->attr & a) == (attr & a)) + continue; + buffer_appendf(buf, "\x1b[%sm", + style->attr & a ? + cell_attrs[i].on : + cell_attrs[i].off); + } + + attr = style->attr; + } + + if (!cell_color_equal(fg, style->fg)) { + fg = style->fg; + if (fg.index != (uint8_t)-1) { + buffer_appendf(buf, "\x1b[%dm", 30 + fg.index); + } else { + buffer_appendf(buf, "\x1b[38;2;%d;%d;%dm", + fg.r, fg.g, fg.b); + } + } + + if (!cell_color_equal(bg, style->bg)) { + bg = style->bg; + if (bg.index != (uint8_t)-1) { + buffer_appendf(buf, "\x1b[%dm", 40 + bg.index); + } else { + buffer_appendf(buf, "\x1b[48;2;%d;%d;%dm", + bg.r, bg.g, bg.b); + } + } + + buffer_append0(buf, cell->data); + cell++; + } + } + output(buffer_content(buf), buffer_length0(buf)); +} + +static void ui_vt100_clear(UiTerm *tui) { } + +static void ui_vt100_resize(UiTerm *tui, int width, int height) { } + +static void ui_vt100_save(UiTerm *tui) { + cursor_visible(true); +} + +static void ui_vt100_restore(UiTerm *tui) { + cursor_visible(false); +} + +static int ui_vt100_colors(Ui *ui) { + char *term = getenv("TERM"); + return (term && strstr(term, "-256color")) ? 256 : 16; +} + +static void ui_vt100_suspend(UiTerm *term) { + cursor_visible(true); + screen_alternate(false); +} + +static void ui_vt100_resume(UiTerm *term) { + screen_alternate(true); + cursor_visible(false); +} + +static bool ui_vt100_init(UiTerm *tui, const char *term) { + ui_vt100_resume(tui); + return true; +} + +static UiTerm *ui_vt100_new(void) { + UiVt100 *vtui = calloc(1, sizeof *vtui); + if (!vtui) + return NULL; + buffer_init(&vtui->buf); + return (UiTerm*)vtui; +} + +static void ui_vt100_free(UiTerm *tui) { + UiVt100 *vtui = (UiVt100*)tui; + ui_vt100_suspend(tui); + buffer_release(&vtui->buf); +} |