op public repos

Blob

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