Telescope Browser

Blob

Date:: Tue Oct 22 19:08:52 2024 UTC
Message:: make forward_line() keep the same column We should probably instead introduce the concept of ``target column'' but for now this brings back the behaviour pre-point_offset introduction, even if it gets it wrong when tabulator characters are involved.
Actions:: History | Blame | Raw File
1 /*
2  * Copyright (c) 2021, 2024 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 <signal.h>
21 #include <stdlib.h>
22 #include <string.h>
23 #include <unistd.h>
24 
25 #include <grapheme.h>
26 
27 #include "certs.h"
28 #include "cmd.h"
29 #include "compl.h"
30 #include "defaults.h"
31 #include "ev.h"
32 #include "exec.h"
33 #include "hist.h"
34 #include "keymap.h"
35 #include "mcache.h"
36 #include "minibuffer.h"
37 #include "session.h"
38 #include "telescope.h"
39 #include "ui.h"
40 #include "utf8.h"
41 #include "utils.h"
42 
43 #define GUARD_RECURSIVE_MINIBUFFER()				\
44 	do {							\
45 		if (in_minibuffer) {				\
46 			message("enable-recursive-minibuffers " \
47 			    "is not yet available.");		\
48 			return;					\
49 		}						\
50 	} while(0)
51 
52 #define GUARD_READ_ONLY()				\
53 	do {						\
54 		if (!in_minibuffer) {			\
55 			message("text is read-only");	\
56 			return;				\
57 		}					\
58 	} while(0)
59 
60 /* return 1 if moved, 0 otherwise */
61 static inline int
62 forward_line(struct buffer *buffer, int n)
63 {
64 	struct vline *vl;
65 	char *text;
66 	size_t left, off;
67 	int did, target, col = 0; /* XXX breaks with tabs! */
68 
69 	if (buffer->current_line == NULL)
70 		return 0;
71 	vl = buffer->current_line;
72 
73 	text = vl->parent->line + vl->from;
74 	left = MIN(vl->len, buffer->point_offset);
75 	target = utf8_snwidth(text, left, 0); /* XXX breaks with tabs! */
76 
77 	did = 0;
78 	while (n != 0) {
79 		if (n > 0) {
80 			vl = TAILQ_NEXT(vl, vlines);
81 			if (vl == NULL)
82 				break;
83 			if (vl->parent->flags & L_HIDDEN)
84 				continue;
85 			buffer->current_line = vl;
86 			n--;
87 		} else {
88 			vl = TAILQ_PREV(vl, vhead, vlines);
89 			if (vl == NULL)
90 				break;
91 			if (vl->parent->flags & L_HIDDEN)
92 				continue;
93 			if (buffer->current_line == buffer->top_line) {
94 				buffer->line_off--;
95 				buffer->top_line = vl;
96 			}
97 			buffer->current_line = vl;
98 			n++;
99 		}
100 
101 		did = 1;
102 	}
103 
104 	/* keep the cursor in the same column */
105 	if (did) {
106 		vl = buffer->current_line;
107 		text = vl->parent->line + vl->from;
108 		left = vl->len;
109 		buffer->point_offset = 0;
110 		while (left > 0 && col < target) {
111 			off = grapheme_next_character_break_utf8(text, left);
112 			col += utf8_snwidth(text, off, col);
113 			text += off;
114 			left -= off;
115 			buffer->point_offset += off;
116 		}
117 	}
118 
119 	return did;
120 }
121 
122 void
123 cmd_previous_line(struct buffer *buffer)
124 {
125 	forward_line(buffer, -1);
126 }
127 
128 void
129 cmd_next_line(struct buffer *buffer)
130 {
131 	forward_line(buffer, +1);
132 }
133 
134 void
135 cmd_backward_char(struct buffer *buffer)
136 {
137 	struct vline	*vl;
138 	char		*text;
139 	size_t		 left, off, point = 0;
140 
141 	if ((vl = buffer->current_line) == NULL)
142 		return;
143 
144 	text = vl->parent->line + vl->from;
145 	left = vl->len;
146 
147 	for (;;) {
148 		off = grapheme_next_character_break_utf8(text, left);
149 		if (point + off >= buffer->point_offset)
150 			break;
151 		point += off;
152 		text += off;
153 		left -= off;
154 	}
155 
156 	buffer->point_offset = point;
157 }
158 
159 void
160 cmd_forward_char(struct buffer *buffer)
161 {
162 	struct vline	*vl;
163 	char		*text;
164 	size_t		 left, off;
165 
166 	if ((vl = buffer->current_line) == NULL)
167 		return;
168 
169 	text = vl->parent->line + vl->from;
170 	left = vl->len;
171 
172 	text += buffer->point_offset;
173 	left -= buffer->point_offset;
174 
175 	off = grapheme_next_character_break_utf8(text, left);
176 	buffer->point_offset += off;
177 }
178 
179 void
180 cmd_backward_paragraph(struct buffer *buffer)
181 {
182 	do {
183 		if (!forward_line(buffer, -1)) {
184 			message("No previous paragraph");
185 			return;
186 		}
187 	} while (buffer->current_line->len != 0 ||
188 	    buffer->current_line->parent->type != LINE_TEXT);
189 }
190 
191 void
192 cmd_forward_paragraph(struct buffer *buffer)
193 {
194 	do {
195 		if (!forward_line(buffer, +1)) {
196 			message("No next paragraph");
197 			return;
198 		}
199 	} while (buffer->current_line->len != 0 ||
200 	    buffer->current_line->parent->type != LINE_TEXT);
201 }
202 
203 void
204 cmd_move_beginning_of_line(struct buffer *buffer)
205 {
206 	buffer->point_offset = 0;
207 }
208 
209 void
210 cmd_move_end_of_line(struct buffer *buffer)
211 {
212 	struct vline	*vl;
213 
214 	vl = buffer->current_line;
215 	if (vl == NULL)
216 		return;
217 	buffer->point_offset = vl->len;
218 }
219 
220 void
221 cmd_redraw(struct buffer *buffer)
222 {
223 	ui_schedule_redraw();
224 }
225 
226 void
227 cmd_scroll_line_up(struct buffer *buffer)
228 {
229 	struct vline	*vl;
230 
231 	for (;;) {
232 		if (buffer->top_line == NULL)
233 			return;
234 
235 		if ((vl = TAILQ_PREV(buffer->top_line, vhead, vlines))
236 		    == NULL)
237 			return;
238 
239 		buffer->top_line = vl;
240 
241 		if (vl->parent->flags & L_HIDDEN)
242 			continue;
243 
244 		break;
245 	}
246 
247 	buffer->line_off--;
248 
249 	forward_line(buffer, -1);
250 }
251 
252 void
253 cmd_scroll_line_down(struct buffer *buffer)
254 {
255 	if (!forward_line(buffer, +1))
256 		return;
257 
258 	for (;;) {
259 		if (buffer->top_line == NULL)
260 			return;
261 
262 		buffer->top_line = TAILQ_NEXT(buffer->top_line, vlines);
263 		if (buffer->top_line->parent->flags & L_HIDDEN)
264 			continue;
265 		break;
266 	}
267 
268 	buffer->line_off++;
269 }
270 
271 void
272 cmd_scroll_up(struct buffer *buffer)
273 {
274 	struct vline	*vl;
275 	int		 i;
276 
277 	if (buffer->top_line == NULL)
278 		return;
279 
280 	for (i = 0; i < body_lines; ++i) {
281 		vl = TAILQ_PREV(buffer->top_line, vhead, vlines);
282 		if (vl == NULL)
283 			break;
284 		buffer->line_off--;
285 		buffer->top_line = vl;
286 		forward_line(buffer, -1);
287 	}
288 }
289 
290 void
291 cmd_scroll_down(struct buffer *buffer)
292 {
293 	int i;
294 
295 	if (buffer->top_line == NULL)
296 		return;
297 
298 	for (i = 0; i < body_lines; ++i) {
299 		if (!forward_line(buffer, +1))
300 			break;
301 
302 		buffer->top_line = TAILQ_NEXT(buffer->top_line,
303 		    vlines);
304 		buffer->line_off++;
305 	}
306 }
307 
308 void
309 cmd_beginning_of_buffer(struct buffer *buffer)
310 {
311 	buffer->current_line = TAILQ_FIRST(&buffer->vhead);
312 	buffer->point_offset = 0;
313 	buffer->top_line = buffer->current_line;
314 	buffer->line_off = 0;
315 }
316 
317 void
318 cmd_end_of_buffer(struct buffer *buffer)
319 {
320 	buffer->current_line = TAILQ_LAST(&buffer->vhead, vhead);
321 
322 	if (buffer->current_line == NULL)
323 		return;
324 
325 	/* deal with invisible lines */
326 	if (buffer->current_line->parent->flags & L_HIDDEN)
327 		forward_line(buffer, -1);
328 
329 	cmd_move_end_of_line(buffer);
330 }
331 
332 static void
333 kill_telescope_cb(int r, void *data)
334 {
335 	if (r) {
336 		save_session();
337 		ev_break();
338 	}
339 }
340 
341 void
342 cmd_kill_telescope(struct buffer *buffer)
343 {
344 	yornp("really quit?", kill_telescope_cb, NULL);
345 }
346 
347 void
348 cmd_push_button(struct buffer *buffer)
349 {
350 	struct vline	*vl;
351 	struct line	*l;
352 
353 	vl = buffer->current_line;
354 
355 	if (vl == NULL)
356 		return;
357 
358 	switch (vl->parent->type) {
359 	case LINE_LINK:
360 		load_url_in_tab(current_tab, vl->parent->alt, NULL,
361 		    LU_MODE_NOCACHE);
362 		break;
363 	case LINE_PRE_START:
364 		l = TAILQ_NEXT(vl->parent, lines);
365 		for (; l != NULL; l = TAILQ_NEXT(l, lines)) {
366 			if (l->type == LINE_PRE_END)
367 				break;
368 			l->flags ^= L_HIDDEN;
369 			if (l->flags & L_HIDDEN)
370 				buffer->line_max--;
371 			else
372 				buffer->line_max++;
373 		}
374 		break;
375 	default:
376 		break;
377 	}
378 }
379 
380 void
381 cmd_push_button_new_tab(struct buffer *buffer)
382 {
383 	struct vline	*vl;
384 
385 	vl = buffer->current_line;
386 	if (vl == NULL || vl->parent->type != LINE_LINK)
387 		return;
388 
389 	new_tab(vl->parent->alt, hist_cur(current_tab->hist), current_tab);
390 }
391 
392 void
393 cmd_previous_button(struct buffer *buffer)
394 {
395 	struct excursion place;
396 
397 	save_excursion(&place, buffer);
398 
399 	do {
400 		if (!forward_line(buffer, -1)) {
401 			restore_excursion(&place, buffer);
402 			message("No previous link");
403 			return;
404 		}
405 	} while (buffer->current_line->parent->type != LINE_LINK);
406 }
407 
408 void
409 cmd_next_button(struct buffer *buffer)
410 {
411 	struct excursion place;
412 
413 	save_excursion(&place, buffer);
414 
415 	do {
416 		if (!forward_line(buffer, +1)){
417 			restore_excursion(&place, buffer);
418 			message("No next link");
419 			return;
420 		}
421 	} while (buffer->current_line->parent->type != LINE_LINK);
422 }
423 
424 static inline int
425 is_heading(const struct line *l)
426 {
427 	return l->type == LINE_TITLE_1 ||
428 		l->type == LINE_TITLE_2 ||
429 		l->type == LINE_TITLE_3;
430 }
431 
432 void
433 cmd_previous_heading(struct buffer *buffer)
434 {
435 	struct excursion place;
436 
437 	save_excursion(&place, buffer);
438 
439 	do {
440 		if (!forward_line(buffer, -1)) {
441 			restore_excursion(&place, buffer);
442 			message("No previous heading");
443 			return;
444 		}
445 	} while (!is_heading(buffer->current_line->parent));
446 }
447 
448 void
449 cmd_next_heading(struct buffer *buffer)
450 {
451 	struct excursion place;
452 
453 	save_excursion(&place, buffer);
454 
455 	do {
456 		if (!forward_line(buffer, +1)) {
457 			restore_excursion(&place, buffer);
458 			message("No next heading");
459 			return;
460 		}
461 	} while (!is_heading(buffer->current_line->parent));
462 }
463 
464 void
465 cmd_previous_page(struct buffer *buffer)
466 {
467 	if (!load_previous_page(current_tab))
468 		message("No previous page");
469 }
470 
471 void
472 cmd_next_page(struct buffer *buffer)
473 {
474 	if (!load_next_page(current_tab))
475 		message("No next page");
476 }
477 
478 void
479 cmd_clear_minibuf(struct buffer *buffer)
480 {
481 	message(NULL);
482 }
483 
484 void
485 cmd_execute_extended_command(struct buffer *buffer)
486 {
487 	struct minibuffer	 m = {
488 		.self_insert = sensible_self_insert,
489 		.done = eecmd_select,
490 		.history = eecmd_history,
491 		.complfn = compl_eecmd,
492 		.must_select = 1,
493 	};
494 
495 	GUARD_RECURSIVE_MINIBUFFER();
496 
497 	enter_minibuffer(&m, "%s%s%s", thiskey.meta ? "M-" : "",
498 	    ui_keyname(thiskey.key), thiskey.meta ? " " : "");
499 }
500 
501 void
502 cmd_tab_close(struct buffer *buffer)
503 {
504 	struct tab *tab, *t;
505 
506 	tab = current_tab;
507 
508 	if ((t = TAILQ_NEXT(tab, tabs)) != NULL ||
509 	    (t = TAILQ_PREV(tab, tabshead, tabs)) != NULL) {
510 		switch_to_tab(t);
511 		kill_tab(tab, 0);
512 	} else
513 		message("Can't close the only tab.");
514 
515 }
516 
517 void
518 cmd_tab_close_other(struct buffer *buffer)
519 {
520 	struct tab *t, *i;
521 
522 	TAILQ_FOREACH_SAFE(t, &tabshead, tabs, i) {
523 		if (t == current_tab)
524 			continue;
525 
526 		kill_tab(t, 0);
527 	}
528 }
529 
530 void
531 cmd_tab_undo_close(struct buffer *buffer)
532 {
533 	struct tab *t;
534 
535 	if ((t = unkill_tab()) == NULL) {
536 		message("No recently-closed tabs");
537 		return;
538 	}
539 
540 	switch_to_tab(t);
541 }
542 
543 void
544 cmd_tab_new(struct buffer *buffer)
545 {
546 	const char *url;
547 
548 	if ((url = new_tab_url) == NULL)
549 		url = NEW_TAB_URL;
550 
551 	new_tab(url, NULL, NULL);
552 }
553 
554 void
555 cmd_tab_next(struct buffer *buffer)
556 {
557 	struct tab *t;
558 
559 	if ((t = TAILQ_NEXT(current_tab, tabs)) == NULL)
560 		t = TAILQ_FIRST(&tabshead);
561 	switch_to_tab(t);
562 }
563 
564 void
565 cmd_tab_previous(struct buffer *buffer)
566 {
567 	struct tab *t;
568 
569 	if ((t = TAILQ_PREV(current_tab, tabshead, tabs)) == NULL)
570 		t = TAILQ_LAST(&tabshead, tabshead);
571 	switch_to_tab(t);
572 }
573 
574 void
575 cmd_tab_move(struct buffer *buffer)
576 {
577 	struct tab *t;
578 
579 	t = TAILQ_NEXT(current_tab, tabs);
580 	TAILQ_REMOVE(&tabshead, current_tab, tabs);
581 
582 	if (t == NULL)
583 		TAILQ_INSERT_HEAD(&tabshead, current_tab, tabs);
584 	else
585 		TAILQ_INSERT_AFTER(&tabshead, t, current_tab, tabs);
586 }
587 
588 void
589 cmd_tab_move_to(struct buffer *buffer)
590 {
591 	struct tab *t;
592 
593 	t = TAILQ_PREV(current_tab, tabshead, tabs);
594 	TAILQ_REMOVE(&tabshead, current_tab, tabs);
595 
596 	if (t == NULL)
597 		TAILQ_INSERT_TAIL(&tabshead, current_tab, tabs);
598 	else
599 		TAILQ_INSERT_BEFORE(t, current_tab, tabs);
600 }
601 
602 void
603 cmd_tab_select(struct buffer *buffer)
604 {
605 	struct minibuffer m = {
606 		.self_insert = sensible_self_insert,
607 		.done = ts_select,
608 		.complfn = compl_ts,
609 		.must_select = 1,
610 	};
611 
612 	GUARD_RECURSIVE_MINIBUFFER();
613 
614 	enter_minibuffer(&m, "Select tab: ");
615 }
616 
617 void
618 cmd_load_url(struct buffer *buffer)
619 {
620 	struct minibuffer m = {
621 		.self_insert = sensible_self_insert,
622 		.done = lu_select,
623 		.history = lu_history,
624 		.complfn = compl_lu,
625 	};
626 
627 	GUARD_RECURSIVE_MINIBUFFER();
628 
629 	enter_minibuffer(&m, "Load URL: ");
630 }
631 
632 void
633 cmd_load_current_url(struct buffer *buffer)
634 {
635 	struct minibuffer m = {
636 		.self_insert = sensible_self_insert,
637 		.done = lu_select,
638 		.history = lu_history,
639 		.complfn = compl_lu,
640 		.input = hist_cur(current_tab->hist),
641 	};
642 
643 	GUARD_RECURSIVE_MINIBUFFER();
644 
645 	enter_minibuffer(&m, "Load URL: ");
646 }
647 
648 void
649 cmd_reload_page(struct buffer *buffer)
650 {
651 	load_url_in_tab(current_tab, hist_cur(current_tab->hist), NULL,
652 	    LU_MODE_NOHIST|LU_MODE_NOCACHE);
653 }
654 
655 void
656 cmd_bookmark_page(struct buffer *buffer)
657 {
658 	struct minibuffer m = {
659 		.self_insert = sensible_self_insert,
660 		.done = bp_select,
661 		.input = hist_cur(current_tab->hist),
662 	};
663 
664 	GUARD_RECURSIVE_MINIBUFFER();
665 
666 	enter_minibuffer(&m, "Bookmark URL: ");
667 }
668 
669 void
670 cmd_list_bookmarks(struct buffer *buffer)
671 {
672 	load_url_in_tab(current_tab, "about:bookmarks", NULL, LU_MODE_NONE);
673 }
674 
675 void
676 cmd_toggle_help(struct buffer *buffer)
677 {
678 	ui_toggle_side_window(SIDE_WINDOW_LEFT);
679 }
680 
681 void
682 cmd_link_select(struct buffer *buffer)
683 {
684 	struct line *l;
685 	struct minibuffer m = {
686 		.self_insert = sensible_self_insert,
687 		.done = ls_select,
688 		.complfn = compl_ls,
689 		.compldata = NULL,
690 		.must_select = 1,
691 	};
692 
693 	GUARD_RECURSIVE_MINIBUFFER();
694 
695 	l = TAILQ_FIRST(&buffer->head);
696 	while (l != NULL && l->type != LINE_LINK)
697 		l = TAILQ_NEXT(l, lines);
698 
699 	if (l == NULL) {
700 		message("No links found");
701 		return;
702 	}
703 
704 	m.compldata = l;
705 	enter_minibuffer(&m, "Select link: ");
706 }
707 
708 void
709 cmd_swiper(struct buffer *buffer)
710 {
711 	struct minibuffer m = {
712 		.self_insert = sensible_self_insert,
713 		.done = swiper_select,
714 		.complfn = compl_swiper,
715 		.compldata = TAILQ_FIRST(&buffer->head),
716 		.must_select = 1,
717 	};
718 
719 	GUARD_RECURSIVE_MINIBUFFER();
720 
721 	enter_minibuffer(&m, "Select line: ");
722 }
723 
724 void
725 cmd_toc(struct buffer *buffer)
726 {
727 	struct line *l;
728 	struct minibuffer m = {
729 		.self_insert = sensible_self_insert,
730 		.done = toc_select,
731 		.complfn = compl_toc,
732 		.compldata = NULL,
733 		.must_select = 1,
734 	};
735 
736 	GUARD_RECURSIVE_MINIBUFFER();
737 
738 	l = TAILQ_FIRST(&buffer->head);
739 	while (l != NULL &&
740 	    l->type != LINE_TITLE_1 &&
741 	    l->type != LINE_TITLE_2 &&
742 	    l->type != LINE_TITLE_3)
743 		l = TAILQ_NEXT(l, lines);
744 
745 	if (l == NULL) {
746 		message("No headings found");
747 		return;
748 	}
749 
750 	m.compldata = l;
751 	enter_minibuffer(&m, "Select heading: ");
752 }
753 
754 void
755 cmd_inc_fill_column(struct buffer *buffer)
756 {
757 	if (fill_column == INT_MAX)
758 		return;
759 
760 	fill_column += 2;
761 	message("fill-column: %d", fill_column);
762 
763 	ui_schedule_redraw();
764 }
765 
766 void
767 cmd_dec_fill_column(struct buffer *buffer)
768 {
769 	if (fill_column == INT_MAX || fill_column < 8)
770 		return;
771 
772 	fill_column -= 2;
773 	message("fill-column: %d", fill_column);
774 
775 	ui_schedule_redraw();
776 }
777 
778 void
779 cmd_olivetti_mode(struct buffer *buffer)
780 {
781 	olivetti_mode = !olivetti_mode;
782 	if (olivetti_mode)
783 		message("olivetti-mode enabled");
784 	else
785 		message("olivetti-mode disabled");
786 
787 	ui_schedule_redraw();
788 }
789 
790 void
791 cmd_mini_delete_char(struct buffer *buffer)
792 {
793 	struct vline	*vl;
794 	char		*text;
795 	size_t		 old_point, gap, rest;
796 
797 	GUARD_READ_ONLY();
798 
799 	vl = buffer->current_line;
800 	old_point = buffer->point_offset;
801 	cmd_forward_char(buffer);
802 	gap = buffer->point_offset - old_point;
803 	if (gap == 0)
804 		return;
805 
806 	minibuffer_taint_hist();
807 
808 	text = vl->parent->line + vl->from + old_point;
809 	rest = vl->len - buffer->point_offset;
810 	memmove(text, text + gap, rest + 1);
811 	buffer->point_offset = old_point;
812 	vl->len -= gap;
813 
814 	recompute_completions(0);
815 }
816 
817 void
818 cmd_mini_delete_backward_char(struct buffer *buffer)
819 {
820 	struct vline	*vl;
821 	char		*text;
822 	size_t		 old_point, gap, rest;
823 
824 	GUARD_READ_ONLY();
825 
826 	vl = buffer->current_line;
827 	old_point = buffer->point_offset;
828 	cmd_backward_char(buffer);
829 	gap = old_point - buffer->point_offset;
830 	if (gap == 0)
831 		return;
832 
833 	minibuffer_taint_hist();
834 
835 	text = vl->parent->line + vl->from + buffer->point_offset;
836 	rest = vl->len - old_point;
837 	memmove(text, text + gap, rest + 1);
838 	vl->len -= gap;
839 
840 	recompute_completions(0);
841 }
842 
843 void
844 cmd_mini_kill_line(struct buffer *buffer)
845 {
846 	char *line, *c;
847 
848 	GUARD_READ_ONLY();
849 
850 	minibuffer_taint_hist();
851 
852 	line = buffer->current_line->parent->line + buffer->current_line->from;
853 	c = line + buffer->point_offset;
854 	*c = '\0';
855 
856 	recompute_completions(0);
857 }
858 
859 void
860 cmd_mini_kill_whole_line(struct buffer *buffer)
861 {
862 	GUARD_READ_ONLY();
863 
864 	minibuffer_taint_hist();
865 	*buffer->current_line->parent->line = '\0';
866 	buffer->point_offset = 0;
867 	buffer->current_line->len = 0;
868 
869 	recompute_completions(0);
870 }
871 
872 void
873 cmd_mini_abort(struct buffer *buffer)
874 {
875 	if (!in_minibuffer)
876 		return;
877 
878 	ministate.abortfn();
879 }
880 
881 void
882 cmd_mini_complete_and_exit(struct buffer *buffer)
883 {
884 	struct vline *vl;
885 
886 	if (!in_minibuffer)
887 		return;
888 
889 	if (ministate.compl.must_select && ministate.hist == NULL) {
890 		vl = ministate.compl.buffer.current_line;
891 		if (vl == NULL || vl->parent->flags & L_HIDDEN ||
892 		    vl->parent->type == LINE_COMPL) {
893 			message("no match");
894 			return;
895 		}
896 	}
897 
898 	minibuffer_confirm();
899 }
900 
901 void
902 cmd_mini_previous_history_element(struct buffer *buffer)
903 {
904 	char *text;
905 
906 	if (ministate.hist == NULL) {
907 		message("No history");
908 		return;
909 	}
910 
911 	if (hist_prev(ministate.hist) == NULL) {
912 		message("No prev history item");
913 		return;
914 	}
915 
916 	ministate.editing = 0;
917 
918 	/* XXX the minibuffer line is never modified so this is fine */
919 	text = (char *)hist_cur(ministate.hist);
920 	buffer->current_line->parent->line = text;
921 	recompute_completions(0);
922 }
923 
924 void
925 cmd_mini_next_history_element(struct buffer *buffer)
926 {
927 	char *text;
928 
929 	if (ministate.hist == NULL) {
930 		message("No history");
931 		return;
932 	}
933 
934 	if (hist_next(ministate.hist) == NULL) {
935 		message("No next history item");
936 		return;
937 	}
938 
939 	ministate.editing = 0;
940 
941 	/* XXX the minibuffer line is never modified so this is fine */
942 	text = (char *)hist_cur(ministate.hist);
943 	buffer->current_line->parent->line = text;
944 	recompute_completions(0);
945 }
946 
947 void
948 cmd_previous_completion(struct buffer *buffer)
949 {
950 	if (in_minibuffer != MB_COMPREAD)
951 		return;
952 
953 	buffer = &ministate.compl.buffer;
954 	if (buffer->current_line == NULL)
955 		return;
956 
957 	buffer->current_line->parent->type = LINE_COMPL;
958 	if (!forward_line(buffer, -1))
959 		buffer->current_line->parent->type = LINE_COMPL;
960 	else
961 		buffer->current_line->parent->type = LINE_COMPL_CURRENT;
962 }
963 
964 void
965 cmd_next_completion(struct buffer *buffer)
966 {
967 	if (in_minibuffer != MB_COMPREAD)
968 		return;
969 
970 	buffer = &ministate.compl.buffer;
971 	if (buffer->current_line == NULL)
972 		return;
973 
974 	if (buffer->current_line->parent->type == LINE_COMPL_CURRENT) {
975 		buffer->current_line->parent->type = LINE_COMPL;
976 		forward_line(buffer, +1);
977 	}
978 
979 	if (buffer->current_line != NULL)
980 		buffer->current_line->parent->type = LINE_COMPL_CURRENT;
981 }
982 
983 void
984 cmd_insert_current_candidate(struct buffer *buffer)
985 {
986 	if (in_minibuffer != MB_COMPREAD)
987 		return;
988 
989 	minibuffer_insert_current_candidate();
990 }
991 
992 void
993 cmd_suspend_telescope(struct buffer *buffer)
994 {
995 	message("Zzz...");
996 	ui_suspend();
997 	kill(getpid(), SIGSTOP);
998 	ui_resume();
999 }
1000 
1001 void
1002 cmd_toggle_pre_wrap(struct buffer *buffer)
1003 {
1004 	dont_wrap_pre = !dont_wrap_pre;
1005 
1006 	if (dont_wrap_pre)
1007 		message("Don't wrap preformatted blocks");
1008 	else
1009 		message("Wrap preformatted blocks");
1010 
1011 	ui_schedule_redraw();
1012 }
1013 
1014 void
1015 cmd_toggle_styling(struct buffer *buffer)
1016 {
1017 	dont_apply_styling = !dont_apply_styling;
1018 
1019 	config_apply_style();
1020 
1021 	/* Force a reload here, rather than calling ui_schedule_redraw() so
1022 	 * that any lines which are set as L_HIDDEN are redrawn appropriately.
1023 	 */
1024 	load_url_in_tab(current_tab, hist_cur(current_tab->hist), NULL,
1025 	    LU_MODE_NOHIST);
1026 }
1027 
1028 void
1029 cmd_mini_goto_beginning(struct buffer *buffer)
1030 {
1031 	struct vline *vl;
1032 
1033 	if (!in_minibuffer)
1034 		return;
1035 
1036 	buffer = &ministate.compl.buffer;
1037 
1038 	if ((vl = buffer->current_line) != NULL)
1039 		vl->parent->type = LINE_COMPL;
1040 
1041 	vl = TAILQ_FIRST(&buffer->vhead);
1042 	while (vl != NULL && vl->parent->flags & L_HIDDEN)
1043 		vl = TAILQ_NEXT(vl, vlines);
1044 
1045 	if (vl == NULL)
1046 		return;
1047 
1048 	vl->parent->type = LINE_COMPL_CURRENT;
1049 	buffer->top_line = vl;
1050 	buffer->current_line = vl;
1051 }
1052 
1053 void
1054 cmd_mini_goto_end(struct buffer *buffer)
1055 {
1056 	struct vline *vl;
1057 
1058 	if (!in_minibuffer)
1059 		return;
1060 
1061 	buffer = &ministate.compl.buffer;
1062 
1063 	if ((vl = buffer->current_line) != NULL)
1064 		vl->parent->type = LINE_COMPL;
1065 
1066 	vl = TAILQ_LAST(&buffer->vhead, vhead);
1067 	while (vl != NULL && vl->parent->flags & L_HIDDEN)
1068 		vl = TAILQ_PREV(vl, vhead, vlines);
1069 
1070 	if (vl == NULL)
1071 		return;
1072 
1073 	vl->parent->type = LINE_COMPL_CURRENT;
1074 	buffer->current_line = vl;
1075 }
1076 
1077 void
1078 cmd_other_window(struct buffer *buffer)
1079 {
1080 	ui_other_window();
1081 }
1082 
1083 void
1084 cmd_mini_scroll_up(struct buffer *buffer)
1085 {
1086 	if (!in_minibuffer)
1087 		return;
1088 
1089 	buffer = &ministate.compl.buffer;
1090 	if (buffer->current_line == NULL)
1091 		return;
1092 
1093 	buffer->current_line->parent->type = LINE_COMPL;
1094 	cmd_scroll_up(buffer);
1095 	buffer->current_line->parent->type = LINE_COMPL_CURRENT;
1096 }
1097 
1098 void
1099 cmd_mini_scroll_down(struct buffer *buffer)
1100 {
1101 	if (!in_minibuffer)
1102 		return;
1103 
1104 	buffer = &ministate.compl.buffer;
1105 	if (buffer->current_line == NULL)
1106 		return;
1107 
1108 	buffer->current_line->parent->type = LINE_COMPL;
1109 	cmd_scroll_down(buffer);
1110 	buffer->current_line->parent->type = LINE_COMPL_CURRENT;
1111 }
1112 
1113 void
1114 cmd_toggle_downloads(struct buffer *buffer)
1115 {
1116 	ui_toggle_side_window(SIDE_WINDOW_BOTTOM);
1117 }
1118 
1119 void
1120 cmd_cache_info(struct buffer *buffer)
1121 {
1122 	size_t	npages, tot;
1123 	char	fmt[FMT_SCALED_STRSIZE];
1124 
1125 	mcache_info(&npages, &tot);
1126 
1127 	if (fmt_scaled(tot, fmt) == 0)
1128 		message("pages: %zu, total: %s", npages, fmt);
1129 	else
1130 		message("pages: %zu, total: %zu", npages, tot);
1131 }
1132 
1133 void
1134 cmd_reply_last_input(struct buffer *buffer)
1135 {
1136 	GUARD_RECURSIVE_MINIBUFFER();
1137 
1138 	if (current_tab->last_input_url == NULL) {
1139 		message("there was no previous input request in this tab");
1140 		return;
1141 	}
1142 
1143 	if (!strncmp(current_tab->last_input_url, "gopher", 6)) {
1144 		load_url_in_tab(current_tab, current_tab->last_input_url,
1145 		    NULL, LU_MODE_NOCACHE);
1146 		return;
1147 	}
1148 
1149 	message("%s", current_tab->last_input_url);
1150 	ui_require_input(current_tab, 0, ir_select_reply);
1151 }
1152 
1153 void
1154 cmd_write_buffer(struct buffer *buffer)
1155 {
1156 	const char *f, *url;
1157 	char path[PATH_MAX];
1158 
1159 	GUARD_RECURSIVE_MINIBUFFER();
1160 
1161 	if (safe_mode) {
1162 		message("Can't write buffer in safe-mode.");
1163 		return;
1164 	}
1165 
1166 	url = hist_cur(current_tab->hist);
1167 
1168 	if ((f = strrchr(url, '/')) != NULL)
1169 		f++;
1170 	if (f == NULL || *f == '\0') {
1171 		/* guess a decent file name based on the protocol used */
1172 		if (!strncmp(url, "gemini://", 9))
1173 			f = "index.gmi";
1174 		else
1175 			f = "index.txt";
1176 	}
1177 
1178 	strlcpy(path, download_path, sizeof(path));
1179 	strlcat(path, f, sizeof(path));
1180 
1181 	ui_read("Write file", write_buffer, current_tab, path);
1182 }
1183 
1184 void
1185 cmd_home(struct buffer *buffer)
1186 {
1187 	char path[GEMINI_URL_LEN];
1188 	char *tilde, *t;
1189 
1190 	strlcpy(path, current_tab->iri.iri_path, sizeof(path));
1191 
1192 	if ((tilde = strstr(path, "/~")) != NULL &&
1193 	    tilde[2] != '\0' && tilde[2] != '/') {
1194 		if ((t = strchr(tilde + 2, '/')) != NULL)
1195 			*++t = '\0';
1196 		load_url_in_tab(current_tab, path, NULL, LU_MODE_NOCACHE);
1197 	} else
1198 		cmd_root(buffer);
1199 }
1200 
1201 void
1202 cmd_root(struct buffer *buffer)
1203 {
1204 	load_url_in_tab(current_tab, "/", NULL, LU_MODE_NOCACHE);
1205 }
1206 
1207 void
1208 cmd_up(struct buffer *buffer)
1209 {
1210 	load_url_in_tab(current_tab, "..", NULL, LU_MODE_NOCACHE);
1211 }
1212 
1213 void
1214 cmd_use_certificate(struct buffer *buffer)
1215 {
1216 	struct minibuffer m = {
1217 		.self_insert = sensible_self_insert,
1218 		.done = uc_select,
1219 		.complfn = compl_uc,
1220 		.must_select = 1,
1221 	};
1222 
1223 	GUARD_RECURSIVE_MINIBUFFER();
1224 
1225 	enter_minibuffer(&m, "Select certificate: ");
1226 }
1227 
1228 void
1229 cmd_client_certificate_info(struct buffer *buffer)
1230 {
1231 	if (current_tab->client_cert)
1232 		message("Using certificate %s", current_tab->client_cert);
1233 	else
1234 		message("Not using any client certificate.");
1235 }
1236 
1237 static void
1238 unload_certificate_cb(int r, void *data)
1239 {
1240 	struct tab	*tab = data;
1241 
1242 	message("Won't use %s for this site.", tab->client_cert);
1243 	cert_delete_for(tab->client_cert, &tab->iri, r);
1244 }
1245 
1246 void
1247 cmd_unload_certificate(struct buffer *buffer)
1248 {
1249 	struct tab	*tab = current_tab;
1250 
1251 	GUARD_RECURSIVE_MINIBUFFER();
1252 
1253 	if (tab->client_cert == NULL) {
1254 		message("No client certificate in use!");
1255 		return;
1256 	}
1257 
1258 	if (tab->client_cert_temp) {
1259 		message("Won't use %s for this site.", tab->client_cert);
1260 		cert_delete_for(tab->client_cert, &tab->iri, 0);
1261 		return;
1262 	}
1263 
1264 	yornp("Unload only for the current session?", unload_certificate_cb,
1265 	    current_tab);
1266 }
1267 
1268 void
1269 cmd_search(struct buffer *buffer)
1270 {
1271 	struct minibuffer m = {
1272 		.self_insert = sensible_self_insert,
1273 		.done = search_select,
1274 	};
1275 
1276 	GUARD_RECURSIVE_MINIBUFFER();
1277 
1278 	if (!strncmp(default_search_engine, "gopher://", 9)) {
1279 		load_url_in_tab(current_tab, default_search_engine, NULL,
1280 		    LU_MODE_NOCACHE);
1281 		return;
1282 	}
1283 
1284 	enter_minibuffer(&m, "Search: ");
1285 }
1286 
1287 void
1288 cmd_mini_edit_external(struct buffer *buffer)
1289 {
1290 	FILE		*fp;
1291 	char		 buf[1024 + 1];
1292 	size_t		 r, len = 0;
1293 
1294 	GUARD_READ_ONLY();
1295 
1296 	if (ministate.compl.must_select || ministate.donefn == NULL) {
1297 		message("Can't use an external editor to complete");
1298 		return;
1299 	}
1300 
1301 	if ((fp = exec_editor(ministate.buf, strlen(ministate.buf))) == NULL)
1302 		return;
1303 
1304 	while (len < sizeof(buf) - 1) {
1305 		r = fread(buf + len, 1, sizeof(buf) - 1 - len, fp);
1306 		len += r;
1307 		if (r == 0)
1308 			break;
1309 	}
1310 	buf[len] = '\0';
1311 	while (len > 0 && buf[len-1] == '\n')
1312 		buf[--len] = '\0';
1313 
1314 	/*
1315 	 * XXX: do not use minibuffer_confirm() since the text could
1316 	 * have multiple lines and we are not prepared to render them
1317 	 * in the history navigation.
1318 	 */
1319 	ministate.donefn(buf);
1320 	exit_minibuffer();
1321 }