op public repos

Blob

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