op public repos

Blob

Date:: Fri Jun 25 09:02:24 2021 UTC
Message:: move the list of cmd to its own file
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 <string.h>
18 #include <stdlib.h>
19 
20 #include "telescope.h"
21 
22 void
23 cmd_previous_line(struct buffer *buffer)
24 {
25 	struct vline	*vl;
26 
27 	if (buffer->current_line == NULL
28 	    || (vl = TAILQ_PREV(buffer->current_line, vhead, vlines)) == NULL)
29 		return;
30 
31 	if (--buffer->curs_y < 0) {
32 		buffer->curs_y = 0;
33 		cmd_scroll_line_up(buffer);
34 		return;
35 	}
36 
37 	buffer->current_line = vl;
38 	restore_cursor(buffer);
39 }
40 
41 void
42 cmd_next_line(struct buffer *buffer)
43 {
44 	struct vline	*vl;
45 
46 	if (buffer->current_line == NULL
47 	    || (vl = TAILQ_NEXT(buffer->current_line, vlines)) == NULL)
48 		return;
49 
50 	if (++buffer->curs_y > body_lines-1) {
51 		buffer->curs_y = body_lines-1;
52 		cmd_scroll_line_down(buffer);
53 		return;
54 	}
55 
56 	buffer->current_line = vl;
57 	restore_cursor(buffer);
58 }
59 
60 void
61 cmd_backward_char(struct buffer *buffer)
62 {
63 	if (buffer->cpoff != 0)
64 		buffer->cpoff--;
65 	restore_cursor(buffer);
66 }
67 
68 void
69 cmd_forward_char(struct buffer *buffer)
70 {
71 	size_t len = 0;
72 
73 	if (buffer->current_line->line != NULL)
74 		len = utf8_cplen(buffer->current_line->line);
75 	if (++buffer->cpoff > len)
76 		buffer->cpoff = len;
77 	restore_cursor(buffer);
78 }
79 
80 void
81 cmd_backward_paragraph(struct buffer *buffer)
82 {
83 	do {
84 		if (buffer->current_line == NULL ||
85 		    buffer->current_line == TAILQ_FIRST(&buffer->head)) {
86 			message("No previous paragraph");
87 			return;
88 		}
89 		cmd_previous_line(buffer);
90 	} while (buffer->current_line->line != NULL ||
91 	    buffer->current_line->parent->type != LINE_TEXT);
92 }
93 
94 void
95 cmd_forward_paragraph(struct buffer *buffer)
96 {
97 	do {
98 		if (buffer->current_line == NULL ||
99 		    buffer->current_line == TAILQ_LAST(&buffer->head, vhead)) {
100 			message("No next paragraph");
101 			return;
102 		}
103 		cmd_next_line(buffer);
104 	} while (buffer->current_line->line != NULL ||
105 	    buffer->current_line->parent->type != LINE_TEXT);
106 }
107 
108 void
109 cmd_move_beginning_of_line(struct buffer *buffer)
110 {
111 	buffer->cpoff = 0;
112 	restore_cursor(buffer);
113 }
114 
115 void
116 cmd_move_end_of_line(struct buffer *buffer)
117 {
118 	struct vline	*vl;
119 
120 	vl = buffer->current_line;
121 	if (vl->line == NULL)
122 		return;
123 	buffer->cpoff = utf8_cplen(vl->line);
124 	restore_cursor(buffer);
125 }
126 
127 void
128 cmd_redraw(struct buffer *buffer)
129 {
130         ui_schedule_redraw();
131 }
132 
133 void
134 cmd_scroll_line_up(struct buffer *buffer)
135 {
136 	if (buffer->current_line == NULL)
137 		return;
138 
139 	if (buffer->line_off == 0)
140 		return;
141 
142 	buffer->line_off--;
143 	buffer->current_line = TAILQ_PREV(buffer->current_line, vhead, vlines);
144 	restore_cursor(buffer);
145 }
146 
147 void
148 cmd_scroll_line_down(struct buffer *buffer)
149 {
150 	struct vline	*vl;
151 
152 	if (buffer->current_line == NULL)
153 		return;
154 
155 	if ((vl = TAILQ_NEXT(buffer->current_line, vlines)) == NULL)
156 		return;
157 
158 	buffer->current_line = vl;
159 	buffer->line_off++;
160 	restore_cursor(buffer);
161 }
162 
163 void
164 cmd_scroll_up(struct buffer *buffer)
165 {
166 	size_t off;
167 
168 	off = body_lines-1;
169 
170 	for (; off > 0; --off)
171 		cmd_scroll_line_up(buffer);
172 }
173 
174 void
175 cmd_scroll_down(struct buffer *buffer)
176 {
177 	size_t off;
178 
179 	off = body_lines-1;
180 
181 	for (; off > 0; --off)
182 		cmd_scroll_line_down(buffer);
183 }
184 
185 void
186 cmd_beginning_of_buffer(struct buffer *buffer)
187 {
188 	buffer->current_line = TAILQ_FIRST(&buffer->head);
189 	buffer->line_off = 0;
190 	buffer->curs_y = 0;
191 	buffer->cpoff = 0;
192 	restore_cursor(buffer);
193 }
194 
195 void
196 cmd_end_of_buffer(struct buffer *buffer)
197 {
198 	ssize_t off;
199 
200 	off = buffer->line_max - body_lines;
201 	off = MAX(0, off);
202 
203 	buffer->line_off = off;
204 	buffer->curs_y = MIN((size_t)body_lines-1, buffer->line_max-1);
205 
206 	buffer->current_line = TAILQ_LAST(&buffer->head, vhead);
207 	buffer->cpoff = body_cols;
208 	restore_cursor(buffer);
209 }
210 
211 void
212 cmd_kill_telescope(struct buffer *buffer)
213 {
214 	save_session();
215 	event_loopbreak();
216 }
217 
218 void
219 cmd_push_button(struct buffer *buffer)
220 {
221 	struct vline	*vl;
222 
223 	vl = buffer->current_line;
224 	if (vl->parent->type != LINE_LINK)
225 		return;
226 
227 	load_url_in_tab(current_tab(), vl->parent->alt);
228 }
229 
230 void
231 cmd_push_button_new_tab(struct buffer *buffer)
232 {
233 	struct vline	*vl;
234 
235 	vl = buffer->current_line;
236 	if (vl->parent->type != LINE_LINK)
237 		return;
238 
239 	new_tab(vl->parent->alt);
240 }
241 
242 void
243 cmd_previous_button(struct buffer *buffer)
244 {
245 	struct excursion place;
246 
247 	save_excursion(&place, buffer);
248 
249 	do {
250 		if (buffer->current_line == NULL ||
251 		    buffer->current_line == TAILQ_FIRST(&buffer->head)) {
252 			restore_excursion(&place, buffer);
253 			message("No previous link");
254 			return;
255 		}
256 		cmd_previous_line(buffer);
257 	} while (buffer->current_line->parent->type != LINE_LINK);
258 }
259 
260 void
261 cmd_next_button(struct buffer *buffer)
262 {
263 	struct excursion place;
264 
265 	save_excursion(&place, buffer);
266 
267 	do {
268 		if (buffer->current_line == NULL ||
269 		    buffer->current_line == TAILQ_LAST(&buffer->head, vhead)) {
270 			restore_excursion(&place, buffer);
271 			message("No next link");
272 			return;
273 		}
274 		cmd_next_line(buffer);
275 	} while (buffer->current_line->parent->type != LINE_LINK);
276 }
277 
278 static inline int
279 is_heading(const struct line *l)
280 {
281 	return l->type == LINE_TITLE_1 ||
282 		l->type == LINE_TITLE_2 ||
283 		l->type == LINE_TITLE_3;
284 }
285 
286 void
287 cmd_previous_heading(struct buffer *buffer)
288 {
289 	struct excursion place;
290 
291 	save_excursion(&place, buffer);
292 
293 	do {
294 		if (buffer->current_line == NULL ||
295 		    buffer->current_line == TAILQ_FIRST(&buffer->head)) {
296 			restore_excursion(&place, buffer);
297 			message("No previous heading");
298 			return;
299 		}
300 		cmd_previous_line(buffer);
301 	} while (!is_heading(buffer->current_line->parent));
302 }
303 
304 void
305 cmd_next_heading(struct buffer *buffer)
306 {
307 	struct excursion place;
308 
309 	save_excursion(&place, buffer);
310 
311 	do {
312 		if (buffer->current_line == NULL ||
313 		    buffer->current_line == TAILQ_LAST(&buffer->head, vhead)) {
314 			restore_excursion(&place, buffer);
315 			message("No next heading");
316 			return;
317 		}
318 		cmd_next_line(buffer);
319 	} while (!is_heading(buffer->current_line->parent));
320 }
321 
322 void
323 cmd_previous_page(struct buffer *buffer)
324 {
325 	struct tab *tab = current_tab();
326 
327 	if (!load_previous_page(tab))
328 		message("No previous page");
329 	else
330 		start_loading_anim(tab);
331 }
332 
333 void
334 cmd_next_page(struct buffer *buffer)
335 {
336 	struct tab *tab = current_tab();
337 
338 	if (!load_next_page(tab))
339 		message("No next page");
340 	else
341 		start_loading_anim(tab);
342 }
343 
344 void
345 cmd_clear_minibuf(struct buffer *buffer)
346 {
347         message(NULL);
348 }
349 
350 void
351 cmd_execute_extended_command(struct buffer *buffer)
352 {
353 	size_t	 len;
354 
355 	if (in_minibuffer) {
356 		message("We don't have enable-recursive-minibuffers");
357 		return;
358 	}
359 
360 	enter_minibuffer(eecmd_self_insert, eecmd_select, exit_minibuffer,
361 	    &eecmd_history);
362 
363 	len = sizeof(ministate.prompt);
364 	strlcpy(ministate.prompt, "", len);
365 
366 	if (thiskey.meta)
367 		strlcat(ministate.prompt, "M-", len);
368 
369 	strlcat(ministate.prompt, ui_keyname(thiskey.key), len);
370 
371 	if (thiskey.meta)
372 		strlcat(ministate.prompt, " ", len);
373 }
374 
375 void
376 cmd_tab_close(struct buffer *buffer)
377 {
378 	struct tab *tab, *t;
379 
380 	tab = current_tab();
381 	if (TAILQ_PREV(tab, tabshead, tabs) == NULL &&
382 	    TAILQ_NEXT(tab, tabs) == NULL) {
383 		message("Can't close the only tab.");
384 		return;
385 	}
386 
387 	if (evtimer_pending(&tab->loadingev, NULL))
388 		evtimer_del(&tab->loadingev);
389 
390 	stop_tab(tab);
391 
392 	if ((t = TAILQ_PREV(tab, tabshead, tabs)) == NULL)
393 		t = TAILQ_NEXT(tab, tabs);
394 	TAILQ_REMOVE(&tabshead, tab, tabs);
395 	free(tab);
396 
397 	switch_to_tab(t);
398 }
399 
400 void
401 cmd_tab_close_other(struct buffer *buffer)
402 {
403 	struct tab *t, *i;
404 
405 	TAILQ_FOREACH_SAFE(t, &tabshead, tabs, i) {
406 		if (t->flags & TAB_CURRENT)
407 			continue;
408 
409 		stop_tab(t);
410 		TAILQ_REMOVE(&tabshead, t, tabs);
411 		free(t);
412 	}
413 }
414 
415 void
416 cmd_tab_new(struct buffer *buffer)
417 {
418 	const char *url;
419 
420 	if ((url = new_tab_url) == NULL)
421 		url = NEW_TAB_URL;
422 
423 	new_tab(url);
424 }
425 
426 void
427 cmd_tab_next(struct buffer *buffer)
428 {
429 	struct tab *tab, *t;
430 
431 	tab = current_tab();
432 	tab->flags &= ~TAB_CURRENT;
433 
434 	if ((t = TAILQ_NEXT(tab, tabs)) == NULL)
435 		t = TAILQ_FIRST(&tabshead);
436 	t->flags |= TAB_CURRENT;
437 	t->flags &= ~TAB_URGENT;
438 }
439 
440 void
441 cmd_tab_previous(struct buffer *buffer)
442 {
443 	struct tab *tab, *t;
444 
445 	tab = current_tab();
446 	tab->flags &= ~TAB_CURRENT;
447 
448 	if ((t = TAILQ_PREV(tab, tabshead, tabs)) == NULL)
449 		t = TAILQ_LAST(&tabshead, tabshead);
450 	t->flags |= TAB_CURRENT;
451 	t->flags &= ~TAB_URGENT;
452 }
453 
454 void
455 cmd_tab_move(struct buffer *buffer)
456 {
457 	struct tab *tab, *t;
458 
459 	tab = current_tab();
460 	t = TAILQ_NEXT(tab, tabs);
461 	TAILQ_REMOVE(&tabshead, tab, tabs);
462 
463 	if (t == NULL)
464 		TAILQ_INSERT_HEAD(&tabshead, tab, tabs);
465 	else
466 		TAILQ_INSERT_AFTER(&tabshead, t, tab, tabs);
467 }
468 
469 void
470 cmd_tab_move_to(struct buffer *buffer)
471 {
472 	struct tab *tab, *t;
473 
474 	tab = current_tab();
475 	t = TAILQ_PREV(tab, tabshead, tabs);
476 	TAILQ_REMOVE(&tabshead, tab, tabs);
477 
478 	if (t == NULL) {
479 		if (TAILQ_EMPTY(&tabshead))
480 			TAILQ_INSERT_HEAD(&tabshead, tab, tabs);
481 		else
482 			TAILQ_INSERT_TAIL(&tabshead, tab, tabs);
483 	} else
484 		TAILQ_INSERT_BEFORE(t, tab, tabs);
485 }
486 
487 void
488 cmd_load_url(struct buffer *buffer)
489 {
490 	if (in_minibuffer) {
491 		message("We don't have enable-recursive-minibuffers");
492 		return;
493 	}
494 
495 	enter_minibuffer(lu_self_insert, lu_select, exit_minibuffer,
496 	    &lu_history);
497 	strlcpy(ministate.prompt, "Load URL: ", sizeof(ministate.prompt));
498 	strlcpy(ministate.buf, "gemini://", sizeof(ministate.buf));
499 	cmd_move_end_of_line(&ministate.buffer);
500 }
501 
502 void
503 cmd_load_current_url(struct buffer *buffer)
504 {
505 	struct tab *tab = current_tab();
506 
507 	if (in_minibuffer) {
508 		message("We don't have enable-recursive-minibuffers");
509 		return;
510 	}
511 
512 	enter_minibuffer(lu_self_insert, lu_select, exit_minibuffer,
513 	    &lu_history);
514 	strlcpy(ministate.prompt, "Load URL: ", sizeof(ministate.prompt));
515 	strlcpy(ministate.buf, tab->hist_cur->h, sizeof(ministate.buf));
516 	ministate.buffer.cpoff = utf8_cplen(ministate.buf);
517 }
518 
519 void
520 cmd_bookmark_page(struct buffer *buffer)
521 {
522 	struct tab *tab = current_tab();
523 
524 	enter_minibuffer(lu_self_insert, bp_select, exit_minibuffer, NULL);
525 	strlcpy(ministate.prompt, "Bookmark URL: ", sizeof(ministate.prompt));
526 	strlcpy(ministate.buf, tab->hist_cur->h, sizeof(ministate.buf));
527 	ministate.buffer.cpoff = utf8_cplen(ministate.buf);
528 }
529 
530 void
531 cmd_list_bookmarks(struct buffer *buffer)
532 {
533 	load_url_in_tab(current_tab(), "about:bookmarks");
534 }
535 
536 void
537 cmd_toggle_help(struct buffer *buffer)
538 {
539 	ui_toggle_side_window();
540 }
541 
542 void
543 cmd_olivetti_mode(struct buffer *buffer)
544 {
545 	olivetti_mode = !olivetti_mode;
546 	if (olivetti_mode)
547 		message("olivetti-mode enabled");
548 	else
549 		message("olivetti-mode disabled");
550 
551 	ui_schedule_redraw();
552 }
553 
554 void
555 cmd_mini_delete_char(struct buffer *buffer)
556 {
557 	char *c, *n;
558 
559 	if (!in_minibuffer) {
560 		message("text is read-only");
561 		return;
562 	}
563 
564 	minibuffer_taint_hist();
565 
566 	c = utf8_nth(buffer->current_line->line, buffer->cpoff);
567 	if (*c == '\0')
568 		return;
569 	n = utf8_next_cp(c);
570 
571 	memmove(c, n, strlen(n)+1);
572 }
573 
574 void
575 cmd_mini_delete_backward_char(struct buffer *buffer)
576 {
577 	char *c, *p, *start;
578 
579 	if (!in_minibuffer) {
580 		message("text is read-only");
581 		return;
582 	}
583 
584 	minibuffer_taint_hist();
585 
586 	c = utf8_nth(buffer->current_line->line, buffer->cpoff);
587 	start = buffer->current_line->line;
588 	if (c == start)
589 		return;
590 	p = utf8_prev_cp(c-1, start);
591 
592 	memmove(p, c, strlen(c)+1);
593 	buffer->cpoff--;
594 }
595 
596 void
597 cmd_mini_kill_line(struct buffer *buffer)
598 {
599 	char *c;
600 
601 	if (!in_minibuffer) {
602 		message("text is read-only");
603 		return;
604 	}
605 
606 	minibuffer_taint_hist();
607 	c = utf8_nth(buffer->current_line->line, buffer->cpoff);
608 	*c = '\0';
609 }
610 
611 void
612 cmd_mini_abort(struct buffer *buffer)
613 {
614 	if (!in_minibuffer)
615 		return;
616 
617 	ministate.abortfn();
618 }
619 
620 void
621 cmd_mini_complete_and_exit(struct buffer *buffer)
622 {
623 	if (!in_minibuffer)
624 		return;
625 
626 	minibuffer_taint_hist();
627 	ministate.donefn();
628 }
629 
630 void
631 cmd_mini_previous_history_element(struct buffer *buffer)
632 {
633 	if (ministate.history == NULL) {
634 		message("No history");
635 		return;
636 	}
637 
638 	if (ministate.hist_cur == NULL ||
639 	    (ministate.hist_cur = TAILQ_PREV(ministate.hist_cur, mhisthead, entries)) == NULL) {
640 		ministate.hist_cur = TAILQ_LAST(&ministate.history->head, mhisthead);
641 		ministate.hist_off = ministate.history->len - 1;
642 		if (ministate.hist_cur == NULL)
643 			message("No prev item");
644 	} else {
645 		ministate.hist_off--;
646 	}
647 
648 	if (ministate.hist_cur != NULL)
649 		buffer->current_line->line = ministate.hist_cur->h;
650 }
651 
652 void
653 cmd_mini_next_history_element(struct buffer *buffer)
654 {
655 	if (ministate.history == NULL) {
656 		message("No history");
657 		return;
658 	}
659 
660 	if (ministate.hist_cur == NULL ||
661 	    (ministate.hist_cur = TAILQ_NEXT(ministate.hist_cur, entries)) == NULL) {
662 		ministate.hist_cur = TAILQ_FIRST(&ministate.history->head);
663 		ministate.hist_off = 0;
664 		if (ministate.hist_cur == NULL)
665 			message("No next item");
666 	} else {
667 		ministate.hist_off++;
668 	}
669 
670 	if (ministate.hist_cur != NULL)
671 		buffer->current_line->line = ministate.hist_cur->h;
672 }