diff options
Diffstat (limited to 'ui.c')
| -rw-r--r-- | ui.c | 974 |
1 files changed, 974 insertions, 0 deletions
diff --git a/ui.c b/ui.c new file mode 100644 index 0000000..6c9606d --- /dev/null +++ b/ui.c @@ -0,0 +1,974 @@ +/* Copyright (C) 2020 C. McEnroe <june@causal.agency> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + +#define _XOPEN_SOURCE_EXTENDED + +#include <assert.h> +#include <ctype.h> +#include <curses.h> +#include <err.h> +#include <errno.h> +#include <signal.h> +#include <stdarg.h> +#include <stdbool.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sysexits.h> +#include <term.h> +#include <termios.h> +#include <time.h> +#include <unistd.h> +#include <wchar.h> +#include <wctype.h> + +#include "chat.h" + +// Annoying stuff from <term.h>: +#undef lines +#undef tab + +#ifndef A_ITALIC +#define A_ITALIC A_NORMAL +#endif + +#define BOTTOM (LINES - 1) +#define RIGHT (COLS - 1) +#define PAGE_LINES (LINES - 2) + +static WINDOW *status; +static WINDOW *marker; +static WINDOW *input; + +enum { BufferCap = 512 }; +struct Buffer { + time_t times[BufferCap]; + char *lines[BufferCap]; + size_t len; +}; +static_assert(!(BufferCap & (BufferCap - 1)), "BufferCap is power of two"); + +static void bufferPush(struct Buffer *buffer, time_t time, const char *line) { + size_t i = buffer->len++ % BufferCap; + free(buffer->lines[i]); + buffer->times[i] = time; + buffer->lines[i] = strdup(line); + if (!buffer->lines[i]) err(EX_OSERR, "strdup"); +} + +static time_t bufferTime(const struct Buffer *buffer, size_t i) { + return buffer->times[(buffer->len + i) % BufferCap]; +} +static const char *bufferLine(const struct Buffer *buffer, size_t i) { + return buffer->lines[(buffer->len + i) % BufferCap]; +} + +enum { WindowLines = BufferCap }; +struct Window { + size_t id; + struct Buffer buffer; + WINDOW *pad; + int scroll; + bool mark; + enum Heat heat; + int unreadCount; + int unreadLines; + struct Window *prev; + struct Window *next; +}; + +static struct { + struct Window *active; + struct Window *other; + struct Window *head; + struct Window *tail; +} windows; + +static void windowAdd(struct Window *window) { + if (windows.tail) windows.tail->next = window; + window->prev = windows.tail; + window->next = NULL; + windows.tail = window; + if (!windows.head) windows.head = window; +} + +static void windowRemove(struct Window *window) { + if (window->prev) window->prev->next = window->next; + if (window->next) window->next->prev = window->prev; + if (windows.head == window) windows.head = window->next; + if (windows.tail == window) windows.tail = window->prev; +} + +static struct Window *windowFor(size_t id) { + struct Window *window; + for (window = windows.head; window; window = window->next) { + if (window->id == id) return window; + } + window = calloc(1, sizeof(*window)); + if (!window) err(EX_OSERR, "malloc"); + + window->id = id; + window->pad = newpad(WindowLines, COLS); + if (!window->pad) err(EX_OSERR, "newpad"); + scrollok(window->pad, true); + wmove(window->pad, WindowLines - 1, 0); + window->mark = true; + + windowAdd(window); + return window; +} + +static short colorPairs; + +static void colorInit(void) { + start_color(); + use_default_colors(); + for (short pair = 0; pair < 16; ++pair) { + init_pair(1 + pair, pair % COLORS, -1); + } + colorPairs = 17; +} + +static attr_t colorAttr(short fg) { + if (fg != COLOR_BLACK && fg % COLORS == COLOR_BLACK) return A_BOLD; + if (COLORS > 8) return A_NORMAL; + return (fg / COLORS & 1 ? A_BOLD : A_NORMAL); +} + +static short colorPair(short fg, short bg) { + fg %= COLORS; + bg %= COLORS; + if (bg == -1 && fg < 16) return 1 + fg; + for (short pair = 17; pair < colorPairs; ++pair) { + short f, b; + pair_content(pair, &f, &b); + if (f == fg && b == bg) return pair; + } + init_pair(colorPairs, fg, bg); + return colorPairs++; +} + +// XXX: Assuming terminals will be fine with these even if they're unsupported, +// since they're "private" modes. +static const char *EnterFocusMode = "\33[?1004h"; +static const char *ExitFocusMode = "\33[?1004l"; +static const char *EnterPasteMode = "\33[?2004h"; +static const char *ExitPasteMode = "\33[?2004l"; + +// Gain use of C-q, C-s, C-c, C-z, C-y, C-o. +static void acquireKeys(void) { + struct termios term; + int error = tcgetattr(STDOUT_FILENO, &term); + if (error) err(EX_OSERR, "tcgetattr"); + term.c_iflag &= ~IXON; + term.c_cc[VINTR] = _POSIX_VDISABLE; + term.c_cc[VSUSP] = _POSIX_VDISABLE; + term.c_cc[VDSUSP] = _POSIX_VDISABLE; + term.c_cc[VDISCARD] = _POSIX_VDISABLE; + error = tcsetattr(STDOUT_FILENO, TCSADRAIN, &term); + if (error) err(EX_OSERR, "tcsetattr"); +} + +static void errExit(void) { + reset_shell_mode(); +} + +#define ENUM_KEY \ + X(KeyMeta0, "\0330") \ + X(KeyMeta1, "\0331") \ + X(KeyMeta2, "\0332") \ + X(KeyMeta3, "\0333") \ + X(KeyMeta4, "\0334") \ + X(KeyMeta5, "\0335") \ + X(KeyMeta6, "\0336") \ + X(KeyMeta7, "\0337") \ + X(KeyMeta8, "\0338") \ + X(KeyMeta9, "\0339") \ + X(KeyMetaA, "\33a") \ + X(KeyMetaB, "\33b") \ + X(KeyMetaD, "\33d") \ + X(KeyMetaF, "\33f") \ + X(KeyMetaL, "\33l") \ + X(KeyMetaM, "\33m") \ + X(KeyMetaU, "\33u") \ + X(KeyMetaSlash, "\33/") \ + X(KeyFocusIn, "\33[I") \ + X(KeyFocusOut, "\33[O") \ + X(KeyPasteOn, "\33[200~") \ + X(KeyPasteOff, "\33[201~") + +enum { + KeyMax = KEY_MAX, +#define X(id, seq) id, + ENUM_KEY +#undef X +}; + +void uiInit(void) { + initscr(); + cbreak(); + noecho(); + acquireKeys(); + def_prog_mode(); + atexit(errExit); + colorInit(); + + if (!to_status_line && !strncmp(termname(), "xterm", 5)) { + to_status_line = "\33]2;"; + from_status_line = "\7"; + } + +#define X(id, seq) define_key(seq, id); + ENUM_KEY +#undef X + + status = newwin(1, COLS, 0, 0); + if (!status) err(EX_OSERR, "newwin"); + + marker = newwin(1, COLS, LINES - 2, 0); + short fg = 8 + COLOR_BLACK; + wbkgd(marker, '~' | colorAttr(fg) | COLOR_PAIR(colorPair(fg, -1))); + + input = newpad(1, 512); + if (!input) err(EX_OSERR, "newpad"); + keypad(input, true); + nodelay(input, true); + + windows.active = windowFor(Network); + uiShow(); +} + +static bool hidden; +static bool waiting; + +static char title[256]; +static char prevTitle[sizeof(title)]; + +void uiDraw(void) { + if (hidden) return; + wnoutrefresh(status); + struct Window *window = windows.active; + pnoutrefresh( + window->pad, + WindowLines - window->scroll - PAGE_LINES + !!window->scroll, 0, + 1, 0, + BOTTOM - 1 - !!window->scroll, RIGHT + ); + if (window->scroll) { + touchwin(marker); + wnoutrefresh(marker); + } + int y, x; + getyx(input, y, x); + pnoutrefresh( + input, + 0, (x + 1 > RIGHT ? x + 1 - RIGHT : 0), + BOTTOM, 0, + BOTTOM, RIGHT + ); + doupdate(); + + if (!to_status_line) return; + if (!strcmp(title, prevTitle)) return; + strcpy(prevTitle, title); + putp(to_status_line); + putp(title); + putp(from_status_line); + fflush(stdout); +} + +void uiShow(void) { + prevTitle[0] = '\0'; + putp(EnterFocusMode); + putp(EnterPasteMode); + fflush(stdout); + hidden = false; +} + +void uiHide(void) { + hidden = true; + putp(ExitFocusMode); + putp(ExitPasteMode); + endwin(); +} + +struct Style { + attr_t attr; + enum Color fg, bg; +}; +static const struct Style Reset = { A_NORMAL, Default, Default }; + +static const short Colors[100] = { + [Default] = -1, + [White] = 8 + COLOR_WHITE, + [Black] = 0 + COLOR_BLACK, + [Blue] = 0 + COLOR_BLUE, + [Green] = 0 + COLOR_GREEN, + [Red] = 8 + COLOR_RED, + [Brown] = 0 + COLOR_RED, + [Magenta] = 0 + COLOR_MAGENTA, + [Orange] = 0 + COLOR_YELLOW, + [Yellow] = 8 + COLOR_YELLOW, + [LightGreen] = 8 + COLOR_GREEN, + [Cyan] = 0 + COLOR_CYAN, + [LightCyan] = 8 + COLOR_CYAN, + [LightBlue] = 8 + COLOR_BLUE, + [Pink] = 8 + COLOR_MAGENTA, + [Gray] = 8 + COLOR_BLACK, + [LightGray] = 0 + COLOR_WHITE, + 52, 94, 100, 58, 22, 29, 23, 24, 17, 54, 53, 89, + 88, 130, 142, 64, 28, 35, 30, 25, 18, 91, 90, 125, + 124, 166, 184, 106, 34, 49, 37, 33, 19, 129, 127, 161, + 196, 208, 226, 154, 46, 86, 51, 75, 21, 171, 201, 198, + 203, 215, 227, 191, 83, 122, 87, 111, 63, 177, 207, 205, + 217, 223, 229, 193, 157, 158, 159, 153, 147, 183, 219, 212, + 16, 233, 235, 237, 239, 241, 244, 247, 250, 254, 231, +}; + +enum { B = '\2', C = '\3', O = '\17', R = '\26', I = '\35', U = '\37' }; + +static void styleParse(struct Style *style, const char **str, size_t *len) { + switch (**str) { + break; case B: (*str)++; style->attr ^= A_BOLD; + break; case O: (*str)++; *style = Reset; + break; case R: (*str)++; style->attr ^= A_REVERSE; + break; case I: (*str)++; style->attr ^= A_ITALIC; + break; case U: (*str)++; style->attr ^= A_UNDERLINE; + break; case C: { + (*str)++; + if (!isdigit(**str)) { + style->fg = Default; + style->bg = Default; + break; + } + style->fg = *(*str)++ - '0'; + if (isdigit(**str)) style->fg = style->fg * 10 + *(*str)++ - '0'; + if ((*str)[0] != ',' || !isdigit((*str)[1])) break; + (*str)++; + style->bg = *(*str)++ - '0'; + if (isdigit(**str)) style->bg = style->bg * 10 + *(*str)++ - '0'; + } + } + *len = strcspn(*str, (const char[]) { B, C, O, R, I, U, '\0' }); +} + +static void statusAdd(const char *str) { + size_t len; + struct Style style = Reset; + while (*str) { + styleParse(&style, &str, &len); + wattr_set( + status, + style.attr | colorAttr(Colors[style.fg]), + colorPair(Colors[style.fg], Colors[style.bg]), + NULL + ); + waddnstr(status, str, len); + str += len; + } +} + +static void statusUpdate(void) { + int otherUnread = 0; + enum Heat otherHeat = Cold; + wmove(status, 0, 0); + + int num; + const struct Window *window; + for (num = 0, window = windows.head; window; ++num, window = window->next) { + if (!window->heat && window != windows.active) continue; + if (window != windows.active) { + otherUnread += window->unreadCount; + if (window->heat > otherHeat) otherHeat = window->heat; + } + int trunc; + char buf[256]; + snprintf( + buf, sizeof(buf), "\3%d%s %d %s %n(\3%02d%d\3%d) ", + idColors[window->id], (window == windows.active ? "\26" : ""), + num, idNames[window->id], + &trunc, (window->heat > Warm ? White : idColors[window->id]), + window->unreadCount, + idColors[window->id] + ); + if (!window->mark || !window->unreadCount) buf[trunc] = '\0'; + statusAdd(buf); + } + wclrtoeol(status); + + window = windows.active; + snprintf(title, sizeof(title), "%s %s", self.network, idNames[window->id]); + if (window->mark && window->unreadCount) { + snprintf( + &title[strlen(title)], sizeof(title) - strlen(title), + " (%d%s)", window->unreadCount, (window->heat > Warm ? "!" : "") + ); + } + if (otherUnread) { + snprintf( + &title[strlen(title)], sizeof(title) - strlen(title), + " (+%d%s)", otherUnread, (otherHeat > Warm ? "!" : "") + ); + } +} + +static void mark(struct Window *window) { + if (window->scroll) return; + window->mark = true; + window->unreadCount = 0; + window->unreadLines = 0; +} + +static void unmark(struct Window *window) { + if (!window->scroll) { + window->mark = false; + window->heat = Cold; + } + statusUpdate(); +} + +static void windowScroll(struct Window *window, int n) { + mark(window); + window->scroll += n; + if (window->scroll > WindowLines - PAGE_LINES) { + window->scroll = WindowLines - PAGE_LINES; + } + if (window->scroll < 0) window->scroll = 0; + unmark(window); +} + +static void windowScrollUnread(struct Window *window) { + window->scroll = 0; + windowScroll(window, window->unreadLines - PAGE_LINES + 1); +} + +static int wordWidth(const char *str) { + size_t len = strcspn(str, " "); + int width = 0; + while (len) { + wchar_t wc; + int n = mbtowc(&wc, str, len); + if (n < 1) return width + len; + width += (iswprint(wc) ? wcwidth(wc) : 0); + str += n; + len -= n; + } + return width; +} + +static int wordWrap(WINDOW *win, const char *str) { + int y, x, width; + getmaxyx(win, y, width); + + size_t len; + int lines = 0; + int align = 0; + struct Style style = Reset; + while (*str) { + if (*str == '\t') { + if (align) { + waddch(win, '\t'); + str++; + } else { + waddch(win, ' '); + getyx(win, y, align); + str++; + } + } else if (*str == ' ') { + getyx(win, y, x); + const char *word = &str[strspn(str, " ")]; + if (width - x - 1 <= wordWidth(word)) { + lines += 1 + (align + wordWidth(word)) / width; + waddch(win, '\n'); + getyx(win, y, x); + wmove(win, y, align); + str = word; + } else { + waddch(win, ' '); + str++; + } + } + + styleParse(&style, &str, &len); + size_t ws = strcspn(str, "\t "); + if (ws < len) len = ws; + + wattr_set( + win, + style.attr | colorAttr(Colors[style.fg]), + colorPair(Colors[style.fg], Colors[style.bg]), + NULL + ); + waddnstr(win, str, len); + str += len; + } + return lines; +} + +void uiWrite(size_t id, enum Heat heat, const time_t *src, const char *str) { + struct Window *window = windowFor(id); + time_t clock = (src ? *src : time(NULL)); + bufferPush(&window->buffer, clock, str); + + int lines = 1; + waddch(window->pad, '\n'); + if (window->mark && heat > Cold) { + if (!window->unreadCount++) { + lines++; + waddch(window->pad, '\n'); + } + if (window->heat < heat) window->heat = heat; + statusUpdate(); + } + lines += wordWrap(window->pad, str); + window->unreadLines += lines; + if (window->scroll) windowScroll(window, lines); + if (heat > Warm) beep(); +} + +void uiFormat( + size_t id, enum Heat heat, const time_t *time, const char *format, ... +) { + char buf[1024]; + va_list ap; + va_start(ap, format); + int len = vsnprintf(buf, sizeof(buf), format, ap); + va_end(ap); + assert((size_t)len < sizeof(buf)); + uiWrite(id, heat, time, buf); +} + +static void reflow(struct Window *window) { + werase(window->pad); + wmove(window->pad, WindowLines - 1, 0); + window->unreadLines = 0; + for (size_t i = 0; i < BufferCap; ++i) { + const char *line = bufferLine(&window->buffer, i); + if (!line) continue; + waddch(window->pad, '\n'); + if (i >= (size_t)(BufferCap - window->unreadCount)) { + window->unreadLines += 1 + wordWrap(window->pad, line); + } else { + wordWrap(window->pad, line); + } + } +} + +static void resize(void) { + mvwin(marker, LINES - 2, 0); + int height, width; + getmaxyx(windows.active->pad, height, width); + if (width == COLS) return; + for (struct Window *window = windows.head; window; window = window->next) { + wresize(window->pad, BufferCap, COLS); + reflow(window); + } + statusUpdate(); +} + +static void bufferList(const struct Buffer *buffer) { + uiHide(); + waiting = true; + for (size_t i = 0; i < BufferCap; ++i) { + time_t time = bufferTime(buffer, i); + const char *line = bufferLine(buffer, i); + if (!line) continue; + + struct tm *tm = localtime(&time); + if (!tm) continue; + char buf[sizeof("[00:00:00]")]; + strftime(buf, sizeof(buf), "[%T]", tm); + vid_attr(colorAttr(Colors[Gray]), colorPair(Colors[Gray], -1), NULL); + printf("%s ", buf); + + size_t len; + bool align = false; + struct Style style = Reset; + while (*line) { + if (*line == '\t') { + printf("%c", (align ? '\t' : ' ')); + align = true; + line++; + } + styleParse(&style, &line, &len); + size_t tab = strcspn(line, "\t"); + if (tab < len) len = tab; + vid_attr( + style.attr | colorAttr(Colors[style.fg]), + colorPair(Colors[style.fg], Colors[style.bg]), + NULL + ); + if (len) printf("%.*s", (int)len, line); + line += len; + } + printf("\n"); + } +} + +static void inputAdd(struct Style *style, const char *str) { + size_t len; + while (*str) { + const char *code = str; + styleParse(style, &str, &len); + wattr_set(input, A_BOLD | A_REVERSE, 0, NULL); + switch (*code) { + break; case B: waddch(input, 'B'); + break; case C: waddch(input, 'C'); + break; case O: waddch(input, 'O'); + break; case R: waddch(input, 'R'); + break; case I: waddch(input, 'I'); + break; case U: waddch(input, 'U'); + } + if (str - code > 1) waddnstr(input, &code[1], str - &code[1]); + wattr_set( + input, + style->attr | colorAttr(Colors[style->fg]), + colorPair(Colors[style->fg], Colors[style->bg]), + NULL + ); + waddnstr(input, str, len); + str += len; + } +} + +static void inputUpdate(void) { + size_t id = windows.active->id; + size_t pos; + char *buf = editBuffer(&pos); + + const char *skip = NULL; + struct Style init = { .fg = self.color, .bg = Default }; + struct Style rest = Reset; + const char *prefix = ""; + const char *prompt = (self.nick ? self.nick : ""); + const char *suffix = ""; + if (NULL != (skip = commandIsPrivmsg(id, buf))) { + prefix = "<"; suffix = "> "; + } else if (NULL != (skip = commandIsNotice(id, buf))) { + prefix = "-"; suffix = "- "; + rest.fg = LightGray; + } else if (NULL != (skip = commandIsAction(id, buf))) { + init.attr |= A_ITALIC; + prefix = "* "; suffix = " "; + rest.attr |= A_ITALIC; + } else if (id == Debug) { + skip = buf; + init.fg = Gray; + prompt = "<< "; + } else { + prompt = ""; + } + if (skip && skip > &buf[pos]) { + skip = NULL; + prefix = prompt = suffix = ""; + } + + int y, x; + wmove(input, 0, 0); + wattr_set( + input, + init.attr | colorAttr(Colors[init.fg]), + colorPair(Colors[init.fg], Colors[init.bg]), + NULL + ); + waddstr(input, prefix); + waddstr(input, prompt); + waddstr(input, suffix); + struct Style style = rest; + char p = buf[pos]; + buf[pos] = '\0'; + inputAdd(&style, (skip ? skip : buf)); + getyx(input, y, x); + buf[pos] = p; + inputAdd(&style, &buf[pos]); + wclrtoeol(input); + wmove(input, y, x); +} + +static void windowShow(struct Window *window) { + if (!window) return; + touchwin(window->pad); + windows.other = windows.active; + windows.active = window; + mark(windows.other); + unmark(windows.active); + inputUpdate(); +} + +void uiShowID(size_t id) { + windowShow(windowFor(id)); +} + +void uiShowNum(size_t num) { + struct Window *window = windows.head; + for (size_t i = 0; i < num; ++i) { + window = window->next; + if (!window) return; + } + windowShow(window); +} + +static void windowClose(struct Window *window) { + if (window->id == Network) return; + if (windows.active == window) { + if (windows.other && windows.other != window) { + windowShow(windows.other); + } else { + windowShow(window->prev ? window->prev : window->next); + } + } + if (windows.other == window) windows.other = NULL; + windowRemove(window); + for (size_t i = 0; i < BufferCap; ++i) { + free(window->buffer.lines[i]); + } + delwin(window->pad); + free(window); + statusUpdate(); +} + +void uiCloseID(size_t id) { + windowClose(windowFor(id)); +} + +void uiCloseNum(size_t num) { + struct Window *window = windows.head; + for (size_t i = 0; i < num; ++i) { + window = window->next; + if (!window) return; + } + windowClose(window); +} + +static void showAuto(void) { + static struct Window *other; + if (windows.other != other) { + other = windows.active; + } + for (struct Window *window = windows.head; window; window = window->next) { + if (window->heat < Hot) continue; + windowShow(window); + windows.other = other; + return; + } + for (struct Window *window = windows.head; window; window = window->next) { + if (window->heat < Warm) continue; + windowShow(window); + windows.other = other; + return; + } + windowShow(windows.other); +} + +static void keyCode(int code) { + struct Window *window = windows.active; + size_t id = window->id; + switch (code) { + break; case KEY_RESIZE: resize(); + break; case KeyFocusIn: unmark(window); + break; case KeyFocusOut: mark(window); + break; case KeyPasteOn:; // TODO + break; case KeyPasteOff:; // TODO + + break; case KeyMetaSlash: windowShow(windows.other); + + break; case KeyMetaA: showAuto(); + break; case KeyMetaB: edit(id, EditPrevWord, 0); + break; case KeyMetaD: edit(id, EditDeleteNextWord, 0); + break; case KeyMetaF: edit(id, EditNextWord, 0); + break; case KeyMetaL: bufferList(&window->buffer); + break; case KeyMetaM: waddch(window->pad, '\n'); + break; case KeyMetaU: windowScrollUnread(window); + + break; case KEY_BACKSPACE: edit(id, EditDeletePrev, 0); + break; case KEY_DC: edit(id, EditDeleteNext, 0); + break; case KEY_DOWN: windowScroll(window, -1); + break; case KEY_END: edit(id, EditTail, 0); + break; case KEY_ENTER: edit(id, EditEnter, 0); + break; case KEY_HOME: edit(id, EditHead, 0); + break; case KEY_LEFT: edit(id, EditPrev, 0); + break; case KEY_NPAGE: windowScroll(window, -(PAGE_LINES - 2)); + break; case KEY_PPAGE: windowScroll(window, +(PAGE_LINES - 2)); + break; case KEY_RIGHT: edit(id, EditNext, 0); + break; case KEY_UP: windowScroll(window, +1); + + break; default: { + if (code >= KeyMeta0 && code <= KeyMeta9) { + uiShowNum(code - KeyMeta0); + } + } + } +} + +static void keyCtrl(wchar_t ch) { + size_t id = windows.active->id; + switch (ch ^ L'@') { + break; case L'?': edit(id, EditDeletePrev, 0); + break; case L'A': edit(id, EditHead, 0); + break; case L'B': edit(id, EditPrev, 0); + break; case L'C': raise(SIGINT); + break; case L'D': edit(id, EditDeleteNext, 0); + break; case L'E': edit(id, EditTail, 0); + break; case L'F': edit(id, EditNext, 0); + break; case L'H': edit(id, EditDeletePrev, 0); + break; case L'I': edit(id, EditComplete, 0); + break; case L'J': edit(id, EditEnter, 0); + break; case L'K': edit(id, EditDeleteTail, 0); + break; case L'L': clearok(curscr, true); + break; case L'N': windowShow(windows.active->next); + break; case L'O': windowShow(windows.other); + break; case L'P': windowShow(windows.active->prev); + break; case L'U': edit(id, EditDeleteHead, 0); + break; case L'W': edit(id, EditDeletePrevWord, 0); + break; case L'Y': edit(id, EditPaste, 0); + } +} + +static void keyStyle(wchar_t ch) { + size_t id = windows.active->id; + switch (iswcntrl(ch) ? ch ^ L'@' : towupper(ch)) { + break; case L'B': edit(id, EditInsert, B); + break; case L'C': edit(id, EditInsert, C); + break; case L'I': edit(id, EditInsert, I); + break; case L'O': edit(id, EditInsert, O); + break; case L'R': edit(id, EditInsert, R); + break; case L'U': edit(id, EditInsert, U); + } +} + +void uiRead(void) { + if (hidden) { + if (waiting) { + uiShow(); + flushinp(); + waiting = false; + } else { + return; + } + } + + int ret; + wint_t ch; + static bool style; + while (ERR != (ret = wget_wch(input, &ch))) { + if (ret == KEY_CODE_YES) { + keyCode(ch); + } else if (ch == (L'Z' ^ L'@')) { + style = true; + continue; + } else if (style) { + keyStyle(ch); + } else if (iswcntrl(ch)) { + keyCtrl(ch); + } else { + edit(windows.active->id, EditInsert, ch); + } + style = false; + } + inputUpdate(); +} + +static const size_t Signatures[] = { + 0x6C72696774616301, +}; + +static size_t signatureVersion(size_t signature) { + for (size_t i = 0; i < ARRAY_LEN(Signatures); ++i) { + if (signature == Signatures[i]) return i; + } + err(EX_DATAERR, "unknown file signature %zX", signature); +} + +static int writeSize(FILE *file, size_t value) { + return (fwrite(&value, sizeof(value), 1, file) ? 0 : -1); +} +static int writeTime(FILE *file, time_t time) { + return (fwrite(&time, sizeof(time), 1, file) ? 0 : -1); +} +static int writeString(FILE *file, const char *str) { + return (fwrite(str, strlen(str) + 1, 1, file) ? 0 : -1); +} + +int uiSave(const char *name) { + FILE *file = dataOpen(name, "w"); + if (!file) return -1; + + if (writeSize(file, Signatures[0])) return -1; + const struct Window *window; + for (window = windows.head; window; window = window->next) { + if (writeString(file, idNames[window->id])) return -1; + for (size_t i = 0; i < BufferCap; ++i) { + time_t time = bufferTime(&window->buffer, i); + const char *line = bufferLine(&window->buffer, i); + if (!line) continue; + if (writeTime(file, time)) return -1; + if (writeString(file, line)) return -1; + } + if (writeTime(file, 0)) return -1; + } + return fclose(file); +} + +static size_t readSize(FILE *file) { + size_t value; + fread(&value, sizeof(value), 1, file); + if (ferror(file)) err(EX_IOERR, "fread"); + if (feof(file)) errx(EX_DATAERR, "unexpected eof"); + return value; +} +static time_t readTime(FILE *file) { + time_t time; + fread(&time, sizeof(time), 1, file); + if (ferror(file)) err(EX_IOERR, "fread"); + if (feof(file)) errx(EX_DATAERR, "unexpected eof"); + return time; +} +static ssize_t readString(FILE *file, char **buf, size_t *cap) { + ssize_t len = getdelim(buf, cap, '\0', file); + if (len < 0 && !feof(file)) err(EX_IOERR, "getdelim"); + return len; +} + +void uiLoad(const char *name) { + FILE *file = dataOpen(name, "r"); + if (!file) { + if (errno != ENOENT) exit(EX_NOINPUT); + file = dataOpen(name, "w"); + if (!file) exit(EX_CANTCREAT); + fclose(file); + return; + } + + size_t signature = readSize(file); + signatureVersion(signature); + + char *buf = NULL; + size_t cap = 0; + while (0 < readString(file, &buf, &cap)) { + struct Window *window = windowFor(idFor(buf)); + for (;;) { + time_t time = readTime(file); + if (!time) break; + readString(file, &buf, &cap); + bufferPush(&window->buffer, time, buf); + } + reflow(window); + waddch(window->pad, '\n'); + } + + free(buf); + fclose(file); +} |