op public repos

Blob

Date:: Thu Jan 6 09:18:00 2022 UTC
Message:: append killed tabs when parsing session to preserve the order The other option, less intrusive, would be to send the killed tabs in reverse order, but it'd seems strange when looking at the session file otherwise. So, add a `append' flag to kill_tab to optionally append the killed tab instead of pre-pending it.
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 #include "compat.h"
18 
19 #include <limits.h>
20 #include <stdlib.h>
21 #include <string.h>
22 
23 #include "compl.h"
24 #include "defaults.h"
25 #include "minibuffer.h"
26 #include "session.h"
27 #include "telescope.h"
28 #include "ui.h"
29 #include "utf8.h"
30 
31 #define GUARD_RECURSIVE_MINIBUFFER()				\
32 	do {							\
33 		if (in_minibuffer) {				\
34 			message("enable-recursive-minibuffers " \
35 			    "is not yet available.");		\
36 			return;					\
37 		}						\
38 	} while(0)
39 
40 #define GUARD_READ_ONLY()				\
41 	do {						\
42 		if (!in_minibuffer) {			\
43 			message("text is read-only");	\
44 			return;				\
45 		}					\
46 	} while(0)
47 
48 /* return 1 if moved, 0 otherwise */
49 static inline int
50 forward_line(struct buffer *buffer, int n)
51 {
52 	struct vline *vl;
53 	int did;
54 
55 	if (buffer->current_line == NULL)
56 		return 0;
57 	vl = buffer->current_line;
58 
59 	did = 0;
60 	while (n != 0) {
61 		if (n > 0) {
62 			vl = TAILQ_NEXT(vl, vlines);
63 			if (vl == NULL)
64 				return did;
65 			if (vl->parent->flags & L_HIDDEN)
66 				continue;
67 			buffer->current_line = vl;
68 			n--;
69 		} else {
70 			vl = TAILQ_PREV(vl, vhead, vlines);
71 			if (vl == NULL)
72 				return did;
73 			if (vl->parent->flags & L_HIDDEN)
74 				continue;
75 			if (buffer->current_line == buffer->top_line) {
76 				buffer->line_off--;
77 				buffer->top_line = vl;
78 			}
79 			buffer->current_line = vl;
80 			n++;
81 		}
82 
83 		did = 1;
84 	}
85 
86 	return did;
87 }
88 
89 void
90 cmd_previous_line(struct buffer *buffer)
91 {
92 	forward_line(buffer, -1);
93 }
94 
95 void
96 cmd_next_line(struct buffer *buffer)
97 {
98 	forward_line(buffer, +1);
99 }
100 
101 void
102 cmd_backward_char(struct buffer *buffer)
103 {
104 	if (buffer->cpoff != 0)
105 		buffer->cpoff--;
106 }
107 
108 void
109 cmd_forward_char(struct buffer *buffer)
110 {
111 	size_t len = 0;
112 
113 	if (buffer->current_line == NULL)
114 		return;
115 
116 	if (buffer->current_line->line != NULL)
117 		len = utf8_cplen(buffer->current_line->line);
118 	if (++buffer->cpoff > len)
119 		buffer->cpoff = len;
120 }
121 
122 void
123 cmd_backward_paragraph(struct buffer *buffer)
124 {
125 	do {
126 		if (!forward_line(buffer, -1)) {
127 			message("No previous paragraph");
128 			return;
129 		}
130 	} while (buffer->current_line->line != NULL ||
131 	    buffer->current_line->parent->type != LINE_TEXT);
132 }
133 
134 void
135 cmd_forward_paragraph(struct buffer *buffer)
136 {
137 	do {
138 		if (!forward_line(buffer, +1)) {
139 			message("No next paragraph");
140 			return;
141 		}
142 	} while (buffer->current_line->line != NULL ||
143 	    buffer->current_line->parent->type != LINE_TEXT);
144 }
145 
146 void
147 cmd_move_beginning_of_line(struct buffer *buffer)
148 {
149 	buffer->cpoff = 0;
150 }
151 
152 void
153 cmd_move_end_of_line(struct buffer *buffer)
154 {
155 	struct vline	*vl;
156 
157 	vl = buffer->current_line;
158 	if (vl == NULL || vl->line == NULL)
159 		return;
160 	buffer->cpoff = utf8_cplen(vl->line);
161 }
162 
163 void
164 cmd_redraw(struct buffer *buffer)
165 {
166 	ui_schedule_redraw();
167 }
168 
169 void
170 cmd_scroll_line_up(struct buffer *buffer)
171 {
172 	struct vline	*vl;
173 
174 	for (;;) {
175 		if (buffer->top_line == NULL)
176 			return;
177 
178 		if ((vl = TAILQ_PREV(buffer->top_line, vhead, vlines))
179 		    == NULL)
180 			return;
181 
182 		buffer->top_line = vl;
183 
184 		if (vl->parent->flags & L_HIDDEN)
185 			continue;
186 
187 		break;
188 	}
189 
190 	buffer->line_off--;
191 
192 	forward_line(buffer, -1);
193 }
194 
195 void
196 cmd_scroll_line_down(struct buffer *buffer)
197 {
198 	if (!forward_line(buffer, +1))
199 		return;
200 
201 	for (;;) {
202 		if (buffer->top_line == NULL)
203 			return;
204 
205 		buffer->top_line = TAILQ_NEXT(buffer->top_line, vlines);
206 		if (buffer->top_line->parent->flags & L_HIDDEN)
207 			continue;
208 		break;
209 	}
210 
211 	buffer->line_off++;
212 }
213 
214 void
215 cmd_scroll_up(struct buffer *buffer)
216 {
217 	struct vline	*vl;
218 	int		 i;
219 
220 	if (buffer->top_line == NULL)
221 		return;
222 
223 	for (i = 0; i < body_lines; ++i) {
224 		vl = TAILQ_PREV(buffer->top_line, vhead, vlines);
225 		if (vl == NULL)
226 			break;
227 		buffer->line_off--;
228 		buffer->top_line = vl;
229 		forward_line(buffer, -1);
230 	}
231 }
232 
233 void
234 cmd_scroll_down(struct buffer *buffer)
235 {
236 	int i;
237 
238 	if (buffer->top_line == NULL)
239 		return;
240 
241 	for (i = 0; i < body_lines; ++i) {
242 		if (!forward_line(buffer, +1))
243 			break;
244 
245 		buffer->top_line = TAILQ_NEXT(buffer->top_line,
246 		    vlines);
247 		buffer->line_off++;
248 	}
249 }
250 
251 void
252 cmd_beginning_of_buffer(struct buffer *buffer)
253 {
254 	buffer->current_line = TAILQ_FIRST(&buffer->head);
255 	buffer->cpoff = 0;
256 	buffer->top_line = buffer->current_line;
257 	buffer->line_off = 0;
258 }
259 
260 void
261 cmd_end_of_buffer(struct buffer *buffer)
262 {
263 	buffer->current_line = TAILQ_LAST(&buffer->head, vhead);
264 
265 	if (buffer->current_line == NULL)
266 		return;
267 
268 	/* deal with invisible lines */
269 	if (buffer->current_line->parent->flags & L_HIDDEN)
270 		forward_line(buffer, -1);
271 
272 	cmd_move_end_of_line(buffer);
273 }
274 
275 static void
276 kill_telescope_cb(int r, struct tab *tab)
277 {
278 	if (r) {
279 		save_session();
280 		event_loopbreak();
281 	}
282 }
283 
284 void
285 cmd_kill_telescope(struct buffer *buffer)
286 {
287 	yornp("really quit?", kill_telescope_cb, NULL);
288 }
289 
290 void
291 cmd_push_button(struct buffer *buffer)
292 {
293 	struct vline	*vl;
294 	struct line	*l;
295 
296 	vl = buffer->current_line;
297 
298 	if (vl == NULL)
299 		return;
300 
301 	switch (vl->parent->type) {
302 	case LINE_LINK:
303 		load_url_in_tab(current_tab, vl->parent->alt, NULL, 0);
304 		break;
305 	case LINE_PRE_START:
306 		l = TAILQ_NEXT(vl->parent, lines);
307 		for (; l != NULL; l = TAILQ_NEXT(l, lines)) {
308 			if (l->type == LINE_PRE_END)
309 				break;
310 			l->flags ^= L_HIDDEN;
311 			if (l->flags & L_HIDDEN)
312 				buffer->line_max--;
313 			else
314 				buffer->line_max++;
315 		}
316 		break;
317 	default:
318 		break;
319 	}
320 }
321 
322 void
323 cmd_push_button_new_tab(struct buffer *buffer)
324 {
325 	struct vline	*vl;
326 
327 	vl = buffer->current_line;
328 	if (vl == NULL || vl->parent->type != LINE_LINK)
329 		return;
330 
331 	new_tab(vl->parent->alt, current_tab->hist_cur->h, current_tab);
332 }
333 
334 void
335 cmd_previous_button(struct buffer *buffer)
336 {
337 	struct excursion place;
338 
339 	save_excursion(&place, buffer);
340 
341 	do {
342 		if (!forward_line(buffer, -1)) {
343 			restore_excursion(&place, buffer);
344 			message("No previous link");
345 			return;
346 		}
347 	} while (buffer->current_line->parent->type != LINE_LINK);
348 }
349 
350 void
351 cmd_next_button(struct buffer *buffer)
352 {
353 	struct excursion place;
354 
355 	save_excursion(&place, buffer);
356 
357 	do {
358 		if (!forward_line(buffer, +1)){
359 			restore_excursion(&place, buffer);
360 			message("No next link");
361 			return;
362 		}
363 	} while (buffer->current_line->parent->type != LINE_LINK);
364 }
365 
366 static inline int
367 is_heading(const struct line *l)
368 {
369 	return l->type == LINE_TITLE_1 ||
370 		l->type == LINE_TITLE_2 ||
371 		l->type == LINE_TITLE_3;
372 }
373 
374 void
375 cmd_previous_heading(struct buffer *buffer)
376 {
377 	struct excursion place;
378 
379 	save_excursion(&place, buffer);
380 
381 	do {
382 		if (!forward_line(buffer, -1)) {
383 			restore_excursion(&place, buffer);
384 			message("No previous heading");
385 			return;
386 		}
387 	} while (!is_heading(buffer->current_line->parent));
388 }
389 
390 void
391 cmd_next_heading(struct buffer *buffer)
392 {
393 	struct excursion place;
394 
395 	save_excursion(&place, buffer);
396 
397 	do {
398 		if (!forward_line(buffer, +1)) {
399 			restore_excursion(&place, buffer);
400 			message("No next heading");
401 			return;
402 		}
403 	} while (!is_heading(buffer->current_line->parent));
404 }
405 
406 void
407 cmd_previous_page(struct buffer *buffer)
408 {
409 	if (!load_previous_page(current_tab))
410 		message("No previous page");
411 	else
412 		start_loading_anim(current_tab);
413 }
414 
415 void
416 cmd_next_page(struct buffer *buffer)
417 {
418 	if (!load_next_page(current_tab))
419 		message("No next page");
420 	else
421 		start_loading_anim(current_tab);
422 }
423 
424 void
425 cmd_clear_minibuf(struct buffer *buffer)
426 {
427 	message(NULL);
428 }
429 
430 void
431 cmd_execute_extended_command(struct buffer *buffer)
432 {
433 	size_t	 len;
434 
435 	GUARD_RECURSIVE_MINIBUFFER();
436 
437 	enter_minibuffer(sensible_self_insert, eecmd_select, exit_minibuffer,
438 	    &eecmd_history, compl_eecmd, NULL);
439 
440 	len = sizeof(ministate.prompt);
441 	strlcpy(ministate.prompt, "", len);
442 
443 	if (thiskey.meta)
444 		strlcat(ministate.prompt, "M-", len);
445 
446 	strlcat(ministate.prompt, ui_keyname(thiskey.key), len);
447 
448 	if (thiskey.meta)
449 		strlcat(ministate.prompt, " ", len);
450 }
451 
452 void
453 cmd_tab_close(struct buffer *buffer)
454 {
455 	struct tab *tab, *t;
456 
457 	tab = current_tab;
458 
459 	if ((t = TAILQ_NEXT(tab, tabs)) != NULL ||
460 	    (t = TAILQ_PREV(tab, tabshead, tabs)) != NULL) {
461 		switch_to_tab(t);
462 		kill_tab(tab, 0);
463 	} else
464 		message("Can't close the only tab.");
465 
466 }
467 
468 void
469 cmd_tab_close_other(struct buffer *buffer)
470 {
471 	struct tab *t, *i;
472 
473 	TAILQ_FOREACH_SAFE(t, &tabshead, tabs, i) {
474 		if (t == current_tab)
475 			continue;
476 
477 		kill_tab(t, 0);
478 	}
479 }
480 
481 void
482 cmd_tab_undo_close(struct buffer *buffer)
483 {
484 	struct tab *t;
485 
486 	if ((t = unkill_tab()) == NULL) {
487 		message("No recently-closed tabs");
488 		return;
489 	}
490 
491 	switch_to_tab(t);
492 }
493 
494 void
495 cmd_tab_new(struct buffer *buffer)
496 {
497 	const char *url;
498 
499 	if ((url = new_tab_url) == NULL)
500 		url = NEW_TAB_URL;
501 
502 	new_tab(url, NULL, NULL);
503 }
504 
505 void
506 cmd_tab_next(struct buffer *buffer)
507 {
508 	struct tab *t;
509 
510 	if ((t = TAILQ_NEXT(current_tab, tabs)) == NULL)
511 		t = TAILQ_FIRST(&tabshead);
512 	switch_to_tab(t);
513 }
514 
515 void
516 cmd_tab_previous(struct buffer *buffer)
517 {
518 	struct tab *t;
519 
520 	if ((t = TAILQ_PREV(current_tab, tabshead, tabs)) == NULL)
521 		t = TAILQ_LAST(&tabshead, tabshead);
522 	switch_to_tab(t);
523 }
524 
525 void
526 cmd_tab_move(struct buffer *buffer)
527 {
528 	struct tab *t;
529 
530 	t = TAILQ_NEXT(current_tab, tabs);
531 	TAILQ_REMOVE(&tabshead, current_tab, tabs);
532 
533 	if (t == NULL)
534 		TAILQ_INSERT_HEAD(&tabshead, current_tab, tabs);
535 	else
536 		TAILQ_INSERT_AFTER(&tabshead, t, current_tab, tabs);
537 }
538 
539 void
540 cmd_tab_move_to(struct buffer *buffer)
541 {
542 	struct tab *t;
543 
544 	t = TAILQ_PREV(current_tab, tabshead, tabs);
545 	TAILQ_REMOVE(&tabshead, current_tab, tabs);
546 
547 	if (t == NULL)
548 		TAILQ_INSERT_TAIL(&tabshead, current_tab, tabs);
549 	else
550 		TAILQ_INSERT_BEFORE(t, current_tab, tabs);
551 }
552 
553 void
554 cmd_tab_select(struct buffer *buffer)
555 {
556 	GUARD_RECURSIVE_MINIBUFFER();
557 
558 	enter_minibuffer(sensible_self_insert, ts_select, exit_minibuffer,
559 	    NULL, compl_ts, NULL);
560 	strlcpy(ministate.prompt, "Select tab: ", sizeof(ministate.prompt));
561 }
562 
563 void
564 cmd_load_url(struct buffer *buffer)
565 {
566 	GUARD_RECURSIVE_MINIBUFFER();
567 
568 	enter_minibuffer(sensible_self_insert, lu_select, exit_minibuffer,
569 	    &lu_history, NULL, NULL);
570 	strlcpy(ministate.prompt, "Load URL: ", sizeof(ministate.prompt));
571 }
572 
573 void
574 cmd_load_current_url(struct buffer *buffer)
575 {
576 	GUARD_RECURSIVE_MINIBUFFER();
577 
578 	enter_minibuffer(sensible_self_insert, lu_select, exit_minibuffer,
579 	    &lu_history, NULL, NULL);
580 	strlcpy(ministate.prompt, "Load URL: ", sizeof(ministate.prompt));
581 	strlcpy(ministate.buf, current_tab->hist_cur->h, sizeof(ministate.buf));
582 	ministate.buffer.cpoff = utf8_cplen(ministate.buf);
583 }
584 
585 void
586 cmd_reload_page(struct buffer *buffer)
587 {
588 	load_url_in_tab(current_tab, current_tab->hist_cur->h, NULL, 1);
589 }
590 
591 void
592 cmd_bookmark_page(struct buffer *buffer)
593 {
594 	GUARD_RECURSIVE_MINIBUFFER();
595 
596 	enter_minibuffer(sensible_self_insert, bp_select, exit_minibuffer, NULL,
597 	    NULL, NULL);
598 	strlcpy(ministate.prompt, "Bookmark URL: ", sizeof(ministate.prompt));
599 	strlcpy(ministate.buf, current_tab->hist_cur->h, sizeof(ministate.buf));
600 	ministate.buffer.cpoff = utf8_cplen(ministate.buf);
601 }
602 
603 void
604 cmd_list_bookmarks(struct buffer *buffer)
605 {
606 	load_url_in_tab(current_tab, "about:bookmarks", NULL, 0);
607 }
608 
609 void
610 cmd_toggle_help(struct buffer *buffer)
611 {
612 	ui_toggle_side_window(SIDE_WINDOW_LEFT);
613 }
614 
615 void
616 cmd_link_select(struct buffer *buffer)
617 {
618 	struct line *l;
619 
620 	GUARD_RECURSIVE_MINIBUFFER();
621 
622 	l = TAILQ_FIRST(&buffer->page.head);
623 	while (l != NULL && l->type != LINE_LINK)
624 		l = TAILQ_NEXT(l, lines);
625 
626 	if (l == NULL) {
627 		message("No links found");
628 		return;
629 	}
630 
631 	enter_minibuffer(sensible_self_insert, ls_select, exit_minibuffer,
632 	    NULL, compl_ls, l);
633 	strlcpy(ministate.prompt, "Select link: ", sizeof(ministate.prompt));
634 }
635 
636 void
637 cmd_swiper(struct buffer *buffer)
638 {
639 	GUARD_RECURSIVE_MINIBUFFER();
640 
641 	enter_minibuffer(sensible_self_insert, swiper_select, exit_minibuffer,
642 	    NULL, compl_swiper, TAILQ_FIRST(&buffer->page.head));
643 	strlcpy(ministate.prompt, "Select line: ", sizeof(ministate.prompt));
644 }
645 
646 void
647 cmd_toc(struct buffer *buffer)
648 {
649 	struct line *l;
650 
651 	GUARD_RECURSIVE_MINIBUFFER();
652 
653 	l = TAILQ_FIRST(&buffer->page.head);
654 	while (l != NULL &&
655 	    l->type != LINE_TITLE_1 &&
656 	    l->type != LINE_TITLE_2 &&
657 	    l->type != LINE_TITLE_3)
658 		l = TAILQ_NEXT(l, lines);
659 
660 	if (l == NULL) {
661 		message("No headings found");
662 		return;
663 	}
664 
665 	enter_minibuffer(sensible_self_insert, toc_select, exit_minibuffer,
666 	    NULL, compl_toc, l);
667 	strlcpy(ministate.prompt, "Select heading: ",
668 	    sizeof(ministate.prompt));
669 }
670 
671 void
672 cmd_inc_fill_column(struct buffer *buffer)
673 {
674 	if (fill_column == INT_MAX)
675 		return;
676 
677 	fill_column += 2;
678 	message("fill-column: %d", fill_column);
679 
680 	ui_schedule_redraw();
681 }
682 
683 void
684 cmd_dec_fill_column(struct buffer *buffer)
685 {
686 	if (fill_column == INT_MAX || fill_column < 8)
687 		return;
688 
689 	fill_column -= 2;
690 	message("fill-column: %d", fill_column);
691 
692 	ui_schedule_redraw();
693 }
694 
695 void
696 cmd_olivetti_mode(struct buffer *buffer)
697 {
698 	olivetti_mode = !olivetti_mode;
699 	if (olivetti_mode)
700 		message("olivetti-mode enabled");
701 	else
702 		message("olivetti-mode disabled");
703 
704 	ui_schedule_redraw();
705 }
706 
707 void
708 cmd_mini_delete_char(struct buffer *buffer)
709 {
710 	char *c, *n;
711 
712 	GUARD_READ_ONLY();
713 
714 	minibuffer_taint_hist();
715 
716 	c = utf8_nth(buffer->current_line->line, buffer->cpoff);
717 	if (*c == '\0')
718 		return;
719 	n = utf8_next_cp(c);
720 
721 	memmove(c, n, strlen(n)+1);
722 
723 	recompute_completions(0);
724 }
725 
726 void
727 cmd_mini_delete_backward_char(struct buffer *buffer)
728 {
729 	char *c, *p, *start;
730 
731 	GUARD_READ_ONLY();
732 
733 	minibuffer_taint_hist();
734 
735 	c = utf8_nth(buffer->current_line->line, buffer->cpoff);
736 	start = buffer->current_line->line;
737 	if (c == start)
738 		return;
739 	p = utf8_prev_cp(c-1, start);
740 
741 	memmove(p, c, strlen(c)+1);
742 	buffer->cpoff--;
743 
744 	recompute_completions(0);
745 }
746 
747 void
748 cmd_mini_kill_line(struct buffer *buffer)
749 {
750 	char *c;
751 
752 	GUARD_READ_ONLY();
753 
754 	minibuffer_taint_hist();
755 	c = utf8_nth(buffer->current_line->line, buffer->cpoff);
756 	*c = '\0';
757 
758 	recompute_completions(0);
759 }
760 
761 void
762 cmd_mini_abort(struct buffer *buffer)
763 {
764 	if (!in_minibuffer)
765 		return;
766 
767 	ministate.abortfn();
768 }
769 
770 void
771 cmd_mini_complete_and_exit(struct buffer *buffer)
772 {
773 	if (!in_minibuffer)
774 		return;
775 
776 	minibuffer_taint_hist();
777 	ministate.donefn();
778 }
779 
780 void
781 cmd_mini_previous_history_element(struct buffer *buffer)
782 {
783 	if (ministate.history == NULL) {
784 		message("No history");
785 		return;
786 	}
787 
788 	if (ministate.hist_cur == NULL ||
789 	    (ministate.hist_cur = TAILQ_PREV(ministate.hist_cur, mhisthead, entries)) == NULL) {
790 		ministate.hist_cur = TAILQ_LAST(&ministate.history->head, mhisthead);
791 		ministate.hist_off = ministate.history->len - 1;
792 		if (ministate.hist_cur == NULL)
793 			message("No prev history item");
794 	} else {
795 		ministate.hist_off--;
796 	}
797 
798 	if (ministate.hist_cur != NULL)
799 		buffer->current_line->line = ministate.hist_cur->h;
800 }
801 
802 void
803 cmd_mini_next_history_element(struct buffer *buffer)
804 {
805 	if (ministate.history == NULL) {
806 		message("No history");
807 		return;
808 	}
809 
810 	if (ministate.hist_cur == NULL ||
811 	    (ministate.hist_cur = TAILQ_NEXT(ministate.hist_cur, entries)) == NULL) {
812 		ministate.hist_cur = TAILQ_FIRST(&ministate.history->head);
813 		ministate.hist_off = 0;
814 		if (ministate.hist_cur == NULL)
815 			message("No next history item");
816 	} else {
817 		ministate.hist_off++;
818 	}
819 
820 	if (ministate.hist_cur != NULL)
821 		buffer->current_line->line = ministate.hist_cur->h;
822 }
823 
824 void
825 cmd_previous_completion(struct buffer *buffer)
826 {
827 	if (in_minibuffer != MB_COMPREAD)
828 		return;
829 
830 	buffer = &ministate.compl.buffer;
831 
832 	if (buffer->current_line != NULL)
833 		buffer->current_line->parent->type = LINE_COMPL;
834 
835 	forward_line(buffer, -1);
836 
837 	if (buffer->current_line != NULL)
838 		buffer->current_line->parent->type = LINE_COMPL_CURRENT;
839 }
840 
841 void
842 cmd_next_completion(struct buffer *buffer)
843 {
844 	if (in_minibuffer != MB_COMPREAD)
845 		return;
846 
847 	buffer = &ministate.compl.buffer;
848 
849 	if (buffer->current_line != NULL)
850 		buffer->current_line->parent->type = LINE_COMPL;
851 
852 	forward_line(buffer, +1);
853 
854 	if (buffer->current_line != NULL)
855 		buffer->current_line->parent->type = LINE_COMPL_CURRENT;
856 }
857 
858 void
859 cmd_insert_current_candidate(struct buffer *buffer)
860 {
861 	if (in_minibuffer != MB_COMPREAD)
862 		return;
863 
864 	minibuffer_insert_current_candidate();
865 }
866 
867 void
868 cmd_suspend_telescope(struct buffer *buffer)
869 {
870 	message("Zzz...");
871 	ui_suspend();
872 }
873 
874 void
875 cmd_toggle_pre_wrap(struct buffer *buffer)
876 {
877 	dont_wrap_pre = !dont_wrap_pre;
878 
879 	if (dont_wrap_pre)
880 		message("Don't wrap preformatted blocks");
881 	else
882 		message("Wrap preformatted blocks");
883 
884 	ui_schedule_redraw();
885 }
886 
887 void
888 cmd_mini_goto_beginning(struct buffer *buffer)
889 {
890 	struct vline *vl;
891 
892 	if (!in_minibuffer)
893 		return;
894 
895 	buffer = &ministate.compl.buffer;
896 
897 	if ((vl = buffer->current_line) != NULL)
898 		vl->parent->type = LINE_COMPL;
899 
900 	vl = TAILQ_FIRST(&buffer->head);
901 	while (vl != NULL && vl->parent->flags & L_HIDDEN)
902 		vl = TAILQ_NEXT(vl, vlines);
903 
904 	if (vl == NULL)
905 		return;
906 
907 	vl->parent->type = LINE_COMPL_CURRENT;
908 	buffer->top_line = vl;
909 	buffer->current_line = vl;
910 }
911 
912 void
913 cmd_mini_goto_end(struct buffer *buffer)
914 {
915 	struct vline *vl;
916 
917 	if (!in_minibuffer)
918 		return;
919 
920 	buffer = &ministate.compl.buffer;
921 
922 	if ((vl = buffer->current_line) != NULL)
923 		vl->parent->type = LINE_COMPL;
924 
925 	vl = TAILQ_LAST(&buffer->head, vhead);
926 	while (vl != NULL && vl->parent->flags & L_HIDDEN)
927 		vl = TAILQ_PREV(vl, vhead, vlines);
928 
929 	if (vl == NULL)
930 		return;
931 
932 	vl->parent->type = LINE_COMPL_CURRENT;
933 	buffer->current_line = vl;
934 }
935 
936 void
937 cmd_other_window(struct buffer *buffer)
938 {
939 	ui_other_window();
940 }
941 
942 void
943 cmd_mini_scroll_up(struct buffer *buffer)
944 {
945 	if (!in_minibuffer)
946 		return;
947 
948 	buffer = &ministate.compl.buffer;
949 	if (buffer->current_line == NULL)
950 		return;
951 
952 	buffer->current_line->parent->type = LINE_COMPL;
953 	cmd_scroll_up(buffer);
954 	buffer->current_line->parent->type = LINE_COMPL_CURRENT;
955 }
956 
957 void
958 cmd_mini_scroll_down(struct buffer *buffer)
959 {
960 	if (!in_minibuffer)
961 		return;
962 
963 	buffer = &ministate.compl.buffer;
964 	if (buffer->current_line == NULL)
965 		return;
966 
967 	buffer->current_line->parent->type = LINE_COMPL;
968 	cmd_scroll_down(buffer);
969 	buffer->current_line->parent->type = LINE_COMPL_CURRENT;
970 }
971 
972 void
973 cmd_toggle_downloads(struct buffer *buffer)
974 {
975 	ui_toggle_side_window(SIDE_WINDOW_BOTTOM);
976 }