op public repos

Blob

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