Recently Written · git

ui_ti.c (11696 bytes)

 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <term.h>
 #include <termios.h>
 #include <unistd.h>
 #include <sys/types.h>
 
 #include "common.h"
 #include "config.h"
 
 #define C(c) #c
 #define S(c) C(c)
 
 /* ncurses doesn't define those in term.h, where they're used */
 #ifndef OK
 #define OK (0)
 #endif
 #ifndef ERR
 #define ERR (-1)
 #endif
 
 static char bufout[256];
 static struct termios tsave;
 static struct termios tsacc;
 static Item *curentry;
 static int termset = ERR;
 
 void
 uisetup(void)
 {
 	tcgetattr(0, &tsave);
 	tsacc = tsave;
 	tsacc.c_lflag &= ~(ECHO|ICANON);
 	tsacc.c_cc[VMIN] = 1;
 	tsacc.c_cc[VTIME] = 0;
 	tcsetattr(0, TCSANOW, &tsacc);
 
 	if (termset != OK)
 		/* setupterm call exits on error */
 		termset = setupterm(NULL, 1, NULL);
 	putp(tiparm(clear_screen));
 	putp(tiparm(save_cursor));
 	putp(tiparm(change_scroll_region, 0, lines-2));
 	putp(tiparm(restore_cursor, 0));
 	fflush(stdout);
 }
 
 void
 uicleanup(void)
 {
 	tcsetattr(0, TCSANOW, &tsave);
 
 	if (termset != OK)
 		return;
 
 	putp(tiparm(change_scroll_region, 0, lines-1));
 	putp(tiparm(clear_screen));
 	fflush(stdout);
 }
 
 char *
 uiprompt(char *fmt, ...)
 {
 	va_list ap;
 	char *input = NULL;
 	size_t n;
 	ssize_t r;
 
 	putp(tiparm(save_cursor));
 
 	putp(tiparm(cursor_address, lines-1, 0));
 	putp(tiparm(clr_eol));
 	putp(tiparm(enter_standout_mode));
 
 	va_start(ap, fmt);
 	vsnprintf(bufout, sizeof(bufout), fmt, ap);
 	va_end(ap);
 
 	n = mbsprint(bufout, columns);
 
 	putp(tiparm(exit_standout_mode));
 	putp(tiparm(clr_eol));
 
 	putp(tiparm(cursor_address, lines-1, n));
 
 	tsacc.c_lflag |= (ECHO|ICANON);
 	tcsetattr(0, TCSANOW, &tsacc);
 	fflush(stdout);
 
 	n = 0;
 	r = getline(&input, &n, stdin);
 
 	tsacc.c_lflag &= ~(ECHO|ICANON);
 	tcsetattr(0, TCSANOW, &tsacc);
 	putp(tiparm(restore_cursor));
 	fflush(stdout);
 
 	if (r == -1 || feof(stdin)) {
 		clearerr(stdin);
 		clear(&input);
 	} else if (input[r - 1] == '\n') {
 		input[--r] = '\0';
 	}
 
 	return input;
 }
 
 static void
 printitem(Item *item)
 {
 	snprintf(bufout, sizeof(bufout), "%s %s",
 	         typedisplay(item->type), item->username);
 
 	mbsprint(bufout, columns);
 	putchar('\r');
 }
 
 static Item *
 help(Item *entry)
 {
 	static Item item = {
 		.type = '0',
 		.raw = "Commands:\n"
 		       "Down, " S(_key_lndown) ": move one line down.\n"
 			S(_key_entrydown) ": move to next link.\n"
 		       "Up, " S(_key_lnup) ": move one line up.\n"
 			S(_key_entryup) ": move to previous link.\n"
 		       "PgDown, " S(_key_pgdown) ": move one page down.\n"
 		       "PgUp, " S(_key_pgup) ": move one page up.\n"
 		       "Home, " S(_key_home) ": move to top of the page.\n"
 		       "End, " S(_key_end) ": move to end of the page.\n"
 		       "Right, " S(_key_pgnext) ": view highlighted item.\n"
 		       "Left, " S(_key_pgprev) ": view previous item.\n"
 		       S(_key_search) ": search current page.\n"
 		       S(_key_searchnext) ": search string forward.\n"
 		       S(_key_searchprev) ": search string backward.\n"
 		       S(_key_cururi) ": print page URI.\n"
 		       S(_key_seluri) ": print item URI.\n"
 		       S(_key_yankcur) ": yank page URI to external program.\n"
 		       S(_key_yanksel) ": yank item URI to external program.\n"
 		       S(_key_help) ": show this help.\n"
 		       "^D, " S(_key_quit) ": exit sacc.\n"
 	};
 
 	item.entry = entry;
 
 	return &item;
 }
 
 void
 uistatus(char *fmt, ...)
 {
 	va_list ap;
 	size_t n;
 
 	putp(tiparm(save_cursor));
 
 	putp(tiparm(cursor_address, lines-1, 0));
 	putp(tiparm(enter_standout_mode));
 
 	va_start(ap, fmt);
 	n = vsnprintf(bufout, sizeof(bufout), fmt, ap);
 	va_end(ap);
 
 	if (n < sizeof(bufout)-1) {
 		snprintf(bufout+n, sizeof(bufout)-n,
 		         " [Press a key to continue \xe2\x98\x83]");
 	}
 
 	mbsprint(bufout, columns);
 
 	putp(tiparm(exit_standout_mode));
 	putp(tiparm(clr_eol));
 
 	putp(tiparm(restore_cursor));
 	fflush(stdout);
 
 	getchar();
 }
 
 static void
 displaystatus(Item *item)
 {
 	Dir *dir = item->dat;
 	char *fmt;
 	size_t nitems = dir ? dir->nitems : 0;
 	unsigned long long printoff = dir ? dir->printoff : 0;
 
 	putp(tiparm(save_cursor));
 
 	putp(tiparm(cursor_address, lines-1, 0));
 	putp(tiparm(enter_standout_mode));
 
 	fmt = (strcmp(item->port, "70") && strcmp(item->port, "gopher")) ?
 	      "%1$3lld%%| %2$s:%5$s/%3$c%4$s" : "%3lld%%| %s/%c%s";
 	snprintf(bufout, sizeof(bufout), fmt,
 	         (printoff + lines-1 >= nitems) ? 100 :
 	         (printoff + lines-1) * 100 / nitems,
 	         item->host, item->type, item->selector, item->port);
 
 	mbsprint(bufout, columns);
 
 	putp(tiparm(exit_standout_mode));
 	putp(tiparm(clr_eol));
 
 	putp(tiparm(restore_cursor));
 	fflush(stdout);
 }
 
 static void
 displayuri(Item *item)
 {
 	if (item->type == 0 || item->type == 'i')
 		return;
 
 	putp(tiparm(save_cursor));
 
 	putp(tiparm(cursor_address, lines-1, 0));
 	putp(tiparm(enter_standout_mode));
 
 	itemuri(item, bufout, sizeof(bufout));
 
 	mbsprint(bufout, columns);
 
 	putp(tiparm(exit_standout_mode));
 	putp(tiparm(clr_eol));
 
 	putp(tiparm(restore_cursor));
 	fflush(stdout);
 }
 
 void
 uidisplay(Item *entry)
 {
 	Item *items;
 	Dir *dir;
 	size_t i, curln, lastln, nitems, printoff;
 
 	if (!entry ||
 	    !(entry->type == '1' || entry->type == '+' || entry->type == '7'))
 		return;
 
 	curentry = entry;
 
 	putp(tiparm(clear_screen));
 	displaystatus(entry);
 
 	if (!(dir = entry->dat))
 		return;
 
 	putp(tiparm(save_cursor));
 
 	items = dir->items;
 	nitems = dir->nitems;
 	printoff = dir->printoff;
 	curln = dir->curline;
 	lastln = printoff + lines-1; /* one off for status bar */
 
 	for (i = printoff; i < nitems && i < lastln; ++i) {
 		if (i != printoff)
 			putp(tiparm(cursor_down));
 		if (i == curln) {
 			putp(tiparm(save_cursor));
 			putp(tiparm(enter_standout_mode));
 		}
 		printitem(&items[i]);
 		putp(tiparm(column_address, 0));
 		if (i == curln)
 			putp(tiparm(exit_standout_mode));
 	}
 
 	putp(tiparm(restore_cursor));
 	fflush(stdout);
 }
 
 static void
 movecurline(Item *item, int l)
 {
 	Dir *dir = item->dat;
 	size_t nitems;
 	ssize_t curline, offline;
 	int plines = lines-2;
 
 	if (dir == NULL)
 		return;
 
 	curline = dir->curline + l;
 	nitems = dir->nitems;
 	if (curline < 0 || curline >= nitems)
 		return;
 
 	printitem(&dir->items[dir->curline]);
 	dir->curline = curline;
 
 	if (l > 0) {
 		offline = dir->printoff + lines-1;
 		if (curline - dir->printoff >= plines / 2 && offline < nitems) {
 			putp(tiparm(save_cursor));
 
 			putp(tiparm(cursor_address, plines, 0));
 			putp(tiparm(scroll_forward));
 			printitem(&dir->items[offline]);
 
 			putp(tiparm(restore_cursor));
 			dir->printoff += l;
 		}
 	} else {
 		offline = dir->printoff + l;
 		if (curline - offline <= plines / 2 && offline >= 0) {
 			putp(tiparm(save_cursor));
 
 			putp(tiparm(cursor_address, 0, 0));
 			putp(tiparm(scroll_reverse));
 			printitem(&dir->items[offline]);
 			putchar('\n');
 
 			putp(tiparm(restore_cursor));
 			dir->printoff += l;
 		}
 	}
 
 	putp(tiparm(cursor_address, curline - dir->printoff, 0));
 	putp(tiparm(enter_standout_mode));
 	printitem(&dir->items[curline]);
 	putp(tiparm(exit_standout_mode));
 	displaystatus(item);
 	fflush(stdout);
 }
 
 static void
 jumptoline(Item *entry, ssize_t line, int absolute)
 {
 	Dir *dir = entry->dat;
 	size_t lastitem;
 	int lastpagetop, plines = lines-2;
 
 	if (!dir)
 		return;
 	lastitem = dir->nitems-1;
 
 	if (line < 0)
 		line = 0;
 	if (line > lastitem)
 		line = lastitem;
 
 	if (dir->curline == line)
 		return;
 
 	if (lastitem <= plines) {              /* all items fit on one page */
 		dir->curline = line;
 	} else if (line == 0) {                /* jump to top */
 		if (absolute || dir->curline > plines || dir->printoff == 0)
 			dir->curline = 0;
 		dir->printoff = 0;
 	} else if (line + plines < lastitem) { /* jump before last page */
 		dir->curline = line;
 		dir->printoff = line;
 	} else {                               /* jump within the last page */
 		lastpagetop = lastitem - plines;
 		if (dir->printoff == lastpagetop || absolute)
 			dir->curline = line;
 		else if (dir->curline < lastpagetop)
 			dir->curline = lastpagetop;
 		dir->printoff = lastpagetop;
 	}
 
 	uidisplay(entry);
 	return;
 }
 
 static void
 searchinline(const char *searchstr, Item *entry, int pos)
 {
 	Dir *dir;
 	int i;
 
 	if (!searchstr || !(dir = entry->dat))
 		return;
 
 	if (pos > 0) {
 		for (i = dir->curline + 1; i < dir->nitems; ++i) {
 			if (strcasestr(dir->items[i].username, searchstr)) {
 				jumptoline(entry, i, 1);
 				break;
 			}
 		}
 	} else {
 		for (i = dir->curline - 1; i > -1; --i) {
 			if (strcasestr(dir->items[i].username, searchstr)) {
 				jumptoline(entry, i, 1);
 				break;
 			}
 		}
 	}
 }
 
 static ssize_t
 nearentry(Item *entry, int direction)
 {
 	Dir *dir = entry->dat;
 	size_t item, lastitem;
 
 	if (!dir)
 		return -1;
 	lastitem = dir->nitems;
 	item = dir->curline + direction;
 
 	for (; item < lastitem; item += direction) {
 		if (dir->items[item].type != 'i')
 			return item;
 	}
 
 	return dir->curline;
 }
 
 Item *
 uiselectitem(Item *entry)
 {
 	Dir *dir;
 	char *searchstr = NULL;
 	int c, plines = lines-2;
 
 	if (!entry || !(dir = entry->dat))
 		return NULL;
 
 	for (;;) {
 		switch (getchar()) {
 		case 0x1b: /* ESC */
 			switch (getchar()) {
 			case 0x1b:
 				goto quit;
 			case 'O': /* application key */
 			case '[': /* DEC */
 				break;
 			default:
 				continue;
 			}
 			c = getchar();
 			switch (c) {
 			case '1':
 			case '4':
 			case '5':
 			case '6':
 			case '7': /* urxvt */
 			case '8': /* urxvt */
 				if (getchar() != '~')
 					continue;
 				switch (c) {
 				case '1':
 					goto home;
 				case '4':
 					goto end;
 				case '5':
 					goto pgup;
 				case '6':
 					goto pgdown;
 				case '7':
 					goto home;
 				case '8':
 					goto end;
 				}
 			case 'A':
 				goto lnup;
 			case 'B':
 				goto lndown;
 			case 'C':
 				goto pgnext;
 			case 'D':
 				goto pgprev;
 			case 'H':
 				goto home;
 			case 0x1b:
 				goto quit;
 			}
 			continue;
 		case _key_pgprev:
 		pgprev:
 			return entry->entry;
 		case _key_pgnext:
 		case '\n':
 		pgnext:
 			if (dir)
 				return &dir->items[dir->curline];
 			continue;
 		case _key_lndown:
 		lndown:
 			movecurline(entry, 1);
 			continue;
 		case _key_entrydown:
 			jumptoline(entry, nearentry(entry, 1), 1);
 			continue;
 		case _key_pgdown:
 		pgdown:
 			jumptoline(entry, dir->printoff + plines, 0);
 			continue;
 		case _key_end:
 		end:
 			jumptoline(entry, dir->nitems, 0);
 			continue;
 		case _key_lnup:
 		lnup:
 			movecurline(entry, -1);
 			continue;
 		case _key_entryup:
 			jumptoline(entry, nearentry(entry, -1), 1);
 			continue;
 		case _key_pgup:
 		pgup:
 			jumptoline(entry, dir->printoff - plines, 0);
 			continue;
 		case _key_home:
 		home:
 			jumptoline(entry, 0, 0);
 			continue;
 		case _key_search:
 			free(searchstr);
 			if (!((searchstr = uiprompt("Search for: ")) &&
 			    searchstr[0])) {
 				clear(&searchstr);
 				continue;
 			}
 		case _key_searchnext:
 			searchinline(searchstr, entry, +1);
 			continue;
 		case _key_searchprev:
 			searchinline(searchstr, entry, -1);
 			continue;
 		case EOF:
 		case 0x04:
 		case _key_quit:
 		quit:
 			return NULL;
 		case _key_fetch:
 			if (entry->raw)
 				continue;
 			return entry;
 		case _key_cururi:
 			if (dir)
 				displayuri(entry);
 			continue;
 		case _key_seluri:
 			if (dir)
 				displayuri(&dir->items[dir->curline]);
 			continue;
 		case _key_yankcur:
 			if (dir)
 				yankitem(entry);
 			continue;
 		case _key_yanksel:
 			if (dir)
 				yankitem(&dir->items[dir->curline]);
 			continue;
 		case _key_help: /* FALLTHROUGH */
 			return help(entry);
 		default:
 			continue;
 		}
 	}
 }
 
 void
 uisigwinch(int signal)
 {
 	Dir *dir;
 
 	if (termset == OK)
 		del_curterm(cur_term);
 	termset = setupterm(NULL, 1, NULL);
 	putp(tiparm(change_scroll_region, 0, lines-2));
 
 	if (!curentry || !(dir = curentry->dat))
 		return;
 
 	if (dir->curline - dir->printoff > lines-2)
 		dir->printoff = dir->curline - (lines-2);
 
 	uidisplay(curentry);
 }