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  * This way is easy to scroll: just call wscrl and then render the
27  * first/last line!
28  *
29  * This means that on every resize we have to clear our list of lines
30  * and re-render everything.  A clever approach would be to do this
31  * ``on-demand'', but it's still missing.
32  *
33  */
34 
35 #include "telescope.h"
36 #include "cmd.gen.h"
37 
38 #include <assert.h>
39 #include <curses.h>
40 #include <event.h>
41 #include <limits.h>
42 #include <locale.h>
43 #include <signal.h>
44 #include <stdarg.h>
45 #include <stdlib.h>
46 #include <string.h>
47 #include <unistd.h>
48 
49 static struct event	stdioev, winchev;
50 
51 static void		 load_default_keys(void);
52 
53 static void		 global_key_unbound(void);
54 static void		 minibuffer_hist_save_entry(void);
55 static void		 minibuffer_self_insert(void);
56 static void		 yornp_self_insert(void);
57 static void		 yornp_abort(void);
58 static void		 read_self_insert(void);
59 static void		 read_abort(void);
60 static void		 read_select(void);
61 
62 static struct vline	*nth_line(struct buffer*, size_t);
63 static struct buffer	*current_buffer(void);
64 static int		 readkey(void);
65 static void		 dispatch_stdio(int, short, void*);
66 static void		 handle_clear_minibuf(int, short, void*);
67 static void		 handle_resize(int, short, void*);
68 static void		 handle_resize_nodelay(int, short, void*);
69 static int		 wrap_page(struct buffer*, int);
70 static void		 print_vline(int, int, WINDOW*, struct vline*);
71 static void		 redraw_tabline(void);
72 static void		 redraw_window(WINDOW*, int, int, struct buffer*);
73 static void		 redraw_help(void);
74 static void		 redraw_body(struct tab*);
75 static void		 redraw_modeline(struct tab*);
76 static void		 redraw_minibuffer(void);
77 static void		 redraw_tab(struct tab*);
78 static void		 emit_help_item(char*, void*);
79 static void		 rec_compute_help(struct kmap*, char*, size_t);
80 static void		 recompute_help(void);
81 static void		 update_loading_anim(int, short, void*);
82 static void		 stop_loading_anim(struct tab*);
83 static void		 session_new_tab_cb(const char*);
84 static void		 usage(void);
85 
86 static int		 x_offset;
87 
88 struct thiskey thiskey;
89 
90 static struct event	resizeev;
91 static struct timeval	resize_timer = { 0, 250000 };
92 
93 static WINDOW	*tabline, *body, *modeline, *minibuf;
94 
95 int			 body_lines, body_cols;
96 
97 static WINDOW		*help;
98 static struct buffer	 helpwin;
99 static int		 help_lines, help_cols;
100 
101 static int		 side_window;
102 
103 static struct event	clminibufev;
104 static struct timeval	clminibufev_timer = { 5, 0 };
105 static struct timeval	loadingev_timer = { 0, 250000 };
106 
107 static uint32_t		 tab_counter;
108 
109 static char	keybuf[64];
110 
111 static void (*yornp_cb)(int, unsigned int);
112 static unsigned int yornp_data;
113 
114 static void (*read_cb)(const char*, unsigned int);
115 static unsigned int read_data;
116 
117 struct kmap global_map,
118 	minibuffer_map,
119 	*current_map,
120 	*base_map;
121 
122 struct histhead eecmd_history,
123 	ir_history,
124 	lu_history,
125 	read_history;
126 
127 int in_minibuffer;
128 
129 struct ministate ministate;
130 
131 static inline void
132 update_x_offset(void)
133 {
134 	if (olivetti_mode && fill_column < body_cols)
135 		x_offset = (body_cols - fill_column)/2;
136 	else
137 		x_offset = 0;
138 }
139 
140 static inline void
141 global_set_key(const char *key, void (*fn)(struct buffer*))
142 {
143 	if (!kmap_define_key(&global_map, key, fn))
144 		_exit(1);
145 }
146 
147 static inline void
148 minibuffer_set_key(const char *key, void (*fn)(struct buffer*))
149 {
150 	if (!kmap_define_key(&minibuffer_map, key, fn))
151 		_exit(1);
152 }
153 
154 static void
155 load_default_keys(void)
156 {
157 	/* === global map === */
158 
159 	/* emacs */
160 	global_set_key("C-p",		cmd_previous_line);
161 	global_set_key("C-n",		cmd_next_line);
162 	global_set_key("C-f",		cmd_forward_char);
163 	global_set_key("C-b",		cmd_backward_char);
164 	global_set_key("M-{",		cmd_backward_paragraph);
165 	global_set_key("M-}",		cmd_forward_paragraph);
166 	global_set_key("C-a",		cmd_move_beginning_of_line);
167 	global_set_key("C-e",		cmd_move_end_of_line);
168 
169 	global_set_key("M-v",		cmd_scroll_up);
170 	global_set_key("C-v",		cmd_scroll_down);
171 	global_set_key("M-space",	cmd_scroll_up);
172 	global_set_key("space",		cmd_scroll_down);
173 
174 	global_set_key("M-<",		cmd_beginning_of_buffer);
175 	global_set_key("M->",		cmd_end_of_buffer);
176 
177 	global_set_key("C-x C-c",	cmd_kill_telescope);
178 
179 	global_set_key("C-g",		cmd_clear_minibuf);
180 
181 	global_set_key("M-x",		cmd_execute_extended_command);
182 	global_set_key("C-x C-f",	cmd_load_url);
183 	global_set_key("C-x M-f",	cmd_load_current_url);
184 
185 	global_set_key("C-x t 0",	cmd_tab_close);
186 	global_set_key("C-x t 1",	cmd_tab_close_other);
187 	global_set_key("C-x t 2",	cmd_tab_new);
188 	global_set_key("C-x t o",	cmd_tab_next);
189 	global_set_key("C-x t O",	cmd_tab_previous);
190 	global_set_key("C-x t m",	cmd_tab_move);
191 	global_set_key("C-x t M",	cmd_tab_move_to);
192 
193 	global_set_key("C-M-b",		cmd_previous_page);
194 	global_set_key("C-M-f",		cmd_next_page);
195 
196 	global_set_key("<f7> a",	cmd_bookmark_page);
197 	global_set_key("<f7> <f7>",	cmd_list_bookmarks);
198 
199 	/* vi/vi-like */
200 	global_set_key("k",		cmd_previous_line);
201 	global_set_key("j",		cmd_next_line);
202 	global_set_key("l",		cmd_forward_char);
203 	global_set_key("h",		cmd_backward_char);
204 	global_set_key("{",		cmd_backward_paragraph);
205 	global_set_key("}",		cmd_forward_paragraph);
206 	global_set_key("^",		cmd_move_beginning_of_line);
207 	global_set_key("$",		cmd_move_end_of_line);
208 
209 	global_set_key("K",		cmd_scroll_line_up);
210 	global_set_key("J",		cmd_scroll_line_down);
211 
212 	global_set_key("g g",		cmd_beginning_of_buffer);
213 	global_set_key("G",		cmd_end_of_buffer);
214 
215 	global_set_key("g D",		cmd_tab_close);
216 	global_set_key("g N",		cmd_tab_new);
217 	global_set_key("g t",		cmd_tab_next);
218 	global_set_key("g T",		cmd_tab_previous);
219 	global_set_key("g M-t",		cmd_tab_move);
220 	global_set_key("g M-T",		cmd_tab_move_to);
221 
222 	global_set_key("H",		cmd_previous_page);
223 	global_set_key("L",		cmd_next_page);
224 
225 	/* tmp */
226 	global_set_key("q",		cmd_kill_telescope);
227 
228 	global_set_key("esc",		cmd_clear_minibuf);
229 
230 	global_set_key(":",		cmd_execute_extended_command);
231 
232 	/* cua */
233 	global_set_key("<up>",		cmd_previous_line);
234 	global_set_key("<down>",	cmd_next_line);
235 	global_set_key("<right>",	cmd_forward_char);
236 	global_set_key("<left>",	cmd_backward_char);
237 	global_set_key("<prior>",	cmd_scroll_up);
238 	global_set_key("<next>",	cmd_scroll_down);
239 
240 	global_set_key("M-<left>",	cmd_previous_page);
241 	global_set_key("M-<right>",	cmd_next_page);
242 
243 	/* "ncurses standard" */
244 	global_set_key("C-l",		cmd_redraw);
245 
246 	/* global */
247 	global_set_key("<f1>",		cmd_toggle_help);
248 	global_set_key("C-m",		cmd_push_button);
249 	global_set_key("M-enter",	cmd_push_button_new_tab);
250 	global_set_key("M-tab",		cmd_previous_button);
251 	global_set_key("backtab",	cmd_previous_button);
252 	global_set_key("tab",		cmd_next_button);
253 
254 	/* === minibuffer map === */
255 	minibuffer_set_key("ret",		cmd_mini_complete_and_exit);
256 	minibuffer_set_key("C-g",		cmd_mini_abort);
257 	minibuffer_set_key("esc",		cmd_mini_abort);
258 	minibuffer_set_key("C-d",		cmd_mini_delete_char);
259 	minibuffer_set_key("del",		cmd_mini_delete_backward_char);
260 	minibuffer_set_key("backspace",		cmd_mini_delete_backward_char);
261 	minibuffer_set_key("C-h",		cmd_mini_delete_backward_char);
262 
263 	minibuffer_set_key("C-b",		cmd_backward_char);
264 	minibuffer_set_key("C-f",		cmd_forward_char);
265 	minibuffer_set_key("<left>",		cmd_backward_char);
266 	minibuffer_set_key("<right>",		cmd_forward_char);
267 	minibuffer_set_key("C-e",		cmd_move_end_of_line);
268 	minibuffer_set_key("C-a",		cmd_move_beginning_of_line);
269 	minibuffer_set_key("<end>",		cmd_move_end_of_line);
270 	minibuffer_set_key("<home>",		cmd_move_beginning_of_line);
271 	minibuffer_set_key("C-k",		cmd_mini_kill_line);
272 
273 	minibuffer_set_key("M-p",		cmd_mini_previous_history_element);
274 	minibuffer_set_key("M-n",		cmd_mini_next_history_element);
275 	minibuffer_set_key("<up>",		cmd_mini_previous_history_element);
276 	minibuffer_set_key("<down>",		cmd_mini_next_history_element);
277 }
278 
279 void
280 save_excursion(struct excursion *place, struct buffer *buffer)
281 {
282 	place->curs_x = buffer->curs_x;
283 	place->curs_y = buffer->curs_y;
284 	place->line_off = buffer->line_off;
285 	place->current_line = buffer->current_line;
286 	place->cpoff = buffer->cpoff;
287 }
288 
289 void
290 restore_excursion(struct excursion *place, struct buffer *buffer)
291 {
292 	buffer->curs_x = place->curs_x;
293 	buffer->curs_y = place->curs_y;
294 	buffer->line_off = place->line_off;
295 	buffer->current_line = place->current_line;
296 	buffer->cpoff = place->cpoff;
297 }
298 
299 void
300 restore_cursor(struct buffer *buffer)
301 {
302 	struct vline	*vl;
303 	const char	*prfx;
304 
305 	vl = buffer->current_line;
306 	if (vl == NULL || vl->line == NULL)
307 		buffer->curs_x = buffer->cpoff = 0;
308 	else
309 		buffer->curs_x = utf8_snwidth(vl->line, buffer->cpoff);
310 
311 	buffer->curs_x += x_offset;
312 
313 	if (vl != NULL) {
314 		prfx = line_prefixes[vl->parent->type].prfx1;
315 		buffer->curs_x += utf8_swidth(prfx);
316 	}
317 }
318 
319 static void
320 global_key_unbound(void)
321 {
322 	message("%s is undefined", keybuf);
323 }
324 
325 static void
326 minibuffer_hist_save_entry(void)
327 {
328 	struct hist	*hist;
329 
330 	if (ministate.history == NULL)
331 		return;
332 
333 	if ((hist = calloc(1, sizeof(*hist))) == NULL)
334 		abort();
335 
336 	strlcpy(hist->h, ministate.buf, sizeof(hist->h));
337 
338 	if (TAILQ_EMPTY(&ministate.history->head))
339 		TAILQ_INSERT_HEAD(&ministate.history->head, hist, entries);
340 	else
341 		TAILQ_INSERT_TAIL(&ministate.history->head, hist, entries);
342 	ministate.history->len++;
343 }
344 
345 /*
346  * taint the minibuffer cache: if we're currently showing a history
347  * element, copy that to the current buf and reset the "history
348  * navigation" thing.
349  */
350 void
351 minibuffer_taint_hist(void)
352 {
353 	if (ministate.hist_cur == NULL)
354 		return;
355 
356 	strlcpy(ministate.buf, ministate.hist_cur->h, sizeof(ministate.buf));
357 	ministate.hist_cur = NULL;
358 }
359 
360 static void
361 minibuffer_self_insert(void)
362 {
363 	char	*c, tmp[5] = {0};
364 	size_t	len;
365 
366 	minibuffer_taint_hist();
367 
368 	if (thiskey.cp == 0)
369 		return;
370 
371 	len = utf8_encode(thiskey.cp, tmp);
372 	c = utf8_nth(ministate.buffer.current_line->line, ministate.buffer.cpoff);
373 	if (c + len > ministate.buf + sizeof(ministate.buf) - 1)
374 		return;
375 
376 	memmove(c + len, c, strlen(c)+1);
377 	memcpy(c, tmp, len);
378 	ministate.buffer.cpoff++;
379 }
380 
381 void
382 eecmd_self_insert(void)
383 {
384 	if (thiskey.meta || unicode_isspace(thiskey.cp) ||
385 	    !unicode_isgraph(thiskey.cp)) {
386 		global_key_unbound();
387 		return;
388 	}
389 
390 	minibuffer_self_insert();
391 }
392 
393 void
394 eecmd_select(void)
395 {
396 	struct cmds *cmd;
397 
398 	for (cmd = cmds; cmd->cmd != NULL; ++cmd) {
399 		if (!strcmp(cmd->cmd, ministate.buf)) {
400 			exit_minibuffer();
401 			minibuffer_hist_save_entry();
402 			cmd->fn(current_buffer());
403 			return;
404 		}
405 	}
406 
407 	message("No match");
408 }
409 
410 void
411 ir_self_insert(void)
412 {
413 	minibuffer_self_insert();
414 }
415 
416 void
417 ir_select(void)
418 {
419 	char		 buf[1025] = {0};
420 	struct phos_uri	 uri;
421 	struct tab	*tab;
422 
423 	tab = current_tab();
424 
425 	exit_minibuffer();
426 	minibuffer_hist_save_entry();
427 
428 	/* a bit ugly but... */
429 	memcpy(&uri, &tab->uri, sizeof(tab->uri));
430 	phos_uri_set_query(&uri, ministate.buf);
431 	phos_serialize_uri(&uri, buf, sizeof(buf));
432 	load_url_in_tab(tab, buf);
433 }
434 
435 void
436 lu_self_insert(void)
437 {
438 	if (thiskey.meta || unicode_isspace(thiskey.key) ||
439 	    !unicode_isgraph(thiskey.key)) {
440 		global_key_unbound();
441 		return;
442 	}
443 
444 	minibuffer_self_insert();
445 }
446 
447 void
448 lu_select(void)
449 {
450 	exit_minibuffer();
451 	minibuffer_hist_save_entry();
452 	load_url_in_tab(current_tab(), ministate.buf);
453 }
454 
455 void
456 bp_select(void)
457 {
458 	exit_minibuffer();
459 	if (*ministate.buf != '\0')
460 		add_to_bookmarks(ministate.buf);
461 	else
462 		message("Abort.");
463 }
464 
465 static void
466 yornp_self_insert(void)
467 {
468 	if (thiskey.key != 'y' && thiskey.key != 'n') {
469 		message("Please answer y or n");
470 		return;
471 	}
472 
473 	exit_minibuffer();
474 	yornp_cb(thiskey.key == 'y', yornp_data);
475 }
476 
477 static void
478 yornp_abort(void)
479 {
480 	exit_minibuffer();
481 	yornp_cb(0, yornp_data);
482 }
483 
484 static void
485 read_self_insert(void)
486 {
487 	if (thiskey.meta || !unicode_isgraph(thiskey.cp)) {
488 		global_key_unbound();
489 		return;
490 	}
491 
492 	minibuffer_self_insert();
493 }
494 
495 static void
496 read_abort(void)
497 {
498 	exit_minibuffer();
499 	read_cb(NULL, read_data);
500 }
501 
502 static void
503 read_select(void)
504 {
505         exit_minibuffer();
506 	minibuffer_hist_save_entry();
507 	read_cb(ministate.buf, read_data);
508 }
509 
510 static struct vline *
511 nth_line(struct buffer *buffer, size_t n)
512 {
513 	struct vline	*vl;
514 	size_t		 i;
515 
516 	i = 0;
517 	TAILQ_FOREACH(vl, &buffer->head, vlines) {
518 		if (i == n)
519 			return vl;
520 		i++;
521 	}
522 
523 	/* unreachable */
524 	abort();
525 }
526 
527 struct tab *
528 current_tab(void)
529 {
530 	struct tab *t;
531 
532 	TAILQ_FOREACH(t, &tabshead, tabs) {
533 		if (t->flags & TAB_CURRENT)
534 			return t;
535 	}
536 
537 	/* unreachable */
538 	abort();
539 }
540 
541 struct buffer *
542 current_buffer(void)
543 {
544 	if (in_minibuffer)
545 		return &ministate.buffer;
546 	return &current_tab()->buffer;
547 }
548 
549 static int
550 readkey(void)
551 {
552 	uint32_t state = 0;
553 
554 	if ((thiskey.key = wgetch(body)) == ERR)
555 		return 0;
556 
557 	thiskey.meta = thiskey.key == 27;
558 	if (thiskey.meta) {
559 		thiskey.key = wgetch(body);
560 		if (thiskey.key == ERR || thiskey.key == 27) {
561 			thiskey.meta = 0;
562 			thiskey.key = 27;
563 		}
564 	}
565 
566 	thiskey.cp = 0;
567 	if ((unsigned int)thiskey.key < UINT8_MAX) {
568 		while (1) {
569 			if (!utf8_decode(&state, &thiskey.cp, (uint8_t)thiskey.key))
570 				break;
571 			if ((thiskey.key = wgetch(body)) == ERR) {
572 				message("Error decoding user input");
573 				return 0;
574 			}
575 		}
576 	}
577 
578 	return 1;
579 }
580 
581 static void
582 dispatch_stdio(int fd, short ev, void *d)
583 {
584 	struct keymap	*k;
585 	const char	*keyname;
586 	char		 tmp[5] = {0};
587 
588 	if (!readkey())
589 		return;
590 
591 	if (keybuf[0] != '\0')
592 		strlcat(keybuf, " ", sizeof(keybuf));
593 	if (thiskey.meta)
594 		strlcat(keybuf, "M-", sizeof(keybuf));
595 	if (thiskey.cp != 0) {
596 		utf8_encode(thiskey.cp, tmp);
597 		strlcat(keybuf, tmp, sizeof(keybuf));
598 	} else {
599 		if ((keyname = unkbd(thiskey.key)) != NULL)
600 			strlcat(keybuf, keyname, sizeof(keybuf));
601 		else {
602 			tmp[0] = thiskey.key;
603 			strlcat(keybuf, tmp, sizeof(keybuf));
604 		}
605 	}
606 
607 	TAILQ_FOREACH(k, &current_map->m, keymaps) {
608 		if (k->meta == thiskey.meta &&
609 		    k->key == thiskey.key) {
610 			if (k->fn == NULL)
611 				current_map = &k->map;
612 			else {
613 				current_map = base_map;
614 				strlcpy(keybuf, "", sizeof(keybuf));
615 				k->fn(current_buffer());
616 			}
617 			goto done;
618 		}
619 	}
620 
621 	if (current_map->unhandled_input != NULL)
622 		current_map->unhandled_input();
623 	else
624 		global_key_unbound();
625 
626 	strlcpy(keybuf, "", sizeof(keybuf));
627 	current_map = base_map;
628 
629 done:
630 	if (side_window)
631 		recompute_help();
632 
633 	redraw_tab(current_tab());
634 }
635 
636 static void
637 handle_clear_minibuf(int fd, short ev, void *d)
638 {
639 	free(ministate.curmesg);
640 	ministate.curmesg = NULL;
641 
642 	redraw_minibuffer();
643 	if (in_minibuffer) {
644 		wrefresh(body);
645 		wrefresh(minibuf);
646 	} else {
647 		wrefresh(minibuf);
648 		wrefresh(body);
649 	}
650 }
651 
652 static void
653 handle_resize(int sig, short ev, void *d)
654 {
655 	if (event_pending(&resizeev, EV_TIMEOUT, NULL)) {
656 		event_del(&resizeev);
657 	}
658 	evtimer_set(&resizeev, handle_resize_nodelay, NULL);
659 	evtimer_add(&resizeev, &resize_timer);
660 }
661 
662 static void
663 handle_resize_nodelay(int s, short ev, void *d)
664 {
665 	struct tab	*tab;
666 
667 	endwin();
668 	refresh();
669 	clear();
670 
671 	/* move and resize the windows, in reverse order! */
672 
673 	mvwin(minibuf, LINES-1, 0);
674 	wresize(minibuf, 1, COLS);
675 
676 	mvwin(modeline, LINES-2, 0);
677 	wresize(modeline, 1, COLS);
678 
679 	body_lines = LINES-3;
680 	body_cols = COLS;
681 
682 	if (side_window) {
683 		help_cols = 0.3 * COLS;
684 		help_lines = LINES-3;
685 		mvwin(help, 1, 0);
686 		wresize(help, help_lines, help_cols);
687 
688 		wrap_page(&helpwin, help_cols);
689 
690 		body_cols = COLS - help_cols - 1;
691 		mvwin(body, 1, help_cols);
692 	} else
693 		mvwin(body, 1, 0);
694 
695 	update_x_offset();
696 	wresize(body, body_lines, body_cols);
697 
698 	wresize(tabline, 1, COLS);
699 
700 	tab = current_tab();
701 
702 	wrap_page(&tab->buffer, body_cols);
703 	redraw_tab(tab);
704 }
705 
706 static int
707 wrap_page(struct buffer *buffer, int width)
708 {
709 	struct line		*l;
710 	const struct line	*orig;
711 	struct vline		*vl;
712 	int			 pre_width;
713 	const char		*prfx;
714 
715 	orig = buffer->current_line == NULL
716 		? NULL
717 		: buffer->current_line->parent;
718 	buffer->current_line = NULL;
719 
720 	buffer->force_redraw = 1;
721 	buffer->curs_y = 0;
722 	buffer->line_off = 0;
723 
724 	empty_vlist(buffer);
725 
726 	TAILQ_FOREACH(l, &buffer->page.head, lines) {
727 		prfx = line_prefixes[l->type].prfx1;
728 		switch (l->type) {
729 		case LINE_TEXT:
730 		case LINE_LINK:
731 		case LINE_TITLE_1:
732 		case LINE_TITLE_2:
733 		case LINE_TITLE_3:
734 		case LINE_ITEM:
735 		case LINE_QUOTE:
736 		case LINE_PRE_START:
737 		case LINE_PRE_END:
738 			wrap_text(buffer, prfx, l, MIN(fill_column, width));
739 			break;
740 		case LINE_PRE_CONTENT:
741 			if (olivetti_mode)
742 				pre_width = MIN(fill_column, width);
743 			else
744 				pre_width = width;
745 			hardwrap_text(buffer, l, pre_width);
746 			break;
747 		}
748 
749 		if (orig == l && buffer->current_line == NULL) {
750 			buffer->line_off = buffer->line_max-1;
751 			buffer->current_line = TAILQ_LAST(&buffer->head, vhead);
752 
753 			while (1) {
754 				vl = TAILQ_PREV(buffer->current_line, vhead, vlines);
755 				if (vl == NULL || vl->parent != orig)
756 					break;
757 				buffer->current_line = vl;
758 				buffer->line_off--;
759 			}
760 		}
761 	}
762 
763         if (buffer->current_line == NULL)
764 		buffer->current_line = TAILQ_FIRST(&buffer->head);
765 
766 	return 1;
767 }
768 
769 static void
770 print_vline(int off, int width, WINDOW *window, struct vline *vl)
771 {
772 	const char *text;
773 	const char *prfx;
774 	struct line_face *f;
775 	int i, left, x, y;
776 
777 	f = &line_faces[vl->parent->type];
778 
779 	/* unused, set by getyx */
780 	(void)y;
781 
782 	if (!vl->flags)
783 		prfx = line_prefixes[vl->parent->type].prfx1;
784 	else
785 		prfx = line_prefixes[vl->parent->type].prfx2;
786 
787 	text = vl->line;
788 	if (text == NULL)
789 		text = "";
790 
791 	wattr_on(window, body_face.left, NULL);
792 	for (i = 0; i < off; i++)
793 		waddch(window, ' ');
794 	wattr_off(window, body_face.left, NULL);
795 
796 	wattr_on(window, f->prefix, NULL);
797 	wprintw(window, "%s", prfx);
798 	wattr_off(window, f->prefix, NULL);
799 
800 	wattr_on(window, f->text, NULL);
801 	wprintw(window, "%s", text);
802 	wattr_off(window, f->text, NULL);
803 
804 	getyx(window, y, x);
805 
806 	left = width - x;
807 
808 	wattr_on(window, f->trail, NULL);
809 	for (i = 0; i < left - off - 1; ++i)
810 		waddch(window, ' ');
811 	wattr_off(window, f->trail, NULL);
812 
813 	wattr_on(window, body_face.right, NULL);
814 	for (i = 0; i < off; i++)
815 		waddch(window, ' ');
816 	wattr_off(window, body_face.right, NULL);
817 
818 }
819 
820 static void
821 redraw_tabline(void)
822 {
823 	struct tab	*tab;
824 	size_t		 toskip, ots, tabwidth, space, x;
825 	int		 current, y, truncated;
826 	const char	*title;
827 	char		 buf[25];
828 
829 	x = 0;
830 
831 	/* unused, but setted by a getyx */
832 	(void)y;
833 
834 	tabwidth = sizeof(buf)+1;
835 	space = COLS-2;
836 
837 	toskip = 0;
838 	TAILQ_FOREACH(tab, &tabshead, tabs) {
839 		toskip++;
840 		if (tab->flags & TAB_CURRENT)
841 			break;
842 	}
843 
844 	if (toskip * tabwidth < space)
845 		toskip = 0;
846 	else {
847 		ots = toskip;
848 		toskip--;
849                 while (toskip != 0 &&
850 		    (ots - toskip+1) * tabwidth < space)
851 			toskip--;
852 	}
853 
854 	werase(tabline);
855 	wattr_on(tabline, tab_face.background, NULL);
856 	wprintw(tabline, toskip == 0 ? " " : "<");
857 	wattr_off(tabline, tab_face.background, NULL);
858 
859 	truncated = 0;
860 	TAILQ_FOREACH(tab, &tabshead, tabs) {
861 		if (truncated)
862 			break;
863 		if (toskip != 0) {
864 			toskip--;
865 			continue;
866 		}
867 
868 		getyx(tabline, y, x);
869 		if (x + sizeof(buf)+2 >= (size_t)COLS)
870 			truncated = 1;
871 
872 		current = tab->flags & TAB_CURRENT;
873 
874 		if (*(title = tab->buffer.page.title) == '\0')
875 			title = tab->hist_cur->h;
876 
877 		if (tab->flags & TAB_URGENT)
878 			strlcpy(buf, "!", sizeof(buf));
879 		else
880 			strlcpy(buf, " ", sizeof(buf));
881 
882                 if (strlcat(buf, title, sizeof(buf)) >= sizeof(buf)) {
883 			/* truncation happens */
884 			strlcpy(&buf[sizeof(buf)-4], "...", 4);
885 		} else {
886 			/* pad with spaces */
887 			while (strlcat(buf, "    ", sizeof(buf)) < sizeof(buf))
888 				/* nop */ ;
889 		}
890 
891 		if (current)
892 			wattr_on(tabline, tab_face.current, NULL);
893 		else
894 			wattr_on(tabline, tab_face.tab, NULL);
895 
896 		wprintw(tabline, "%s", buf);
897 		if (TAILQ_NEXT(tab, tabs) != NULL)
898 			wprintw(tabline, " ");
899 
900 		if (current)
901 			wattr_off(tabline, tab_face.current, NULL);
902 		else
903 			wattr_off(tabline, tab_face.tab, NULL);
904 	}
905 
906 	wattr_on(tabline, tab_face.background, NULL);
907 	for (; x < (size_t)COLS; ++x)
908 		waddch(tabline, ' ');
909 	if (truncated)
910 		mvwprintw(tabline, 0, COLS-1, ">");
911 	wattr_off(tabline, tab_face.background, NULL);
912 }
913 
914 static void
915 redraw_window(WINDOW *win, int height, int width, struct buffer *buffer)
916 {
917 	struct vline	*vl;
918 	int		 l;
919 
920 	/*
921 	 * Don't bother redraw the body if nothing changed.  Cursor
922 	 * movements count as "nothing changed" if it hasn't produced
923 	 * a scroll.  Ensure that wmove is called though!
924 	 */
925 	if (!buffer->force_redraw &&
926 	    buffer->last_line_off == buffer->line_off)
927 		goto end;
928 
929 	werase(win);
930 
931 	buffer->line_off = MIN(buffer->line_max-1, buffer->line_off);
932 	buffer->force_redraw = 0;
933 	buffer->last_line_off = buffer->line_off;
934 
935 	if (TAILQ_EMPTY(&buffer->head))
936 		goto end;
937 
938 	l = 0;
939 	vl = nth_line(buffer, buffer->line_off);
940 	for (; vl != NULL; vl = TAILQ_NEXT(vl, vlines)) {
941 		wmove(win, l, 0);
942 		print_vline(x_offset, width, win, vl);
943 		l++;
944 		if (l == height)
945 			break;
946 	}
947 
948 end:
949 	wmove(win, buffer->curs_y, buffer->curs_x);
950 }
951 
952 static void
953 redraw_help(void)
954 {
955 	redraw_window(help, help_lines, help_cols, &helpwin);
956 }
957 
958 static void
959 redraw_body(struct tab *tab)
960 {
961 	static struct tab *last_tab;
962 
963 	if (last_tab != tab)
964 		tab->buffer.force_redraw =1;
965 	last_tab = tab;
966 
967 	redraw_window(body, body_lines, body_cols, &tab->buffer);
968 }
969 
970 static inline char
971 trust_status_char(enum trust_state ts)
972 {
973 	switch (ts) {
974 	case TS_UNKNOWN:	return 'u';
975 	case TS_UNTRUSTED:	return '!';
976 	case TS_TRUSTED:	return 'v';
977 	case TS_VERIFIED:	return 'V';
978 	default:		return 'X';
979 	}
980 }
981 
982 static void
983 redraw_modeline(struct tab *tab)
984 {
985 	double		 pct;
986 	int		 x, y, max_x, max_y;
987 	const char	*mode = tab->buffer.page.name;
988 	const char	*spin = "-\\|/";
989 
990 	werase(modeline);
991 	wattr_on(modeline, modeline_face.background, NULL);
992 	wmove(modeline, 0, 0);
993 
994 	wprintw(modeline, "-%c%c %s ",
995 	    spin[tab->loading_anim_step],
996 	    trust_status_char(tab->trust),
997 	    mode == NULL ? "(none)" : mode);
998 
999 	pct = (tab->buffer.line_off + tab->buffer.curs_y) * 100.0 / tab->buffer.line_max;
1000 
1001 	if (tab->buffer.line_max <= (size_t)body_lines)
1002                 wprintw(modeline, "All ");
1003 	else if (tab->buffer.line_off == 0)
1004                 wprintw(modeline, "Top ");
1005 	else if (tab->buffer.line_off + body_lines >= tab->buffer.line_max)
1006 		wprintw(modeline, "Bottom ");
1007 	else
1008 		wprintw(modeline, "%.0f%% ", pct);
1009 
1010 	wprintw(modeline, "%d/%d %s ",
1011 	    tab->buffer.line_off + tab->buffer.curs_y,
1012 	    tab->buffer.line_max,
1013 	    tab->hist_cur->h);
1014 
1015 	getyx(modeline, y, x);
1016 	getmaxyx(modeline, max_y, max_x);
1017 
1018 	(void)y;
1019 	(void)max_y;
1020 
1021 	for (; x < max_x; ++x)
1022 		waddstr(modeline, "-");
1023 
1024 	wattr_off(modeline, modeline_face.background, NULL);
1025 }
1026 
1027 static void
1028 redraw_minibuffer(void)
1029 {
1030 	struct tab *tab;
1031 	size_t off_y, off_x = 0;
1032 	char *start = NULL, *c = NULL;
1033 
1034 	/* unused, but set by getyx */
1035 	(void)off_y;
1036 
1037 	wattr_on(minibuf, minibuffer_face.background, NULL);
1038 	werase(minibuf);
1039 
1040 	if (in_minibuffer) {
1041 		mvwprintw(minibuf, 0, 0, "%s", ministate.prompt);
1042 		if (ministate.hist_cur != NULL)
1043 			wprintw(minibuf, "(%zu/%zu) ",
1044 			    ministate.hist_off + 1,
1045 			    ministate.history->len);
1046 
1047 		getyx(minibuf, off_y, off_x);
1048 
1049 		start = ministate.hist_cur != NULL
1050 			? ministate.hist_cur->h
1051 			: ministate.buf;
1052 		c = utf8_nth(ministate.buffer.current_line->line,
1053 		    ministate.buffer.cpoff);
1054 		while (utf8_swidth_between(start, c) > (size_t)COLS/2) {
1055 			start = utf8_next_cp(start);
1056 		}
1057 
1058 		waddstr(minibuf, start);
1059 	}
1060 
1061 	if (ministate.curmesg != NULL)
1062                 wprintw(minibuf, in_minibuffer ? "  [%s]" : "%s",
1063 		    ministate.curmesg);
1064 
1065 	if (!in_minibuffer && ministate.curmesg == NULL)
1066 		waddstr(minibuf, keybuf);
1067 
1068 	/* If nothing else, show the URL at point */
1069 	if (!in_minibuffer && ministate.curmesg == NULL && *keybuf == '\0') {
1070 		tab = current_tab();
1071 		if (tab->buffer.current_line != NULL &&
1072 		    tab->buffer.current_line->parent->type == LINE_LINK)
1073 			waddstr(minibuf, tab->buffer.current_line->parent->alt);
1074 	}
1075 
1076 	if (in_minibuffer)
1077 		wmove(minibuf, 0, off_x + utf8_swidth_between(start, c));
1078 
1079 	wattr_off(minibuf, minibuffer_face.background, NULL);
1080 }
1081 
1082 static void
1083 redraw_tab(struct tab *tab)
1084 {
1085 	if (side_window) {
1086 		redraw_help();
1087 		wnoutrefresh(help);
1088 	}
1089 
1090 	restore_cursor(&tab->buffer);
1091 
1092 	redraw_tabline();
1093 	redraw_body(tab);
1094 	redraw_modeline(tab);
1095 	redraw_minibuffer();
1096 
1097 	wnoutrefresh(tabline);
1098 	wnoutrefresh(modeline);
1099 
1100 	if (in_minibuffer) {
1101 		wnoutrefresh(body);
1102 		wnoutrefresh(minibuf);
1103 	} else {
1104 		wnoutrefresh(minibuf);
1105 		wnoutrefresh(body);
1106 	}
1107 
1108 	doupdate();
1109 }
1110 
1111 static void
1112 emit_help_item(char *prfx, void *fn)
1113 {
1114 	struct line	*l;
1115 	struct cmds	*cmd;
1116 
1117 	for (cmd = cmds; cmd->cmd != NULL; ++cmd) {
1118 		if (fn == cmd->fn)
1119 			break;
1120 	}
1121 	assert(cmd != NULL);
1122 
1123 	if ((l = calloc(1, sizeof(*l))) == NULL)
1124 		abort();
1125 
1126 	l->type = LINE_TEXT;
1127 	l->alt = NULL;
1128 
1129 	asprintf(&l->line, "%s %s", prfx, cmd->cmd);
1130 
1131 	if (TAILQ_EMPTY(&helpwin.page.head))
1132 		TAILQ_INSERT_HEAD(&helpwin.page.head, l, lines);
1133 	else
1134 		TAILQ_INSERT_TAIL(&helpwin.page.head, l, lines);
1135 }
1136 
1137 static void
1138 rec_compute_help(struct kmap *keymap, char *prfx, size_t len)
1139 {
1140 	struct keymap	*k;
1141 	char		 p[32];
1142 	const char	*kn;
1143 
1144 	TAILQ_FOREACH(k, &keymap->m, keymaps) {
1145 		strlcpy(p, prfx, sizeof(p));
1146 		if (*p != '\0')
1147 			strlcat(p, " ", sizeof(p));
1148 		if (k->meta)
1149 			strlcat(p, "M-", sizeof(p));
1150 		if ((kn = unkbd(k->key)) != NULL)
1151 			strlcat(p, kn, sizeof(p));
1152 		else
1153 			strlcat(p, keyname(k->key), sizeof(p));
1154 
1155 		if (k->fn == NULL)
1156 			rec_compute_help(&k->map, p, sizeof(p));
1157 		else
1158 			emit_help_item(p, k->fn);
1159 	}
1160 }
1161 
1162 static void
1163 recompute_help(void)
1164 {
1165 	char	p[32] = { 0 };
1166 
1167 	empty_vlist(&helpwin);
1168 	empty_linelist(&helpwin);
1169 	rec_compute_help(current_map, p, sizeof(p));
1170 	wrap_page(&helpwin, help_cols);
1171 }
1172 
1173 void
1174 vmessage(const char *fmt, va_list ap)
1175 {
1176 	if (evtimer_pending(&clminibufev, NULL))
1177 		evtimer_del(&clminibufev);
1178 
1179 	free(ministate.curmesg);
1180 	ministate.curmesg = NULL;
1181 
1182 	if (fmt != NULL) {
1183 		evtimer_set(&clminibufev, handle_clear_minibuf, NULL);
1184 		evtimer_add(&clminibufev, &clminibufev_timer);
1185 
1186 		/* TODO: what to do if the allocation fails here? */
1187 		if (vasprintf(&ministate.curmesg, fmt, ap) == -1)
1188 			ministate.curmesg = NULL;
1189 	}
1190 
1191 	redraw_minibuffer();
1192 	if (in_minibuffer) {
1193 		wrefresh(body);
1194 		wrefresh(minibuf);
1195 	} else {
1196 		wrefresh(minibuf);
1197 		wrefresh(body);
1198 	}
1199 }
1200 
1201 void
1202 message(const char *fmt, ...)
1203 {
1204 	va_list ap;
1205 
1206 	va_start(ap, fmt);
1207 	vmessage(fmt, ap);
1208 	va_end(ap);
1209 }
1210 
1211 void
1212 start_loading_anim(struct tab *tab)
1213 {
1214 	if (tab->loading_anim)
1215 		return;
1216 	tab->loading_anim = 1;
1217 	evtimer_set(&tab->loadingev, update_loading_anim, tab);
1218 	evtimer_add(&tab->loadingev, &loadingev_timer);
1219 }
1220 
1221 static void
1222 update_loading_anim(int fd, short ev, void *d)
1223 {
1224 	struct tab	*tab = d;
1225 
1226 	tab->loading_anim_step = (tab->loading_anim_step+1)%4;
1227 
1228 	if (tab->flags & TAB_CURRENT) {
1229 		redraw_modeline(tab);
1230 		wrefresh(modeline);
1231 		wrefresh(body);
1232 		if (in_minibuffer)
1233 			wrefresh(minibuf);
1234 	}
1235 
1236 	evtimer_add(&tab->loadingev, &loadingev_timer);
1237 }
1238 
1239 static void
1240 stop_loading_anim(struct tab *tab)
1241 {
1242 	if (!tab->loading_anim)
1243 		return;
1244 	evtimer_del(&tab->loadingev);
1245 	tab->loading_anim = 0;
1246 	tab->loading_anim_step = 0;
1247 
1248 	if (!(tab->flags & TAB_CURRENT))
1249 		return;
1250 
1251 	redraw_modeline(tab);
1252 
1253 	wrefresh(modeline);
1254 	wrefresh(body);
1255 	if (in_minibuffer)
1256 		wrefresh(minibuf);
1257 }
1258 
1259 void
1260 load_url_in_tab(struct tab *tab, const char *url)
1261 {
1262 	message("Loading %s...", url);
1263 	start_loading_anim(tab);
1264 	load_url(tab, url);
1265 
1266 	tab->buffer.curs_x = 0;
1267 	tab->buffer.curs_y = 0;
1268 	redraw_tab(tab);
1269 }
1270 
1271 void
1272 enter_minibuffer(void (*self_insert_fn)(void), void (*donefn)(void),
1273     void (*abortfn)(void), struct histhead *hist)
1274 {
1275 	in_minibuffer = 1;
1276 	base_map = &minibuffer_map;
1277 	current_map = &minibuffer_map;
1278 
1279 	base_map->unhandled_input = self_insert_fn;
1280 
1281 	ministate.donefn = donefn;
1282 	ministate.abortfn = abortfn;
1283 	memset(ministate.buf, 0, sizeof(ministate.buf));
1284 	ministate.buffer.current_line = &ministate.vline;
1285 	ministate.buffer.current_line->line = ministate.buf;
1286 	ministate.buffer.cpoff = 0;
1287 	strlcpy(ministate.buf, "", sizeof(ministate.prompt));
1288 
1289 	ministate.history = hist;
1290 	ministate.hist_cur = NULL;
1291 	ministate.hist_off = 0;
1292 }
1293 
1294 void
1295 exit_minibuffer(void)
1296 {
1297 	werase(minibuf);
1298 
1299 	in_minibuffer = 0;
1300 	base_map = &global_map;
1301 	current_map = &global_map;
1302 }
1303 
1304 void
1305 switch_to_tab(struct tab *tab)
1306 {
1307 	struct tab	*t;
1308 
1309 	TAILQ_FOREACH(t, &tabshead, tabs) {
1310 		t->flags &= ~TAB_CURRENT;
1311 	}
1312 
1313 	tab->flags |= TAB_CURRENT;
1314 	tab->flags &= ~TAB_URGENT;
1315 }
1316 
1317 unsigned int
1318 tab_new_id(void)
1319 {
1320 	return tab_counter++;
1321 }
1322 
1323 struct tab *
1324 new_tab(const char *url)
1325 {
1326 	struct tab	*tab;
1327 
1328 	if ((tab = calloc(1, sizeof(*tab))) == NULL) {
1329 		event_loopbreak();
1330 		return NULL;
1331 	}
1332 	tab->fd = -1;
1333 
1334 	TAILQ_INIT(&tab->hist.head);
1335 
1336 	TAILQ_INIT(&tab->buffer.head);
1337 
1338 	tab->id = tab_new_id();
1339 	switch_to_tab(tab);
1340 
1341 	if (TAILQ_EMPTY(&tabshead))
1342 		TAILQ_INSERT_HEAD(&tabshead, tab, tabs);
1343 	else
1344 		TAILQ_INSERT_TAIL(&tabshead, tab, tabs);
1345 
1346 	load_url_in_tab(tab, url);
1347 	return tab;
1348 }
1349 
1350 static void
1351 session_new_tab_cb(const char *url)
1352 {
1353 	new_tab(url);
1354 }
1355 
1356 static void
1357 usage(void)
1358 {
1359 	fprintf(stderr, "USAGE: %s [-hn] [-c config] [url]\n", getprogname());
1360 	fprintf(stderr, "version: " PACKAGE " " VERSION "\n");
1361 }
1362 
1363 int
1364 ui_init(int argc, char * const *argv)
1365 {
1366 	char path[PATH_MAX];
1367 	const char *url = NEW_TAB_URL;
1368 	int ch, configtest = 0, fonf = 0;
1369 
1370 	if (getenv("NO_COLOR") != NULL)
1371 		enable_colors = 0;
1372 
1373 	strlcpy(path, getenv("HOME"), sizeof(path));
1374 	strlcat(path, "/.telescope/config", sizeof(path));
1375 
1376 	while ((ch = getopt(argc, argv, "c:hn")) != -1) {
1377 		switch (ch) {
1378 		case 'c':
1379 			fonf = 1;
1380 			strlcpy(path, optarg, sizeof(path));
1381 			break;
1382 		case 'n':
1383 			configtest = 1;
1384 			break;
1385 		case 'h':
1386 			usage();
1387 			return 0;
1388 		default:
1389 			usage();
1390 			return 1;
1391 		}
1392 	}
1393 	argc -= optind;
1394 	argv += optind;
1395 
1396 	config_init();
1397 	parseconfig(path, fonf);
1398 	if (configtest){
1399 		puts("config OK");
1400 		exit(0);
1401 	}
1402 
1403 	if (argc != 0)
1404 		url = argv[0];
1405 
1406 	setlocale(LC_ALL, "");
1407 
1408 	TAILQ_INIT(&global_map.m);
1409 	global_map.unhandled_input = global_key_unbound;
1410 
1411 	TAILQ_INIT(&minibuffer_map.m);
1412 
1413 	TAILQ_INIT(&eecmd_history.head);
1414 	TAILQ_INIT(&ir_history.head);
1415 	TAILQ_INIT(&lu_history.head);
1416 
1417 	ministate.line.type = LINE_TEXT;
1418 	ministate.vline.parent = &ministate.line;
1419 	ministate.buffer.current_line = &ministate.vline;
1420 
1421 	/* initialize help window */
1422 	TAILQ_INIT(&helpwin.head);
1423 
1424 	base_map = &global_map;
1425 	current_map = &global_map;
1426 	load_default_keys();
1427 
1428 	initscr();
1429 
1430 	if (enable_colors) {
1431 		if (has_colors()) {
1432 			start_color();
1433 			use_default_colors();
1434 		} else
1435 			enable_colors = 0;
1436 	}
1437 
1438 	config_apply_style();
1439 
1440 	raw();
1441 	noecho();
1442 	nonl();
1443 	intrflush(stdscr, FALSE);
1444 
1445 	if ((tabline = newwin(1, COLS, 0, 0)) == NULL)
1446 		return 0;
1447 	if ((body = newwin(LINES - 3, COLS, 1, 0)) == NULL)
1448 		return 0;
1449 	if ((modeline = newwin(1, COLS, LINES-2, 0)) == NULL)
1450 		return 0;
1451 	if ((minibuf = newwin(1, COLS, LINES-1, 0)) == NULL)
1452 		return 0;
1453 	if ((help = newwin(1, 1, 1, 0)) == NULL)
1454 		return 0;
1455 
1456 	body_lines = LINES-3;
1457 	body_cols = COLS;
1458 
1459 	wbkgd(body, body_face.body);
1460 
1461 	update_x_offset();
1462 
1463 	keypad(body, TRUE);
1464 	scrollok(body, FALSE);
1465 
1466 	/* non-blocking input */
1467 	wtimeout(body, 0);
1468 
1469 	mvwprintw(body, 0, 0, "");
1470 
1471 	event_set(&stdioev, 0, EV_READ | EV_PERSIST, dispatch_stdio, NULL);
1472 	event_add(&stdioev, NULL);
1473 
1474 	signal_set(&winchev, SIGWINCH, handle_resize, NULL);
1475 	signal_add(&winchev, NULL);
1476 
1477 	load_last_session(session_new_tab_cb);
1478 	if (strcmp(url, NEW_TAB_URL) || TAILQ_EMPTY(&tabshead))
1479 		new_tab(url);
1480 
1481 	return 1;
1482 }
1483 
1484 void
1485 ui_on_tab_loaded(struct tab *tab)
1486 {
1487 	stop_loading_anim(tab);
1488 	message("Loaded %s", tab->hist_cur->h);
1489 
1490 	redraw_tabline();
1491 	wrefresh(tabline);
1492 	if (in_minibuffer)
1493 		wrefresh(minibuf);
1494 	else
1495 		wrefresh(body);
1496 }
1497 
1498 void
1499 ui_on_tab_refresh(struct tab *tab)
1500 {
1501 	wrap_page(&tab->buffer, body_cols);
1502 	if (tab->flags & TAB_CURRENT) {
1503 		restore_cursor(&tab->buffer);
1504 		redraw_tab(tab);
1505 	} else
1506 		tab->flags |= TAB_URGENT;
1507 }
1508 
1509 const char *
1510 ui_keyname(int k)
1511 {
1512 	return keyname(k);
1513 }
1514 
1515 void
1516 ui_toggle_side_window(void)
1517 {
1518 	side_window = !side_window;
1519 	if (side_window)
1520 		recompute_help();
1521 
1522 	/*
1523 	 * ugly hack, but otherwise the window doesn't get updated
1524 	 * until I call handle_resize a second time (i.e. C-l).  I
1525 	 * will be happy to know why something like this is needed.
1526 	 */
1527 	handle_resize_nodelay(0, 0, NULL);
1528 	handle_resize_nodelay(0, 0, NULL);
1529 }
1530 
1531 void
1532 ui_schedule_redraw(void)
1533 {
1534 	handle_resize_nodelay(0, 0, NULL);
1535 }
1536 
1537 void
1538 ui_require_input(struct tab *tab, int hide)
1539 {
1540 	/* TODO: hard-switching to another tab is ugly */
1541 	switch_to_tab(tab);
1542 
1543 	enter_minibuffer(ir_self_insert, ir_select, exit_minibuffer,
1544 	    &ir_history);
1545 	strlcpy(ministate.prompt, "Input required: ",
1546 	    sizeof(ministate.prompt));
1547 	redraw_tab(tab);
1548 }
1549 
1550 void
1551 ui_yornp(const char *prompt, void (*fn)(int, unsigned int),
1552     unsigned int data)
1553 {
1554 	size_t len;
1555 
1556 	if (in_minibuffer) {
1557 		fn(0, data);
1558 		return;
1559 	}
1560 
1561 	yornp_cb = fn;
1562 	yornp_data = data;
1563 	enter_minibuffer(yornp_self_insert, yornp_self_insert,
1564 	    yornp_abort, NULL);
1565 
1566 	len = sizeof(ministate.prompt);
1567 	strlcpy(ministate.prompt, prompt, len);
1568 	strlcat(ministate.prompt, " (y or n) ", len);
1569 	redraw_tab(current_tab());
1570 }
1571 
1572 void
1573 ui_read(const char *prompt, void (*fn)(const char*, unsigned int),
1574     unsigned int data)
1575 {
1576 	size_t len;
1577 
1578 	if (in_minibuffer)
1579 		return;
1580 
1581 	read_cb = fn;
1582 	read_data = data;
1583 	enter_minibuffer(read_self_insert, read_select, read_abort,
1584 	    &read_history);
1585 
1586 	len = sizeof(ministate.prompt);
1587 	strlcpy(ministate.prompt, prompt, len);
1588 	strlcat(ministate.prompt, ": ", len);
1589 	redraw_tab(current_tab());
1590 }
1591 
1592 void
1593 ui_end(void)
1594 {
1595 	endwin();
1596 }