op public repos

Blob

Date:: Mon Jul 12 17:28:39 2021 UTC
Message:: move ui decl. to ui.h
Actions:: History | Blame | Raw File
1 /*
2  * Copyright (c) 2021 Omar Polo <op@omarpolo.com>
3  *
4  * Permission to use, copy, modify, and distribute this software for any
5  * purpose with or without fee is hereby granted, provided that the above
6  * copyright notice and this permission notice appear in all copies.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15  */
16 
17 /*
18  * Ncurses UI for telescope.
19  *
20  * Text scrolling
21  * ==============
22  *
23  * ncurses allows you to scroll a window, but when a line goes out of
24  * the visible area it's forgotten.  We keep a list of formatted lines
25  * (``visual lines'') that we know fits in the window, and draw them.
26  *
27  * This means that on every resize we have to clear our list of lines
28  * and re-render everything.  A clever approach would be to do this
29  * ``on-demand'', but it's still missing.
30  *
31  */
32 
33 #include <assert.h>
34 #include <curses.h>
35 #include <event.h>
36 #include <locale.h>
37 #include <signal.h>
38 #include <stdarg.h>
39 #include <stdlib.h>
40 #include <string.h>
41 #include <unistd.h>
42 
43 #include "minibuffer.h"
44 #include "telescope.h"
45 #include "ui.h"
46 
47 static struct event	stdioev, winchev;
48 
49 static void		 restore_curs_x(struct buffer *);
50 
51 static struct vline	*nth_line(struct buffer*, size_t);
52 static int		 readkey(void);
53 static void		 dispatch_stdio(int, short, void*);
54 static void		 handle_clear_echoarea(int, short, void*);
55 static void		 handle_resize(int, short, void*);
56 static void		 handle_resize_nodelay(int, short, void*);
57 static int		 wrap_page(struct buffer*, int);
58 static void		 print_vline(int, int, WINDOW*, struct vline*);
59 static void		 redraw_tabline(void);
60 static void		 redraw_window(WINDOW*, int, int, struct buffer*);
61 static void		 redraw_help(void);
62 static void		 redraw_body(struct tab*);
63 static void		 redraw_modeline(struct tab*);
64 static void		 redraw_echoarea(void);
65 static void		 redraw_tab(struct tab*);
66 static void		 emit_help_item(char*, void*);
67 static void		 rec_compute_help(struct kmap*, char*, size_t);
68 static void		 recompute_help(void);
69 static void		 update_loading_anim(int, short, void*);
70 static void		 stop_loading_anim(struct tab*);
71 
72 static int		 x_offset;
73 
74 struct thiskey thiskey;
75 
76 static struct event	resizeev;
77 static struct timeval	resize_timer = { 0, 250000 };
78 
79 static WINDOW	*tabline, *body, *modeline, *echoarea;
80 
81 int			 body_lines, body_cols;
82 
83 static WINDOW		*help;
84 static struct buffer	 helpwin;
85 static int		 help_lines, help_cols;
86 
87 static int		 side_window;
88 
89 static struct event	clechoev;
90 static struct timeval	clechoev_timer = { 5, 0 };
91 static struct timeval	loadingev_timer = { 0, 250000 };
92 
93 static uint32_t		 tab_counter;
94 
95 static char	keybuf[64];
96 
97 struct kmap global_map,
98 	minibuffer_map,
99 	*current_map,
100 	*base_map;
101 
102 int in_minibuffer;
103 
104 static inline void
105 update_x_offset(void)
106 {
107 	if (olivetti_mode && fill_column < body_cols)
108 		x_offset = (body_cols - fill_column)/2;
109 	else
110 		x_offset = 0;
111 }
112 
113 void
114 save_excursion(struct excursion *place, struct buffer *buffer)
115 {
116 	place->curs_x = buffer->curs_x;
117 	place->curs_y = buffer->curs_y;
118 	place->line_off = buffer->line_off;
119 	place->current_line = buffer->current_line;
120 	place->cpoff = buffer->cpoff;
121 }
122 
123 void
124 restore_excursion(struct excursion *place, struct buffer *buffer)
125 {
126 	buffer->curs_x = place->curs_x;
127 	buffer->curs_y = place->curs_y;
128 	buffer->line_off = place->line_off;
129 	buffer->current_line = place->current_line;
130 	buffer->cpoff = place->cpoff;
131 }
132 
133 static void
134 restore_curs_x(struct buffer *buffer)
135 {
136 	struct vline	*vl;
137 	const char	*prfx;
138 
139 	vl = buffer->current_line;
140 	if (vl == NULL || vl->line == NULL)
141 		buffer->curs_x = buffer->cpoff = 0;
142 	else
143 		buffer->curs_x = utf8_snwidth(vl->line, buffer->cpoff);
144 
145 	buffer->curs_x += x_offset;
146 
147 	if (vl != NULL) {
148 		prfx = line_prefixes[vl->parent->type].prfx1;
149 		buffer->curs_x += utf8_swidth(prfx);
150 	}
151 }
152 
153 void
154 global_key_unbound(void)
155 {
156 	message("%s is undefined", keybuf);
157 }
158 
159 static struct vline *
160 nth_line(struct buffer *buffer, size_t n)
161 {
162 	struct vline	*vl;
163 	size_t		 i;
164 
165 	i = 0;
166 	TAILQ_FOREACH(vl, &buffer->head, vlines) {
167 		if (i == n)
168 			return vl;
169 		i++;
170 	}
171 
172 	/* unreachable */
173 	abort();
174 }
175 
176 struct tab *
177 current_tab(void)
178 {
179 	struct tab *t;
180 
181 	TAILQ_FOREACH(t, &tabshead, tabs) {
182 		if (t->flags & TAB_CURRENT)
183 			return t;
184 	}
185 
186 	/* unreachable */
187 	abort();
188 }
189 
190 struct buffer *
191 current_buffer(void)
192 {
193 	if (in_minibuffer)
194 		return &ministate.buffer;
195 	return &current_tab()->buffer;
196 }
197 
198 static int
199 readkey(void)
200 {
201 	uint32_t state = 0;
202 
203 	if ((thiskey.key = wgetch(body)) == ERR)
204 		return 0;
205 
206 	thiskey.meta = thiskey.key == 27;
207 	if (thiskey.meta) {
208 		thiskey.key = wgetch(body);
209 		if (thiskey.key == ERR || thiskey.key == 27) {
210 			thiskey.meta = 0;
211 			thiskey.key = 27;
212 		}
213 	}
214 
215 	thiskey.cp = 0;
216 	if ((unsigned int)thiskey.key < UINT8_MAX) {
217 		while (1) {
218 			if (!utf8_decode(&state, &thiskey.cp, (uint8_t)thiskey.key))
219 				break;
220 			if ((thiskey.key = wgetch(body)) == ERR) {
221 				message("Error decoding user input");
222 				return 0;
223 			}
224 		}
225 	}
226 
227 	return 1;
228 }
229 
230 static void
231 dispatch_stdio(int fd, short ev, void *d)
232 {
233 	struct keymap	*k;
234 	const char	*keyname;
235 	char		 tmp[5] = {0};
236 
237 	if (!readkey())
238 		return;
239 
240 	if (keybuf[0] != '\0')
241 		strlcat(keybuf, " ", sizeof(keybuf));
242 	if (thiskey.meta)
243 		strlcat(keybuf, "M-", sizeof(keybuf));
244 	if (thiskey.cp != 0) {
245 		utf8_encode(thiskey.cp, tmp);
246 		strlcat(keybuf, tmp, sizeof(keybuf));
247 	} else {
248 		if ((keyname = unkbd(thiskey.key)) != NULL)
249 			strlcat(keybuf, keyname, sizeof(keybuf));
250 		else {
251 			tmp[0] = thiskey.key;
252 			strlcat(keybuf, tmp, sizeof(keybuf));
253 		}
254 	}
255 
256 	TAILQ_FOREACH(k, &current_map->m, keymaps) {
257 		if (k->meta == thiskey.meta &&
258 		    k->key == thiskey.key) {
259 			if (k->fn == NULL)
260 				current_map = &k->map;
261 			else {
262 				current_map = base_map;
263 				strlcpy(keybuf, "", sizeof(keybuf));
264 				k->fn(current_buffer());
265 			}
266 			goto done;
267 		}
268 	}
269 
270 	if (current_map->unhandled_input != NULL)
271 		current_map->unhandled_input();
272 	else
273 		global_key_unbound();
274 
275 	strlcpy(keybuf, "", sizeof(keybuf));
276 	current_map = base_map;
277 
278 done:
279 	if (side_window)
280 		recompute_help();
281 
282 	redraw_tab(current_tab());
283 }
284 
285 static void
286 handle_clear_echoarea(int fd, short ev, void *d)
287 {
288 	free(ministate.curmesg);
289 	ministate.curmesg = NULL;
290 
291 	redraw_echoarea();
292 	if (in_minibuffer) {
293 		wrefresh(body);
294 		wrefresh(echoarea);
295 	} else {
296 		wrefresh(echoarea);
297 		wrefresh(body);
298 	}
299 }
300 
301 static void
302 handle_resize(int sig, short ev, void *d)
303 {
304 	if (event_pending(&resizeev, EV_TIMEOUT, NULL)) {
305 		event_del(&resizeev);
306 	}
307 	evtimer_set(&resizeev, handle_resize_nodelay, NULL);
308 	evtimer_add(&resizeev, &resize_timer);
309 }
310 
311 static void
312 handle_resize_nodelay(int s, short ev, void *d)
313 {
314 	struct tab	*tab;
315 
316 	endwin();
317 	refresh();
318 	clear();
319 
320 	/* move and resize the windows, in reverse order! */
321 
322 	mvwin(echoarea, LINES-1, 0);
323 	wresize(echoarea, 1, COLS);
324 
325 	mvwin(modeline, LINES-2, 0);
326 	wresize(modeline, 1, COLS);
327 
328 	body_lines = LINES-3;
329 	body_cols = COLS;
330 
331 	if (side_window) {
332 		help_cols = 0.3 * COLS;
333 		help_lines = LINES-3;
334 		mvwin(help, 1, 0);
335 		wresize(help, help_lines, help_cols);
336 
337 		wrap_page(&helpwin, help_cols);
338 
339 		body_cols = COLS - help_cols - 1;
340 		mvwin(body, 1, help_cols);
341 	} else
342 		mvwin(body, 1, 0);
343 
344 	update_x_offset();
345 	wresize(body, body_lines, body_cols);
346 
347 	wresize(tabline, 1, COLS);
348 
349 	tab = current_tab();
350 
351 	wrap_page(&tab->buffer, body_cols);
352 	redraw_tab(tab);
353 }
354 
355 static int
356 wrap_page(struct buffer *buffer, int width)
357 {
358 	struct line		*l;
359 	const struct line	*top_orig, *orig;
360 	struct vline		*vl;
361 	int			 pre_width;
362 	const char		*prfx;
363 
364 	top_orig = buffer->top_line == NULL ? NULL : buffer->top_line->parent;
365 	orig = buffer->current_line == NULL ? NULL : buffer->current_line->parent;
366 
367 	buffer->top_line = NULL;
368 	buffer->current_line = NULL;
369 
370 	buffer->force_redraw = 1;
371 	buffer->curs_y = 0;
372 	buffer->line_off = 0;
373 
374 	empty_vlist(buffer);
375 
376 	TAILQ_FOREACH(l, &buffer->page.head, lines) {
377 		prfx = line_prefixes[l->type].prfx1;
378 		switch (l->type) {
379 		case LINE_TEXT:
380 		case LINE_LINK:
381 		case LINE_TITLE_1:
382 		case LINE_TITLE_2:
383 		case LINE_TITLE_3:
384 		case LINE_ITEM:
385 		case LINE_QUOTE:
386 		case LINE_PRE_START:
387 		case LINE_PRE_END:
388 			wrap_text(buffer, prfx, l, MIN(fill_column, width));
389 			break;
390 		case LINE_PRE_CONTENT:
391 			if (olivetti_mode)
392 				pre_width = MIN(fill_column, width);
393 			else
394 				pre_width = width;
395 			hardwrap_text(buffer, l, pre_width);
396 			break;
397 		}
398 
399 		if (top_orig == l && buffer->top_line == NULL) {
400 			buffer->line_off = buffer->line_max-1;
401 			buffer->top_line = TAILQ_LAST(&buffer->head, vhead);
402 
403 			while (1) {
404 				vl = TAILQ_PREV(buffer->top_line, vhead, vlines);
405 				if (vl == NULL || vl->parent != orig)
406 					break;
407 				buffer->top_line = vl;
408 				buffer->line_off--;
409 			}
410 		}
411 
412 		if (orig == l && buffer->current_line == NULL) {
413 			buffer->current_line = TAILQ_LAST(&buffer->head, vhead);
414 
415 			while (1) {
416 				vl = TAILQ_PREV(buffer->current_line, vhead, vlines);
417 				if (vl == NULL || vl->parent != orig)
418 					break;
419 				buffer->current_line = vl;
420 			}
421 		}
422 	}
423 
424         if (buffer->current_line == NULL)
425 		buffer->current_line = TAILQ_FIRST(&buffer->head);
426 
427 	if (buffer->top_line == NULL)
428 		buffer->top_line = buffer->current_line;
429 
430 	return 1;
431 }
432 
433 static void
434 print_vline(int off, int width, WINDOW *window, struct vline *vl)
435 {
436 	const char *text;
437 	const char *prfx;
438 	struct line_face *f;
439 	int i, left, x, y;
440 
441 	f = &line_faces[vl->parent->type];
442 
443 	/* unused, set by getyx */
444 	(void)y;
445 
446 	if (!vl->flags)
447 		prfx = line_prefixes[vl->parent->type].prfx1;
448 	else
449 		prfx = line_prefixes[vl->parent->type].prfx2;
450 
451 	text = vl->line;
452 	if (text == NULL)
453 		text = "";
454 
455 	wattr_on(window, body_face.left, NULL);
456 	for (i = 0; i < off; i++)
457 		waddch(window, ' ');
458 	wattr_off(window, body_face.left, NULL);
459 
460 	wattr_on(window, f->prefix, NULL);
461 	wprintw(window, "%s", prfx);
462 	wattr_off(window, f->prefix, NULL);
463 
464 	wattr_on(window, f->text, NULL);
465 	wprintw(window, "%s", text);
466 	wattr_off(window, f->text, NULL);
467 
468 	getyx(window, y, x);
469 
470 	left = width - x;
471 
472 	wattr_on(window, f->trail, NULL);
473 	for (i = 0; i < left - off; ++i)
474 		waddch(window, ' ');
475 	wattr_off(window, f->trail, NULL);
476 
477 	wattr_on(window, body_face.right, NULL);
478 	for (i = 0; i < off; i++)
479 		waddch(window, ' ');
480 	wattr_off(window, body_face.right, NULL);
481 
482 }
483 
484 static void
485 redraw_tabline(void)
486 {
487 	struct tab	*tab;
488 	size_t		 toskip, ots, tabwidth, space, x;
489 	int		 current, y, truncated;
490 	const char	*title;
491 	char		 buf[25];
492 
493 	x = 0;
494 
495 	/* unused, but setted by a getyx */
496 	(void)y;
497 
498 	tabwidth = sizeof(buf)+1;
499 	space = COLS-2;
500 
501 	toskip = 0;
502 	TAILQ_FOREACH(tab, &tabshead, tabs) {
503 		toskip++;
504 		if (tab->flags & TAB_CURRENT)
505 			break;
506 	}
507 
508 	if (toskip * tabwidth < space)
509 		toskip = 0;
510 	else {
511 		ots = toskip;
512 		toskip--;
513                 while (toskip != 0 &&
514 		    (ots - toskip+1) * tabwidth < space)
515 			toskip--;
516 	}
517 
518 	werase(tabline);
519 	wattr_on(tabline, tab_face.background, NULL);
520 	wprintw(tabline, toskip == 0 ? " " : "<");
521 	wattr_off(tabline, tab_face.background, NULL);
522 
523 	truncated = 0;
524 	TAILQ_FOREACH(tab, &tabshead, tabs) {
525 		if (truncated)
526 			break;
527 		if (toskip != 0) {
528 			toskip--;
529 			continue;
530 		}
531 
532 		getyx(tabline, y, x);
533 		if (x + sizeof(buf)+2 >= (size_t)COLS)
534 			truncated = 1;
535 
536 		current = tab->flags & TAB_CURRENT;
537 
538 		if (*(title = tab->buffer.page.title) == '\0')
539 			title = tab->hist_cur->h;
540 
541 		if (tab->flags & TAB_URGENT)
542 			strlcpy(buf, "!", sizeof(buf));
543 		else
544 			strlcpy(buf, " ", sizeof(buf));
545 
546                 if (strlcat(buf, title, sizeof(buf)) >= sizeof(buf)) {
547 			/* truncation happens */
548 			strlcpy(&buf[sizeof(buf)-4], "...", 4);
549 		} else {
550 			/* pad with spaces */
551 			while (strlcat(buf, "    ", sizeof(buf)) < sizeof(buf))
552 				/* nop */ ;
553 		}
554 
555 		if (current)
556 			wattr_on(tabline, tab_face.current, NULL);
557 		else
558 			wattr_on(tabline, tab_face.tab, NULL);
559 
560 		wprintw(tabline, "%s", buf);
561 		if (TAILQ_NEXT(tab, tabs) != NULL)
562 			wprintw(tabline, " ");
563 
564 		if (current)
565 			wattr_off(tabline, tab_face.current, NULL);
566 		else
567 			wattr_off(tabline, tab_face.tab, NULL);
568 	}
569 
570 	wattr_on(tabline, tab_face.background, NULL);
571 	for (; x < (size_t)COLS; ++x)
572 		waddch(tabline, ' ');
573 	if (truncated)
574 		mvwprintw(tabline, 0, COLS-1, ">");
575 	wattr_off(tabline, tab_face.background, NULL);
576 }
577 
578 /*
579  * Compute the first visible line around vl.  Try to search forward
580  * until the end of the buffer; if a visible line is not found, search
581  * backward.  Return NULL if no viable line was found.
582  */
583 static inline struct vline *
584 adjust_line(struct vline *vl, struct buffer *buffer)
585 {
586 	struct vline *t;
587 
588 	if (!(vl->parent->flags & L_HIDDEN))
589 		return vl;
590 
591 	/* search forward */
592 	for (t = vl;
593 	     t != NULL && t->parent->flags & L_HIDDEN;
594 	     t = TAILQ_NEXT(t, vlines))
595 		;		/* nop */
596 
597 	if (t != NULL)
598 		return t;
599 
600 	/* search backward */
601 	for (t = vl;
602 	     t != NULL && t->parent->flags & L_HIDDEN;
603 	     t = TAILQ_PREV(t, vhead, vlines))
604 		;		/* nop */
605 
606 	return t;
607 }
608 
609 static void
610 redraw_window(WINDOW *win, int height, int width, struct buffer *buffer)
611 {
612         struct vline	*vl;
613 	int		 l, onscreen;
614 
615 	restore_curs_x(buffer);
616 
617 	/*
618 	 * TODO: ignoring buffer->force_update and always
619 	 * re-rendering.  In theory we can recompute the y position
620 	 * without a re-render, and optimize here.  It's not the only
621 	 * optimisation possible here, wscrl wolud also be an
622 	 * interesting one.
623 	 */
624 
625 again:
626 	werase(win);
627 	buffer->curs_y = 0;
628 
629 	if (TAILQ_EMPTY(&buffer->head))
630 		goto end;
631 
632 	buffer->top_line = adjust_line(buffer->top_line, buffer);
633 	if (buffer->top_line == NULL)
634 		goto end;
635 
636 	buffer->current_line = adjust_line(buffer->current_line, buffer);
637 
638 	l = 0;
639 	onscreen = 0;
640 	for (vl = buffer->top_line; vl != NULL; vl = TAILQ_NEXT(vl, vlines)) {
641 		if (vl->parent->flags & L_HIDDEN)
642 			continue;
643 
644 		wmove(win, l, 0);
645 		print_vline(x_offset, width, win, vl);
646 
647 		if (vl == buffer->current_line)
648 			onscreen = 1;
649 
650 		if (!onscreen)
651 			buffer->curs_y++;
652 
653 		l++;
654 		if (l == height)
655 			break;
656 	}
657 
658 	if (!onscreen) {
659 		for (; vl != NULL; vl = TAILQ_NEXT(vl, vlines)) {
660 			if (vl == buffer->current_line)
661 				break;
662 			if (vl->parent->flags & L_HIDDEN)
663 				continue;
664 			buffer->line_off++;
665 			buffer->top_line = TAILQ_NEXT(buffer->top_line, vlines);
666 		}
667 
668 		goto again;
669 	}
670 
671 	buffer->last_line_off = buffer->line_off;
672 	buffer->force_redraw = 0;
673 end:
674 	wmove(win, buffer->curs_y, buffer->curs_x);
675 }
676 
677 static void
678 redraw_help(void)
679 {
680 	redraw_window(help, help_lines, help_cols, &helpwin);
681 }
682 
683 static void
684 redraw_body(struct tab *tab)
685 {
686 	static struct tab *last_tab;
687 
688 	if (last_tab != tab)
689 		tab->buffer.force_redraw =1;
690 	last_tab = tab;
691 
692 	redraw_window(body, body_lines, body_cols, &tab->buffer);
693 }
694 
695 static inline char
696 trust_status_char(enum trust_state ts)
697 {
698 	switch (ts) {
699 	case TS_UNKNOWN:	return 'u';
700 	case TS_UNTRUSTED:	return '!';
701 	case TS_TEMP_TRUSTED:	return '!';
702 	case TS_TRUSTED:	return 'v';
703 	case TS_VERIFIED:	return 'V';
704 	default:		return 'X';
705 	}
706 }
707 
708 static void
709 redraw_modeline(struct tab *tab)
710 {
711 	double		 pct;
712 	int		 x, y, max_x, max_y;
713 	const char	*mode = tab->buffer.page.name;
714 	const char	*spin = "-\\|/";
715 
716 	werase(modeline);
717 	wattr_on(modeline, modeline_face.background, NULL);
718 	wmove(modeline, 0, 0);
719 
720 	wprintw(modeline, "-%c%c %s ",
721 	    spin[tab->loading_anim_step],
722 	    trust_status_char(tab->trust),
723 	    mode == NULL ? "(none)" : mode);
724 
725 	pct = (tab->buffer.line_off + tab->buffer.curs_y) * 100.0 / tab->buffer.line_max;
726 
727 	if (tab->buffer.line_max <= (size_t)body_lines)
728                 wprintw(modeline, "All ");
729 	else if (tab->buffer.line_off == 0)
730                 wprintw(modeline, "Top ");
731 	else if (tab->buffer.line_off + body_lines >= tab->buffer.line_max)
732 		wprintw(modeline, "Bottom ");
733 	else
734 		wprintw(modeline, "%.0f%% ", pct);
735 
736 	wprintw(modeline, "%d/%d %s ",
737 	    tab->buffer.line_off + tab->buffer.curs_y,
738 	    tab->buffer.line_max,
739 	    tab->hist_cur->h);
740 
741 	getyx(modeline, y, x);
742 	getmaxyx(modeline, max_y, max_x);
743 
744 	(void)y;
745 	(void)max_y;
746 
747 	for (; x < max_x; ++x)
748 		waddstr(modeline, "-");
749 
750 	wattr_off(modeline, modeline_face.background, NULL);
751 }
752 
753 static void
754 redraw_echoarea(void)
755 {
756 	struct tab *tab;
757 	size_t off_y, off_x = 0;
758 	char *start = NULL, *c = NULL;
759 
760 	/* unused, but set by getyx */
761 	(void)off_y;
762 
763 	wattr_on(echoarea, minibuffer_face.background, NULL);
764 	werase(echoarea);
765 
766 	if (in_minibuffer) {
767 		mvwprintw(echoarea, 0, 0, "%s", ministate.prompt);
768 		if (ministate.hist_cur != NULL)
769 			wprintw(echoarea, "(%zu/%zu) ",
770 			    ministate.hist_off + 1,
771 			    ministate.history->len);
772 
773 		getyx(echoarea, off_y, off_x);
774 
775 		start = ministate.hist_cur != NULL
776 			? ministate.hist_cur->h
777 			: ministate.buf;
778 		c = utf8_nth(ministate.buffer.current_line->line,
779 		    ministate.buffer.cpoff);
780 		while (utf8_swidth_between(start, c) > (size_t)COLS/2) {
781 			start = utf8_next_cp(start);
782 		}
783 
784 		waddstr(echoarea, start);
785 	}
786 
787 	if (ministate.curmesg != NULL)
788                 wprintw(echoarea, in_minibuffer ? "  [%s]" : "%s",
789 		    ministate.curmesg);
790 
791 	if (!in_minibuffer && ministate.curmesg == NULL)
792 		waddstr(echoarea, keybuf);
793 
794 	/* If nothing else, show the URL at point */
795 	if (!in_minibuffer && ministate.curmesg == NULL && *keybuf == '\0') {
796 		tab = current_tab();
797 		if (tab->buffer.current_line != NULL &&
798 		    tab->buffer.current_line->parent->type == LINE_LINK)
799 			waddstr(echoarea, tab->buffer.current_line->parent->alt);
800 	}
801 
802 	if (in_minibuffer)
803 		wmove(echoarea, 0, off_x + utf8_swidth_between(start, c));
804 
805 	wattr_off(echoarea, minibuffer_face.background, NULL);
806 }
807 
808 static void
809 redraw_tab(struct tab *tab)
810 {
811 	if (side_window) {
812 		redraw_help();
813 		wnoutrefresh(help);
814 	}
815 
816 	redraw_tabline();
817 	redraw_body(tab);
818 	redraw_modeline(tab);
819 	redraw_echoarea();
820 
821 	wnoutrefresh(tabline);
822 	wnoutrefresh(modeline);
823 
824 	if (in_minibuffer) {
825 		wnoutrefresh(body);
826 		wnoutrefresh(echoarea);
827 	} else {
828 		wnoutrefresh(echoarea);
829 		wnoutrefresh(body);
830 	}
831 
832 	doupdate();
833 }
834 
835 static void
836 emit_help_item(char *prfx, void *fn)
837 {
838 	struct line	*l;
839 	struct cmd	*cmd;
840 
841 	for (cmd = cmds; cmd->cmd != NULL; ++cmd) {
842 		if (fn == cmd->fn)
843 			break;
844 	}
845 	assert(cmd != NULL);
846 
847 	if ((l = calloc(1, sizeof(*l))) == NULL)
848 		abort();
849 
850 	l->type = LINE_TEXT;
851 	l->alt = NULL;
852 
853 	asprintf(&l->line, "%s %s", prfx, cmd->cmd);
854 
855 	if (TAILQ_EMPTY(&helpwin.page.head))
856 		TAILQ_INSERT_HEAD(&helpwin.page.head, l, lines);
857 	else
858 		TAILQ_INSERT_TAIL(&helpwin.page.head, l, lines);
859 }
860 
861 static void
862 rec_compute_help(struct kmap *keymap, char *prfx, size_t len)
863 {
864 	struct keymap	*k;
865 	char		 p[32];
866 	const char	*kn;
867 
868 	TAILQ_FOREACH(k, &keymap->m, keymaps) {
869 		strlcpy(p, prfx, sizeof(p));
870 		if (*p != '\0')
871 			strlcat(p, " ", sizeof(p));
872 		if (k->meta)
873 			strlcat(p, "M-", sizeof(p));
874 		if ((kn = unkbd(k->key)) != NULL)
875 			strlcat(p, kn, sizeof(p));
876 		else
877 			strlcat(p, keyname(k->key), sizeof(p));
878 
879 		if (k->fn == NULL)
880 			rec_compute_help(&k->map, p, sizeof(p));
881 		else
882 			emit_help_item(p, k->fn);
883 	}
884 }
885 
886 static void
887 recompute_help(void)
888 {
889 	char	p[32] = { 0 };
890 
891 	empty_vlist(&helpwin);
892 	empty_linelist(&helpwin);
893 	rec_compute_help(current_map, p, sizeof(p));
894 	wrap_page(&helpwin, help_cols);
895 }
896 
897 void
898 vmessage(const char *fmt, va_list ap)
899 {
900 	if (evtimer_pending(&clechoev, NULL))
901 		evtimer_del(&clechoev);
902 
903 	free(ministate.curmesg);
904 	ministate.curmesg = NULL;
905 
906 	if (fmt != NULL) {
907 		evtimer_set(&clechoev, handle_clear_echoarea, NULL);
908 		evtimer_add(&clechoev, &clechoev_timer);
909 
910 		/* TODO: what to do if the allocation fails here? */
911 		if (vasprintf(&ministate.curmesg, fmt, ap) == -1)
912 			ministate.curmesg = NULL;
913 	}
914 
915 	redraw_echoarea();
916 	if (in_minibuffer) {
917 		wrefresh(body);
918 		wrefresh(echoarea);
919 	} else {
920 		wrefresh(echoarea);
921 		wrefresh(body);
922 	}
923 }
924 
925 void
926 message(const char *fmt, ...)
927 {
928 	va_list ap;
929 
930 	va_start(ap, fmt);
931 	vmessage(fmt, ap);
932 	va_end(ap);
933 }
934 
935 void
936 start_loading_anim(struct tab *tab)
937 {
938 	if (tab->loading_anim)
939 		return;
940 	tab->loading_anim = 1;
941 	evtimer_set(&tab->loadingev, update_loading_anim, tab);
942 	evtimer_add(&tab->loadingev, &loadingev_timer);
943 }
944 
945 static void
946 update_loading_anim(int fd, short ev, void *d)
947 {
948 	struct tab	*tab = d;
949 
950 	tab->loading_anim_step = (tab->loading_anim_step+1)%4;
951 
952 	if (tab->flags & TAB_CURRENT) {
953 		redraw_modeline(tab);
954 		wrefresh(modeline);
955 		wrefresh(body);
956 		if (in_minibuffer)
957 			wrefresh(echoarea);
958 	}
959 
960 	evtimer_add(&tab->loadingev, &loadingev_timer);
961 }
962 
963 static void
964 stop_loading_anim(struct tab *tab)
965 {
966 	if (!tab->loading_anim)
967 		return;
968 	evtimer_del(&tab->loadingev);
969 	tab->loading_anim = 0;
970 	tab->loading_anim_step = 0;
971 
972 	if (!(tab->flags & TAB_CURRENT))
973 		return;
974 
975 	redraw_modeline(tab);
976 
977 	wrefresh(modeline);
978 	wrefresh(body);
979 	if (in_minibuffer)
980 		wrefresh(echoarea);
981 }
982 
983 void
984 load_url_in_tab(struct tab *tab, const char *url)
985 {
986 	message("Loading %s...", url);
987 	start_loading_anim(tab);
988 	load_url(tab, url);
989 
990 	tab->buffer.curs_x = 0;
991 	tab->buffer.curs_y = 0;
992 	redraw_tab(tab);
993 }
994 
995 void
996 switch_to_tab(struct tab *tab)
997 {
998 	struct tab	*t;
999 
1000 	TAILQ_FOREACH(t, &tabshead, tabs) {
1001 		t->flags &= ~TAB_CURRENT;
1002 	}
1003 
1004 	tab->flags |= TAB_CURRENT;
1005 	tab->flags &= ~TAB_URGENT;
1006 }
1007 
1008 unsigned int
1009 tab_new_id(void)
1010 {
1011 	return tab_counter++;
1012 }
1013 
1014 struct tab *
1015 new_tab(const char *url)
1016 {
1017 	struct tab	*tab;
1018 
1019 	if ((tab = calloc(1, sizeof(*tab))) == NULL) {
1020 		event_loopbreak();
1021 		return NULL;
1022 	}
1023 	tab->fd = -1;
1024 
1025 	TAILQ_INIT(&tab->hist.head);
1026 
1027 	TAILQ_INIT(&tab->buffer.head);
1028 
1029 	tab->id = tab_new_id();
1030 	switch_to_tab(tab);
1031 
1032 	if (TAILQ_EMPTY(&tabshead))
1033 		TAILQ_INSERT_HEAD(&tabshead, tab, tabs);
1034 	else
1035 		TAILQ_INSERT_TAIL(&tabshead, tab, tabs);
1036 
1037 	load_url_in_tab(tab, url);
1038 	return tab;
1039 }
1040 
1041 int
1042 ui_init()
1043 {
1044 	setlocale(LC_ALL, "");
1045 
1046 	TAILQ_INIT(&eecmd_history.head);
1047 	TAILQ_INIT(&ir_history.head);
1048 	TAILQ_INIT(&lu_history.head);
1049 
1050 	ministate.line.type = LINE_TEXT;
1051 	ministate.vline.parent = &ministate.line;
1052 	ministate.buffer.current_line = &ministate.vline;
1053 
1054 	/* initialize help window */
1055 	TAILQ_INIT(&helpwin.head);
1056 
1057 	base_map = &global_map;
1058 	current_map = &global_map;
1059 
1060 	initscr();
1061 
1062 	if (enable_colors) {
1063 		if (has_colors()) {
1064 			start_color();
1065 			use_default_colors();
1066 		} else
1067 			enable_colors = 0;
1068 	}
1069 
1070 	config_apply_style();
1071 
1072 	raw();
1073 	noecho();
1074 	nonl();
1075 	intrflush(stdscr, FALSE);
1076 
1077 	if ((tabline = newwin(1, COLS, 0, 0)) == NULL)
1078 		return 0;
1079 	if ((body = newwin(LINES - 3, COLS, 1, 0)) == NULL)
1080 		return 0;
1081 	if ((modeline = newwin(1, COLS, LINES-2, 0)) == NULL)
1082 		return 0;
1083 	if ((echoarea = newwin(1, COLS, LINES-1, 0)) == NULL)
1084 		return 0;
1085 	if ((help = newwin(1, 1, 1, 0)) == NULL)
1086 		return 0;
1087 
1088 	body_lines = LINES-3;
1089 	body_cols = COLS;
1090 
1091 	wbkgd(body, body_face.body);
1092 	wbkgd(echoarea, minibuffer_face.background);
1093 
1094 	update_x_offset();
1095 
1096 	keypad(body, TRUE);
1097 	scrollok(body, FALSE);
1098 
1099 	/* non-blocking input */
1100 	wtimeout(body, 0);
1101 
1102 	mvwprintw(body, 0, 0, "");
1103 
1104 	event_set(&stdioev, 0, EV_READ | EV_PERSIST, dispatch_stdio, NULL);
1105 	event_add(&stdioev, NULL);
1106 
1107 	signal_set(&winchev, SIGWINCH, handle_resize, NULL);
1108 	signal_add(&winchev, NULL);
1109 
1110 	return 1;
1111 }
1112 
1113 void
1114 ui_on_tab_loaded(struct tab *tab)
1115 {
1116 	stop_loading_anim(tab);
1117 	message("Loaded %s", tab->hist_cur->h);
1118 
1119 	redraw_tabline();
1120 	wrefresh(tabline);
1121 	if (in_minibuffer)
1122 		wrefresh(echoarea);
1123 	else
1124 		wrefresh(body);
1125 }
1126 
1127 void
1128 ui_on_tab_refresh(struct tab *tab)
1129 {
1130 	wrap_page(&tab->buffer, body_cols);
1131 	if (tab->flags & TAB_CURRENT)
1132 		redraw_tab(tab);
1133 	else
1134 		tab->flags |= TAB_URGENT;
1135 }
1136 
1137 const char *
1138 ui_keyname(int k)
1139 {
1140 	return keyname(k);
1141 }
1142 
1143 void
1144 ui_toggle_side_window(void)
1145 {
1146 	side_window = !side_window;
1147 	if (side_window)
1148 		recompute_help();
1149 
1150 	/*
1151 	 * ugly hack, but otherwise the window doesn't get updated
1152 	 * until I call handle_resize a second time (i.e. C-l).  I
1153 	 * will be happy to know why something like this is needed.
1154 	 */
1155 	handle_resize_nodelay(0, 0, NULL);
1156 	handle_resize_nodelay(0, 0, NULL);
1157 }
1158 
1159 void
1160 ui_schedule_redraw(void)
1161 {
1162 	handle_resize_nodelay(0, 0, NULL);
1163 }
1164 
1165 void
1166 ui_require_input(struct tab *tab, int hide)
1167 {
1168 	/* TODO: hard-switching to another tab is ugly */
1169 	switch_to_tab(tab);
1170 
1171 	enter_minibuffer(ir_self_insert, ir_select, exit_minibuffer,
1172 	    &ir_history);
1173 	strlcpy(ministate.prompt, "Input required: ",
1174 	    sizeof(ministate.prompt));
1175 	redraw_tab(tab);
1176 }
1177 
1178 void
1179 ui_yornp(const char *prompt, void (*fn)(int, struct tab *),
1180     struct tab *data)
1181 {
1182 	yornp(prompt, fn, data);
1183 	redraw_tab(current_tab());
1184 }
1185 
1186 void
1187 ui_read(const char *prompt, void (*fn)(const char*, unsigned int),
1188     unsigned int data)
1189 {
1190 	completing_read(prompt, fn, data);
1191 	redraw_tab(current_tab());
1192 }
1193 
1194 void
1195 ui_end(void)
1196 {
1197 	endwin();
1198 }