Bruce/bb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Mostly working version with linked lists and regular arrays

Browse Source
This commit is contained in:
Bruce Hill 2019-05-21 02:17:11 -07:00
parent 12e366c735
commit 9786f9a525
1 changed files with 376 additions and 301 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

677
bb.c
View File

@ -24,6 +24,7 @@
#define MIN(a,b) ((a) > (b) ? (b) : (a)) #define MIN(a,b) ((a) > (b) ? (b) : (a))
#define MAX_PATH 4096 #define MAX_PATH 4096
#define writez(fd, str) write(fd, str, strlen(str)) #define writez(fd, str) write(fd, str, strlen(str))
#define IS_SELECTED(p) ((p)->next || (p)->prev)
static const int SCROLLOFF = 5; static const int SCROLLOFF = 5;
@ -32,6 +33,27 @@ static int termfd;
static int width, height; static int width, height;
static int mouse_x, mouse_y; static int mouse_x, mouse_y;
typedef struct entry_s {
struct entry_s *next, *prev;
int visible : 1;
ino_t d_ino;
__uint16_t d_reclen;
__uint8_t d_type;
__uint8_t d_namlen;
char *d_name;
char d_fullname[0];
} entry_t;
typedef struct {
char *path;
entry_t *firstselected, **files;
size_t nselected, nfiles;
int scroll, cursor;
struct timespec lastclick;
} bb_state_t;
static void err(const char *msg, ...);
static void update_term_size(void) static void update_term_size(void)
{ {
struct winsize sz = {0}; struct winsize sz = {0};
@ -56,16 +78,20 @@ static void init_term()
tios.c_cc[VTIME] = 0; tios.c_cc[VTIME] = 0;
tcsetattr(termfd, TCSAFLUSH, &tios); tcsetattr(termfd, TCSAFLUSH, &tios);
// xterm-specific: // xterm-specific:
writez(termfd, "\033[?1049h"); writez(termfd, "\e[?1049h");
update_term_size(); update_term_size();
// Initiate mouse tracking: // Initiate mouse tracking:
writez(termfd, "\e[?1000h\e[?1002h\e[?1015h\e[?1006h"); writez(termfd, "\e[?1000h\e[?1002h\e[?1015h\e[?1006h");
// hide cursor
writez(termfd, "\e[?25l");
} }
static void close_term() static void close_term()
{ {
// xterm-specific: // xterm-specific:
writez(termfd, "\033[?1049l"); writez(termfd, "\e[?1049l");
// Show cursor:
writez(termfd, "\e[?25h");
tcsetattr(termfd, TCSAFLUSH, &orig_termios); tcsetattr(termfd, TCSAFLUSH, &orig_termios);
close(termfd); close(termfd);
} }
@ -75,7 +101,7 @@ static void err(const char *msg, ...)
close_term(); close_term();
va_list args; va_list args;
va_start(args, msg); va_start(args, msg);
fprintf(stderr, msg, args); int len = fprintf(stderr, msg, args);
va_end(args); va_end(args);
if (errno) if (errno)
fprintf(stderr, "\n%s", strerror(errno)); fprintf(stderr, "\n%s", strerror(errno));
@ -83,32 +109,42 @@ static void err(const char *msg, ...)
_exit(1); _exit(1);
} }
static pid_t run_cmd(int *readable_fd, int *writable_fd, const char *cmd, ...) static pid_t run_cmd(int *child_out, int *child_in, const char *cmd, ...)
{ {
int fd[2]; int child_outfds[2], child_infds[2];
pid_t child; pid_t child;
pipe(fd); if (child_out)
pipe(child_outfds);
if (child_in)
pipe(child_infds);
if ((child = fork())) { if ((child = fork())) {
if (child == -1) if (child == -1)
err("Failed to fork"); err("Failed to fork");
if (writable_fd) *writable_fd = fd[0]; if (child_out) {
else close(fd[0]); *child_out = child_outfds[0];
if (readable_fd) *readable_fd = fd[1]; close(child_outfds[1]);
else close(fd[1]); }
if (child_in) {
*child_in = child_infds[1];
close(child_infds[0]);
}
} else { } else {
close(fd[0]); if (child_out) {
if (writable_fd) dup2(child_outfds[1], STDOUT_FILENO);
dup2(fd[1], STDIN_FILENO); close(child_outfds[0]);
if (readable_fd) }
dup2(fd[0], STDOUT_FILENO); if (child_in) {
dup2(child_infds[0], STDIN_FILENO);
close(child_infds[1]);
}
char *formatted_cmd; char *formatted_cmd;
va_list args; va_list args;
va_start(args, cmd); va_start(args, cmd);
vasprintf(&formatted_cmd, cmd, args); int len = vasprintf(&formatted_cmd, cmd, args);
va_end(args); va_end(args);
if (formatted_cmd) if (formatted_cmd)
execlp("sh", "sh", "-c", formatted_cmd); execlp("sh", "sh", "-c", formatted_cmd);
err("Failed to execute command: %s", formatted_cmd); err("Failed to execute command %d: '%s'", len, formatted_cmd);
_exit(0); _exit(0);
} }
return child; return child;
@ -122,98 +158,75 @@ static void term_move(int x, int y)
write(termfd, buf, len); write(termfd, buf, len);
} }
static int term_write(const char *str, ...) static void render(bb_state_t *state)
{
char buf[1024] = {0};
va_list args;
va_start(args, str);
int len = snprintf(buf, sizeof(buf), str, args);
va_end(args);
if (len > 0)
write(termfd, buf, len);
return len;
/*
char *formatted = NULL;
va_list args;
va_start(args, str);
int ret = asprintf(&formatted, str, args);
va_end(args);
if (!formatted)
err("failed to allocate for string format");
write(termfd, formatted, ret);
free(formatted);
return ret;
*/
}
typedef struct {
struct dirent entry;
const char *path;
int selected : 1;
} entry_t;
static void render(const char *path, entry_t *files, size_t nfiles, int cursor, int scroll, size_t nselected)
{ {
writez(termfd, "\e[2J\e[0;1m"); // Clear, reset color + bold writez(termfd, "\e[2J\e[0;1m"); // Clear, reset color + bold
term_move(0,0); term_move(0,0);
writez(termfd, path); writez(termfd, state->path);
writez(termfd, "\e[0m"); // Reset color writez(termfd, "\e[0m"); // Reset color
char fullpath[MAX_PATH]; char fullpath[MAX_PATH];
size_t pathlen = strlen(path); size_t pathlen = strlen(state->path);
strncpy(fullpath, path, pathlen + 1); strncpy(fullpath, state->path, pathlen + 1);
for (int i = scroll; i < scroll + height - 3 && i < nfiles; i++) { entry_t **files = state->files;
for (int i = state->scroll; i < state->scroll + height - 3 && i < state->nfiles; i++) {
entry_t *entry = files[i];
int x = 0; int x = 0;
int y = i - scroll + 1; int y = i - state->scroll + 1;
term_move(x, y); term_move(x, y);
// Selection box: // Selection box:
if (files[i].selected) if (IS_SELECTED(entry))
writez(termfd, "\e[43m \e[0m"); // Yellow BG writez(termfd, "\e[43m \e[0m"); // Yellow BG
else else
writez(termfd, " "); writez(termfd, " ");
if (i != cursor && files[i].entry.d_type & DT_DIR) { if (i != state->cursor && entry->d_type & DT_DIR) {
writez(termfd, "\e[34m"); // Blue FG writez(termfd, "\e[34m"); // Blue FG
} }
if (i == cursor) { if (i == state->cursor) {
writez(termfd, "\e[7m"); // Reverse color writez(termfd, "\e[7m"); // Reverse color
} }
// Filesize: struct stat info = {0};
struct stat info;
fullpath[pathlen] = '/'; fullpath[pathlen] = '/';
strncpy(fullpath + pathlen + 1, files[i].entry.d_name, files[i].entry.d_namlen); strncpy(fullpath + pathlen + 1, entry->d_name, entry->d_namlen);
fullpath[pathlen + 1 + files[i].entry.d_namlen] = '\0'; fullpath[pathlen + 1 + entry->d_namlen] = '\0';
lstat(fullpath, &info); lstat(fullpath, &info);
int j = 0; {
const char* units[] = {"B", "K", "M", "G", "T", "P", "E", "Z", "Y"}; // Filesize:
int bytes = info.st_size; int j = 0;
while (bytes > 1024) { const char* units = "BKMGTPEZY";
bytes /= 1024; double bytes = (double)info.st_size;
j++; while (bytes > 1024) {
bytes /= 1024;
j++;
}
char buf[16] = {0};
sprintf(buf, "%6.*f%c ", j > 0 ? 1 : 0, bytes, units[j]);
writez(termfd, buf);
} }
//term_write("%10.*f%s ", j, bytes, units[j]);
// Date: {
char buf[64]; // Date:
strftime(buf, sizeof(buf), "%l:%M%p %b %e %Y", localtime(&(info.st_mtime))); char buf[64];
writez(termfd, buf); strftime(buf, sizeof(buf), "%l:%M%p %b %e %Y", localtime(&(info.st_mtime)));
writez(termfd, " "); writez(termfd, buf);
writez(termfd, " ");
}
// Name: // Name:
write(termfd, files[i].entry.d_name, files[i].entry.d_namlen); write(termfd, entry->d_name, entry->d_namlen);
if (files[i].entry.d_type & DT_DIR) { if (entry->d_type & DT_DIR) {
writez(termfd, "/"); writez(termfd, "/");
} }
if (files[i].entry.d_type == DT_LNK) { if (entry->d_type == DT_LNK) {
char linkpath[MAX_PATH] = {0}; char linkpath[MAX_PATH] = {0};
ssize_t pathlen; ssize_t pathlen;
if ((pathlen = readlink(files[i].entry.d_name, linkpath, sizeof(linkpath))) < 0) if ((pathlen = readlink(entry->d_name, linkpath, sizeof(linkpath))) < 0)
err("readlink() failed"); err("readlink() failed");
writez(termfd, "\e[36m -> "); // Cyan FG writez(termfd, "\e[36m -> "); // Cyan FG
write(termfd, linkpath, pathlen); write(termfd, linkpath, pathlen);
@ -223,23 +236,23 @@ static void render(const char *path, entry_t *files, size_t nfiles, int cursor,
term_move(0, height - 1); term_move(0, height - 1);
char buf[32] = {0}; char buf[32] = {0};
int len = snprintf(buf, sizeof(buf), "%lu selected", nselected); int len = snprintf(buf, sizeof(buf), "%lu selected", state->nselected);
write(termfd, buf, len); write(termfd, buf, len);
} }
static int compare_alpha(const void *v1, const void *v2) static int compare_alpha(const void *v1, const void *v2)
{ {
const entry_t *f1 = (const entry_t*)v1, *f2 = (const entry_t*)v2; const entry_t *f1 = *((const entry_t**)v1), *f2 = *((const entry_t**)v2);
int diff; int diff;
diff = (f1->entry.d_type & DT_DIR) - (f2->entry.d_type & DT_DIR); diff = (f1->d_type & DT_DIR) - (f2->d_type & DT_DIR);
if (diff) return -diff; if (diff) return -diff;
const char *p1 = f1->entry.d_name, *p2 = f2->entry.d_name; const char *p1 = f1->d_name, *p2 = f2->d_name;
while (*p1 && *p2) { while (*p1 && *p2) {
int diff = (*p1 - *p2); int diff = (*p1 - *p2);
if ('0' <= *p1 && *p1 <= '9' && '0' <= *p2 && *p2 <= '9') { if ('0' <= *p1 && *p1 <= '9' && '0' <= *p2 && *p2 <= '9') {
long n1 = strtol(p1, (char**)&p1, 10); long n1 = strtol(p1, (char**)&p1, 10);
long n2 = strtol(p2, (char**)&p2, 10); long n2 = strtol(p2, (char**)&p2, 10);
diff = ((p1 - f1->entry.d_name) - (p2 - f2->entry.d_name)) || (n1 - n2); diff = ((p1 - f1->d_name) - (p2 - f2->d_name)) || (n1 - n2);
if (diff) return diff; if (diff) return diff;
} else if (diff) { } else if (diff) {
return diff; return diff;
@ -250,34 +263,20 @@ static int compare_alpha(const void *v1, const void *v2)
return *p1 - *p2; return *p1 - *p2;
} }
static void write_selection(int fd, entry_t *selected, size_t nselected, size_t ndeselected) static void write_selection(int fd, entry_t *firstselected)
{ {
for (int i = 0; i < nselected + ndeselected; i++) { while (firstselected) {
if (!selected[i].selected) const char *p = firstselected->d_fullname;
continue;
const char *p = selected[i].path;
while (*p) { while (*p) {
const char *p2 = strchr(p, '\n'); const char *p2 = strchr(p, '\n');
if (!p2) p2 = p + strlen(p) + 1; if (!p2) p2 = p + strlen(p);
write(fd, p, p2 - p);
if (*p2 == '\n')
write(fd, "\\", 1);
p = p2;
}
write(fd, "/", 1);
p = selected[i].entry.d_name;
while (*p) {
const char *p2 = strchr(p, '\n');
if (!p2) p2 = p + strlen(p) + 1;
write(fd, p, p2 - p); write(fd, p, p2 - p);
if (*p2 == '\n') if (*p2 == '\n')
write(fd, "\\", 1); write(fd, "\\", 1);
p = p2; p = p2;
} }
write(fd, "\n", 1); write(fd, "\n", 1);
firstselected = firstselected->next;
} }
} }
@ -286,140 +285,171 @@ static int term_get_event()
char c; char c;
if (read(termfd, &c, 1) != 1) if (read(termfd, &c, 1) != 1)
return -1; return -1;
if (c != '\x1b')
return c;
// Actual escape key:
if (read(termfd, &c, 1) != 1)
return KEY_ESC;
switch (c) { switch (c) {
case '\x1b': case '[':
if (read(termfd, &c, 1) != 1) if (read(termfd, &c, 1) != 1)
return -1; return -1;
switch (c) { switch (c) {
case '[': case 'H': return KEY_HOME;
if (read(termfd, &c, 1) != 1) case 'F': return KEY_END;
return -1; case '<': // Mouse clicks
switch (c) { {
case 'H': return KEY_HOME; int buttons = 0, x = 0, y = 0;
case 'F': return KEY_END; char buf;
case 'M': while (read(termfd, &buf, 1) == 1 && '0' <= buf && buf <= '9')
{ buttons = buttons * 10 + (buf - '0');
char buf[7] = {0}; if (buf != ';') return -1;
if (read(termfd, buf, 6) != 6) while (read(termfd, &buf, 1) == 1 && '0' <= buf && buf <= '9')
return -1; x = x * 10 + (buf - '0');
unsigned char buttons, x, y; if (buf != ';') return -1;
if (sscanf(buf, "%c%c%c", &buttons, &x, &y) != 3) while (read(termfd, &buf, 1) == 1 && '0' <= buf && buf <= '9')
return -1; y = y * 10 + (buf - '0');
if (buf != 'm' && buf != 'M') return -1;
mouse_x = (int)x - 32, mouse_y = (int)y - 32; mouse_x = x - 1, mouse_y = y - 1;
switch (buttons) {
case 0: return KEY_MOUSE_LEFT; if (buf == 'm')
case 1: return KEY_MOUSE_RIGHT; return KEY_MOUSE_RELEASE;
case 2: return KEY_MOUSE_MIDDLE; switch (buttons) {
case 3: return KEY_MOUSE_RELEASE; case 0: return KEY_MOUSE_LEFT;
default: return -1; case 1: return KEY_MOUSE_RIGHT;
} case 2: return KEY_MOUSE_MIDDLE;
} default: return -1;
break; }
default:
break;
} }
return '\x1b'; break;
default: default:
return '\x1b'; break;
} }
break; return -1;
default: default:
return c; return -1;
} }
return -1; return -1;
} }
static void explore(const char *path) static void explore(char *path)
{ {
static entry_t *selected; char *tmp = path;
static size_t nselected = 0, ndeselected = 0, selectedcapacity = 0; path = malloc(strlen(tmp) + 1);
strcpy(path, tmp);
tmp = NULL;
char to_select[MAX_PATH] = {0}; char to_select[MAX_PATH] = {0};
char _path[MAX_PATH]; bb_state_t state = {0};
tail_call:; memset(&state, 0, sizeof(bb_state_t));
DIR *dir = opendir(path);
tail_call:
state.path = path;
DIR *dir = opendir(state.path);
if (!dir) if (!dir)
err("Couldn't open dir: %s", path); err("Couldn't open dir: %s", state.path);
if (chdir(path) != 0) if (chdir(state.path) != 0)
err("Couldn't chdir into %s", path); err("Couldn't chdir into %s", state.path);
struct dirent *dp; struct dirent *dp;
size_t filecap = 0, nfiles = 0; // Hash inode -> entry_t with linear probing
entry_t *files = NULL; size_t hashsize = 2 * state.nselected;
entry_t **selecthash = calloc(hashsize, sizeof(entry_t*));
// Hash inode -> inode with linear probing
size_t hashsize = 2 * nselected;
ino_t *selecthash = calloc(hashsize, sizeof(ino_t));
if (!selecthash) if (!selecthash)
err("Failed to allocate %d spaces for selecthash", hashsize); err("Failed to allocate %d spaces for selecthash", hashsize);
for (int i = nselected + ndeselected - 1; i >= 0; i--) { for (entry_t *p = state.firstselected; p; p = p->next) {
if (!selected[i].selected) continue; int probe = ((int)p->d_ino) % hashsize;
ino_t inode = selected[i].entry.d_ino;
int probe = ((int)inode) % hashsize;
while (selecthash[probe]) while (selecthash[probe])
probe = (probe + 1) % hashsize; probe = (probe + 1) % hashsize;
selecthash[probe] = inode; selecthash[probe] = p;
} }
if (state.files) {
for (int i = 0; i < state.nfiles; i++) {
entry_t *e = state.files[i];
e->visible = 0;
if (!IS_SELECTED(e))
free(e);
}
free(state.files);
state.files = NULL;
}
size_t pathlen = strlen(state.path);
size_t filecap = 0;
state.nfiles = 0;
while ((dp = readdir(dir)) != NULL) { while ((dp = readdir(dir)) != NULL) {
if (dp->d_name[0] == '.' && dp->d_name[1] == '\0') if (dp->d_name[0] == '.' && dp->d_name[1] == '\0')
continue; continue;
if (nfiles >= filecap) { // Hashed lookup from selected:
filecap += 100; if (state.firstselected) {
if ((files = realloc(files, sizeof(entry_t)*filecap)) == NULL)
err("Alloc fail");
}
int selected = 0;
if (nselected) {
for (int probe = ((int)dp->d_ino) % hashsize; selecthash[probe]; probe = (probe + 1) % hashsize) { for (int probe = ((int)dp->d_ino) % hashsize; selecthash[probe]; probe = (probe + 1) % hashsize) {
if (selecthash[probe] == dp->d_ino) { if (selecthash[probe]->d_ino == dp->d_ino) {
selected = 1; selecthash[probe]->visible = 1;
break; state.files[state.nfiles++] = selecthash[probe];
goto next_file;
} }
} }
} }
entry_t file = {*dp, path, selected}; entry_t *entry = malloc(sizeof(entry_t) + pathlen + dp->d_namlen + 2);
files[nfiles++] = file; strncpy(entry->d_fullname, state.path, pathlen);
entry->d_fullname[pathlen] = '/';
entry->d_name = &entry->d_fullname[pathlen + 1];
strncpy(entry->d_name, dp->d_name, dp->d_namlen + 1);
entry->d_ino = dp->d_ino;
entry->d_reclen = dp->d_reclen;
entry->d_type = dp->d_type;
entry->d_namlen = dp->d_namlen;
entry->next = NULL, entry->prev = NULL;
if (state.nfiles >= filecap) {
filecap += 100;
state.files = realloc(state.files, filecap*sizeof(entry_t*));
}
state.files[state.nfiles++] = entry;
next_file:;
} }
free(selecthash); free(selecthash);
if (nfiles == 0) { if (state.nfiles == 0) err("No files found (not even '..')");
err("No files found (not even '..')"); qsort(state.files, state.nfiles, sizeof(entry_t*), compare_alpha);
}
qsort(files, nfiles, sizeof(entry_t), compare_alpha);
closedir(dir); closedir(dir);
int cursor = 0; state.cursor = 0;
int scroll = 0; state.scroll = 0;
if (to_select[0]) { if (to_select[0]) {
for (int i = 0; i < nfiles; i++) { for (int i = 0; i < state.nfiles; i++) {
if (strcmp(to_select, files[i].entry.d_name) == 0) { if (strcmp(to_select, state.files[i]->d_name) == 0) {
cursor = i; state.cursor = i;
break; break;
} }
} }
} }
struct timespec lastclick; clock_gettime(CLOCK_MONOTONIC, &state.lastclick);
clock_gettime(CLOCK_MONOTONIC, &lastclick);
int picked, scrolloff; int picked, scrolloff;
while (1) { while (1) {
redraw: redraw:
render(path, files, nfiles, cursor, scroll, nselected); render(&state);
skip_redraw: skip_redraw:
scrolloff = MIN(SCROLLOFF, height/2); scrolloff = MIN(SCROLLOFF, height/2);
//sleep(2); //sleep(2);
//if (1) goto done; //if (1) goto done;
switch (term_get_event()) { int key = term_get_event();
switch (key) {
case KEY_MOUSE_LEFT: { case KEY_MOUSE_LEFT: {
struct timespec clicktime; struct timespec clicktime;
clock_gettime(CLOCK_MONOTONIC, &clicktime); clock_gettime(CLOCK_MONOTONIC, &clicktime);
double dt_ms = 1e3*(double)(clicktime.tv_sec - lastclick.tv_sec); double dt_ms = 1e3*(double)(clicktime.tv_sec - state.lastclick.tv_sec);
dt_ms += 1e-6*(double)(clicktime.tv_nsec - lastclick.tv_nsec); dt_ms += 1e-6*(double)(clicktime.tv_nsec - state.lastclick.tv_nsec);
lastclick = clicktime; state.lastclick = clicktime;
if (mouse_y > 0 && scroll + (mouse_y - 1) < nfiles) { if (mouse_y > 0 && state.scroll + (mouse_y - 1) < state.nfiles) {
int clicked = scroll + (mouse_y - 1); int clicked = state.scroll + (mouse_y - 1);
if (dt_ms > 200) { if (dt_ms > 200) {
// Single click // Single click
if (mouse_x == 0) { if (mouse_x == 0) {
@ -427,7 +457,8 @@ static void explore(const char *path)
picked = clicked; picked = clicked;
goto toggle; goto toggle;
} else { } else {
cursor = clicked; state.cursor = clicked;
goto redraw;
} }
} else { } else {
// Double click // Double click
@ -435,122 +466,133 @@ static void explore(const char *path)
goto open_file; goto open_file;
} }
} }
break;
} }
case KEY_ESC: case 'q': case 'Q':
goto done;
case KEY_CTRL_D:
cursor = MIN(nfiles - 1, cursor + (height - 3) / 2);
if (nfiles <= height - 3)
goto redraw;
scroll += (height - 3)/2;
if (scroll > nfiles - (height - 3))
scroll = nfiles - (height - 3);
goto redraw;
case KEY_CTRL_U:
cursor = MAX(0, cursor - (height - 3) / 2);
if (nfiles <= height - 3)
goto redraw;
scroll -= (height - 3)/2;
if (scroll < 0)
scroll = 0;
goto redraw;
case ' ': case '\r':
picked = cursor;
toggle:
files[picked].selected ^= 1;
if (files[picked].selected) {
if (nselected + ndeselected + 1 > selectedcapacity) {
selectedcapacity += 100;
selected = realloc(selected, selectedcapacity);
}
selected[nselected++] = files[picked];
} else {
// Find and destroy
for (int i = nselected + ndeselected - 1; i >= 0; i--) {
if (!selected[i].selected) continue;
if (selected[i].entry.d_ino == files[picked].entry.d_ino) {
selected[i].selected = 0;
--nselected;
// Leave a hole to clean up later
if (i == nselected + ndeselected) {
goto redraw;
}
++ndeselected;
goto found_it;
}
}
err("Didn't find selection");
found_it:
// Coalesce removals:
if (selectedcapacity > nselected + 100) {
entry_t *first = &selected[0];
entry_t *last = &selected[nselected + ndeselected - 1];
entry_t *p = first;
while (first != last) {
if (first->selected) {
*p = *first;
++p;
}
++first;
}
ndeselected = 0;
selectedcapacity = nselected + 100; case 'q': case 'Q': case KEY_CTRL_C:
selected = realloc(selected, selectedcapacity); goto done;
case KEY_CTRL_D:
state.cursor = MIN(state.nfiles - 1, state.cursor + (height - 3) / 2);
if (state.nfiles <= height - 3)
goto redraw;
state.scroll += (height - 3)/2;
if (state.scroll > state.nfiles - (height - 3))
state.scroll = state.nfiles - (height - 3);
goto redraw;
case KEY_CTRL_U:
state.cursor = MAX(0, state.cursor - (height - 3) / 2);
if (state.nfiles <= height - 3)
goto redraw;
state.scroll -= (height - 3)/2;
if (state.scroll < 0)
state.scroll = 0;
goto redraw;
case ' ':
picked = state.cursor;
toggle:
if (IS_SELECTED(state.files[picked])) {
toggle_off:;
entry_t *e = state.files[picked];
if (state.firstselected == e)
state.firstselected = e->next;
if (e->prev) e->prev->next = e->next;
if (e->next) e->next->prev = e->prev;
e->next = NULL;
e->prev = NULL;
--state.nselected;
} else {
toggle_on:;
entry_t *e = state.files[picked];
if (state.firstselected) {
e->next = state.firstselected;
state.firstselected->prev = e;
}
state.firstselected = e;
++state.nselected;
}
goto redraw;
case KEY_ESC:
for (entry_t *e = state.firstselected; e; e = e->next) {
e->next = NULL;
e->prev = NULL;
if (!e->visible) free(e);
}
state.firstselected = NULL;
state.nselected = 0;
goto redraw;
case 'j':
if (state.cursor >= state.nfiles - 1)
goto skip_redraw;
++state.cursor;
if (state.cursor > state.scroll + height - 4 - scrolloff && state.scroll < state.nfiles - (height - 3)) {
++state.scroll;
}
goto redraw;
case 'k':
if (state.cursor <= 0)
goto skip_redraw;
--state.cursor;
if (state.cursor < state.scroll + scrolloff && state.scroll > 0) {
--state.scroll;
}
goto redraw;
case 'J':
if (state.cursor < state.nfiles - 1) {
if (IS_SELECTED(state.files[state.cursor])) {
picked = ++state.cursor;
goto toggle_on;
} else {
picked = ++state.cursor;
goto toggle_off;
} }
} }
goto redraw; goto skip_redraw;
case 'j':
if (cursor >= nfiles - 1)
goto skip_redraw;
++cursor;
if (cursor > scroll + height - 4 - scrolloff && scroll < nfiles - (height - 3)) {
++scroll;
}
goto redraw;
case 'k':
if (cursor <= 0)
goto skip_redraw;
--cursor;
if (cursor < scroll + scrolloff && scroll > 0) {
--scroll;
}
goto redraw;
case 'J':
if (cursor < nfiles - 1) {
++cursor;
files[cursor].selected = files[cursor - 1].selected;
}
goto redraw;
case 'K': case 'K':
if (cursor > 0) { if (state.cursor > 0) {
--cursor; if (IS_SELECTED(state.files[state.cursor])) {
files[cursor].selected = files[cursor + 1].selected; picked = --state.cursor;
goto toggle_on;
} else {
picked = --state.cursor;
goto toggle_off;
}
} }
goto redraw; goto skip_redraw;
case 'h': case 'h':
if (strcmp(path, "/") != 0) { if (strcmp(state.path, "/") != 0) {
char *p = strrchr(path, '/'); char *p = strrchr(state.path, '/');
if (p) strcpy(to_select, p+1); if (p) strcpy(to_select, p+1);
else to_select[0] = '\0'; else to_select[0] = '\0';
char tmp[MAX_PATH]; char tmp[MAX_PATH], tmp2[MAX_PATH];
strcpy(tmp, path); strcpy(tmp, state.path);
strcat(tmp, "/"); strcat(tmp, "/");
strcat(tmp, ".."); strcat(tmp, "..");
if (!realpath(tmp, _path)) if (!realpath(tmp, tmp2))
err("realpath failed"); err("realpath failed");
path = _path; free(path);
path = malloc(strlen(tmp2) + 1);
strcpy(path, tmp2);
goto tail_call; goto tail_call;
} }
break; break;
case 'l':
picked = cursor; case 'l': case '\r':
picked = state.cursor;
open_file: open_file:
{ {
int is_dir = files[picked].entry.d_type & DT_DIR; int is_dir = state.files[picked]->d_type & DT_DIR;
if (files[picked].entry.d_type == DT_LNK) { if (state.files[picked]->d_type == DT_LNK) {
char linkpath[MAX_PATH]; char linkpath[MAX_PATH];
if (readlink(files[picked].entry.d_name, linkpath, sizeof(linkpath)) < 0) if (readlink(state.files[picked]->d_name, linkpath, sizeof(linkpath)) < 0)
err("readlink() failed"); err("readlink() failed");
DIR *dir = opendir(linkpath); DIR *dir = opendir(linkpath);
if (dir) { if (dir) {
@ -560,27 +602,30 @@ static void explore(const char *path)
} }
} }
if (is_dir) { if (is_dir) {
if (strcmp(files[picked].entry.d_name, "..") == 0) { if (strcmp(state.files[picked]->d_name, "..") == 0) {
char *p = strrchr(path, '/'); char *p = strrchr(state.path, '/');
if (p) strcpy(to_select, p+1); if (p) strcpy(to_select, p+1);
else to_select[0] = '\0'; else to_select[0] = '\0';
} else to_select[0] = '\0'; } else to_select[0] = '\0';
char tmp[MAX_PATH];
strcpy(tmp, path); char tmp[MAX_PATH], tmp2[MAX_PATH];
strcpy(tmp, state.path);
strcat(tmp, "/"); strcat(tmp, "/");
strcat(tmp, files[picked].entry.d_name); strcat(tmp, state.files[picked]->d_name);
if (!realpath(tmp, _path)) if (!realpath(tmp, tmp2))
err("realpath failed"); err("realpath failed");
path = _path; free(path);
path = malloc(strlen(tmp2) + 1);
strcpy(path, tmp2);
goto tail_call; goto tail_call;
} else { } else {
char *name = files[picked].entry.d_name; char *name = state.files[picked]->d_name;
close_term(); close_term();
pid_t child = run_cmd(NULL, NULL, pid_t child = run_cmd(NULL, NULL,
#ifdef __APPLE__ #ifdef __APPLE__
"if file -bI %s | grep '^text/'; then $EDITOR %s; else open %s; fi", "if file -bI %s | grep '^text/' >/dev/null; then $EDITOR %s; else open %s; fi",
#else #else
"if file -bi %s | grep '^text/'; then $EDITOR %s; else xdg-open %s; fi", "if file -bi %s | grep '^text/' >/dev/null; then $EDITOR %s; else xdg-open %s; fi",
#endif #endif
name, name, name); name, name, name);
waitpid(child, NULL, 0); waitpid(child, NULL, 0);
@ -589,30 +634,60 @@ static void explore(const char *path)
} }
break; break;
} }
case 'm': case 'm':
if (nselected) { if (state.nselected) {
int fd; int fd;
run_cmd(NULL, &fd, "xargs mv"); run_cmd(NULL, &fd, "xargs -I {} mv {} .");
write_selection(fd, selected, nselected, ndeselected); write_selection(fd, state.firstselected);
close(fd); close(fd);
} }
break; break;
case 'd': case 'd':
if (nselected) { if (state.nselected) {
int fd; int fd;
run_cmd(NULL, &fd, "xargs rm -rf"); run_cmd(NULL, &fd, "xargs rm -rf");
write_selection(fd, selected, nselected, ndeselected); write_selection(fd, state.firstselected);
close(fd); close(fd);
} }
break; break;
case 'p': case 'p':
if (nselected) { if (state.nselected) {
int fd; int fd;
run_cmd(NULL, &fd, "xargs cp"); run_cmd(NULL, &fd, "xargs -I {} cp {} .");
write_selection(fd, selected, nselected, ndeselected); write_selection(fd, state.firstselected);
close(fd); close(fd);
} }
break; break;
case 'x':
if (state.nselected) {
close_term();
char *buf = NULL;
size_t bufsize = 0;
printf("> ");
fflush(stdout);
getline(&buf, &bufsize, stdin);
int fd;
pid_t child = run_cmd(NULL, &fd, "xargs %s", buf);
write_selection(fd, state.firstselected);
close(fd);
waitpid(child, NULL, 0);
printf("press enter to continue...");
fflush(stdout);
getline(&buf, &bufsize, stdin);
free(buf);
init_term();
goto redraw;
}
break;
default: default:
goto skip_redraw; goto skip_redraw;
} }
@ -620,7 +695,7 @@ static void explore(const char *path)
} }
done: done:
close_term(); close_term();
write_selection(STDOUT_FILENO, selected, nselected, ndeselected); write_selection(STDOUT_FILENO, state.firstselected);
return; return;
} }