catgirl/ui.c

355 lines
8.8 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 <curses.h>
#include <err.h>
2020-02-11 00:40:13 +00:00
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/file.h>
#include <sysexits.h>
#include <term.h>
#include <time.h>
#include <unistd.h>
2021-06-24 22:07:30 +00:00
#ifdef __FreeBSD__
2021-06-28 13:11:02 +00:00
#include <capsicum_helpers.h>
2021-06-24 22:07:30 +00:00
#endif
#include "chat.h"
#define BOTTOM (LINES - 1)
#define RIGHT (COLS - 1)
#define MAIN_LINES (LINES - StatusLines - InputLines)
WINDOW *uiStatus;
WINDOW *uiMain;
2022-02-20 01:20:19 +00:00
WINDOW *uiInput;
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++;
}
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.
2021-02-15 23:59:17 +00:00
static const char *FocusMode[2] = { "\33[?1004l", "\33[?1004h" };
static const char *PasteMode[2] = { "\33[?2004l", "\33[?2004h" };
2020-02-19 06:18:09 +00:00
static void errExit(void) {
2021-02-15 23:59:17 +00:00
putp(FocusMode[false]);
putp(PasteMode[false]);
2020-02-19 06:18:09 +00:00
reset_shell_mode();
}
2022-02-20 01:20:19 +00:00
void uiInit(void) {
initscr();
cbreak();
noecho();
2020-02-08 07:13:02 +00:00
colorInit();
atexit(errExit);
#ifndef A_ITALIC
#define A_ITALIC A_BLINK
// Force ncurses to use individual enter_attr_mode strings:
set_attributes = NULL;
enter_blink_mode = enter_italics_mode;
#endif
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
uiStatus = newwin(StatusLines, COLS, 0, 0);
if (!uiStatus) err(EX_OSERR, "newwin");
uiMain = newwin(MAIN_LINES, COLS, StatusLines, 0);
if (!uiMain) err(EX_OSERR, "newwin");
2022-02-20 01:20:19 +00:00
uiInput = newpad(InputLines, InputCols);
if (!uiInput) err(EX_OSERR, "newpad");
2020-02-08 07:13:02 +00:00
windowInit();
2020-02-04 08:58:56 +00:00
uiShow();
}
static bool hidden = true;
2020-02-11 03:05:02 +00:00
char uiTitle[TitleCap];
static char prevTitle[TitleCap];
2020-02-11 02:24:30 +00:00
void uiDraw(void) {
if (hidden) return;
wnoutrefresh(uiStatus);
wnoutrefresh(uiMain);
int y, x;
2022-02-20 01:20:19 +00:00
getyx(uiInput, y, x);
pnoutrefresh(
2022-02-20 01:20:19 +00:00
uiInput,
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;
if (!strcmp(uiTitle, prevTitle)) return;
strcpy(prevTitle, uiTitle);
2020-02-11 02:24:30 +00:00
putp(to_status_line);
putp(uiTitle);
2020-02-11 02:24:30 +00:00
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,
};
uint uiAttr(struct Style style) {
2020-09-01 22:05:17 +00:00
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]);
}
2022-02-20 01:20:19 +00:00
bool uiSpoilerReveal;
short uiPair(struct Style style) {
2022-02-20 01:20:19 +00:00
if (uiSpoilerReveal && style.fg == style.bg) {
return colorPair(Colors[Default], Colors[style.bg]);
}
2020-09-01 22:05:17 +00:00
return colorPair(Colors[style.fg], Colors[style.bg]);
}
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';
2021-02-15 23:59:17 +00:00
putp(FocusMode[true]);
putp(PasteMode[true]);
2020-02-13 00:40:55 +00:00
fflush(stdout);
hidden = false;
windowUnmark();
2020-02-13 00:40:55 +00:00
}
void uiHide(void) {
if (hidden) return;
windowMark();
2020-02-13 00:40:55 +00:00
hidden = true;
2021-02-15 23:59:17 +00:00
putp(FocusMode[false]);
putp(PasteMode[false]);
2020-02-13 00:40:55 +00:00
endwin();
}
2020-02-13 01:12:34 +00:00
struct Util uiNotifyUtil;
static void notify(uint id, const char *str) {
if (self.restricted) return;
2020-02-13 01:12:34 +00:00
if (!uiNotifyUtil.argc) return;
2021-06-07 04:09:58 +00:00
char buf[1024];
styleStrip(buf, sizeof(buf), str);
2020-10-09 22:45:52 +00:00
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;
setsid();
2020-02-13 01:12:34 +00:00
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) {
bool note = windowWrite(id, heat, src, str);
if (note) {
2020-02-13 01:12:34 +00:00
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
2022-02-20 01:20:19 +00:00
void uiResize(void) {
wclear(uiMain);
wresize(uiMain, MAIN_LINES, COLS);
windowResize();
2020-02-09 23:16:01 +00:00
}
static FILE *saveFile;
static const uint64_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
2021-01-27 20:35:26 +00:00
0x6C72696774616307, // no window time
0x6C72696774616308,
2020-02-11 00:40:13 +00:00
};
static size_t signatureVersion(uint64_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;
}
errx(EX_DATAERR, "unknown file signature %" PRIX64, signature);
2020-02-11 00:40:13 +00:00
}
static int writeUint64(FILE *file, uint64_t u) {
return (fwrite(&u, sizeof(u), 1, file) ? 0 : -1);
2020-02-11 00:40:13 +00:00
}
int uiSave(void) {
return 0
|| ftruncate(fileno(saveFile), 0)
|| writeUint64(saveFile, Signatures[7])
|| writeUint64(saveFile, self.pos)
|| windowSave(saveFile)
|| urlSave(saveFile)
|| fclose(saveFile);
2020-02-11 00:40:13 +00:00
}
static uint64_t readUint64(FILE *file) {
uint64_t u;
fread(&u, sizeof(u), 1, file);
2020-02-11 00:40:13 +00:00
if (ferror(file)) err(EX_IOERR, "fread");
if (feof(file)) errx(EX_DATAERR, "unexpected eof");
return u;
2020-02-11 00:40:13 +00:00
}
void uiLoad(const char *name) {
2021-06-24 22:07:30 +00:00
int error;
saveFile = dataOpen(name, "a+e");
if (!saveFile) exit(EX_CANTCREAT);
rewind(saveFile);
2020-02-11 00:40:13 +00:00
2021-06-24 22:07:30 +00:00
#ifdef __FreeBSD__
cap_rights_t rights;
cap_rights_init(&rights, CAP_READ, CAP_WRITE, CAP_FLOCK, CAP_FTRUNCATE);
2021-06-28 13:11:02 +00:00
error = caph_rights_limit(fileno(saveFile), &rights);
2021-06-24 22:07:30 +00:00
if (error) err(EX_OSERR, "cap_rights_limit");
#endif
error = flock(fileno(saveFile), LOCK_EX | LOCK_NB);
if (error && errno == EWOULDBLOCK) {
errx(EX_CANTCREAT, "%s: save file in use", name);
}
time_t signature;
fread(&signature, sizeof(signature), 1, saveFile);
if (ferror(saveFile)) err(EX_IOERR, "fread");
if (feof(saveFile)) {
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 = readUint64(saveFile);
2020-02-11 00:40:13 +00:00
}
windowLoad(saveFile, version);
urlLoad(saveFile, version);
2020-02-11 00:40:13 +00:00
}