catboy/ui.c

1075 lines
28 KiB
C
Raw Normal View History

/* 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/>.
*
* Additional permission under GNU GPL version 3 section 7:
*
* If you modify this Program, or any covered work, by linking or
* combining it with OpenSSL (or a modified version of that library),
* containing parts covered by the terms of the OpenSSL License and the
* original SSLeay license, the licensors of this Program grant you
* additional permission to convey the resulting work. Corresponding
* Source for a non-source form of such a combination shall include the
* source code for the parts of OpenSSL used as well as that of the
* covered work.
*/
2020-02-04 08:58:56 +00:00
#define _XOPEN_SOURCE_EXTENDED
#include <assert.h>
#include <ctype.h>
#include <curses.h>
#include <err.h>
2020-02-11 00:40:13 +00:00
#include <errno.h>
#include <limits.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>
2020-02-02 06:54:51 +00:00
#include <wchar.h>
#include <wctype.h>
#include "chat.h"
2020-02-05 07:03:21 +00:00
// Annoying stuff from <term.h>:
#undef lines
#undef tab
2020-02-05 07:03:21 +00:00
#ifndef A_ITALIC
#define A_ITALIC A_NORMAL
#endif
enum {
StatusLines = 1,
MarkerLines = 1,
SplitLines = 5,
InputLines = 1,
InputCols = 1024,
};
#define BOTTOM (LINES - 1)
#define RIGHT (COLS - 1)
#define MAIN_LINES (LINES - StatusLines - InputLines)
static WINDOW *status;
static WINDOW *main;
static WINDOW *input;
struct Window {
uint id;
2020-02-10 06:59:08 +00:00
int scroll;
2020-02-09 17:13:51 +00:00
bool mark;
2020-04-15 20:18:09 +00:00
bool mute;
enum Heat thresh;
enum Heat heat;
uint unreadSoft;
uint unreadHard;
uint unreadWarm;
struct Buffer *buffer;
};
static struct {
struct Window *ptrs[IDCap];
uint len;
uint show;
uint swap;
uint user;
} windows;
static uint windowPush(struct Window *window) {
assert(windows.len < IDCap);
windows.ptrs[windows.len] = window;
return windows.len++;
}
static uint windowInsert(uint num, struct Window *window) {
assert(windows.len < IDCap);
assert(num <= windows.len);
memmove(
&windows.ptrs[num + 1],
&windows.ptrs[num],
sizeof(*windows.ptrs) * (windows.len - num)
);
windows.ptrs[num] = window;
windows.len++;
return num;
}
static struct Window *windowRemove(uint num) {
assert(num < windows.len);
struct Window *window = windows.ptrs[num];
windows.len--;
memmove(
&windows.ptrs[num],
&windows.ptrs[num + 1],
sizeof(*windows.ptrs) * (windows.len - num)
);
return window;
}
static uint windowFor(uint id) {
for (uint num = 0; num < windows.len; ++num) {
if (windows.ptrs[num]->id == id) return num;
}
struct Window *window = calloc(1, sizeof(*window));
if (!window) err(EX_OSERR, "malloc");
2020-02-03 00:38:37 +00:00
window->id = id;
2020-02-05 07:03:21 +00:00
window->mark = true;
window->thresh = Cold;
window->buffer = bufferAlloc();
2020-02-03 00:38:37 +00:00
return windowPush(window);
}
static void windowFree(struct Window *window) {
bufferFree(window->buffer);
free(window);
}
2020-02-03 00:38:37 +00:00
static short colorPairs;
static void colorInit(void) {
start_color();
use_default_colors();
if (!COLORS) return;
2020-02-03 00:38:37 +00:00
for (short pair = 0; pair < 16; ++pair) {
init_pair(1 + pair, pair % COLORS, -1);
}
colorPairs = 17;
}
static attr_t colorAttr(short fg) {
if (!COLORS) return (fg > 0 ? A_BOLD : A_NORMAL);
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);
2020-02-03 00:38:37 +00:00
}
static short colorPair(short fg, short bg) {
if (!COLORS) return 0;
fg %= COLORS;
bg %= COLORS;
if (bg == -1 && fg < 16) return 1 + fg;
2020-02-03 00:38:37 +00:00
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);
2020-02-03 00:38:37 +00:00
return colorPairs++;
}
#define ENUM_KEY \
X(KeyMeta0, "\0330", "\33)") \
X(KeyMeta1, "\0331", "\33!") \
X(KeyMeta2, "\0332", "\33@") \
X(KeyMeta3, "\0333", "\33#") \
X(KeyMeta4, "\0334", "\33$") \
X(KeyMeta5, "\0335", "\33%") \
X(KeyMeta6, "\0336", "\33^") \
X(KeyMeta7, "\0337", "\33&") \
X(KeyMeta8, "\0338", "\33*") \
X(KeyMeta9, "\0339", "\33(") \
X(KeyMetaA, "\33a", NULL) \
X(KeyMetaB, "\33b", NULL) \
X(KeyMetaD, "\33d", NULL) \
X(KeyMetaF, "\33f", NULL) \
X(KeyMetaL, "\33l", NULL) \
X(KeyMetaM, "\33m", NULL) \
2020-09-03 20:37:31 +00:00
X(KeyMetaN, "\33n", NULL) \
X(KeyMetaP, "\33p", NULL) \
2020-04-07 14:48:44 +00:00
X(KeyMetaQ, "\33q", NULL) \
X(KeyMetaU, "\33u", NULL) \
X(KeyMetaV, "\33v", NULL) \
2020-03-23 19:03:55 +00:00
X(KeyMetaEnter, "\33\r", "\33\n") \
X(KeyMetaGt, "\33>", "\33.") \
X(KeyMetaLt, "\33<", "\33,") \
X(KeyMetaEqual, "\33=", NULL) \
2020-03-31 18:31:10 +00:00
X(KeyMetaMinus, "\33-", "\33_") \
X(KeyMetaPlus, "\33+", NULL) \
2020-04-15 20:18:09 +00:00
X(KeyMetaSlash, "\33/", "\33?") \
X(KeyFocusIn, "\33[I", NULL) \
X(KeyFocusOut, "\33[O", NULL) \
X(KeyPasteOn, "\33[200~", NULL) \
X(KeyPasteOff, "\33[201~", NULL)
enum {
KeyMax = KEY_MAX,
#define X(id, seq, alt) id,
ENUM_KEY
#undef X
};
2020-02-19 06:18:09 +00:00
// 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";
static void errExit(void) {
putp(ExitFocusMode);
putp(ExitPasteMode);
reset_shell_mode();
}
void uiInitEarly(void) {
initscr();
cbreak();
noecho();
2020-02-08 07:13:02 +00:00
colorInit();
atexit(errExit);
if (!to_status_line && !strncmp(termname(), "xterm", 5)) {
to_status_line = "\33]2;";
from_status_line = "\7";
}
2020-02-08 07:13:02 +00:00
#define X(id, seq, alt) define_key(seq, id); if (alt) define_key(alt, id);
ENUM_KEY
#undef X
status = newwin(StatusLines, COLS, 0, 0);
2020-02-08 07:13:02 +00:00
if (!status) err(EX_OSERR, "newwin");
main = newwin(MAIN_LINES, COLS, StatusLines, 0);
if (!main) err(EX_OSERR, "newwin");
2020-02-09 16:50:56 +00:00
input = newpad(InputLines, InputCols);
2020-02-08 07:13:02 +00:00
if (!input) err(EX_OSERR, "newpad");
keypad(input, true);
nodelay(input, true);
2020-02-08 07:13:02 +00:00
windowFor(Network);
2020-02-04 08:58:56 +00:00
uiShow();
}
// Avoid disabling VINTR until main loop.
void uiInitLate(void) {
struct termios term;
int error = tcgetattr(STDOUT_FILENO, &term);
if (error) err(EX_OSERR, "tcgetattr");
// Gain use of C-q, C-s, C-c, C-z, C-y, C-v, C-o.
term.c_iflag &= ~IXON;
term.c_cc[VINTR] = _POSIX_VDISABLE;
term.c_cc[VSUSP] = _POSIX_VDISABLE;
#ifdef VDSUSP
term.c_cc[VDSUSP] = _POSIX_VDISABLE;
#endif
term.c_cc[VLNEXT] = _POSIX_VDISABLE;
term.c_cc[VDISCARD] = _POSIX_VDISABLE;
error = tcsetattr(STDOUT_FILENO, TCSANOW, &term);
if (error) err(EX_OSERR, "tcsetattr");
def_prog_mode();
}
static bool hidden = true;
2020-02-11 03:05:02 +00:00
static bool waiting;
2020-02-11 02:24:30 +00:00
static char title[256];
2020-02-11 03:05:02 +00:00
static char prevTitle[sizeof(title)];
2020-02-11 02:24:30 +00:00
void uiDraw(void) {
if (hidden) return;
wnoutrefresh(status);
wnoutrefresh(main);
int y, x;
getyx(input, y, x);
pnoutrefresh(
input,
0, (x + 1 > RIGHT ? x + 1 - RIGHT : 0),
LINES - InputLines, 0,
BOTTOM, RIGHT
);
2020-02-11 08:47:30 +00:00
(void)y;
doupdate();
2020-02-11 02:34:23 +00:00
2020-02-11 03:05:02 +00:00
if (!to_status_line) return;
2020-02-11 02:34:23 +00:00
if (!strcmp(title, prevTitle)) return;
strcpy(prevTitle, title);
2020-02-11 02:24:30 +00:00
putp(to_status_line);
putp(title);
putp(from_status_line);
fflush(stdout);
}
static const short Colors[ColorCap] = {
[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,
};
2020-09-01 22:05:17 +00:00
static attr_t styleAttr(struct Style style) {
attr_t attr = A_NORMAL;
if (style.attr & Bold) attr |= A_BOLD;
if (style.attr & Reverse) attr |= A_REVERSE;
if (style.attr & Italic) attr |= A_ITALIC;
if (style.attr & Underline) attr |= A_UNDERLINE;
return attr | colorAttr(Colors[style.fg]);
}
static short stylePair(struct Style style) {
return colorPair(Colors[style.fg], Colors[style.bg]);
}
static void styleAdd(WINDOW *win, const char *str) {
2020-09-01 22:05:17 +00:00
struct Style style = StyleDefault;
while (*str) {
2020-02-19 06:18:09 +00:00
size_t len = styleParse(&style, &str);
wattr_set(win, styleAttr(style), stylePair(style), NULL);
waddnstr(win, str, len);
str += len;
}
}
static void statusUpdate(void) {
2020-02-19 06:18:09 +00:00
struct {
uint unread;
enum Heat heat;
} others = { 0, Cold };
2020-02-10 22:54:16 +00:00
2020-02-19 06:18:09 +00:00
wmove(status, 0, 0);
for (uint num = 0; num < windows.len; ++num) {
const struct Window *window = windows.ptrs[num];
if (num != windows.show && !window->scroll) {
2020-04-15 20:18:09 +00:00
if (window->heat < Warm) continue;
if (window->mute && window->heat < Hot) continue;
}
if (num != windows.show) {
2020-02-19 06:18:09 +00:00
others.unread += window->unreadWarm;
if (window->heat > others.heat) others.heat = window->heat;
2020-02-10 22:54:16 +00:00
}
2020-05-24 16:34:23 +00:00
char buf[256] = "";
struct Cat cat = { buf, sizeof(buf), 0 };
2020-05-24 16:34:23 +00:00
catf(
&cat, "\3%d%s %u ",
2020-05-24 16:34:23 +00:00
idColors[window->id], (num == windows.show ? "\26" : ""), num
);
if (window->thresh != Cold || window->mute) {
const char *thresh[] = { "-", "", "+", "++" };
catf(&cat, "%s%s ", thresh[window->thresh], &"="[!window->mute]);
2020-05-24 16:34:23 +00:00
}
catf(&cat, "%s ", idNames[window->id]);
2020-05-24 16:34:23 +00:00
if (window->mark && window->unreadWarm) {
catf(
&cat, "\3%d+%d\3%d%s",
2020-05-24 16:34:23 +00:00
(window->heat > Warm ? White : idColors[window->id]),
window->unreadWarm, idColors[window->id],
(window->scroll ? "" : " ")
);
}
if (window->scroll) {
catf(&cat, "~%d ", window->scroll);
2020-04-06 18:34:32 +00:00
}
styleAdd(status, buf);
}
wclrtoeol(status);
2020-02-02 22:57:07 +00:00
struct Cat cat = { title, sizeof(title), 0 };
const struct Window *window = windows.ptrs[windows.show];
catf(&cat, "%s %s", network.name, idNames[window->id]);
if (window->mark && window->unreadWarm) {
catf(&cat, " +%d%s", window->unreadWarm, &"!"[window->heat < Hot]);
2020-02-10 22:54:16 +00:00
}
2020-02-19 06:18:09 +00:00
if (others.unread) {
catf(&cat, " (+%d%s)", others.unread, &"!"[others.heat < Hot]);
2020-02-10 22:54:16 +00:00
}
}
2020-02-10 06:59:08 +00:00
static void mark(struct Window *window) {
if (window->scroll) return;
window->mark = true;
window->unreadSoft = 0;
window->unreadWarm = 0;
2020-02-10 06:59:08 +00:00
}
2020-02-09 13:52:17 +00:00
static void unmark(struct Window *window) {
2020-02-09 16:50:56 +00:00
if (!window->scroll) {
2020-02-09 14:18:26 +00:00
window->mark = false;
2020-02-10 06:59:08 +00:00
window->heat = Cold;
2020-02-09 14:18:26 +00:00
}
2020-02-04 09:09:54 +00:00
statusUpdate();
}
2020-02-13 00:40:55 +00:00
void uiShow(void) {
if (!hidden) return;
2020-02-13 00:40:55 +00:00
prevTitle[0] = '\0';
putp(EnterFocusMode);
putp(EnterPasteMode);
fflush(stdout);
hidden = false;
unmark(windows.ptrs[windows.show]);
2020-02-13 00:40:55 +00:00
}
void uiHide(void) {
if (hidden) return;
mark(windows.ptrs[windows.show]);
2020-02-13 00:40:55 +00:00
hidden = true;
putp(ExitFocusMode);
putp(ExitPasteMode);
endwin();
}
2020-09-02 20:06:34 +00:00
static void mainAdd(int y, const char *str) {
int ny, nx;
wmove(main, y, 0);
styleAdd(main, str);
getyx(main, ny, nx);
if (ny == y) wclrtoeol(main);
(void)nx;
2020-09-02 20:06:34 +00:00
}
static void windowUpdate(void) {
struct Window *window = windows.ptrs[windows.show];
int y = MAIN_LINES - 1;
2020-09-02 20:06:34 +00:00
size_t bottom = BufferCap - 1 - window->scroll + !!window->scroll;
for (size_t i = bottom; i < BufferCap; --i) {
const struct Line *line = bufferHard(window->buffer, i);
if (!line) break;
2020-09-02 20:06:34 +00:00
mainAdd(y, line->str);
if (!y--) break;
}
while (y >= 0) {
wmove(main, y--, 0);
wclrtoeol(main);
}
2020-09-02 20:06:34 +00:00
if (!window->scroll) return;
y = MAIN_LINES - 1;
for (size_t i = BufferCap - 1; i < BufferCap; --i) {
const struct Line *line = bufferHard(window->buffer, i);
if (!line) break;
2020-09-02 20:06:34 +00:00
mainAdd(y, line->str);
if (--y < MAIN_LINES - SplitLines) break;
}
wattr_set(main, A_NORMAL, 0, NULL);
mvwhline(main, y, 0, ACS_BULLET, COLS);
}
2020-02-09 13:52:17 +00:00
static void windowScroll(struct Window *window, int n) {
2020-02-10 06:59:08 +00:00
mark(window);
2020-02-09 13:52:17 +00:00
window->scroll += n;
if (window->scroll > BufferCap - MAIN_LINES) {
window->scroll = BufferCap - MAIN_LINES;
2020-02-09 16:50:56 +00:00
}
if (window->scroll < 0) window->scroll = 0;
2020-02-10 06:59:08 +00:00
unmark(window);
if (window == windows.ptrs[windows.show]) windowUpdate();
2020-02-09 13:52:17 +00:00
}
static void windowScrollPage(struct Window *window, int n) {
windowScroll(window, n * (MAIN_LINES - SplitLines - MarkerLines - 1));
}
2020-09-03 20:37:31 +00:00
static void windowScrollTo(struct Window *window, int top) {
2020-02-09 17:13:51 +00:00
window->scroll = 0;
2020-09-03 20:37:31 +00:00
windowScroll(window, top - MAIN_LINES + MarkerLines);
}
static void windowScrollHot(struct Window *window, int dir) {
size_t from = BufferCap - window->scroll - MAIN_LINES + MarkerLines + dir;
for (size_t i = from; i < BufferCap; i += dir) {
const struct Line *line = bufferHard(window->buffer, i);
const struct Line *prev = bufferHard(window->buffer, i - 1);
if (!line || line->heat < Hot) continue;
if (prev && prev->heat > Warm) continue;
windowScrollTo(window, BufferCap - i);
break;
}
2020-02-09 17:13:51 +00:00
}
static void
windowScrollSearch(struct Window *window, const char *str, int dir) {
size_t from = BufferCap - window->scroll - MAIN_LINES + MarkerLines + dir;
for (size_t i = from; i < BufferCap; i += dir) {
const struct Line *line = bufferHard(window->buffer, i);
if (!line || !strcasestr(line->str, str)) continue;
windowScrollTo(window, BufferCap - i);
break;
}
}
2020-02-13 01:12:34 +00:00
struct Util uiNotifyUtil;
static void notify(uint id, const char *str) {
2020-02-13 01:12:34 +00:00
if (!uiNotifyUtil.argc) return;
2020-10-09 22:45:52 +00:00
char buf[1024] = "";
styleStrip(&(struct Cat) { buf, sizeof(buf), 0 }, str);
2020-02-13 01:12:34 +00:00
struct Util util = uiNotifyUtil;
utilPush(&util, idNames[id]);
utilPush(&util, buf);
pid_t pid = fork();
if (pid < 0) err(EX_OSERR, "fork");
if (pid) return;
close(STDIN_FILENO);
2020-02-14 02:57:55 +00:00
dup2(utilPipe[1], STDOUT_FILENO);
dup2(utilPipe[1], STDERR_FILENO);
2020-02-13 01:12:34 +00:00
execvp(util.argv[0], (char *const *)util.argv);
warn("%s", util.argv[0]);
_exit(EX_CONFIG);
}
void uiWrite(uint id, enum Heat heat, const time_t *src, const char *str) {
struct Window *window = windows.ptrs[windowFor(id)];
2020-02-19 06:18:09 +00:00
time_t ts = (src ? *src : time(NULL));
if (heat >= window->thresh) {
if (!window->unreadSoft++) window->unreadHard = 0;
}
2020-02-03 01:23:36 +00:00
if (window->mark && heat > Cold) {
if (!window->unreadWarm++) {
int lines = bufferPush(window->buffer, COLS, false, Warm, ts, "");
if (window->scroll) windowScroll(window, lines);
if (window->unreadSoft > 1) {
window->unreadSoft++;
window->unreadHard += lines;
}
2020-02-03 01:23:36 +00:00
}
2020-02-19 06:18:09 +00:00
if (heat > window->heat) window->heat = heat;
2020-02-03 01:23:36 +00:00
statusUpdate();
}
int lines = bufferPush(window->buffer, COLS, window->thresh, heat, ts, str);
window->unreadHard += lines;
2020-02-09 16:50:56 +00:00
if (window->scroll) windowScroll(window, lines);
if (window == windows.ptrs[windows.show]) windowUpdate();
2020-02-19 06:18:09 +00:00
2020-02-13 01:12:34 +00:00
if (window->mark && heat > Warm) {
beep();
notify(id, str);
}
}
void uiFormat(
uint 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);
}
2020-02-04 08:58:56 +00:00
2020-02-05 07:03:21 +00:00
static void resize(void) {
statusUpdate();
wclear(main);
wresize(main, MAIN_LINES, COLS);
for (uint num = 0; num < windows.len; ++num) {
struct Window *window = windows.ptrs[num];
2020-09-03 01:29:03 +00:00
window->unreadHard = bufferReflow(
window->buffer, COLS, window->thresh, window->unreadSoft
2020-09-03 01:29:03 +00:00
);
2020-02-05 07:03:21 +00:00
}
windowUpdate();
2020-02-05 07:03:21 +00:00
}
2020-02-11 00:40:13 +00:00
static void bufferList(const struct Buffer *buffer) {
2020-02-09 23:16:01 +00:00
uiHide();
waiting = true;
2020-02-19 06:18:09 +00:00
2020-02-09 23:16:01 +00:00
for (size_t i = 0; i < BufferCap; ++i) {
const struct Line *line = bufferSoft(buffer, i);
if (!line) continue;
2020-02-09 23:16:01 +00:00
struct tm *tm = localtime(&line->time);
2020-02-19 06:18:09 +00:00
if (!tm) err(EX_OSERR, "localtime");
char buf[sizeof("00:00:00")];
strftime(buf, sizeof(buf), "%T", tm);
vid_attr(colorAttr(Colors[Gray]), colorPair(Colors[Gray], -1), NULL);
2020-02-19 06:18:09 +00:00
printf("[%s] ", buf);
2020-02-09 23:16:01 +00:00
bool align = false;
2020-09-01 22:05:17 +00:00
struct Style style = StyleDefault;
for (const char *str = line->str; *str;) {
if (*str == '\t') {
printf("%c", (align ? '\t' : ' '));
align = true;
str++;
}
2020-02-19 06:18:09 +00:00
size_t len = styleParse(&style, &str);
size_t tab = strcspn(str, "\t");
if (tab < len) len = tab;
2020-02-19 06:18:09 +00:00
2020-09-01 22:05:17 +00:00
vid_attr(styleAttr(style), stylePair(style), NULL);
printf("%.*s", (int)len, str);
str += len;
2020-02-09 23:16:01 +00:00
}
printf("\n");
}
}
static void inputAdd(struct Style *style, const char *str) {
while (*str) {
const char *code = str;
2020-02-19 06:18:09 +00:00
size_t len = styleParse(style, &str);
wattr_set(input, A_BOLD | A_REVERSE, 0, NULL);
switch (*code) {
2020-02-07 07:46:40 +00:00
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');
break; case '\n': waddch(input, 'N');
}
if (str - code > 1) waddnstr(input, &code[1], str - &code[1]);
if (str[0] == '\n') {
str++;
len--;
}
size_t nl = strcspn(str, "\n");
if (nl < len) len = nl;
2020-09-01 22:05:17 +00:00
wattr_set(input, styleAttr(*style), stylePair(*style), NULL);
waddnstr(input, str, len);
str += len;
}
}
static void inputUpdate(void) {
size_t pos;
char *buf = editBuffer(&pos);
2020-02-19 06:18:09 +00:00
uint id = windows.ptrs[windows.show]->id;
const char *prefix = "";
const char *prompt = self.nick;
const char *suffix = "";
2020-02-19 06:18:09 +00:00
const char *skip = buf;
struct Style stylePrompt = { .fg = self.color, .bg = Default };
2020-09-01 22:05:17 +00:00
struct Style styleInput = StyleDefault;
2020-02-19 06:18:09 +00:00
const char *privmsg = commandIsPrivmsg(id, buf);
const char *notice = commandIsNotice(id, buf);
const char *action = commandIsAction(id, buf);
if (privmsg) {
prefix = "<"; suffix = "> ";
2020-02-19 06:18:09 +00:00
skip = privmsg;
} else if (notice) {
prefix = "-"; suffix = "- ";
2020-02-19 06:18:09 +00:00
styleInput.fg = LightGray;
skip = notice;
} else if (action) {
prefix = "* "; suffix = " ";
2020-09-01 22:05:17 +00:00
stylePrompt.attr |= Italic;
styleInput.attr |= Italic;
2020-02-19 06:18:09 +00:00
skip = action;
} else if (id == Debug && buf[0] != '/') {
prompt = "<< ";
2020-02-19 06:18:09 +00:00
stylePrompt.fg = Gray;
} else {
prompt = "";
}
2020-02-19 06:18:09 +00:00
if (skip > &buf[pos]) {
prefix = prompt = suffix = "";
2020-02-19 06:18:09 +00:00
skip = buf;
}
int y, x;
wmove(input, 0, 0);
2020-09-01 22:05:17 +00:00
wattr_set(input, styleAttr(stylePrompt), stylePair(stylePrompt), NULL);
waddstr(input, prefix);
waddstr(input, prompt);
waddstr(input, suffix);
2020-02-19 06:18:09 +00:00
struct Style style = styleInput;
char p = buf[pos];
buf[pos] = '\0';
2020-02-19 06:18:09 +00:00
inputAdd(&style, skip);
getyx(input, y, x);
buf[pos] = p;
inputAdd(&style, &buf[pos]);
wclrtoeol(input);
wmove(input, y, x);
}
static void windowShow(uint num) {
windows.swap = windows.show;
windows.show = num;
windows.user = num;
mark(windows.ptrs[windows.swap]);
unmark(windows.ptrs[windows.show]);
windowUpdate();
2020-02-10 06:59:08 +00:00
inputUpdate();
}
void uiShowID(uint id) {
windowShow(windowFor(id));
}
void uiShowNum(uint num) {
if (num < windows.len) windowShow(num);
}
void uiMoveID(uint id, uint num) {
struct Window *window = windowRemove(windowFor(id));
if (num < windows.len) {
windowShow(windowInsert(num, window));
} else {
windowShow(windowPush(window));
}
}
static void windowClose(uint num) {
if (windows.ptrs[num]->id == Network) return;
struct Window *window = windowRemove(num);
completeClear(window->id);
windowFree(window);
if (windows.swap >= num) windows.swap--;
if (windows.show == num) {
windowShow(windows.swap);
windows.swap = windows.show;
} else if (windows.show > num) {
windows.show--;
windowUpdate();
2020-02-08 07:26:00 +00:00
}
statusUpdate();
}
void uiCloseID(uint id) {
2020-02-08 07:26:00 +00:00
windowClose(windowFor(id));
}
void uiCloseNum(uint num) {
if (num < windows.len) windowClose(num);
2020-02-08 07:26:00 +00:00
}
static void incThresh(struct Window *window, int n) {
if (n > 0 && window->thresh == Hot) return;
if (n < 0 && window->thresh == Ice) {
window->thresh = Cold;
} else {
window->thresh += n;
}
2020-09-03 01:29:03 +00:00
window->unreadHard = bufferReflow(
window->buffer, COLS, window->thresh, window->unreadSoft
2020-09-03 01:29:03 +00:00
);
windowUpdate();
statusUpdate();
}
2020-02-09 13:14:22 +00:00
static void showAuto(void) {
uint minHot = UINT_MAX, numHot = 0;
uint minWarm = UINT_MAX, numWarm = 0;
for (uint num = 0; num < windows.len; ++num) {
2020-04-15 20:18:09 +00:00
struct Window *window = windows.ptrs[num];
if (window->heat >= Hot) {
if (window->unreadWarm >= minHot) continue;
minHot = window->unreadWarm;
numHot = num;
}
2020-04-15 20:18:09 +00:00
if (window->heat >= Warm && !window->mute) {
if (window->unreadWarm >= minWarm) continue;
minWarm = window->unreadWarm;
numWarm = num;
}
2020-02-09 13:14:22 +00:00
}
uint user = windows.user;
if (minHot < UINT_MAX) {
windowShow(numHot);
windows.user = user;
} else if (minWarm < UINT_MAX) {
windowShow(numWarm);
windows.user = user;
} else if (user != windows.show) {
windowShow(user);
2020-02-09 13:14:22 +00:00
}
}
2020-02-04 08:58:56 +00:00
static void keyCode(int code) {
struct Window *window = windows.ptrs[windows.show];
uint id = window->id;
2020-02-04 08:58:56 +00:00
switch (code) {
2020-02-05 07:03:21 +00:00
break; case KEY_RESIZE: resize();
2020-02-09 13:52:17 +00:00
break; case KeyFocusIn: unmark(window);
2020-02-10 06:59:08 +00:00
break; case KeyFocusOut: mark(window);
2020-02-07 06:55:26 +00:00
2020-03-23 19:03:55 +00:00
break; case KeyMetaEnter: edit(id, EditInsert, L'\n');
2020-04-15 20:18:09 +00:00
break; case KeyMetaEqual: window->mute ^= true; statusUpdate();
break; case KeyMetaMinus: incThresh(window, -1);
break; case KeyMetaPlus: incThresh(window, +1);
break; case KeyMetaSlash: windowShow(windows.swap);
2020-02-09 13:17:05 +00:00
break; case KeyMetaGt: windowScroll(window, -BufferCap);
break; case KeyMetaLt: windowScroll(window, +BufferCap);
break; case KeyMeta0 ... KeyMeta9: uiShowNum(code - KeyMeta0);
2020-02-09 13:14:22 +00:00
break; case KeyMetaA: showAuto();
2020-02-09 09:20:07 +00:00
break; case KeyMetaB: edit(id, EditPrevWord, 0);
2020-02-09 09:32:32 +00:00
break; case KeyMetaD: edit(id, EditDeleteNextWord, 0);
2020-02-09 09:20:07 +00:00
break; case KeyMetaF: edit(id, EditNextWord, 0);
break; case KeyMetaL: bufferList(window->buffer);
break; case KeyMetaM: uiWrite(id, Cold, NULL, "");
2020-09-03 20:37:31 +00:00
break; case KeyMetaN: windowScrollHot(window, +1);
break; case KeyMetaP: windowScrollHot(window, -1);
2020-04-07 14:48:44 +00:00
break; case KeyMetaQ: edit(id, EditCollapse, 0);
2020-09-03 20:37:31 +00:00
break; case KeyMetaU: windowScrollTo(window, window->unreadHard);
break; case KeyMetaV: windowScrollPage(window, +1);
break; case KEY_BACKSPACE: edit(id, EditDeletePrev, 0);
break; case KEY_DC: edit(id, EditDeleteNext, 0);
2020-02-09 16:50:56 +00:00
break; case KEY_DOWN: windowScroll(window, -1);
break; case KEY_END: edit(id, EditTail, 0);
2020-02-07 06:55:26 +00:00
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: windowScrollPage(window, -1);
break; case KEY_PPAGE: windowScrollPage(window, +1);
break; case KEY_RIGHT: edit(id, EditNext, 0);
break; case KEY_SEND: windowScroll(window, -BufferCap);
break; case KEY_SHOME: windowScroll(window, +BufferCap);
2020-02-09 16:50:56 +00:00
break; case KEY_UP: windowScroll(window, +1);
2020-02-04 08:58:56 +00:00
}
}
2020-02-05 01:56:27 +00:00
static void keyCtrl(wchar_t ch) {
struct Window *window = windows.ptrs[windows.show];
uint id = window->id;
2020-02-07 07:46:40 +00:00
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);
2020-02-08 02:30:25 +00:00
break; case L'I': edit(id, EditComplete, 0);
break; case L'J': edit(id, EditEnter, 0);
2020-02-09 09:22:41 +00:00
break; case L'K': edit(id, EditDeleteTail, 0);
2020-02-05 01:56:27 +00:00
break; case L'L': clearok(curscr, true);
break; case L'N': uiShowNum(windows.show + 1);
break; case L'P': uiShowNum(windows.show - 1);
break; case L'R': windowScrollSearch(window, editBuffer(NULL), -1);
break; case L'S': windowScrollSearch(window, editBuffer(NULL), +1);
break; case L'T': edit(id, EditTranspose, 0);
2020-02-09 09:22:41 +00:00
break; case L'U': edit(id, EditDeleteHead, 0);
break; case L'V': windowScrollPage(window, -1);
break; case L'W': edit(id, EditDeletePrevWord, 0);
2020-03-30 18:56:26 +00:00
break; case L'X': edit(id, EditExpand, 0);
break; case L'Y': edit(id, EditPaste, 0);
2020-02-04 08:58:56 +00:00
}
}
2020-02-07 07:46:40 +00:00
static void keyStyle(wchar_t ch) {
uint id = windows.ptrs[windows.show]->id;
switch (iswcntrl(ch) ? ch ^ L'@' : (wchar_t)towupper(ch)) {
2020-02-07 07:46:40 +00:00
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);
}
}
2020-02-04 08:58:56 +00:00
void uiRead(void) {
2020-02-09 23:16:01 +00:00
if (hidden) {
if (waiting) {
uiShow();
flushinp();
waiting = false;
} else {
return;
}
}
2020-02-04 08:58:56 +00:00
wint_t ch;
static bool paste, style;
for (int ret; ERR != (ret = wget_wch(input, &ch));) {
if (ret == KEY_CODE_YES && ch == KeyPasteOn) {
paste = true;
} else if (ret == KEY_CODE_YES && ch == KeyPasteOff) {
paste = false;
} else if (paste) {
edit(windows.ptrs[windows.show]->id, EditInsert, ch);
} else if (ret == KEY_CODE_YES) {
2020-02-04 08:58:56 +00:00
keyCode(ch);
2020-02-07 07:46:40 +00:00
} else if (ch == (L'Z' ^ L'@')) {
style = true;
continue;
} else if (style) {
keyStyle(ch);
2020-02-05 01:56:27 +00:00
} else if (iswcntrl(ch)) {
2020-02-07 07:46:40 +00:00
keyCtrl(ch);
2020-02-04 08:58:56 +00:00
} else {
edit(windows.ptrs[windows.show]->id, EditInsert, ch);
2020-02-04 08:58:56 +00:00
}
style = false;
2020-02-04 08:58:56 +00:00
}
inputUpdate();
2020-02-04 08:58:56 +00:00
}
2020-02-11 00:40:13 +00:00
static const time_t Signatures[] = {
2020-02-19 06:18:09 +00:00
0x6C72696774616301, // no heat, unread, unreadWarm
0x6C72696774616302, // no self.pos
2020-03-31 18:12:43 +00:00
0x6C72696774616303, // no buffer line heat
2020-04-15 20:18:09 +00:00
0x6C72696774616304, // no mute
0x6C72696774616305, // no URLs
0x6C72696774616306, // no thresh
0x6C72696774616307,
2020-02-11 00:40:13 +00:00
};
static size_t signatureVersion(time_t signature) {
2020-02-11 00:40:13 +00:00
for (size_t i = 0; i < ARRAY_LEN(Signatures); ++i) {
if (signature == Signatures[i]) return i;
}
err(EX_DATAERR, "unknown file signature %jX", (uintmax_t)signature);
2020-02-11 00:40:13 +00:00
}
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;
int error = 0
|| writeTime(file, Signatures[6])
|| writeTime(file, self.pos);
if (error) return error;
for (uint num = 0; num < windows.len; ++num) {
const struct Window *window = windows.ptrs[num];
error = 0
|| writeString(file, idNames[window->id])
|| writeTime(file, window->mute)
|| writeTime(file, window->thresh)
|| writeTime(file, window->heat)
|| writeTime(file, window->unreadSoft)
|| writeTime(file, window->unreadWarm);
if (error) return error;
2020-02-11 00:40:13 +00:00
for (size_t i = 0; i < BufferCap; ++i) {
const struct Line *line = bufferSoft(window->buffer, i);
if (!line) continue;
error = 0
|| writeTime(file, line->time)
|| writeTime(file, line->heat)
|| writeString(file, line->str);
if (error) return error;
2020-02-11 00:40:13 +00:00
}
error = writeTime(file, 0);
if (error) return error;
2020-02-11 00:40:13 +00:00
}
return 0
|| writeString(file, "")
|| urlSave(file)
|| fclose(file);
2020-02-11 00:40:13 +00:00
}
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;
}
time_t signature;
fread(&signature, sizeof(signature), 1, file);
if (ferror(file)) err(EX_IOERR, "fread");
if (feof(file)) {
fclose(file);
return;
}
2020-02-14 10:20:22 +00:00
size_t version = signatureVersion(signature);
2020-02-11 00:40:13 +00:00
if (version > 1) {
self.pos = readTime(file);
}
2020-02-11 00:40:13 +00:00
char *buf = NULL;
size_t cap = 0;
while (0 < readString(file, &buf, &cap) && buf[0]) {
struct Window *window = windows.ptrs[windowFor(idFor(buf))];
2020-04-15 20:18:09 +00:00
if (version > 3) window->mute = readTime(file);
if (version > 5) window->thresh = readTime(file);
2020-02-14 10:20:22 +00:00
if (version > 0) {
window->heat = readTime(file);
window->unreadSoft = readTime(file);
2020-02-14 10:20:22 +00:00
window->unreadWarm = readTime(file);
}
2020-02-11 00:40:13 +00:00
for (;;) {
time_t time = readTime(file);
if (!time) break;
2020-03-31 18:12:43 +00:00
enum Heat heat = (version > 2 ? readTime(file) : Cold);
2020-02-11 00:40:13 +00:00
readString(file, &buf, &cap);
bufferPush(window->buffer, COLS, window->thresh, heat, time, buf);
2020-02-11 00:40:13 +00:00
}
2020-09-03 01:29:03 +00:00
window->unreadHard = bufferReflow(
window->buffer, COLS, window->thresh, window->unreadSoft
2020-09-03 01:29:03 +00:00
);
2020-02-11 00:40:13 +00:00
}
urlLoad(file, version);
2020-02-11 00:40:13 +00:00
free(buf);
fclose(file);
}