1 #define _XOPEN_SOURCE 700
2 #define _XOPEN_SOURCE_EXTENDED
3 #define _FILE_OFFSET_BITS 64
11 #include <sys/types.h> /* pid_t, ... */
13 #include <limits.h> /* PATH_MAX */
14 #include <locale.h> /* setlocale(), LC_ALL */
15 #include <unistd.h> /* chdir(), getcwd(), read(), close(), ... */
16 #include <dirent.h> /* DIR, struct dirent, opendir(), ... */
18 #include <fcntl.h> /* open() */
19 #include <sys/wait.h> /* waitpid() */
20 #include <signal.h> /* struct sigaction, sigaction() */
28 #define BUFLEN PATH_MAX
29 static char BUF1[BUFLEN];
30 static char BUF2[BUFLEN];
31 static char INPUT[BUFLEN];
32 static wchar_t WBUF[BUFLEN];
34 /* Argument buffers for execvp(). */
36 static char *ARGS[MAXARGS];
38 /* Listing view parameters. */
39 #define HEIGHT (LINES-4)
40 #define STATUSPOS (COLS-16)
42 /* Listing view flags. */
43 #define SHOW_FILES 0x01u
44 #define SHOW_DIRS 0x02u
45 #define SHOW_HIDDEN 0x04u
47 /* Marks parameters. */
49 #define BULK_THRESH 256
51 /* Information associated to each entry in listing. */
60 /* Dynamic array of marked entries. */
61 typedef struct Marks {
62 char dirpath[PATH_MAX];
68 /* Line editing state. */
70 wchar_t buffer[BUFLEN+1];
74 /* Each tab only stores the following information. */
97 volatile sig_atomic_t pending_winch;
102 /* Macros for accessing global state. */
103 #define ENAME(I) rover.rows[I].name
104 #define ESIZE(I) rover.rows[I].size
105 #define EMODE(I) rover.rows[I].mode
106 #define ISLINK(I) rover.rows[I].islink
107 #define MARKED(I) rover.rows[I].marked
108 #define SCROLL rover.tabs[rover.tab].scroll
109 #define ESEL rover.tabs[rover.tab].esel
110 #define FLAGS rover.tabs[rover.tab].flags
111 #define CWD rover.tabs[rover.tab].cwd
114 #define MIN(A, B) ((A) < (B) ? (A) : (B))
115 #define MAX(A, B) ((A) > (B) ? (A) : (B))
116 #define ISDIR(E) (strchr((E), '/') != NULL)
118 /* Line Editing Macros. */
119 #define EDIT_FULL(E) ((E).left == (E).right)
120 #define EDIT_CAN_LEFT(E) ((E).left)
121 #define EDIT_CAN_RIGHT(E) ((E).right < BUFLEN-1)
122 #define EDIT_LEFT(E) (E).buffer[(E).right--] = (E).buffer[--(E).left]
123 #define EDIT_RIGHT(E) (E).buffer[(E).left++] = (E).buffer[++(E).right]
124 #define EDIT_INSERT(E, C) (E).buffer[(E).left++] = (C)
125 #define EDIT_BACKSPACE(E) (E).left--
126 #define EDIT_DELETE(E) (E).right++
127 #define EDIT_CLEAR(E) do { (E).left = 0; (E).right = BUFLEN-1; } while(0)
129 typedef enum EditStat {CONTINUE, CONFIRM, CANCEL} EditStat;
130 typedef enum Color {DEFAULT, RED, GREEN, YELLOW, BLUE, CYAN, MAGENTA, WHITE, BLACK} Color;
131 typedef int (*PROCESS)(const char *path);
134 init_marks(Marks *marks)
136 strcpy(marks->dirpath, "");
137 marks->bulk = BULK_INIT;
139 marks->entries = calloc(marks->bulk, sizeof *marks->entries);
142 /* Unmark all entries. */
144 mark_none(Marks *marks)
148 strcpy(marks->dirpath, "");
149 for (i = 0; i < marks->bulk && marks->nentries; i++)
150 if (marks->entries[i]) {
151 free(marks->entries[i]);
152 marks->entries[i] = NULL;
155 if (marks->bulk > BULK_THRESH) {
156 /* Reset bulk to free some memory. */
157 free(marks->entries);
158 marks->bulk = BULK_INIT;
159 marks->entries = calloc(marks->bulk, sizeof *marks->entries);
164 add_mark(Marks *marks, char *dirpath, char *entry)
168 if (!strcmp(marks->dirpath, dirpath)) {
169 /* Append mark to directory. */
170 if (marks->nentries == marks->bulk) {
171 /* Expand bulk to accomodate new entry. */
172 int extra = marks->bulk / 2;
173 marks->bulk += extra; /* bulk *= 1.5; */
174 marks->entries = realloc(marks->entries,
175 marks->bulk * sizeof *marks->entries);
176 memset(&marks->entries[marks->nentries], 0,
177 extra * sizeof *marks->entries);
180 /* Search for empty slot (there must be one). */
181 for (i = 0; i < marks->bulk; i++)
182 if (!marks->entries[i])
186 /* Directory changed. Discard old marks. */
188 strcpy(marks->dirpath, dirpath);
191 marks->entries[i] = malloc(strlen(entry) + 1);
192 strcpy(marks->entries[i], entry);
197 del_mark(Marks *marks, char *entry)
201 if (marks->nentries > 1) {
202 for (i = 0; i < marks->bulk; i++)
203 if (marks->entries[i] && !strcmp(marks->entries[i], entry))
205 free(marks->entries[i]);
206 marks->entries[i] = NULL;
213 free_marks(Marks *marks)
217 for (i = 0; i < marks->bulk && marks->nentries; i++)
218 if (marks->entries[i]) {
219 free(marks->entries[i]);
222 free(marks->entries);
226 handle_winch(int sig)
228 rover.pending_winch = 1;
236 memset(&sa, 0, sizeof (struct sigaction));
237 sa.sa_handler = handle_winch;
238 sigaction(SIGWINCH, &sa, NULL);
246 memset(&sa, 0, sizeof (struct sigaction));
247 sa.sa_handler = SIG_DFL;
248 sigaction(SIGWINCH, &sa, NULL);
251 static void update_view();
253 /* Handle any signals received since last call. */
257 if (rover.pending_winch) {
258 /* SIGWINCH received: resize application accordingly. */
259 delwin(rover.window);
263 rover.window = subwin(stdscr, LINES - 2, COLS, 1, 0);
264 if (HEIGHT < rover.nfiles && SCROLL + HEIGHT > rover.nfiles)
265 SCROLL = ESEL - HEIGHT;
267 rover.pending_winch = 0;
271 /* This function must be used in place of getch().
272 It handles signals while waiting for user input. */
278 while ((ch = getch()) == ERR)
283 /* This function must be used in place of get_wch().
284 It handles signals while waiting for user input. */
286 rover_get_wch(wint_t *wch)
290 while ((ret = get_wch(wch)) == (wint_t) ERR)
295 /* Do a fork-exec to external program (e.g. $EDITOR). */
302 setenv("RVSEL", rover.nfiles ? ENAME(ESEL) : "", 1);
305 /* fork() succeeded. */
308 waitpid(pid, &status, 0);
310 kill(getpid(), SIGWINCH);
311 } else if (pid == 0) {
313 execvp(ARGS[0], ARGS);
321 setlocale(LC_ALL, "");
323 cbreak(); /* Get one character at a time. */
324 timeout(100); /* For getch(). */
326 nonl(); /* No NL->CR/NL on output. */
327 intrflush(stdscr, FALSE);
328 keypad(stdscr, TRUE);
329 curs_set(FALSE); /* Hide blinking cursor. */
333 #ifdef NCURSES_EXT_FUNCS
334 use_default_colors();
339 init_pair(RED, COLOR_RED, bg);
340 init_pair(GREEN, COLOR_GREEN, bg);
341 init_pair(YELLOW, COLOR_YELLOW, bg);
342 init_pair(BLUE, COLOR_BLUE, bg);
343 init_pair(CYAN, COLOR_CYAN, bg);
344 init_pair(MAGENTA, COLOR_MAGENTA, bg);
345 init_pair(WHITE, COLOR_WHITE, bg);
346 init_pair(BLACK, COLOR_BLACK, bg);
348 atexit((void (*)(void)) endwin);
352 /* Update the listing view. */
361 mvhline(0, 0, ' ', COLS);
362 attr_on(A_BOLD, NULL);
363 color_set(RVC_TABNUM, NULL);
364 mvaddch(0, COLS - 2, rover.tab + '0');
365 attr_off(A_BOLD, NULL);
366 if (rover.marks.nentries) {
367 numsize = snprintf(BUF1, BUFLEN, "%d", rover.marks.nentries);
368 color_set(RVC_MARKS, NULL);
369 mvaddstr(0, COLS - 3 - numsize, BUF1);
372 color_set(RVC_CWD, NULL);
373 mbstowcs(WBUF, CWD, PATH_MAX);
374 mvaddnwstr(0, 0, WBUF, COLS - 4 - numsize);
375 wcolor_set(rover.window, RVC_BORDER, NULL);
376 wborder(rover.window, 0, 0, 0, 0, 0, 0, 0, 0);
377 ESEL = MAX(MIN(ESEL, rover.nfiles - 1), 0);
378 /* Selection might not be visible, due to cursor wrapping or window
379 shrinking. In that case, the scroll must be moved to make it visible. */
380 if (rover.nfiles > HEIGHT) {
381 SCROLL = MAX(MIN(SCROLL, ESEL), ESEL - HEIGHT + 1);
382 SCROLL = MIN(MAX(SCROLL, 0), rover.nfiles - HEIGHT);
385 marking = !strcmp(CWD, rover.marks.dirpath);
386 for (i = 0, j = SCROLL; i < HEIGHT && j < rover.nfiles; i++, j++) {
387 ishidden = ENAME(j)[0] == '.';
389 wattr_on(rover.window, A_REVERSE, NULL);
391 wcolor_set(rover.window, RVC_LINK, NULL);
393 wcolor_set(rover.window, RVC_HIDDEN, NULL);
394 else if (S_ISREG(EMODE(j))) {
395 if (EMODE(j) & (S_IXUSR | S_IXGRP | S_IXOTH))
396 wcolor_set(rover.window, RVC_EXEC, NULL);
398 wcolor_set(rover.window, RVC_REG, NULL);
399 } else if (S_ISDIR(EMODE(j)))
400 wcolor_set(rover.window, RVC_DIR, NULL);
401 else if (S_ISCHR(EMODE(j)))
402 wcolor_set(rover.window, RVC_CHR, NULL);
403 else if (S_ISBLK(EMODE(j)))
404 wcolor_set(rover.window, RVC_BLK, NULL);
405 else if (S_ISFIFO(EMODE(j)))
406 wcolor_set(rover.window, RVC_FIFO, NULL);
407 else if (S_ISSOCK(EMODE(j)))
408 wcolor_set(rover.window, RVC_SOCK, NULL);
409 if (!S_ISDIR(EMODE(j))) {
410 char *suffix, *suffixes = "BKMGTPEZY";
411 off_t human_size = ESIZE(j) * 10;
412 int length = mbstowcs(NULL, ENAME(j), 0);
413 for (suffix = suffixes; human_size >= 10240; suffix++)
414 human_size = (human_size + 512) / 1024;
416 swprintf(WBUF, PATH_MAX, L"%s%*d %c", ENAME(j),
417 (int) (COLS - length - 6),
418 (int) human_size / 10, *suffix);
420 swprintf(WBUF, PATH_MAX, L"%s%*d.%d %c", ENAME(j),
421 (int) (COLS - length - 8),
422 (int) human_size / 10, (int) human_size % 10, *suffix);
424 mbstowcs(WBUF, ENAME(j), PATH_MAX);
425 mvwhline(rover.window, i + 1, 1, ' ', COLS - 2);
426 mvwaddnwstr(rover.window, i + 1, 2, WBUF, COLS - 4);
427 if (marking && MARKED(j)) {
428 wcolor_set(rover.window, RVC_MARKS, NULL);
429 mvwaddch(rover.window, i + 1, 1, RVS_MARK);
431 mvwaddch(rover.window, i + 1, 1, ' ');
433 wattr_off(rover.window, A_REVERSE, NULL);
435 for (; i < HEIGHT; i++)
436 mvwhline(rover.window, i + 1, 1, ' ', COLS - 2);
437 if (rover.nfiles > HEIGHT) {
439 center = (SCROLL + HEIGHT / 2) * HEIGHT / rover.nfiles;
440 height = (HEIGHT-1) * HEIGHT / rover.nfiles;
441 if (!height) height = 1;
442 wcolor_set(rover.window, RVC_SCROLLBAR, NULL);
443 mvwvline(rover.window, center-height/2+1, COLS-1, RVS_SCROLLBAR, height);
445 BUF1[0] = FLAGS & SHOW_FILES ? 'F' : ' ';
446 BUF1[1] = FLAGS & SHOW_DIRS ? 'D' : ' ';
447 BUF1[2] = FLAGS & SHOW_HIDDEN ? 'H' : ' ';
451 snprintf(BUF2, BUFLEN, "%d/%d", ESEL + 1, rover.nfiles);
452 snprintf(BUF1+3, BUFLEN-3, "%12s", BUF2);
453 color_set(RVC_STATUS, NULL);
454 mvaddstr(LINES - 1, STATUSPOS, BUF1);
455 wrefresh(rover.window);
458 /* Show a message on the status bar. */
460 message(Color color, char *fmt, ...)
466 vsnprintf(BUF1, MIN(BUFLEN, STATUSPOS), fmt, args);
469 pos = (STATUSPOS - len) / 2;
470 attr_on(A_BOLD, NULL);
471 color_set(color, NULL);
472 mvaddstr(LINES - 1, pos, BUF1);
473 color_set(DEFAULT, NULL);
474 attr_off(A_BOLD, NULL);
477 /* Clear message area, leaving only status info. */
481 mvhline(LINES - 1, 0, ' ', STATUSPOS);
484 /* Comparison used to sort listing entries. */
486 rowcmp(const void *a, const void *b)
488 int isdir1, isdir2, cmpdir;
491 isdir1 = S_ISDIR(r1->mode);
492 isdir2 = S_ISDIR(r2->mode);
493 cmpdir = isdir2 - isdir1;
494 return cmpdir ? cmpdir : strcoll(r1->name, r2->name);
497 /* Get all entries in current working directory. */
499 ls(Row **rowsp, uint8_t flags)
507 if(!(dp = opendir("."))) return -1;
508 n = -2; /* We don't want the entries "." and "..". */
509 while (readdir(dp)) n++;
511 rows = malloc(n * sizeof *rows);
513 while ((ep = readdir(dp))) {
514 if (!strcmp(ep->d_name, ".") || !strcmp(ep->d_name, ".."))
516 if (!(flags & SHOW_HIDDEN) && ep->d_name[0] == '.')
518 lstat(ep->d_name, &statbuf);
519 rows[i].islink = S_ISLNK(statbuf.st_mode);
520 stat(ep->d_name, &statbuf);
521 if (S_ISDIR(statbuf.st_mode)) {
522 if (flags & SHOW_DIRS) {
523 rows[i].name = malloc(strlen(ep->d_name) + 2);
524 strcpy(rows[i].name, ep->d_name);
525 strcat(rows[i].name, "/");
526 rows[i].mode = statbuf.st_mode;
529 } else if (flags & SHOW_FILES) {
530 rows[i].name = malloc(strlen(ep->d_name) + 1);
531 strcpy(rows[i].name, ep->d_name);
532 rows[i].size = statbuf.st_size;
533 rows[i].mode = statbuf.st_mode;
537 n = i; /* Ignore unused space in array caused by filters. */
538 qsort(rows, n, sizeof (*rows), rowcmp);
545 free_rows(Row **rowsp, int nfiles)
549 for (i = 0; i < nfiles; i++)
550 free((*rowsp)[i].name);
555 /* Change working directory to the path in CWD. */
561 message(CYAN, "Loading...");
563 if (reset) ESEL = SCROLL = 0;
566 free_rows(&rover.rows, rover.nfiles);
567 rover.nfiles = ls(&rover.rows, FLAGS);
568 if (!strcmp(CWD, rover.marks.dirpath)) {
569 for (i = 0; i < rover.nfiles; i++) {
570 for (j = 0; j < rover.marks.bulk; j++)
572 rover.marks.entries[j] &&
573 !strcmp(rover.marks.entries[j], ENAME(i))
576 MARKED(i) = j < rover.marks.bulk;
579 for (i = 0; i < rover.nfiles; i++)
585 /* Select a target entry, if it is present. */
587 try_to_sel(const char *target)
591 while ((ESEL+1) < rover.nfiles && S_ISDIR(EMODE(ESEL)))
593 while ((ESEL+1) < rover.nfiles && strcoll(ENAME(ESEL), target) < 0)
597 /* Reload CWD, but try to keep selection. */
602 strcpy(INPUT, ENAME(ESEL));
611 count_dir(const char *path)
616 char subpath[PATH_MAX];
619 if(!(dp = opendir(path))) return 0;
621 while ((ep = readdir(dp))) {
622 if (!strcmp(ep->d_name, ".") || !strcmp(ep->d_name, ".."))
624 snprintf(subpath, PATH_MAX, "%s%s", path, ep->d_name);
625 lstat(subpath, &statbuf);
626 if (S_ISDIR(statbuf.st_mode)) {
627 strcat(subpath, "/");
628 total += count_dir(subpath);
630 total += statbuf.st_size;
645 chdir(rover.marks.dirpath);
646 for (i = 0; i < rover.marks.bulk; i++) {
647 entry = rover.marks.entries[i];
650 total += count_dir(entry);
652 lstat(entry, &statbuf);
653 total += statbuf.st_size;
661 /* Recursively process a source directory using CWD as destination root.
662 For each node (i.e. directory), do the following:
663 1. call pre(destination);
664 2. call proc() on every child leaf (i.e. files);
665 3. recurse into every child node;
667 E.g. to move directory /src/ (and all its contents) inside /dst/:
668 strcpy(CWD, "/dst/");
669 process_dir(adddir, movfile, deldir, "/src/"); */
671 process_dir(PROCESS pre, PROCESS proc, PROCESS pos, const char *path)
677 char subpath[PATH_MAX];
681 char dstpath[PATH_MAX];
682 strcpy(dstpath, CWD);
683 strcat(dstpath, path + strlen(rover.marks.dirpath));
686 if(!(dp = opendir(path))) return -1;
687 while ((ep = readdir(dp))) {
688 if (!strcmp(ep->d_name, ".") || !strcmp(ep->d_name, ".."))
690 snprintf(subpath, PATH_MAX, "%s%s", path, ep->d_name);
691 stat(subpath, &statbuf);
692 if (S_ISDIR(statbuf.st_mode)) {
693 strcat(subpath, "/");
694 ret |= process_dir(pre, proc, pos, subpath);
696 ret |= proc(subpath);
699 if (pos) ret |= pos(path);
703 /* Process all marked entries using CWD as destination root.
704 All marked entries that are directories will be recursively processed.
705 See process_dir() for details on the parameters. */
707 process_marked(PROCESS pre, PROCESS proc, PROCESS pos,
708 const char *msg_doing, const char *msg_done)
715 message(CYAN, "%s...", msg_doing);
717 rover.prog = (Prog) {0, count_marked(), msg_doing};
718 for (i = 0; i < rover.marks.bulk; i++) {
719 entry = rover.marks.entries[i];
722 snprintf(path, PATH_MAX, "%s%s", rover.marks.dirpath, entry);
724 if (!strncmp(path, CWD, strlen(path)))
727 ret = process_dir(pre, proc, pos, path);
731 del_mark(&rover.marks, entry);
736 rover.prog.total = 0;
738 if (!rover.marks.nentries)
739 message(GREEN, "%s all marked entries.", msg_done);
741 message(RED, "Some errors occured while %s.", msg_doing);
746 update_progress(off_t delta)
750 if (!rover.prog.total) return;
751 rover.prog.partial += delta;
752 percent = (int) (rover.prog.partial * 100 / rover.prog.total);
753 message(CYAN, "%s...%d%%", rover.prog.msg, percent);
757 /* Wrappers for file operations. */
758 static int delfile(const char *path) {
762 ret = lstat(path, &st);
763 if (ret < 0) return ret;
764 update_progress(st.st_size);
767 static PROCESS deldir = rmdir;
768 static int addfile(const char *path) {
769 /* Using creat(2) because mknod(2) doesn't seem to be portable. */
772 ret = creat(path, 0644);
773 if (ret < 0) return ret;
776 static int cpyfile(const char *srcpath) {
781 char dstpath[PATH_MAX];
783 ret = src = open(srcpath, O_RDONLY);
784 if (ret < 0) return ret;
785 ret = fstat(src, &st);
786 if (ret < 0) return ret;
787 strcpy(dstpath, CWD);
788 strcat(dstpath, srcpath + strlen(rover.marks.dirpath));
789 ret = dst = creat(dstpath, st.st_mode);
790 if (ret < 0) return ret;
791 while ((size = read(src, buf, BUFSIZ)) > 0) {
792 write(dst, buf, size);
793 update_progress(size);
800 static int adddir(const char *path) {
804 ret = stat(CWD, &st);
805 if (ret < 0) return ret;
806 return mkdir(path, st.st_mode);
808 static int movfile(const char *srcpath) {
811 char dstpath[PATH_MAX];
813 strcpy(dstpath, CWD);
814 strcat(dstpath, srcpath + strlen(rover.marks.dirpath));
815 ret = rename(srcpath, dstpath);
817 ret = lstat(dstpath, &st);
818 if (ret < 0) return ret;
819 update_progress(st.st_size);
820 } else if (errno == EXDEV) {
821 ret = cpyfile(srcpath);
822 if (ret < 0) return ret;
823 ret = unlink(srcpath);
829 start_line_edit(const char *init_input)
832 strncpy(INPUT, init_input, BUFLEN);
833 rover.edit.left = mbstowcs(rover.edit.buffer, init_input, BUFLEN);
834 rover.edit.right = BUFLEN - 1;
835 rover.edit.buffer[BUFLEN] = L'\0';
836 rover.edit_scroll = 0;
839 /* Read input and change editing state accordingly. */
843 wchar_t eraser, killer, wch;
846 ret = rover_get_wch((wint_t *) &wch);
849 if (ret == KEY_CODE_YES) {
850 if (wch == KEY_ENTER) {
853 } else if (wch == KEY_LEFT) {
854 if (EDIT_CAN_LEFT(rover.edit)) EDIT_LEFT(rover.edit);
855 } else if (wch == KEY_RIGHT) {
856 if (EDIT_CAN_RIGHT(rover.edit)) EDIT_RIGHT(rover.edit);
857 } else if (wch == KEY_UP) {
858 while (EDIT_CAN_LEFT(rover.edit)) EDIT_LEFT(rover.edit);
859 } else if (wch == KEY_DOWN) {
860 while (EDIT_CAN_RIGHT(rover.edit)) EDIT_RIGHT(rover.edit);
861 } else if (wch == KEY_BACKSPACE) {
862 if (EDIT_CAN_LEFT(rover.edit)) EDIT_BACKSPACE(rover.edit);
863 } else if (wch == KEY_DC) {
864 if (EDIT_CAN_RIGHT(rover.edit)) EDIT_DELETE(rover.edit);
867 if (wch == L'\r' || wch == L'\n') {
870 } else if (wch == L'\t') {
873 } else if (wch == eraser) {
874 if (EDIT_CAN_LEFT(rover.edit)) EDIT_BACKSPACE(rover.edit);
875 } else if (wch == killer) {
876 EDIT_CLEAR(rover.edit);
878 } else if (iswprint(wch)) {
879 if (!EDIT_FULL(rover.edit)) EDIT_INSERT(rover.edit, wch);
882 /* Encode edit contents in INPUT. */
883 rover.edit.buffer[rover.edit.left] = L'\0';
884 length = wcstombs(INPUT, rover.edit.buffer, BUFLEN);
885 wcstombs(&INPUT[length], &rover.edit.buffer[rover.edit.right+1],
890 /* Update line input on the screen. */
892 update_input(const char *prompt, Color color)
894 int plen, ilen, maxlen;
896 plen = strlen(prompt);
897 ilen = mbstowcs(NULL, INPUT, 0);
898 maxlen = STATUSPOS - plen - 2;
899 if (ilen - rover.edit_scroll < maxlen)
900 rover.edit_scroll = MAX(ilen - maxlen, 0);
901 else if (rover.edit.left > rover.edit_scroll + maxlen - 1)
902 rover.edit_scroll = rover.edit.left - maxlen;
903 else if (rover.edit.left < rover.edit_scroll)
904 rover.edit_scroll = MAX(rover.edit.left - maxlen, 0);
905 color_set(RVC_PROMPT, NULL);
906 mvaddstr(LINES - 1, 0, prompt);
907 color_set(color, NULL);
908 mbstowcs(WBUF, INPUT, COLS);
909 mvaddnwstr(LINES - 1, plen, &WBUF[rover.edit_scroll], maxlen);
910 mvaddch(LINES - 1, plen + MIN(ilen - rover.edit_scroll, maxlen + 1), ' ');
911 color_set(DEFAULT, NULL);
912 if (rover.edit_scroll)
913 mvaddch(LINES - 1, plen - 1, '<');
914 if (ilen > rover.edit_scroll + maxlen)
915 mvaddch(LINES - 1, plen + maxlen, '>');
916 move(LINES - 1, plen + rover.edit.left - rover.edit_scroll);
920 main(int argc, char *argv[])
927 FILE *save_cwd_file = NULL;
930 if (!strcmp(argv[1], "-v") || !strcmp(argv[1], "--version")) {
931 printf("rover %s\n", RV_VERSION);
933 } else if (!strcmp(argv[1], "-h") || !strcmp(argv[1], "--help")) {
935 "Usage: rover [-s|--save-cwd FILE] [DIR [DIR [DIR [...]]]]\n"
936 " Browse current directory or the ones specified.\n"
937 " If FILE is given, write last visited path to it.\n\n"
938 " or: rover -h|--help\n"
939 " Print this help message and exit.\n\n"
940 " or: rover -v|--version\n"
941 " Print program version and exit.\n\n"
942 "See rover(1) for more information.\n\n"
943 "Rover homepage: <https://github.com/lecram/rover>.\n"
946 } else if (!strcmp(argv[1], "-s") || !strcmp(argv[1], "--save-cwd")) {
948 save_cwd_file = fopen(argv[2], "w");
949 argc -= 2; argv += 2;
951 fprintf(stderr, "error: missing argument to %s\n", argv[1]);
958 for (i = 0; i < 10; i++) {
959 rover.tabs[i].esel = rover.tabs[i].scroll = 0;
960 rover.tabs[i].flags = SHOW_FILES | SHOW_DIRS;
962 strcpy(rover.tabs[0].cwd, getenv("HOME"));
963 for (i = 1; i < argc && i < 10; i++) {
964 if ((d = opendir(argv[i]))) {
965 realpath(argv[i], rover.tabs[i].cwd);
968 strcpy(rover.tabs[i].cwd, rover.tabs[0].cwd);
970 getcwd(rover.tabs[i].cwd, PATH_MAX);
971 for (i++; i < 10; i++)
972 strcpy(rover.tabs[i].cwd, rover.tabs[i-1].cwd);
973 for (i = 0; i < 10; i++)
974 if (rover.tabs[i].cwd[strlen(rover.tabs[i].cwd) - 1] != '/')
975 strcat(rover.tabs[i].cwd, "/");
977 rover.window = subwin(stdscr, LINES - 2, COLS, 1, 0);
978 init_marks(&rover.marks);
984 if (!strcmp(key, RVK_QUIT)) break;
985 else if (ch >= '0' && ch <= '9') {
986 rover.tab = ch - '0';
988 } else if (!strcmp(key, RVK_HELP)) {
993 } else if (!strcmp(key, RVK_DOWN)) {
994 if (!rover.nfiles) continue;
995 ESEL = MIN(ESEL + 1, rover.nfiles - 1);
997 } else if (!strcmp(key, RVK_UP)) {
998 if (!rover.nfiles) continue;
999 ESEL = MAX(ESEL - 1, 0);
1001 } else if (!strcmp(key, RVK_JUMP_DOWN)) {
1002 if (!rover.nfiles) continue;
1003 ESEL = MIN(ESEL + RV_JUMP, rover.nfiles - 1);
1004 if (rover.nfiles > HEIGHT)
1005 SCROLL = MIN(SCROLL + RV_JUMP, rover.nfiles - HEIGHT);
1007 } else if (!strcmp(key, RVK_JUMP_UP)) {
1008 if (!rover.nfiles) continue;
1009 ESEL = MAX(ESEL - RV_JUMP, 0);
1010 SCROLL = MAX(SCROLL - RV_JUMP, 0);
1012 } else if (!strcmp(key, RVK_JUMP_TOP)) {
1013 if (!rover.nfiles) continue;
1016 } else if (!strcmp(key, RVK_JUMP_BOTTOM)) {
1017 if (!rover.nfiles) continue;
1018 ESEL = rover.nfiles - 1;
1020 } else if (!strcmp(key, RVK_CD_DOWN)) {
1021 if (!rover.nfiles || !S_ISDIR(EMODE(ESEL))) continue;
1022 if (chdir(ENAME(ESEL)) == -1) {
1023 message(RED, "Cannot access \"%s\".", ENAME(ESEL));
1026 strcat(CWD, ENAME(ESEL));
1028 } else if (!strcmp(key, RVK_CD_UP)) {
1029 char *dirname, first;
1030 if (!strcmp(CWD, "/")) continue;
1031 CWD[strlen(CWD) - 1] = '\0';
1032 dirname = strrchr(CWD, '/') + 1;
1037 dirname[strlen(dirname)] = '/';
1038 try_to_sel(dirname);
1040 if (rover.nfiles > HEIGHT)
1041 SCROLL = ESEL - HEIGHT / 2;
1043 } else if (!strcmp(key, RVK_HOME)) {
1044 strcpy(CWD, getenv("HOME"));
1045 if (CWD[strlen(CWD) - 1] != '/')
1048 } else if (!strcmp(key, RVK_REFRESH)) {
1050 } else if (!strcmp(key, RVK_SHELL)) {
1051 program = getenv("SHELL");
1058 } else if (!strcmp(key, RVK_VIEW)) {
1059 if (!rover.nfiles || S_ISDIR(EMODE(ESEL))) continue;
1060 program = getenv("PAGER");
1063 ARGS[1] = ENAME(ESEL);
1067 } else if (!strcmp(key, RVK_EDIT)) {
1068 if (!rover.nfiles || S_ISDIR(EMODE(ESEL))) continue;
1069 program = getenv("EDITOR");
1072 ARGS[1] = ENAME(ESEL);
1077 } else if (!strcmp(key, RVK_SEARCH)) {
1078 int oldsel, oldscroll, length;
1079 if (!rover.nfiles) continue;
1082 start_line_edit("");
1083 update_input(RVP_SEARCH, RED);
1084 while ((edit_stat = get_line_edit()) == CONTINUE) {
1087 length = strlen(INPUT);
1089 for (sel = 0; sel < rover.nfiles; sel++)
1090 if (!strncmp(ENAME(sel), INPUT, length))
1092 if (sel < rover.nfiles) {
1095 if (rover.nfiles > HEIGHT) {
1098 else if (sel - 3 > rover.nfiles - HEIGHT)
1099 SCROLL = rover.nfiles - HEIGHT;
1109 update_input(RVP_SEARCH, color);
1111 if (edit_stat == CANCEL) {
1117 } else if (!strcmp(key, RVK_TG_FILES)) {
1118 FLAGS ^= SHOW_FILES;
1120 } else if (!strcmp(key, RVK_TG_DIRS)) {
1123 } else if (!strcmp(key, RVK_TG_HIDDEN)) {
1124 FLAGS ^= SHOW_HIDDEN;
1126 } else if (!strcmp(key, RVK_NEW_FILE)) {
1128 start_line_edit("");
1129 update_input(RVP_NEW_FILE, RED);
1130 while ((edit_stat = get_line_edit()) == CONTINUE) {
1131 int length = strlen(INPUT);
1133 for (i = 0; i < rover.nfiles; i++) {
1135 !strncmp(ENAME(i), INPUT, length) &&
1136 (!strcmp(ENAME(i) + length, "") ||
1137 !strcmp(ENAME(i) + length, "/"))
1143 update_input(RVP_NEW_FILE, ok ? GREEN : RED);
1146 if (edit_stat == CONFIRM) {
1153 message(RED, "\"%s\" already exists.", INPUT);
1155 } else if (!strcmp(key, RVK_NEW_DIR)) {
1157 start_line_edit("");
1158 update_input(RVP_NEW_DIR, RED);
1159 while ((edit_stat = get_line_edit()) == CONTINUE) {
1160 int length = strlen(INPUT);
1162 for (i = 0; i < rover.nfiles; i++) {
1164 !strncmp(ENAME(i), INPUT, length) &&
1165 (!strcmp(ENAME(i) + length, "") ||
1166 !strcmp(ENAME(i) + length, "/"))
1172 update_input(RVP_NEW_DIR, ok ? GREEN : RED);
1175 if (edit_stat == CONFIRM) {
1183 message(RED, "\"%s\" already exists.", INPUT);
1185 } else if (!strcmp(key, RVK_RENAME)) {
1189 strcpy(INPUT, ENAME(ESEL));
1190 last = INPUT + strlen(INPUT) - 1;
1191 if ((isdir = *last == '/'))
1193 start_line_edit(INPUT);
1194 update_input(RVP_RENAME, RED);
1195 while ((edit_stat = get_line_edit()) == CONTINUE) {
1196 int length = strlen(INPUT);
1198 for (i = 0; i < rover.nfiles; i++)
1200 !strncmp(ENAME(i), INPUT, length) &&
1201 (!strcmp(ENAME(i) + length, "") ||
1202 !strcmp(ENAME(i) + length, "/"))
1207 update_input(RVP_RENAME, ok ? GREEN : RED);
1210 if (edit_stat == CONFIRM) {
1214 if (!rename(ENAME(ESEL), INPUT) && MARKED(ESEL)) {
1215 del_mark(&rover.marks, ENAME(ESEL));
1216 add_mark(&rover.marks, CWD, INPUT);
1222 message(RED, "\"%s\" already exists.", INPUT);
1224 } else if (!strcmp(key, RVK_DELETE)) {
1226 message(YELLOW, "Delete \"%s\"? (Y to confirm)", ENAME(ESEL));
1227 if (rover_getch() == 'Y') {
1228 const char *name = ENAME(ESEL);
1229 int ret = S_ISDIR(EMODE(ESEL)) ? deldir(name) : delfile(name);
1232 message(RED, "Could not delete \"%s\".", ENAME(ESEL));
1236 message(RED, "No entry selected for deletion.");
1237 } else if (!strcmp(key, RVK_TG_MARK)) {
1239 del_mark(&rover.marks, ENAME(ESEL));
1241 add_mark(&rover.marks, CWD, ENAME(ESEL));
1242 MARKED(ESEL) = !MARKED(ESEL);
1243 ESEL = (ESEL + 1) % rover.nfiles;
1245 } else if (!strcmp(key, RVK_INVMARK)) {
1246 for (i = 0; i < rover.nfiles; i++) {
1248 del_mark(&rover.marks, ENAME(i));
1250 add_mark(&rover.marks, CWD, ENAME(i));
1251 MARKED(i) = !MARKED(i);
1254 } else if (!strcmp(key, RVK_MARKALL)) {
1255 for (i = 0; i < rover.nfiles; i++)
1257 add_mark(&rover.marks, CWD, ENAME(i));
1261 } else if (!strcmp(key, RVK_MARK_DELETE)) {
1262 if (rover.marks.nentries) {
1263 message(YELLOW, "Delete all marked entries? (Y to confirm)");
1264 if (rover_getch() == 'Y')
1265 process_marked(NULL, delfile, deldir, "Deleting", "Deleted");
1269 message(RED, "No entries marked for deletion.");
1270 } else if (!strcmp(key, RVK_MARK_COPY)) {
1271 if (rover.marks.nentries)
1272 process_marked(adddir, cpyfile, NULL, "Copying", "Copied");
1274 message(RED, "No entries marked for copying.");
1275 } else if (!strcmp(key, RVK_MARK_MOVE)) {
1276 if (rover.marks.nentries)
1277 process_marked(adddir, movfile, deldir, "Moving", "Moved");
1279 message(RED, "No entries marked for moving.");
1283 free_rows(&rover.rows, rover.nfiles);
1284 free_marks(&rover.marks);
1285 delwin(rover.window);
1286 if (save_cwd_file != NULL) {
1287 fputs(CWD, save_cwd_file);
1288 fclose(save_cwd_file);