fe

tty_interface.c

(15458B)

 #include <sys/types.h>
 #include <sys/wait.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <stdarg.h>
 #include <unistd.h>
 #include <stdio.h>
 #include <string.h>
 #include "tty_interface.h"
 
 static void clear(tty_interface_t *state) {
     tty_t *tty = state->tty;
 
     tty_setcol(tty, 0);
     size_t line = 0;
     while (line++ <= state->options->num_files) {
         tty_newline(tty);
     }
     tty_clearline(tty);
     if (state->options->num_files > 0) {
         tty_moveup(tty, line - 1);
     }
     tty_unhide_cursor(tty);
     tty_title(tty, "");
     tty_flush(tty);
 }
 
 static int confirm_remove(tty_interface_t *state, const char *name) {
     tty_t *tty = state->tty;
     char fullpath[PATH_MAX];
 
     if (strcmp(state->entries->path, "/") == 0) {
         strlcpy(fullpath, "/", sizeof(fullpath));
         strlcat(fullpath, name, sizeof(fullpath));
     } else {
         strlcpy(fullpath, state->entries->path, sizeof(fullpath));
         strlcat(fullpath, "/", sizeof(fullpath));
         strlcat(fullpath, name, sizeof(fullpath));
     }
 
     tty_unhide_cursor(tty);
     tty_setcol(tty, 0);
     tty_printf(tty, "Remove '%s'? [y/N] ", fullpath);
     tty_flush(tty);
 
     char response = tty_getchar(tty);
 
     return (response == 'y' || response == 'Y');
 }
 
 static void draw(tty_interface_t *state) {
     tty_t *tty = state->tty;
     entries_t *entries = state->entries;
     const options_t *options = state->options;
 
     unsigned int num_header = 1;
     unsigned int num_footer = 1;
     unsigned int num_files = options->num_files;
 
     size_t start = 0;
     size_t scroll_threshold = (num_files / 2) + 1;
 
     if (entries->selection >= scroll_threshold && entries->size > num_files) {
         start = entries->selection - scroll_threshold + num_header;
 
         if (start + num_files >= entries->size && entries->size > 0) {
            start = entries->size - num_files;
         }
     }
 
     tty_title(tty, "");
     tty_clearline(tty);
     tty_setcol(tty, 0);
     tty_printf(tty, "%s", entries->path);
     tty_clearline(tty);
     tty_setcol(tty, 0);
     tty_printf(tty, "\n");
 
     for (size_t i = start; i < start + num_files; i++) {
         tty_clearline(tty);
         tty_setcol(tty, 0);
         tty_printf(tty, "\n");
 
         struct entry *entry = entries_item(entries, i);
         if (entry) {
             tty_clearline(tty);
             tty_setcol(tty, 2);
             tty_setfg(tty, entry->color);
 
             if (i == entries->selection) tty_setinvert(tty);
             tty_printf(tty, "%s%c", entry->name, entry->cm);
             tty_setnormal(tty);
         }
     }
 
     tty_clearline(tty);
     tty_setcol(tty, 0);
     tty_printf(tty, "\n");
     tty_moveup(tty, num_files + num_header + num_footer);
     tty_flush(tty);
 }
 
 #define EXEC_REPLACE 1
 #define EXEC_SHELL   2
 #define EXEC_CAPTURE 4
 
 static int xspawn(const char *cmd, char *const argv[], int flags, char *out_buf, size_t out_sz) {
     int pipefd[2];
 
     if (flags & EXEC_CAPTURE) {
         if (pipe(pipefd) == -1) return -1;
     }
 
     pid_t pid = (flags & EXEC_REPLACE) ? 0 : fork();
 
     if (pid == -1) return -1;
 
     if (pid == 0) {
         if (flags & EXEC_CAPTURE) {
             dup2(pipefd[1], STDOUT_FILENO);
             close(pipefd[0]);
             close(pipefd[1]);
         }
 
         if (flags & EXEC_SHELL) {
             execlp("sh", "sh", "-c", cmd, (char *)NULL);
         } else {
             execvp(cmd, argv);
         }
 
         perror("exec failed");
         if (flags & EXEC_REPLACE) return -1;
         _exit(EXIT_FAILURE);
     }
 
     if (flags & EXEC_CAPTURE) {
         close(pipefd[1]);
         read(pipefd[0], out_buf, out_sz - 1);
         close(pipefd[0]);
     }
 
     int status;
     waitpid(pid, &status, 0);
     return WEXITSTATUS(status);
 }
 
 void action_ignore(tty_interface_t *state, const char *argv) {
     (void)state;
     (void)argv;
 }
 
 void action_select(tty_interface_t *state, const char *argv) {
     (void)argv;
     int done = entries_select(state->entries);
 
     if (!done) {
         draw(state);
     } else {
         clear(state);
         const struct entry *selection = entries_selected(state->entries);
 
         if (state->options->run == NULL) {
             printf("%s/%s\n", state->entries->path, selection->name);
             state->exit = EXIT_SUCCESS;
         } else {
             char fullpath[2*PATH_MAX];
             snprintf(fullpath, sizeof(fullpath), "%s/%s", state->entries->path, selection->name);
 
             char *const sargv[] = {(char *)state->options->run, fullpath, NULL};
             xspawn(state->options->run, sargv, EXEC_REPLACE, NULL, 0);
             state->exit = EXIT_FAILURE;
         }
         tty_close(state->tty);
     }
 }
 
 void action_reload(tty_interface_t *state, const char *argv) {
     (void)argv;
     entries_reload(state->entries);
     draw(state);
 }
 
 void action_parent(tty_interface_t *state, const char *argv) {
     (void)argv;
     entries_parent(state->entries);
     draw(state);
 }
 
 void action_prev(tty_interface_t *state, const char *argv) {
     (void)argv;
     entries_prev(state->entries);
     draw(state);
 }
 
 void action_next(tty_interface_t *state, const char *argv) {
     (void)argv;
     entries_next(state->entries);
     draw(state);
 }
 
 void action_halfpageup(tty_interface_t *state, const char *argv) {
     (void)argv;
     for (size_t i = 0; i < (state->options->num_files / 2) && state->entries->selection > 0; i++)
         entries_prev(state->entries);
 
     draw(state);
 }
 
 void action_halfpagedown(tty_interface_t *state, const char *argv) {
     (void)argv;
     for (size_t i = 0; i < (state->options->num_files / 2) && state->entries->selection < state->entries->size - 1; i++)
         entries_next(state->entries);
 
     draw(state);
 }
 
 void action_pageup(tty_interface_t *state, const char *argv) {
     (void)argv;
     for (size_t i = 0; i < state->options->num_files && state->entries->selection > 0; i++)
         entries_prev(state->entries);
 
     draw(state);
 }
 
 void action_pagedown(tty_interface_t *state, const char *argv) {
     (void)argv;
     for (size_t i = 0; i < state->options->num_files && state->entries->selection < state->entries->size - 1; i++)
         entries_next(state->entries);
 
     draw(state);
 }
 
 void action_first(tty_interface_t *state, const char *argv) {
     (void)argv;
     entries_position(state->entries, 0);
     draw(state);
 }
 
 void action_last(tty_interface_t *state, const char *argv) {
     (void)argv;
     entries_position(state->entries, state->entries->size - 1);
     draw(state);
 }
 
 void action_home(tty_interface_t *state, const char *argv) {
     (void)argv;
     entries_setpath(state->entries, getenv("HOME"));
     draw(state);
 }
 
 void action_togglehidden(tty_interface_t *state, const char *argv) {
     (void)argv;
     entries_togglehidden();
     draw(state);
 }
 
 void action_run(tty_interface_t *state, const char *argv) {
     (void)argv;
 
     const struct entry *entry = entries_item(state->entries, state->entries->selection);
     if (!entry) return;
 
     size_t input_len = strlen(argv) + PATH_MAX;
     char *input = malloc(input_len);
 
     if (input == NULL) {
         perror("Failed to allocate memory");
         return;
     }
 
     snprintf(input, input_len, argv, state->entries->path, entry->name);
 
     clear(state);
     tty_unhide_cursor(state->tty);
     xspawn(input, NULL, EXEC_SHELL, NULL, 0);
 
     free(input);
     tty_hide_cursor(state->tty);
     draw(state);
 }
 
 void action_setpath(tty_interface_t *state, const char *argv) {
     size_t input_len = strlen(argv) + PATH_MAX;
     char *input = malloc(input_len);
 
     if (input == NULL) {
         perror("Failed to allocate memory");
         return;
     }
 
     snprintf(input, input_len, argv, state->entries->path);
 
     char output[PATH_MAX];
     clear(state);
 
     if (0 == xspawn(input, NULL, EXEC_SHELL | EXEC_CAPTURE, output, sizeof(output)))
         entries_setpath(state->entries, output);
 
     free(input);
     tty_hide_cursor(state->tty);
     draw(state);
 }
 
 void action_remove(tty_interface_t *state, const char *argv) {
 	(void)argv;
 
 	const struct entry *entry = entries_selected(state->entries);
 	if (!entry) return;
 
 	if (confirm_remove(state, entry->name)) {
 		if (entries_remove(state->entries) == 0) {
 			size_t selection = state->entries->selection;
 			entries_setpath(state->entries, state->entries->path);
 
 			size_t pos = selection < state->entries->size
 				? selection : state->entries->size - 1;
 			entries_position(state->entries, pos);
 		}
 	}
 
 	tty_hide_cursor(state->tty);
 	draw(state);
 }
 
 static int prompt_input(tty_interface_t *state, const char *prompt, char *buffer, size_t size) {
 	tty_t *tty = state->tty;
 	int len = 0;
 
 	tty_unhide_cursor(tty);
 	tty_setcol(tty, 0);
 	tty_clearline(tty);
 	tty_printf(tty, "%s", prompt);
 	tty_flush(tty);
 
 	for (;;) {
 		char c = tty_getchar(tty);
 		if (c == '\r' || c == '\n') {
 			break;
 		} else if (c == '\x1b') {
 			buffer[0] = '\0';
 			return -1;
 		} else if (c == '\x7f' || c == '\b') {
 			if (len > 0) {
 				len--;
 				buffer[len] = '\0';
 				tty_printf(tty, "\b \b");
 				tty_flush(tty);
 			}
 		} else if (len < (int)size - 1 && c >= ' ' && c <= '~') {
 			buffer[len++] = c;
 			buffer[len] = '\0';
 			tty_printf(tty, "%c", c);
 			tty_flush(tty);
 		}
 	}
 	return len;
 }
 
 void action_create(tty_interface_t *state, const char *argv) {
 	(void)argv;
 	char filename[PATH_MAX] = "";
 
 	if (prompt_input(state, "Create file: ", filename, sizeof(filename)) > 0) {
 		if (entries_create_file(state->entries, filename) == 0) {
 			entries_setpath(state->entries, state->entries->path);
 			int index = entries_find_file(state->entries, filename);
 			if (index != -1) {
 				entries_position(state->entries, (size_t)index);
 			}
 		}
 	}
 
 	tty_hide_cursor(state->tty);
 	draw(state);
 }
 
 void action_mkdir(tty_interface_t *state, const char *argv) {
 	(void)argv;
 	char dirname[PATH_MAX] = "";
 
 	if (prompt_input(state, "Create directory: ", dirname, sizeof(dirname)) > 0) {
 		if (entries_create_dir(state->entries, dirname) == 0) {
 			entries_setpath(state->entries, state->entries->path);
 			int index = entries_find_file(state->entries, dirname);
 			if (index != -1) {
 				entries_position(state->entries, (size_t)index);
 			}
 		}
 	}
 
 	tty_hide_cursor(state->tty);
 	draw(state);
 }
 
 void action_copy(tty_interface_t *state, const char *argv) {
 	(void)argv;
 	const struct entry *entry = entries_selected(state->entries);
 	if (!entry) return;
 
 	if (strcmp(state->entries->path, "/") == 0) {
 		strlcpy(state->copy_buffer, "/", sizeof(state->copy_buffer));
 		strlcat(state->copy_buffer, entry->name, sizeof(state->copy_buffer));
 	} else {
 		strlcpy(state->copy_buffer, state->entries->path, sizeof(state->copy_buffer));
 		strlcat(state->copy_buffer, "/", sizeof(state->copy_buffer));
 		strlcat(state->copy_buffer, entry->name, sizeof(state->copy_buffer));
 	}
 	state->has_copied = 1;
 	state->is_cut = 0;
 
 	tty_setcol(state->tty, 0);
 	tty_clearline(state->tty);
 	tty_printf(state->tty, "Copied %s", state->copy_buffer);
 	tty_flush(state->tty);
 }
 
 void action_cut(tty_interface_t *state, const char *argv) {
 	(void)argv;
 	const struct entry *entry = entries_selected(state->entries);
 	if (!entry) return;
 
 	if (strcmp(state->entries->path, "/") == 0) {
 		strlcpy(state->copy_buffer, "/", sizeof(state->copy_buffer));
 		strlcat(state->copy_buffer, entry->name, sizeof(state->copy_buffer));
 	} else {
 		strlcpy(state->copy_buffer, state->entries->path, sizeof(state->copy_buffer));
 		strlcat(state->copy_buffer, "/", sizeof(state->copy_buffer));
 		strlcat(state->copy_buffer, entry->name, sizeof(state->copy_buffer));
 	}
 	state->has_copied = 1;
 	state->is_cut = 1;
 
 	tty_setcol(state->tty, 0);
 	tty_clearline(state->tty);
 	tty_printf(state->tty, "Cut %s", state->copy_buffer);
 	tty_flush(state->tty);
 }
 
 void action_paste(tty_interface_t *state, const char *argv) {
 	(void)argv;
 	if (!state->has_copied) return;
 
 	char *filename = strrchr(state->copy_buffer, '/');
 	if (!filename) filename = state->copy_buffer;
 	else filename++;
 
 	char dst_path[PATH_MAX];
 	if (strcmp(state->entries->path, "/") == 0) {
 		strlcpy(dst_path, "/", sizeof(dst_path));
 		strlcat(dst_path, filename, sizeof(dst_path));
 	} else {
 		strlcpy(dst_path, state->entries->path, sizeof(dst_path));
 		strlcat(dst_path, "/", sizeof(dst_path));
 		strlcat(dst_path, filename, sizeof(dst_path));
 	}
 
 	int result = 0;
 	if (state->is_cut) {
 		result = entries_move_file(state->copy_buffer, dst_path);
 		if (result == 0) {
 			state->has_copied = 0;
 			state->is_cut = 0;
 		}
 	} else {
 		result = entries_copy_file(state->copy_buffer, dst_path);
 	}
 
 	if (result == 0) {
 		entries_setpath(state->entries, state->entries->path);
 		int index = entries_find_file(state->entries, filename);
 		if (index != -1) {
 			entries_position(state->entries, (size_t)index);
 		}
 	}
 
 draw(state);
 
 	if (result == 0) {
 		tty_setcol(state->tty, 0);
 		tty_clearline(state->tty);
 		if (state->is_cut) {
 			tty_printf(state->tty, "Moved %s", state->copy_buffer);
 		} else {
 			tty_printf(state->tty, "Pasted %s", state->copy_buffer);
 		}
 		tty_flush(state->tty);
 	}
 }
 
 void action_exit(tty_interface_t *state, const char *argv) {
     (void)argv;
     clear(state);
     tty_close(state->tty);
     state->exit = EXIT_FAILURE;
 }
 
 
 void tty_interface_init(tty_interface_t *state, tty_t *tty, entries_t *entries, options_t *options) {
     if (options->num_files + 1 > tty_getheight(tty)) {
         options->num_files = tty_getheight(tty) - 3;
     }
 
     state->tty = tty;
     state->entries = entries;
     state->options = options;
     state->ambiguous_key_pending = 0;
     state->exit = -1;
     state->has_copied = 0;
     state->is_cut = 0;
     strcpy(state->input, "");
 
     tty_hide_cursor(tty);
     draw(state);
 }
 
 static void handle_input(tty_interface_t *state, const char *s, int handle_ambiguous_key) {
     state->ambiguous_key_pending = 0;
 
     char *input = state->input;
     strcat(state->input, s);
 
     /* Figure out if we have completed a keybinding and whether we're in the
      * middle of one (both can happen, because of Esc). */
     int found_keybinding = -1;
     int in_middle = 0;
     const keybinding_t *keybindings = state->options->keybindings;
     for (int i = 0; keybindings[i].key; i++) {
         if (!strcmp(input, keybindings[i].key))
             found_keybinding = i;
         else if (!strncmp(input, keybindings[i].key, strlen(state->input)))
             in_middle = 1;
     }
 
     if (found_keybinding != -1 && (!in_middle || handle_ambiguous_key)) {
         keybindings[found_keybinding].action(state, keybindings[found_keybinding].argv);
         strcpy(input, "");
         return;
     }
 
     if (in_middle) {
         state->ambiguous_key_pending = 1;
         return;
     }
 
     strcpy(input, "");
 }
 
 int tty_interface_run(tty_interface_t *state) {
     for (;;) {
         do {
             while(!tty_input_ready(state->tty, -1, 1)) {
                 draw(state);
             }
 
             const char s[2] = {tty_getchar(state->tty), '\0'};
             handle_input(state, s, 0);
 
             if (state->ambiguous_key_pending == 1)
                 continue;
 
             if (state->exit >= 0)
                 return state->exit;
 
         } while (tty_input_ready(state->tty, state->ambiguous_key_pending ? state->options->keytimeout : 0, 0));
 
         if (state->ambiguous_key_pending) {
             const char s[1] = "";
             handle_input(state, s, 1);
 
             if (state->exit >= 0)
                 return state->exit;
         }
     }
 
     return state->exit;
 }