dzwdz
/
catboy
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Factor out window management to window.c

master
June McEnroe 2022-02-19 18:28:45 -05:00
parent 70f627bc47
commit 3359a5d69b
8 changed files with 827 additions and 673 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Makefile
View File

@ -24,6 +24,7 @@ OBJS += irc.o
OBJS += log.o OBJS += log.o
OBJS += ui.o OBJS += ui.o
OBJS += url.o OBJS += url.o
OBJS += window.o
OBJS += xdg.o OBJS += xdg.o
TESTS += edit.t TESTS += edit.t

4
README.7
View File

@ -1,5 +1,5 @@
.\" To view this file, run: man ./README.7 .\" To view this file, run: man ./README.7
.Dd February 12, 2022 .Dd February 19, 2022
.Dt README 7 .Dt README 7
.Os "Causal Agency" .Os "Causal Agency"
. .
@ -181,6 +181,8 @@ startup and event loop
IRC connection and parsing IRC connection and parsing
.It Pa ui.c .It Pa ui.c
curses interface curses interface
.It Pa window.c
window management
.It Pa handle.c .It Pa handle.c
IRC message handling IRC message handling
.It Pa command.c .It Pa command.c

8
chat.c
View File

@ -293,8 +293,8 @@ int main(int argc, char *argv[]) {
break; case 'R': self.restricted = true; break; case 'R': self.restricted = true;
break; case 'S': bind = optarg; break; case 'S': bind = optarg;
break; case 'T': { break; case 'T': {
uiTime.enable = true; windowTime.enable = true;
if (optarg) uiTime.format = optarg; if (optarg) windowTime.format = optarg;
} }
break; case 'a': sasl = true; parsePlain(optarg); break; case 'a': sasl = true; parsePlain(optarg);
break; case 'c': cert = optarg; break; case 'c': cert = optarg;
@ -309,7 +309,7 @@ int main(int argc, char *argv[]) {
break; case 'n': nick = optarg; break; case 'n': nick = optarg;
break; case 'o': printCert = true; break; case 'o': printCert = true;
break; case 'p': port = optarg; break; case 'p': port = optarg;
break; case 'q': uiThreshold = Warm; break; case 'q': windowThreshold = Warm;
break; case 'r': real = optarg; break; case 'r': real = optarg;
break; case 's': save = optarg; break; case 's': save = optarg;
break; case 't': trust = optarg; break; case 't': trust = optarg;
@ -381,7 +381,7 @@ int main(int argc, char *argv[]) {
uiLoad(save); uiLoad(save);
atexit(exitSave); atexit(exitSave);
} }
uiShowID(Network); windowShow(windowFor(Network));
uiFormat( uiFormat(
Network, Cold, NULL, Network, Cold, NULL,
"\3%dcatgirl\3\tis GPLv3 fwee softwawe ^w^ " "\3%dcatgirl\3\tis GPLv3 fwee softwawe ^w^ "

74
chat.h
View File

@ -293,26 +293,34 @@ const char *commandIsAction(uint id, const char *input);
size_t commandWillSplit(uint id, const char *input); size_t commandWillSplit(uint id, const char *input);
void commandCompleteAdd(void); void commandCompleteAdd(void);
enum Heat { Ice, Cold, Warm, Hot }; enum Heat {
enum { TimeCap = 64 }; Ice,
extern enum Heat uiThreshold; Cold,
extern struct Time { Warm,
bool enable; Hot,
const char *format; };
int width;
} uiTime; enum {
TitleCap = 256,
StatusLines = 1,
MarkerLines = 1,
SplitLines = 5,
InputLines = 1,
InputCols = 1024,
};
extern char uiTitle[TitleCap];
extern struct _win_st *uiStatus;
extern struct _win_st *uiMain;
extern struct Util uiNotifyUtil; extern struct Util uiNotifyUtil;
void uiInitEarly(void); void uiInitEarly(void);
void uiInitLate(void); void uiInitLate(void);
uint uiAttr(struct Style style);
short uiPair(struct Style style);
void uiUpdate(void);
void uiShow(void); void uiShow(void);
void uiHide(void); void uiHide(void);
void uiWait(void);
void uiDraw(void); void uiDraw(void);
void uiWindows(void);
void uiShowID(uint id);
void uiShowNum(uint num);
void uiMoveID(uint id, uint num);
void uiCloseID(uint id);
void uiCloseNum(uint id);
void uiRead(void); void uiRead(void);
void uiWrite(uint id, enum Heat heat, const time_t *time, const char *str); void uiWrite(uint id, enum Heat heat, const time_t *time, const char *str);
void uiFormat( void uiFormat(
@ -321,6 +329,44 @@ void uiFormat(
void uiLoad(const char *name); void uiLoad(const char *name);
int uiSave(void); int uiSave(void);
enum Scroll {
ScrollOne,
ScrollPage,
ScrollAll,
ScrollUnread,
ScrollHot,
};
extern struct Time {
bool enable;
const char *format;
int width;
} windowTime;
extern enum Heat windowThreshold;
void windowInit(void);
void windowUpdate(void);
void windowResize(void);
bool windowWrite(uint id, enum Heat heat, const time_t *time, const char *str);
void windowBare(void);
uint windowID(void);
uint windowNum(void);
uint windowFor(uint id);
void windowShow(uint num);
void windowAuto(void);
void windowSwap(void);
void windowMove(uint from, uint to);
void windowClose(uint num);
void windowList(void);
void windowMark(void);
void windowUnmark(void);
void windowToggleMute(void);
void windowToggleTime(void);
void windowToggleThresh(int n);
bool windowTimeEnable(void);
void windowScroll(enum Scroll by, int n);
void windowSearch(const char *str, int dir);
int windowSave(FILE *file);
void windowLoad(FILE *file, size_t version);
enum { BufferCap = 1024 }; enum { BufferCap = 1024 };
struct Buffer; struct Buffer;
struct Line { struct Line {

22
command.c
View File

@ -144,7 +144,7 @@ static void commandMsg(uint id, char *params) {
if (params) { if (params) {
splitMessage("PRIVMSG", msg, params); splitMessage("PRIVMSG", msg, params);
} else { } else {
uiShowID(msg); windowShow(windowFor(msg));
} }
} }
@ -376,25 +376,25 @@ static void commandQuery(uint id, char *params) {
if (idColors[query] == Default) { if (idColors[query] == Default) {
idColors[query] = completeColor(id, params); idColors[query] = completeColor(id, params);
} }
uiShowID(query); windowShow(windowFor(query));
} }
static void commandWindow(uint id, char *params) { static void commandWindow(uint id, char *params) {
if (!params) { if (!params) {
uiWindows(); windowList();
} else if (isdigit(params[0])) { } else if (isdigit(params[0])) {
uiShowNum(strtoul(params, NULL, 10)); windowShow(strtoul(params, NULL, 10));
} else { } else {
id = idFind(params); id = idFind(params);
if (id) { if (id) {
uiShowID(id); windowShow(windowFor(id));
return; return;
} }
for (const char *match; (match = completeSubstr(None, params));) { for (const char *match; (match = completeSubstr(None, params));) {
id = idFind(match); id = idFind(match);
if (!id) continue; if (!id) continue;
completeAccept(); completeAccept();
uiShowID(id); windowShow(windowFor(id));
break; break;
} }
} }
@ -405,20 +405,20 @@ static void commandMove(uint id, char *params) {
char *name = strsep(&params, " "); char *name = strsep(&params, " ");
if (params) { if (params) {
id = idFind(name); id = idFind(name);
if (id) uiMoveID(id, strtoul(params, NULL, 10)); if (id) windowMove(windowFor(id), strtoul(params, NULL, 10));
} else { } else {
uiMoveID(id, strtoul(name, NULL, 10)); windowMove(windowFor(id), strtoul(name, NULL, 10));
} }
} }
static void commandClose(uint id, char *params) { static void commandClose(uint id, char *params) {
if (!params) { if (!params) {
uiCloseID(id); windowClose(windowFor(id));
} else if (isdigit(params[0])) { } else if (isdigit(params[0])) {
uiCloseNum(strtoul(params, NULL, 10)); windowClose(strtoul(params, NULL, 10));
} else { } else {
id = idFind(params); id = idFind(params);
if (id) uiCloseID(id); if (id) windowClose(windowFor(id));
} }
} }

2
handle.c
View File

@ -343,7 +343,7 @@ static void handleJoin(struct Message *msg) {
idColors[id] = hash(msg->params[0]); idColors[id] = hash(msg->params[0]);
completeTouch(None, msg->params[0], idColors[id]); completeTouch(None, msg->params[0], idColors[id]);
if (replies[ReplyJoin]) { if (replies[ReplyJoin]) {
uiShowID(id); windowShow(windowFor(id));
replies[ReplyJoin]--; replies[ReplyJoin]--;
} }
} }

733
ui.c
View File

@ -33,15 +33,15 @@
#include <err.h> #include <err.h>
#include <errno.h> #include <errno.h>
#include <fcntl.h> #include <fcntl.h>
#include <limits.h> #include <inttypes.h>
#include <signal.h> #include <signal.h>
#include <stdarg.h> #include <stdarg.h>
#include <stdbool.h> #include <stdbool.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <sysexits.h>
#include <sys/file.h> #include <sys/file.h>
#include <sysexits.h>
#include <term.h> #include <term.h>
#include <termios.h> #include <termios.h>
#include <time.h> #include <time.h>
@ -60,102 +60,14 @@
#undef lines #undef lines
#undef tab #undef tab
enum {
StatusLines = 1,
MarkerLines = 1,
SplitLines = 5,
InputLines = 1,
InputCols = 1024,
};
#define BOTTOM (LINES - 1) #define BOTTOM (LINES - 1)
#define RIGHT (COLS - 1) #define RIGHT (COLS - 1)
#define MAIN_LINES (LINES - StatusLines - InputLines) #define MAIN_LINES (LINES - StatusLines - InputLines)
static WINDOW *status; WINDOW *uiStatus;
static WINDOW *main; WINDOW *uiMain;
static WINDOW *input; static WINDOW *input;
struct Window {
uint id;
int scroll;
bool mark;
bool mute;
bool time;
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;
}
enum Heat uiThreshold = Cold;
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");
window->id = id;
window->mark = true;
window->time = uiTime.enable;
if (id == Network || id == Debug) {
window->thresh = Cold;
} else {
window->thresh = uiThreshold;
}
window->buffer = bufferAlloc();
completeAdd(None, idNames[id], idColors[id]);
return windowPush(window);
}
static void windowFree(struct Window *window) {
completeRemove(None, idNames[window->id]);
bufferFree(window->buffer);
free(window);
}
static short colorPairs; static short colorPairs;
static void colorInit(void) { static void colorInit(void) {
@ -240,8 +152,6 @@ enum {
static const char *FocusMode[2] = { "\33[?1004l", "\33[?1004h" }; static const char *FocusMode[2] = { "\33[?1004l", "\33[?1004h" };
static const char *PasteMode[2] = { "\33[?2004l", "\33[?2004h" }; static const char *PasteMode[2] = { "\33[?2004l", "\33[?2004h" };
struct Time uiTime = { .format = "%X" };
static void errExit(void) { static void errExit(void) {
putp(FocusMode[false]); putp(FocusMode[false]);
putp(PasteMode[false]); putp(PasteMode[false]);
@ -271,30 +181,18 @@ void uiInitEarly(void) {
ENUM_KEY ENUM_KEY
#undef X #undef X
status = newwin(StatusLines, COLS, 0, 0); uiStatus = newwin(StatusLines, COLS, 0, 0);
if (!status) err(EX_OSERR, "newwin"); if (!uiStatus) err(EX_OSERR, "newwin");
main = newwin(MAIN_LINES, COLS, StatusLines, 0); uiMain = newwin(MAIN_LINES, COLS, StatusLines, 0);
if (!main) err(EX_OSERR, "newwin"); if (!uiMain) err(EX_OSERR, "newwin");
int y;
char fmt[TimeCap];
char buf[TimeCap];
styleStrip(fmt, sizeof(fmt), uiTime.format);
struct tm *time = localtime(&(time_t) { -22100400 });
size_t len = strftime(buf, sizeof(buf), fmt, time);
if (!len) errx(EX_CONFIG, "invalid timestamp format: %s", fmt);
waddstr(main, buf);
waddch(main, ' ');
getyx(main, y, uiTime.width);
(void)y;
input = newpad(InputLines, InputCols); input = newpad(InputLines, InputCols);
if (!input) err(EX_OSERR, "newpad"); if (!input) err(EX_OSERR, "newpad");
keypad(input, true); keypad(input, true);
nodelay(input, true); nodelay(input, true);
windowFor(Network); windowInit();
uiShow(); uiShow();
} }
@ -323,13 +221,13 @@ void uiInitLate(void) {
static bool hidden = true; static bool hidden = true;
static bool waiting; static bool waiting;
static char title[256]; char uiTitle[TitleCap];
static char prevTitle[sizeof(title)]; static char prevTitle[TitleCap];
void uiDraw(void) { void uiDraw(void) {
if (hidden) return; if (hidden) return;
wnoutrefresh(status); wnoutrefresh(uiStatus);
wnoutrefresh(main); wnoutrefresh(uiMain);
int y, x; int y, x;
getyx(input, y, x); getyx(input, y, x);
pnoutrefresh( pnoutrefresh(
@ -342,10 +240,10 @@ void uiDraw(void) {
doupdate(); doupdate();
if (!to_status_line) return; if (!to_status_line) return;
if (!strcmp(title, prevTitle)) return; if (!strcmp(uiTitle, prevTitle)) return;
strcpy(prevTitle, title); strcpy(prevTitle, uiTitle);
putp(to_status_line); putp(to_status_line);
putp(title); putp(uiTitle);
putp(from_status_line); putp(from_status_line);
fflush(stdout); fflush(stdout);
} }
@ -377,7 +275,7 @@ static const short Colors[ColorCap] = {
16, 233, 235, 237, 239, 241, 244, 247, 250, 254, 231, 16, 233, 235, 237, 239, 241, 244, 247, 250, 254, 231,
}; };
static attr_t styleAttr(struct Style style) { uint uiAttr(struct Style style) {
attr_t attr = A_NORMAL; attr_t attr = A_NORMAL;
if (style.attr & Bold) attr |= A_BOLD; if (style.attr & Bold) attr |= A_BOLD;
if (style.attr & Reverse) attr |= A_REVERSE; if (style.attr & Reverse) attr |= A_REVERSE;
@ -388,96 +286,13 @@ static attr_t styleAttr(struct Style style) {
static bool spoilerReveal; static bool spoilerReveal;
static short stylePair(struct Style style) { short uiPair(struct Style style) {
if (spoilerReveal && style.fg == style.bg) { if (spoilerReveal && style.fg == style.bg) {
return colorPair(Colors[Default], Colors[style.bg]); return colorPair(Colors[Default], Colors[style.bg]);
} }
return colorPair(Colors[style.fg], Colors[style.bg]); return colorPair(Colors[style.fg], Colors[style.bg]);
} }
static int styleAdd(WINDOW *win, struct Style init, const char *str) {
struct Style style = init;
while (*str) {
size_t len = styleParse(&style, &str);
wattr_set(win, styleAttr(style), stylePair(style), NULL);
if (waddnstr(win, str, len) == ERR)
return -1;
str += len;
}
return 0;
}
static void statusUpdate(void) {
struct {
uint unread;
enum Heat heat;
} others = { 0, Cold };
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) {
if (window->heat < Warm) continue;
if (window->mute && window->heat < Hot) continue;
}
if (num != windows.show) {
others.unread += window->unreadWarm;
if (window->heat > others.heat) others.heat = window->heat;
}
char buf[256], *end = &buf[sizeof(buf)];
char *ptr = seprintf(
buf, end, "\3%d%s %u%s%s %s ",
idColors[window->id], (num == windows.show ? "\26" : ""),
num, window->thresh[(const char *[]) { "-", "", "+", "++" }],
&"="[!window->mute], idNames[window->id]
);
if (window->mark && window->unreadWarm) {
ptr = seprintf(
ptr, end, "\3%d+%d\3%d%s",
(window->heat > Warm ? White : idColors[window->id]),
window->unreadWarm, idColors[window->id],
(window->scroll ? "" : " ")
);
}
if (window->scroll) {
ptr = seprintf(ptr, end, "~%d ", window->scroll);
}
if (styleAdd(status, StyleDefault, buf) < 0) break;
}
wclrtoeol(status);
const struct Window *window = windows.ptrs[windows.show];
char *end = &title[sizeof(title)];
char *ptr = seprintf(
title, end, "%s %s", network.name, idNames[window->id]
);
if (window->mark && window->unreadWarm) {
ptr = seprintf(
ptr, end, " +%d%s", window->unreadWarm, &"!"[window->heat < Hot]
);
}
if (others.unread) {
ptr = seprintf(
ptr, end, " (+%d%s)", others.unread, &"!"[others.heat < Hot]
);
}
}
static void mark(struct Window *window) {
if (window->scroll) return;
window->mark = true;
window->unreadSoft = 0;
window->unreadWarm = 0;
}
static void unmark(struct Window *window) {
if (!window->scroll) {
window->mark = false;
window->heat = Cold;
}
statusUpdate();
}
void uiShow(void) { void uiShow(void) {
if (!hidden) return; if (!hidden) return;
prevTitle[0] = '\0'; prevTitle[0] = '\0';
@ -485,86 +300,20 @@ void uiShow(void) {
putp(PasteMode[true]); putp(PasteMode[true]);
fflush(stdout); fflush(stdout);
hidden = false; hidden = false;
unmark(windows.ptrs[windows.show]); windowUnmark();
} }
void uiHide(void) { void uiHide(void) {
if (hidden) return; if (hidden) return;
mark(windows.ptrs[windows.show]); windowMark();
hidden = true; hidden = true;
putp(FocusMode[false]); putp(FocusMode[false]);
putp(PasteMode[false]); putp(PasteMode[false]);
endwin(); endwin();
} }
static size_t windowTop(const struct Window *window) { void uiWait(void) {
size_t top = BufferCap - MAIN_LINES - window->scroll; waiting = true;
if (window->scroll) top += MarkerLines;
return top;
}
static size_t windowBottom(const struct Window *window) {
size_t bottom = BufferCap - (window->scroll ?: 1);
if (window->scroll) bottom -= SplitLines + MarkerLines;
return bottom;
}
static int windowCols(const struct Window *window) {
return COLS - (window->time ? uiTime.width : 0);
}
static void mainAdd(int y, bool time, const struct Line *line) {
int ny, nx;
wmove(main, y, 0);
if (!line || !line->str[0]) {
wclrtoeol(main);
return;
}
if (time && line->time) {
char buf[TimeCap];
strftime(buf, sizeof(buf), uiTime.format, localtime(&line->time));
struct Style init = { .fg = Gray, .bg = Default };
styleAdd(main, init, buf);
waddch(main, ' ');
} else if (time) {
whline(main, ' ', uiTime.width);
wmove(main, y, uiTime.width);
}
styleAdd(main, StyleDefault, line->str);
getyx(main, ny, nx);
if (ny != y) return;
wclrtoeol(main);
(void)nx;
}
static void mainUpdate(void) {
struct Window *window = windows.ptrs[windows.show];
int y = 0;
int marker = MAIN_LINES - SplitLines - MarkerLines;
for (size_t i = windowTop(window); i < BufferCap; ++i) {
mainAdd(y++, window->time, bufferHard(window->buffer, i));
if (window->scroll && y == marker) break;
}
if (!window->scroll) return;
y = MAIN_LINES - SplitLines;
for (size_t i = BufferCap - SplitLines; i < BufferCap; ++i) {
mainAdd(y++, window->time, bufferHard(window->buffer, i));
}
wattr_set(main, A_NORMAL, 0, NULL);
mvwhline(main, marker, 0, ACS_BULLET, COLS);
}
static void windowScroll(struct Window *window, int n) {
mark(window);
window->scroll += n;
if (window->scroll > BufferCap - MAIN_LINES) {
window->scroll = BufferCap - MAIN_LINES;
}
if (window->scroll < 0) window->scroll = 0;
unmark(window);
if (window == windows.ptrs[windows.show]) mainUpdate();
} }
struct Util uiNotifyUtil; struct Util uiNotifyUtil;
@ -593,36 +342,8 @@ static void notify(uint id, const char *str) {
} }
void uiWrite(uint id, enum Heat heat, const time_t *src, const char *str) { void uiWrite(uint id, enum Heat heat, const time_t *src, const char *str) {
struct Window *window = windows.ptrs[windowFor(id)]; bool note = windowWrite(id, heat, src, str);
time_t ts = (src ? *src : time(NULL)); if (note) {
if (heat >= window->thresh) {
if (!window->unreadSoft++) window->unreadHard = 0;
}
if (window->mark && heat > Cold) {
if (!window->unreadWarm++) {
int lines = bufferPush(
window->buffer, windowCols(window),
window->thresh, Warm, ts, ""
);
if (window->scroll) windowScroll(window, lines);
if (window->unreadSoft > 1) {
window->unreadSoft++;
window->unreadHard += lines;
}
}
if (heat > window->heat) window->heat = heat;
statusUpdate();
}
int lines = bufferPush(
window->buffer, windowCols(window),
window->thresh, heat, ts, str
);
window->unreadHard += lines;
if (window->scroll) windowScroll(window, lines);
if (window == windows.ptrs[windows.show]) mainUpdate();
if (window->mark && heat > Warm) {
beep(); beep();
notify(id, str); notify(id, str);
} }
@ -640,78 +361,10 @@ void uiFormat(
uiWrite(id, heat, time, buf); uiWrite(id, heat, time, buf);
} }
static void scrollTo(struct Window *window, int top) {
window->scroll = 0;
windowScroll(window, top - MAIN_LINES + MarkerLines);
}
static void windowReflow(struct Window *window) {
uint num = 0;
const struct Line *line = bufferHard(window->buffer, windowTop(window));
if (line) num = line->num;
window->unreadHard = bufferReflow(
window->buffer, windowCols(window),
window->thresh, window->unreadSoft
);
if (!window->scroll || !num) return;
for (size_t i = 0; i < BufferCap; ++i) {
line = bufferHard(window->buffer, i);
if (!line || line->num != num) continue;
scrollTo(window, BufferCap - i);
break;
}
}
static void resize(void) { static void resize(void) {
wclear(main); wclear(uiMain);
wresize(main, MAIN_LINES, COLS); wresize(uiMain, MAIN_LINES, COLS);
for (uint num = 0; num < windows.len; ++num) { windowResize();
windowReflow(windows.ptrs[num]);
}
statusUpdate();
mainUpdate();
}
static void windowList(const struct Window *window) {
uiHide();
waiting = true;
uint num = 0;
const struct Line *line = bufferHard(window->buffer, windowBottom(window));
if (line) num = line->num;
for (size_t i = 0; i < BufferCap; ++i) {
line = bufferSoft(window->buffer, i);
if (!line) continue;
if (line->num > num) break;
if (!line->str[0]) {
printf("\n");
continue;
}
char buf[TimeCap];
strftime(buf, sizeof(buf), uiTime.format, localtime(&line->time));
vid_attr(colorAttr(Colors[Gray]), colorPair(Colors[Gray], -1), NULL);
printf("%s ", buf);
bool align = false;
struct Style style = StyleDefault;
for (const char *str = line->str; *str;) {
if (*str == '\t') {
printf("%c", (align ? '\t' : ' '));
align = true;
str++;
}
size_t len = styleParse(&style, &str);
size_t tab = strcspn(str, "\t");
if (tab < len) len = tab;
vid_attr(styleAttr(style), stylePair(style), NULL);
printf("%.*s", (int)len, str);
str += len;
}
printf("\n");
}
} }
static void inputAdd(struct Style reset, struct Style *style, const char *str) { static void inputAdd(struct Style reset, struct Style *style, const char *str) {
@ -736,7 +389,7 @@ static void inputAdd(struct Style reset, struct Style *style, const char *str) {
} }
size_t nl = strcspn(str, "\n"); size_t nl = strcspn(str, "\n");
if (nl < len) len = nl; if (nl < len) len = nl;
wattr_set(input, styleAttr(*style), stylePair(*style), NULL); wattr_set(input, uiAttr(*style), uiPair(*style), NULL);
waddnstr(input, str, len); waddnstr(input, str, len);
str += len; str += len;
} }
@ -755,9 +408,9 @@ static char *inputStop(
static struct Edit edit; static struct Edit edit;
static void inputUpdate(void) { void uiUpdate(void) {
char *buf = editString(&edit); char *buf = editString(&edit);
struct Window *window = windows.ptrs[windows.show]; uint id = windowID();
const char *prefix = ""; const char *prefix = "";
const char *prompt = self.nick; const char *prompt = self.nick;
@ -766,10 +419,10 @@ static void inputUpdate(void) {
struct Style stylePrompt = { .fg = self.color, .bg = Default }; struct Style stylePrompt = { .fg = self.color, .bg = Default };
struct Style styleInput = StyleDefault; struct Style styleInput = StyleDefault;
size_t split = commandWillSplit(window->id, buf); size_t split = commandWillSplit(id, buf);
const char *privmsg = commandIsPrivmsg(window->id, buf); const char *privmsg = commandIsPrivmsg(id, buf);
const char *notice = commandIsNotice(window->id, buf); const char *notice = commandIsNotice(id, buf);
const char *action = commandIsAction(window->id, buf); const char *action = commandIsAction(id, buf);
if (privmsg) { if (privmsg) {
prefix = "<"; suffix = "> "; prefix = "<"; suffix = "> ";
skip = privmsg; skip = privmsg;
@ -782,7 +435,7 @@ static void inputUpdate(void) {
stylePrompt.attr |= Italic; stylePrompt.attr |= Italic;
styleInput.attr |= Italic; styleInput.attr |= Italic;
skip = action; skip = action;
} else if (window->id == Debug && buf[0] != '/') { } else if (id == Debug && buf[0] != '/') {
prompt = "<< "; prompt = "<< ";
stylePrompt.fg = Gray; stylePrompt.fg = Gray;
} else { } else {
@ -795,11 +448,11 @@ static void inputUpdate(void) {
int y, x; int y, x;
wmove(input, 0, 0); wmove(input, 0, 0);
if (window->time && window->id != Network) { if (windowTimeEnable() && id != Network) {
whline(input, ' ', uiTime.width); whline(input, ' ', windowTime.width);
wmove(input, 0, uiTime.width); wmove(input, 0, windowTime.width);
} }
wattr_set(input, styleAttr(stylePrompt), stylePair(stylePrompt), NULL); wattr_set(input, uiAttr(stylePrompt), uiPair(stylePrompt), NULL);
waddstr(input, prefix); waddstr(input, prefix);
waddstr(input, prompt); waddstr(input, prompt);
waddstr(input, suffix); waddstr(input, suffix);
@ -823,209 +476,61 @@ static void inputUpdate(void) {
wmove(input, y, pos); wmove(input, y, pos);
} }
void uiWindows(void) { static void inputEnter(void) {
for (uint num = 0; num < windows.len; ++num) { command(windowID(), editString(&edit));
const struct Window *window = windows.ptrs[num];
uiFormat(
Network, Warm, NULL, "\3%02d%u %s",
idColors[window->id], num, idNames[window->id]
);
}
}
static void windowShow(uint num) {
if (num != windows.show) {
windows.swap = windows.show;
mark(windows.ptrs[windows.swap]);
}
windows.show = num;
windows.user = num;
unmark(windows.ptrs[windows.show]);
mainUpdate();
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--;
mainUpdate();
}
statusUpdate();
}
void uiCloseID(uint id) {
windowClose(windowFor(id));
}
void uiCloseNum(uint num) {
if (num < windows.len) windowClose(num);
}
static void scrollPage(struct Window *window, int n) {
windowScroll(window, n * (MAIN_LINES - SplitLines - MarkerLines - 1));
}
static void scrollTop(struct Window *window) {
for (size_t i = 0; i < BufferCap; ++i) {
if (!bufferHard(window->buffer, i)) continue;
scrollTo(window, BufferCap - i);
break;
}
}
static void scrollHot(struct Window *window, int dir) {
for (size_t i = windowTop(window) + dir; 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;
scrollTo(window, BufferCap - i);
break;
}
}
static void scrollSearch(struct Window *window, const char *str, int dir) {
for (size_t i = windowTop(window) + dir; i < BufferCap; i += dir) {
const struct Line *line = bufferHard(window->buffer, i);
if (!line || !strcasestr(line->str, str)) continue;
scrollTo(window, BufferCap - i);
break;
}
}
static void toggleTime(struct Window *window) {
window->time ^= true;
windowReflow(window);
statusUpdate();
mainUpdate();
inputUpdate();
}
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;
}
windowReflow(window);
statusUpdate();
mainUpdate();
statusUpdate();
}
static void showAuto(void) {
uint minHot = UINT_MAX, numHot = 0;
uint minWarm = UINT_MAX, numWarm = 0;
for (uint num = 0; num < windows.len; ++num) {
struct Window *window = windows.ptrs[num];
if (window->heat >= Hot) {
if (window->unreadWarm >= minHot) continue;
minHot = window->unreadWarm;
numHot = num;
}
if (window->heat >= Warm && !window->mute) {
if (window->unreadWarm >= minWarm) continue;
minWarm = window->unreadWarm;
numWarm = num;
}
}
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);
}
}
static void inputEnter(uint id) {
command(id, editString(&edit));
editFn(&edit, EditClear); editFn(&edit, EditClear);
} }
static void keyCode(int code) { static void keyCode(int code) {
struct Window *window = windows.ptrs[windows.show];
uint id = window->id;
switch (code) { switch (code) {
break; case KEY_RESIZE: resize(); break; case KEY_RESIZE: resize();
break; case KeyFocusIn: unmark(window); break; case KeyFocusIn: windowUnmark();
break; case KeyFocusOut: mark(window); break; case KeyFocusOut: windowMark();
break; case KeyMetaEnter: editInsert(&edit, L'\n'); break; case KeyMetaEnter: editInsert(&edit, L'\n');
break; case KeyMetaEqual: window->mute ^= true; statusUpdate(); break; case KeyMetaEqual: windowToggleMute();
break; case KeyMetaMinus: incThresh(window, -1); break; case KeyMetaMinus: windowToggleThresh(-1);
break; case KeyMetaPlus: incThresh(window, +1); break; case KeyMetaPlus: windowToggleThresh(+1);
break; case KeyMetaSlash: windowShow(windows.swap); break; case KeyMetaSlash: windowSwap();
break; case KeyMetaGt: scrollTo(window, 0); break; case KeyMetaGt: windowScroll(ScrollAll, -1);
break; case KeyMetaLt: scrollTop(window); break; case KeyMetaLt: windowScroll(ScrollAll, +1);
break; case KeyMeta0 ... KeyMeta9: uiShowNum(code - KeyMeta0); break; case KeyMeta0 ... KeyMeta9: windowShow(code - KeyMeta0);
break; case KeyMetaA: showAuto(); break; case KeyMetaA: windowAuto();
break; case KeyMetaB: editFn(&edit, EditPrevWord); break; case KeyMetaB: editFn(&edit, EditPrevWord);
break; case KeyMetaD: editFn(&edit, EditDeleteNextWord); break; case KeyMetaD: editFn(&edit, EditDeleteNextWord);
break; case KeyMetaF: editFn(&edit, EditNextWord); break; case KeyMetaF: editFn(&edit, EditNextWord);
break; case KeyMetaL: windowList(window); break; case KeyMetaL: windowBare();
break; case KeyMetaM: uiWrite(id, Warm, NULL, ""); break; case KeyMetaM: uiWrite(windowID(), Warm, NULL, "");
break; case KeyMetaN: scrollHot(window, +1); break; case KeyMetaN: windowScroll(ScrollHot, +1);
break; case KeyMetaP: scrollHot(window, -1); break; case KeyMetaP: windowScroll(ScrollHot, -1);
break; case KeyMetaQ: editFn(&edit, EditCollapse); break; case KeyMetaQ: editFn(&edit, EditCollapse);
break; case KeyMetaS: spoilerReveal ^= true; mainUpdate(); break; case KeyMetaS: spoilerReveal ^= true; windowUpdate();
break; case KeyMetaT: toggleTime(window); break; case KeyMetaT: windowToggleTime();
break; case KeyMetaU: scrollTo(window, window->unreadHard); break; case KeyMetaU: windowScroll(ScrollUnread, 0);
break; case KeyMetaV: scrollPage(window, +1); break; case KeyMetaV: windowScroll(ScrollPage, +1);
break; case KeyCtrlLeft: editFn(&edit, EditPrevWord); break; case KeyCtrlLeft: editFn(&edit, EditPrevWord);
break; case KeyCtrlRight: editFn(&edit, EditNextWord); break; case KeyCtrlRight: editFn(&edit, EditNextWord);
break; case KEY_BACKSPACE: editFn(&edit, EditDeletePrev); break; case KEY_BACKSPACE: editFn(&edit, EditDeletePrev);
break; case KEY_DC: editFn(&edit, EditDeleteNext); break; case KEY_DC: editFn(&edit, EditDeleteNext);
break; case KEY_DOWN: windowScroll(window, -1); break; case KEY_DOWN: windowScroll(ScrollOne, -1);
break; case KEY_END: editFn(&edit, EditTail); break; case KEY_END: editFn(&edit, EditTail);
break; case KEY_ENTER: inputEnter(id); break; case KEY_ENTER: inputEnter();
break; case KEY_HOME: editFn(&edit, EditHead); break; case KEY_HOME: editFn(&edit, EditHead);
break; case KEY_LEFT: editFn(&edit, EditPrev); break; case KEY_LEFT: editFn(&edit, EditPrev);
break; case KEY_NPAGE: scrollPage(window, -1); break; case KEY_NPAGE: windowScroll(ScrollPage, -1);
break; case KEY_PPAGE: scrollPage(window, +1); break; case KEY_PPAGE: windowScroll(ScrollPage, +1);
break; case KEY_RIGHT: editFn(&edit, EditNext); break; case KEY_RIGHT: editFn(&edit, EditNext);
break; case KEY_SEND: scrollTo(window, 0); break; case KEY_SEND: windowScroll(ScrollAll, -1);
break; case KEY_SHOME: scrollTo(window, BufferCap); break; case KEY_SHOME: windowScroll(ScrollAll, +1);
break; case KEY_UP: windowScroll(window, +1); break; case KEY_UP: windowScroll(ScrollOne, +1);
} }
} }
static void keyCtrl(wchar_t ch) { static void keyCtrl(wchar_t ch) {
struct Window *window = windows.ptrs[windows.show];
uint id = window->id;
switch (ch ^ L'@') { switch (ch ^ L'@') {
break; case L'?': editFn(&edit, EditDeletePrev); break; case L'?': editFn(&edit, EditDeletePrev);
break; case L'A': editFn(&edit, EditHead); break; case L'A': editFn(&edit, EditHead);
@ -1035,16 +540,16 @@ static void keyCtrl(wchar_t ch) {
break; case L'E': editFn(&edit, EditTail); break; case L'E': editFn(&edit, EditTail);
break; case L'F': editFn(&edit, EditNext); break; case L'F': editFn(&edit, EditNext);
break; case L'H': editFn(&edit, EditDeletePrev); break; case L'H': editFn(&edit, EditDeletePrev);
break; case L'J': inputEnter(id); break; case L'J': inputEnter();
break; case L'K': editFn(&edit, EditDeleteTail); break; case L'K': editFn(&edit, EditDeleteTail);
break; case L'L': clearok(curscr, true); break; case L'L': clearok(curscr, true);
break; case L'N': uiShowNum(windows.show + 1); break; case L'N': windowShow(windowNum() + 1);
break; case L'P': uiShowNum(windows.show - 1); break; case L'P': windowShow(windowNum() - 1);
break; case L'R': scrollSearch(window, editString(&edit), -1); break; case L'R': windowSearch(editString(&edit), -1);
break; case L'S': scrollSearch(window, editString(&edit), +1); break; case L'S': windowSearch(editString(&edit), +1);
break; case L'T': editFn(&edit, EditTranspose); break; case L'T': editFn(&edit, EditTranspose);
break; case L'U': editFn(&edit, EditDeleteHead); break; case L'U': editFn(&edit, EditDeleteHead);
break; case L'V': scrollPage(window, -1); break; case L'V': windowScroll(ScrollPage, -1);
break; case L'W': editFn(&edit, EditDeletePrevWord); break; case L'W': editFn(&edit, EditDeletePrevWord);
break; case L'Y': editFn(&edit, EditPaste); break; case L'Y': editFn(&edit, EditPaste);
} }
@ -1127,13 +632,15 @@ void uiRead(void) {
literal = false; literal = false;
if (spr) { if (spr) {
spoilerReveal = false; spoilerReveal = false;
mainUpdate(); windowUpdate();
} }
} }
inputUpdate(); uiUpdate();
} }
static const time_t Signatures[] = { static FILE *saveFile;
static const uint64_t Signatures[] = {
0x6C72696774616301, // no heat, unread, unreadWarm 0x6C72696774616301, // no heat, unread, unreadWarm
0x6C72696774616302, // no self.pos 0x6C72696774616302, // no self.pos
0x6C72696774616303, // no buffer line heat 0x6C72696774616303, // no buffer line heat
@ -1144,68 +651,33 @@ static const time_t Signatures[] = {
0x6C72696774616308, 0x6C72696774616308,
}; };
static size_t signatureVersion(time_t signature) { static size_t signatureVersion(uint64_t signature) {
for (size_t i = 0; i < ARRAY_LEN(Signatures); ++i) { for (size_t i = 0; i < ARRAY_LEN(Signatures); ++i) {
if (signature == Signatures[i]) return i; if (signature == Signatures[i]) return i;
} }
errx(EX_DATAERR, "unknown file signature %jX", (uintmax_t)signature); errx(EX_DATAERR, "unknown file signature %" PRIX64, signature);
} }
static int writeTime(FILE *file, time_t time) { static int writeUint64(FILE *file, uint64_t u) {
return (fwrite(&time, sizeof(time), 1, file) ? 0 : -1); return (fwrite(&u, sizeof(u), 1, file) ? 0 : -1);
} }
static int writeString(FILE *file, const char *str) {
return (fwrite(str, strlen(str) + 1, 1, file) ? 0 : -1);
}
static FILE *saveFile;
int uiSave(void) { int uiSave(void) {
int error = 0
|| ftruncate(fileno(saveFile), 0)
|| writeTime(saveFile, Signatures[7])
|| writeTime(saveFile, self.pos);
if (error) return error;
for (uint num = 0; num < windows.len; ++num) {
const struct Window *window = windows.ptrs[num];
error = 0
|| writeString(saveFile, idNames[window->id])
|| writeTime(saveFile, window->mute)
|| writeTime(saveFile, window->time)
|| writeTime(saveFile, window->thresh)
|| writeTime(saveFile, window->heat)
|| writeTime(saveFile, window->unreadSoft)
|| writeTime(saveFile, window->unreadWarm);
if (error) return error;
for (size_t i = 0; i < BufferCap; ++i) {
const struct Line *line = bufferSoft(window->buffer, i);
if (!line) continue;
error = 0
|| writeTime(saveFile, line->time)
|| writeTime(saveFile, line->heat)
|| writeString(saveFile, line->str);
if (error) return error;
}
error = writeTime(saveFile, 0);
if (error) return error;
}
return 0 return 0
|| writeString(saveFile, "") || ftruncate(fileno(saveFile), 0)
|| writeUint64(saveFile, Signatures[7])
|| writeUint64(saveFile, self.pos)
|| windowSave(saveFile)
|| urlSave(saveFile) || urlSave(saveFile)
|| fclose(saveFile); || fclose(saveFile);
} }
static time_t readTime(FILE *file) { static uint64_t readUint64(FILE *file) {
time_t time; uint64_t u;
fread(&time, sizeof(time), 1, file); fread(&u, sizeof(u), 1, file);
if (ferror(file)) err(EX_IOERR, "fread"); if (ferror(file)) err(EX_IOERR, "fread");
if (feof(file)) errx(EX_DATAERR, "unexpected eof"); if (feof(file)) errx(EX_DATAERR, "unexpected eof");
return time; return u;
}
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) { void uiLoad(const char *name) {
@ -1235,31 +707,8 @@ void uiLoad(const char *name) {
size_t version = signatureVersion(signature); size_t version = signatureVersion(signature);
if (version > 1) { if (version > 1) {
self.pos = readTime(saveFile); self.pos = readUint64(saveFile);
}
char *buf = NULL;
size_t cap = 0;
while (0 < readString(saveFile, &buf, &cap) && buf[0]) {
struct Window *window = windows.ptrs[windowFor(idFor(buf))];
if (version > 3) window->mute = readTime(saveFile);
if (version > 6) window->time = readTime(saveFile);
if (version > 5) window->thresh = readTime(saveFile);
if (version > 0) {
window->heat = readTime(saveFile);
window->unreadSoft = readTime(saveFile);
window->unreadWarm = readTime(saveFile);
}
for (;;) {
time_t time = readTime(saveFile);
if (!time) break;
enum Heat heat = (version > 2 ? readTime(saveFile) : Cold);
readString(saveFile, &buf, &cap);
bufferPush(window->buffer, COLS, window->thresh, heat, time, buf);
}
windowReflow(window);
} }
windowLoad(saveFile, version);
urlLoad(saveFile, version); urlLoad(saveFile, version);
free(buf);
} }

656
window.c 100644
View File

@ -0,0 +1,656 @@
/* Copyright (C) 2020 June 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.
*/
#define _XOPEN_SOURCE_EXTENDED
#include <assert.h>
#include <curses.h>
#include <err.h>
#include <limits.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sysexits.h>
#include <time.h>
#include "chat.h"
#define MAIN_LINES (LINES - StatusLines - InputLines)
static struct Window {
uint id;
int scroll;
bool mark;
bool mute;
bool time;
enum Heat thresh;
enum Heat heat;
uint unreadSoft;
uint unreadHard;
uint unreadWarm;
struct Buffer *buffer;
} *windows[IDCap];
static uint count;
static uint show;
static uint swap;
static uint user;
static uint windowPush(struct Window *window) {
assert(count < IDCap);
windows[count] = window;
return count++;
}
static uint windowInsert(uint num, struct Window *window) {
assert(count < IDCap);
assert(num <= count);
memmove(
&windows[num + 1],
&windows[num],
sizeof(*windows) * (count - num)
);
windows[num] = window;
count++;
return num;
}
static struct Window *windowRemove(uint num) {
assert(num < count);
struct Window *window = windows[num];
count--;
memmove(
&windows[num],
&windows[num + 1],
sizeof(*windows) * (count - num)
);
return window;
}
static void windowFree(struct Window *window) {
completeRemove(None, idNames[window->id]);
bufferFree(window->buffer);
free(window);
}
enum Heat windowThreshold = Cold;
struct Time windowTime = { .format = "%X" };
uint windowFor(uint id) {
for (uint num = 0; num < count; ++num) {
if (windows[num]->id == id) return num;
}
struct Window *window = calloc(1, sizeof(*window));
if (!window) err(EX_OSERR, "malloc");
window->id = id;
window->mark = true;
window->time = windowTime.enable;
if (id == Network || id == Debug) {
window->thresh = Cold;
} else {
window->thresh = windowThreshold;
}
window->buffer = bufferAlloc();
completeAdd(None, idNames[id], idColors[id]);
return windowPush(window);
}
enum { TimeCap = 64 };
void windowInit(void) {
char fmt[TimeCap];
char buf[TimeCap];
styleStrip(fmt, sizeof(fmt), windowTime.format);
struct tm *time = localtime(&(time_t) { -22100400 });
size_t len = strftime(buf, sizeof(buf), fmt, time);
if (!len) errx(EX_CONFIG, "invalid timestamp format: %s", fmt);
int y;
waddstr(uiMain, buf);
waddch(uiMain, ' ');
getyx(uiMain, y, windowTime.width);
(void)y;
windowFor(Network);
}
static int styleAdd(WINDOW *win, struct Style init, const char *str) {
struct Style style = init;
while (*str) {
size_t len = styleParse(&style, &str);
wattr_set(win, uiAttr(style), uiPair(style), NULL);
if (waddnstr(win, str, len) == ERR)
return -1;
str += len;
}
return 0;
}
static void statusUpdate(void) {
struct {
uint unread;
enum Heat heat;
} others = { 0, Cold };
wmove(uiStatus, 0, 0);
for (uint num = 0; num < count; ++num) {
const struct Window *window = windows[num];
if (num != show && !window->scroll) {
if (window->heat < Warm) continue;
if (window->mute && window->heat < Hot) continue;
}
if (num != show) {
others.unread += window->unreadWarm;
if (window->heat > others.heat) others.heat = window->heat;
}
char buf[256], *end = &buf[sizeof(buf)];
char *ptr = seprintf(
buf, end, "\3%d%s %u%s%s %s ",
idColors[window->id], (num == show ? "\26" : ""),
num, window->thresh[(const char *[]) { "-", "", "+", "++" }],
&"="[!window->mute], idNames[window->id]
);
if (window->mark && window->unreadWarm) {
ptr = seprintf(
ptr, end, "\3%d+%d\3%d%s",
(window->heat > Warm ? White : idColors[window->id]),
window->unreadWarm, idColors[window->id],
(window->scroll ? "" : " ")
);
}
if (window->scroll) {
ptr = seprintf(ptr, end, "~%d ", window->scroll);
}
if (styleAdd(uiStatus, StyleDefault, buf) < 0) break;
}
wclrtoeol(uiStatus);
const struct Window *window = windows[show];
char *end = &uiTitle[sizeof(uiTitle)];
char *ptr = seprintf(
uiTitle, end, "%s %s", network.name, idNames[window->id]
);
if (window->mark && window->unreadWarm) {
ptr = seprintf(
ptr, end, " +%d%s", window->unreadWarm, &"!"[window->heat < Hot]
);
}
if (others.unread) {
ptr = seprintf(
ptr, end, " (+%d%s)", others.unread, &"!"[others.heat < Hot]
);
}
}
static size_t windowTop(const struct Window *window) {
size_t top = BufferCap - MAIN_LINES - window->scroll;
if (window->scroll) top += MarkerLines;
return top;
}
static size_t windowBottom(const struct Window *window) {
size_t bottom = BufferCap - (window->scroll ?: 1);
if (window->scroll) bottom -= SplitLines + MarkerLines;
return bottom;
}
static void mainAdd(int y, bool time, const struct Line *line) {
int ny, nx;
wmove(uiMain, y, 0);
if (!line || !line->str[0]) {
wclrtoeol(uiMain);
return;
}
if (time && line->time) {
char buf[TimeCap];
strftime(buf, sizeof(buf), windowTime.format, localtime(&line->time));
struct Style init = { .fg = Gray, .bg = Default };
styleAdd(uiMain, init, buf);
waddch(uiMain, ' ');
} else if (time) {
whline(uiMain, ' ', windowTime.width);
wmove(uiMain, y, windowTime.width);
}
styleAdd(uiMain, StyleDefault, line->str);
getyx(uiMain, ny, nx);
if (ny != y) return;
wclrtoeol(uiMain);
(void)nx;
}
static void mainUpdate(void) {
const struct Window *window = windows[show];
int y = 0;
int marker = MAIN_LINES - SplitLines - MarkerLines;
for (size_t i = windowTop(window); i < BufferCap; ++i) {
mainAdd(y++, window->time, bufferHard(window->buffer, i));
if (window->scroll && y == marker) break;
}
if (!window->scroll) return;
y = MAIN_LINES - SplitLines;
for (size_t i = BufferCap - SplitLines; i < BufferCap; ++i) {
mainAdd(y++, window->time, bufferHard(window->buffer, i));
}
wattr_set(uiMain, A_NORMAL, 0, NULL);
mvwhline(uiMain, marker, 0, ACS_BULLET, COLS);
}
void windowUpdate(void) {
statusUpdate();
mainUpdate();
}
void windowBare(void) {
uiHide();
uiWait();
const struct Window *window = windows[show];
const struct Line *line = bufferHard(window->buffer, windowBottom(window));
uint num = 0;
if (line) num = line->num;
for (size_t i = 0; i < BufferCap; ++i) {
line = bufferSoft(window->buffer, i);
if (!line) continue;
if (line->num > num) break;
if (!line->str[0]) {
printf("\n");
continue;
}
char buf[TimeCap];
struct Style style = { .fg = Gray, .bg = Default };
strftime(buf, sizeof(buf), windowTime.format, localtime(&line->time));
vid_attr(uiAttr(style), uiPair(style), NULL);
printf("%s ", buf);
bool align = false;
style = StyleDefault;
for (const char *str = line->str; *str;) {
if (*str == '\t') {
printf("%c", (align ? '\t' : ' '));
align = true;
str++;
}
size_t len = styleParse(&style, &str);
size_t tab = strcspn(str, "\t");
if (tab < len) len = tab;
vid_attr(uiAttr(style), uiPair(style), NULL);
printf("%.*s", (int)len, str);
str += len;
}
printf("\n");
}
}
static void mark(struct Window *window) {
if (window->scroll) return;
window->mark = true;
window->unreadSoft = 0;
window->unreadWarm = 0;
}
static void unmark(struct Window *window) {
if (!window->scroll) {
window->mark = false;
window->heat = Cold;
}
statusUpdate();
}
static void scrollN(struct Window *window, int n) {
mark(window);
window->scroll += n;
if (window->scroll > BufferCap - MAIN_LINES) {
window->scroll = BufferCap - MAIN_LINES;
}
if (window->scroll < 0) window->scroll = 0;
unmark(window);
if (window == windows[show]) mainUpdate();
}
static void scrollTo(struct Window *window, int top) {
window->scroll = 0;
scrollN(window, top - MAIN_LINES + MarkerLines);
}
static int windowCols(const struct Window *window) {
return COLS - (window->time ? windowTime.width : 0);
}
bool windowWrite(uint id, enum Heat heat, const time_t *src, const char *str) {
struct Window *window = windows[windowFor(id)];
time_t ts = (src ? *src : time(NULL));
if (heat >= window->thresh) {
if (!window->unreadSoft++) window->unreadHard = 0;
}
if (window->mark && heat > Cold) {
if (!window->unreadWarm++) {
int lines = bufferPush(
window->buffer, windowCols(window),
window->thresh, Warm, ts, ""
);
if (window->scroll) scrollN(window, lines);
if (window->unreadSoft > 1) {
window->unreadSoft++;
window->unreadHard += lines;
}
}
if (heat > window->heat) window->heat = heat;
statusUpdate();
}
int lines = bufferPush(
window->buffer, windowCols(window),
window->thresh, heat, ts, str
);
window->unreadHard += lines;
if (window->scroll) scrollN(window, lines);
if (window == windows[show]) mainUpdate();
return window->mark && heat > Warm;
}
static void reflow(struct Window *window) {
uint num = 0;
const struct Line *line = bufferHard(window->buffer, windowTop(window));
if (line) num = line->num;
window->unreadHard = bufferReflow(
window->buffer, windowCols(window),
window->thresh, window->unreadSoft
);
if (!window->scroll || !num) return;
for (size_t i = 0; i < BufferCap; ++i) {
line = bufferHard(window->buffer, i);
if (!line || line->num != num) continue;
scrollTo(window, BufferCap - i);
break;
}
}
void windowResize(void) {
for (uint num = 0; num < count; ++num) {
reflow(windows[num]);
}
windowUpdate();
}
uint windowID(void) {
return windows[show]->id;
}
uint windowNum(void) {
return show;
}
void windowShow(uint num) {
if (num >= count) return;
if (num != show) {
swap = show;
mark(windows[swap]);
}
show = num;
user = num;
unmark(windows[show]);
mainUpdate();
uiUpdate();
}
void windowAuto(void) {
uint minHot = UINT_MAX, numHot = 0;
uint minWarm = UINT_MAX, numWarm = 0;
for (uint num = 0; num < count; ++num) {
struct Window *window = windows[num];
if (window->heat >= Hot) {
if (window->unreadWarm >= minHot) continue;
minHot = window->unreadWarm;
numHot = num;
}
if (window->heat >= Warm && !window->mute) {
if (window->unreadWarm >= minWarm) continue;
minWarm = window->unreadWarm;
numWarm = num;
}
}
uint oldUser = user;
if (minHot < UINT_MAX) {
windowShow(numHot);
user = oldUser;
} else if (minWarm < UINT_MAX) {
windowShow(numWarm);
user = oldUser;
} else if (user != show) {
windowShow(user);
}
}
void windowSwap(void) {
windowShow(swap);
}
void windowMove(uint from, uint to) {
if (from >= count) return;
struct Window *window = windowRemove(from);
if (to < count) {
windowShow(windowInsert(to, window));
} else {
windowShow(windowPush(window));
}
}
void windowClose(uint num) {
if (num >= count) return;
if (windows[num]->id == Network) return;
struct Window *window = windowRemove(num);
completeClear(window->id);
windowFree(window);
if (swap >= num) swap--;
if (show == num) {
windowShow(swap);
swap = show;
} else if (show > num) {
show--;
mainUpdate();
}
statusUpdate();
}
void windowList(void) {
for (uint num = 0; num < count; ++num) {
const struct Window *window = windows[num];
uiFormat(
Network, Warm, NULL, "\3%02d%u %s",
idColors[window->id], num, idNames[window->id]
);
}
}
void windowMark(void) {
mark(windows[show]);
}
void windowUnmark(void) {
unmark(windows[show]);
}
void windowToggleMute(void) {
windows[show]->mute ^= true;
statusUpdate();
}
void windowToggleTime(void) {
windows[show]->time ^= true;
reflow(windows[show]);
windowUpdate();
uiUpdate();
}
void windowToggleThresh(int n) {
struct Window *window = windows[show];
if (n > 0 && window->thresh == Hot) return;
if (n < 0 && window->thresh == Ice) {
window->thresh = Cold;
} else {
window->thresh += n;
}
reflow(window);
windowUpdate();
}
bool windowTimeEnable(void) {
return windows[show]->time;
}
void windowScroll(enum Scroll by, int n) {
struct Window *window = windows[show];
switch (by) {
break; case ScrollOne: {
scrollN(window, n);
}
break; case ScrollPage: {
scrollN(window, n * (MAIN_LINES - SplitLines - MarkerLines - 1));
}
break; case ScrollAll: {
if (n < 0) {
scrollTo(window, 0);
break;
}
for (size_t i = 0; i < BufferCap; ++i) {
if (!bufferHard(window->buffer, i)) continue;
scrollTo(window, BufferCap - i);
break;
}
}
break; case ScrollUnread: {
scrollTo(window, window->unreadHard);
}
break; case ScrollHot: {
for (size_t i = windowTop(window) + n; i < BufferCap; i += n) {
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;
scrollTo(window, BufferCap - i);
break;
}
}
}
}
void windowSearch(const char *str, int dir) {
struct Window *window = windows[show];
for (size_t i = windowTop(window) + dir; i < BufferCap; i += dir) {
const struct Line *line = bufferHard(window->buffer, i);
if (!line || !strcasestr(line->str, str)) continue;
scrollTo(window, BufferCap - i);
break;
}
}
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 windowSave(FILE *file) {
int error;
for (uint num = 0; num < count; ++num) {
const struct Window *window = windows[num];
error = 0
|| writeString(file, idNames[window->id])
|| writeTime(file, window->mute)
|| writeTime(file, window->time)
|| writeTime(file, window->thresh)
|| writeTime(file, window->heat)
|| writeTime(file, window->unreadSoft)
|| writeTime(file, window->unreadWarm);
if (error) return error;
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;
}
error = writeTime(file, 0);
if (error) return error;
}
return writeString(file, "");
}
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 windowLoad(FILE *file, size_t version) {
size_t cap = 0;
char *buf = NULL;
while (0 < readString(file, &buf, &cap) && buf[0]) {
struct Window *window = windows[windowFor(idFor(buf))];
if (version > 3) window->mute = readTime(file);
if (version > 6) window->time = readTime(file);
if (version > 5) window->thresh = readTime(file);
if (version > 0) {
window->heat = readTime(file);
window->unreadSoft = readTime(file);
window->unreadWarm = readTime(file);
}
for (;;) {
time_t time = readTime(file);
if (!time) break;
enum Heat heat = (version > 2 ? readTime(file) : Cold);
readString(file, &buf, &cap);
bufferPush(window->buffer, COLS, window->thresh, heat, time, buf);
}
reflow(window);
}
free(buf);
}