Bruce Hill
0f0bacceb4
up the default bindings a bit to be more explicit about manipulating the cursor file vs. manipulated selected files. Added support for `ask -n` and generally confirming with a single 'y' keystroke instead of 'y<enter>' Also added a binding for `rename`-command batch renaming.
1531 lines
50 KiB
C
1531 lines
50 KiB
C
/*
|
||
* Bitty Browser (bb)
|
||
* Copyright 2019 Bruce Hill
|
||
* Released under the MIT license
|
||
*/
|
||
#include <dirent.h>
|
||
#include <fcntl.h>
|
||
#include <limits.h>
|
||
#include <poll.h>
|
||
#include <signal.h>
|
||
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#include <sys/dir.h>
|
||
#include <sys/errno.h>
|
||
#include <sys/ioctl.h>
|
||
#include <sys/stat.h>
|
||
#include <sys/types.h>
|
||
#include <sys/wait.h>
|
||
#include <termios.h>
|
||
#include <time.h>
|
||
#include <unistd.h>
|
||
|
||
#include "config.h"
|
||
#include "bterm.h"
|
||
|
||
#define BB_VERSION "0.15.2"
|
||
|
||
#ifndef PATH_MAX
|
||
#define PATH_MAX 4096
|
||
#endif
|
||
|
||
#define MAX_COLS 12
|
||
#define MAX_SORT (2*MAX_COLS)
|
||
#define HASH_SIZE 1024
|
||
#define HASH_MASK (HASH_SIZE - 1)
|
||
#define MAX(a,b) ((a) < (b) ? (b) : (a))
|
||
#define MIN(a,b) ((a) > (b) ? (b) : (a))
|
||
#define IS_SELECTED(p) (((p)->selected.atme) != NULL)
|
||
#define IS_VIEWED(p) ((p)->index >= 0)
|
||
#define LOWERCASE(c) ('A' <= (c) && (c) <= 'Z' ? ((c) + 'a' - 'A') : (c))
|
||
#define E_ISDIR(e) (S_ISDIR(S_ISLNK((e)->info.st_mode) ? (e)->linkedmode : (e)->info.st_mode))
|
||
#define ONSCREEN (termheight - 3)
|
||
|
||
#ifdef __APPLE__
|
||
#define mtime(s) (s).st_mtimespec
|
||
#define atime(s) (s).st_atimespec
|
||
#define ctime(s) (s).st_ctimespec
|
||
#else
|
||
#define mtime(s) (s).st_mtim
|
||
#define atime(s) (s).st_atim
|
||
#define ctime(s) (s).st_ctim
|
||
#endif
|
||
|
||
#define err(...) do { \
|
||
cleanup(); \
|
||
fprintf(stderr, __VA_ARGS__); \
|
||
if (errno) fprintf(stderr, "\n%s", strerror(errno)); \
|
||
fprintf(stderr, "\n"); \
|
||
exit(EXIT_FAILURE); \
|
||
} while (0)
|
||
|
||
// Types
|
||
typedef enum {
|
||
COL_NONE = 0,
|
||
COL_NAME = 'n',
|
||
COL_SIZE = 's',
|
||
COL_PERM = 'p',
|
||
COL_MTIME = 'm',
|
||
COL_CTIME = 'c',
|
||
COL_ATIME = 'a',
|
||
COL_RANDOM = 'r',
|
||
COL_SELECTED = '*',
|
||
} column_e;
|
||
|
||
/* entry_t uses intrusive linked lists. This means entries can only belong to
|
||
* one list at a time, in this case the list of selected entries. 'atme' is an
|
||
* indirect pointer to either the 'next' field of the previous list member, or
|
||
* the variable that points to the first list member. In other words,
|
||
* item->next->atme == &item->next and firstitem->atme == &firstitem.
|
||
*/
|
||
typedef struct {
|
||
struct entry_s *next, **atme;
|
||
} llnode_t;
|
||
|
||
typedef struct entry_s {
|
||
llnode_t selected, hash;
|
||
char *name, *linkname;
|
||
struct stat info;
|
||
mode_t linkedmode;
|
||
int no_esc : 1;
|
||
int link_no_esc : 1;
|
||
int shufflepos;
|
||
int index;
|
||
char fullname[1];
|
||
// ------- fullname must be last! --------------
|
||
} entry_t;
|
||
|
||
typedef struct bb_s {
|
||
entry_t *hash[HASH_SIZE];
|
||
entry_t **files;
|
||
entry_t *firstselected;
|
||
char path[PATH_MAX];
|
||
char prev_path[PATH_MAX];
|
||
int nfiles;
|
||
int scroll, cursor;
|
||
|
||
char sort[MAX_SORT+1];
|
||
char columns[MAX_COLS+1];
|
||
unsigned int dirty : 1;
|
||
unsigned int show_dotdot : 1;
|
||
unsigned int show_dot : 1;
|
||
unsigned int show_dotfiles : 1;
|
||
unsigned int interleave_dirs : 1;
|
||
unsigned int should_quit : 1;
|
||
} bb_t;
|
||
|
||
typedef enum { BB_OK = 0, BB_INVALID, BB_QUIT } bb_result_t;
|
||
|
||
// Functions
|
||
static void bb_browse(bb_t *bb, const char *path);
|
||
static int cd_to(bb_t *bb, const char *path);
|
||
static const char* color_of(mode_t mode);
|
||
static void cleanup(void);
|
||
static void cleanup_and_exit(int sig);
|
||
static void restore_term(struct termios *term);
|
||
#ifdef __APPLE__
|
||
static int compare_files(void *v, const void *v1, const void *v2);
|
||
#else
|
||
static int compare_files(const void *v1, const void *v2, void *v);
|
||
#endif
|
||
static int fputs_escaped(FILE *f, const char *str, const char *color);
|
||
static void init_term(void);
|
||
static entry_t* load_entry(bb_t *bb, const char *path, int clear_dots);
|
||
static void* memcheck(void *p);
|
||
static void normalize_path(const char *root, const char *path, char *pbuf, int clear_dots);
|
||
static void populate_files(bb_t *bb, int samedir);
|
||
static void print_bindings(int fd);
|
||
static bb_result_t process_cmd(bb_t *bb, const char *cmd);
|
||
static void render(bb_t *bb);
|
||
static int run_script(bb_t *bb, const char *cmd);
|
||
static void set_cursor(bb_t *bb, int i);
|
||
static void set_selected(bb_t *bb, entry_t *e, int selected);
|
||
static void set_scroll(bb_t *bb, int i);
|
||
static void set_sort(bb_t *bb, const char *sort);
|
||
static void sort_files(bb_t *bb);
|
||
static int try_free_entry(entry_t *e);
|
||
static void update_term_size(int sig);
|
||
|
||
// Config options
|
||
extern binding_t bindings[];
|
||
extern const char *startupcmds[];
|
||
extern const column_t columns[128];
|
||
|
||
// Constants
|
||
static const char *T_ENTER_BBMODE = T_OFF(T_SHOW_CURSOR ";" T_WRAP) T_ON(T_ALT_SCREEN ";" T_MOUSE_XY ";" T_MOUSE_CELL ";" T_MOUSE_SGR);
|
||
static const char *T_LEAVE_BBMODE = T_OFF(T_MOUSE_XY ";" T_MOUSE_CELL ";" T_MOUSE_SGR ";" T_ALT_SCREEN) T_ON(T_SHOW_CURSOR ";" T_WRAP);
|
||
static const char *T_LEAVE_BBMODE_PARTIAL = T_OFF(T_MOUSE_XY ";" T_MOUSE_CELL ";" T_MOUSE_SGR) T_ON(T_WRAP);
|
||
|
||
static const char *bbcmdfn = "bb() {\n"
|
||
" if test $# -eq 0; then cat >> $BBCMD; return; fi\n"
|
||
" for arg; do\n"
|
||
" shift;\n"
|
||
" if echo \"$arg\" | grep \"^+[^:]*:$\" >/dev/null 2>/dev/null; then\n"
|
||
" if test $# -gt 0; then printf \"$arg%s\\0\" \"$@\" >> $BBCMD\n"
|
||
" else sed \"s/\\([^\\x00]\\+\\)/$arg\\1/g\" >> $BBCMD; fi\n"
|
||
" return\n"
|
||
" fi\n"
|
||
" printf \"$arg\\0\" >> $BBCMD\n"
|
||
" done\n"
|
||
"}\n";
|
||
|
||
// Global variables
|
||
static struct termios orig_termios, bb_termios;
|
||
static struct termios default_termios = {
|
||
.c_iflag = ICRNL,
|
||
.c_oflag = OPOST | ONLCR | NL0 | CR0 | TAB0 | BS0 | VT0 | FF0,
|
||
.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOKE,
|
||
.c_cflag = CS8 | CREAD,
|
||
.c_cc[VINTR] = '',
|
||
.c_cc[VQUIT] = ' ',
|
||
.c_cc[VERASE] = 127,
|
||
.c_cc[VKILL] = '',
|
||
.c_cc[VEOF] = '',
|
||
.c_cc[VSTART] = '',
|
||
.c_cc[VSTOP] = '',
|
||
.c_cc[VSUSP] = '',
|
||
.c_cc[VREPRINT] = '',
|
||
.c_cc[VWERASE] = '',
|
||
.c_cc[VLNEXT] = '',
|
||
.c_cc[VDISCARD] = '',
|
||
.c_cc[VMIN] = 1,
|
||
.c_cc[VTIME] = 0,
|
||
};
|
||
static FILE *tty_out = NULL, *tty_in = NULL;
|
||
static int termwidth, termheight;
|
||
static int mouse_x, mouse_y;
|
||
static char *cmdfilename = NULL;
|
||
static struct timespec lastclick = {0, 0};
|
||
|
||
|
||
/*
|
||
* Hanlder for SIGWINCH events
|
||
*/
|
||
void update_term_size(int sig)
|
||
{
|
||
(void)sig;
|
||
struct winsize sz = {0};
|
||
ioctl(fileno(tty_in), TIOCGWINSZ, &sz);
|
||
termwidth = sz.ws_col;
|
||
termheight = sz.ws_row;
|
||
}
|
||
|
||
/*
|
||
* Initialize the terminal files for /dev/tty and set up some desired
|
||
* attributes like passing Ctrl-c as a key instead of interrupting
|
||
*/
|
||
void init_term(void)
|
||
{
|
||
static int first_time = 1;
|
||
tty_in = fopen("/dev/tty", "r");
|
||
tty_out = fopen("/dev/tty", "w");
|
||
if (first_time) {
|
||
tcgetattr(fileno(tty_out), &orig_termios);
|
||
first_time = 0;
|
||
}
|
||
memcpy(&bb_termios, &orig_termios, sizeof(bb_termios));
|
||
cfmakeraw(&bb_termios);
|
||
bb_termios.c_cc[VMIN] = 0;
|
||
bb_termios.c_cc[VTIME] = 1;
|
||
if (tcsetattr(fileno(tty_out), TCSAFLUSH, &bb_termios) == -1)
|
||
err("Couldn't tcsetattr");
|
||
update_term_size(0);
|
||
signal(SIGWINCH, update_term_size);
|
||
// Initiate mouse tracking and disable text wrapping:
|
||
fputs(T_ENTER_BBMODE, tty_out);
|
||
}
|
||
|
||
/*
|
||
* Close the /dev/tty terminals and restore some of the attributes.
|
||
*/
|
||
void restore_term(struct termios *term)
|
||
{
|
||
if (tty_out) {
|
||
tcsetattr(fileno(tty_out), TCSAFLUSH, term);
|
||
fputs(T_LEAVE_BBMODE_PARTIAL, tty_out);
|
||
fflush(tty_out);
|
||
fclose(tty_out);
|
||
tty_out = NULL;
|
||
fclose(tty_in);
|
||
tty_in = NULL;
|
||
}
|
||
signal(SIGWINCH, SIG_DFL);
|
||
}
|
||
|
||
/*
|
||
* Close safely in a way that doesn't gunk up the terminal.
|
||
*/
|
||
void cleanup_and_exit(int sig)
|
||
{
|
||
static volatile sig_atomic_t error_in_progress = 0;
|
||
if (error_in_progress)
|
||
raise(sig);
|
||
error_in_progress = 1;
|
||
cleanup();
|
||
signal(sig, SIG_DFL);
|
||
raise(sig);
|
||
}
|
||
|
||
/*
|
||
* Close the terminal, reset the screen, and delete the cmdfile
|
||
*/
|
||
void cleanup(void)
|
||
{
|
||
if (cmdfilename) {
|
||
unlink(cmdfilename);
|
||
free(cmdfilename);
|
||
cmdfilename = NULL;
|
||
}
|
||
if (tty_out)
|
||
fputs(T_OFF(T_ALT_SCREEN) T_ON(T_SHOW_CURSOR), tty_out);
|
||
restore_term(&orig_termios);
|
||
}
|
||
|
||
/*
|
||
* Memory allocation failures are unrecoverable in bb, so this wrapper just
|
||
* prints an error message and exits if that happens.
|
||
*/
|
||
void* memcheck(void *p)
|
||
{
|
||
if (!p) err("Allocation failure");
|
||
return p;
|
||
}
|
||
|
||
/*
|
||
* Run a shell script with the selected files passed as sequential arguments to
|
||
* the script (or pass the cursor file if none are selected).
|
||
* Return the exit status of the script.
|
||
*/
|
||
int run_script(bb_t *bb, const char *cmd)
|
||
{
|
||
pid_t child;
|
||
void (*old_handler)(int) = signal(SIGINT, SIG_IGN);
|
||
if ((child = fork()) == 0) {
|
||
signal(SIGINT, SIG_DFL);
|
||
// TODO: is there a max number of args? Should this be batched?
|
||
size_t space = 32;
|
||
char **args = memcheck(calloc(space, sizeof(char*)));
|
||
size_t i = 0;
|
||
args[i++] = SH;
|
||
args[i++] = "-c";
|
||
char *fullcmd = calloc(strlen(cmd) + strlen(bbcmdfn) + 1, sizeof(char));
|
||
strcpy(fullcmd, bbcmdfn);
|
||
strcat(fullcmd, cmd);
|
||
args[i++] = fullcmd;
|
||
args[i++] = "--"; // ensure files like "-i" are not interpreted as flags for sh
|
||
for (entry_t *e = bb->firstselected; e; e = e->selected.next) {
|
||
if (i >= space)
|
||
args = memcheck(realloc(args, (space += 100)*sizeof(char*)));
|
||
args[i++] = e->fullname;
|
||
}
|
||
args[i] = NULL;
|
||
|
||
setenv("BBDOTFILES", bb->show_dotfiles ? "1" : "", 1);
|
||
setenv("BBCURSOR", bb->nfiles ? bb->files[bb->cursor]->fullname : "", 1);
|
||
setenv("BBSHELLFUNC", bbcmdfn, 1);
|
||
|
||
int ttyout, ttyin;
|
||
ttyout = open("/dev/tty", O_RDWR);
|
||
ttyin = open("/dev/tty", O_RDONLY);
|
||
dup2(ttyout, STDOUT_FILENO);
|
||
dup2(ttyin, STDIN_FILENO);
|
||
execvp(SH, args);
|
||
err("Failed to execute command: '%s'", cmd);
|
||
return -1;
|
||
}
|
||
|
||
if (child == -1)
|
||
err("Failed to fork");
|
||
|
||
int status;
|
||
waitpid(child, &status, 0);
|
||
signal(SIGINT, old_handler);
|
||
|
||
bb->dirty = 1;
|
||
return status;
|
||
}
|
||
|
||
/*
|
||
* Print a string, but replacing bytes like '\n' with a red-colored "\n".
|
||
* The color argument is what color to put back after the red.
|
||
* Returns the number of bytes that were escaped.
|
||
*/
|
||
int fputs_escaped(FILE *f, const char *str, const char *color)
|
||
{
|
||
static const char *escapes = " abtnvfr e";
|
||
int escaped = 0;
|
||
for (const char *c = str; *c; ++c) {
|
||
if (*c > 0 && *c <= '\x1b' && escapes[(int)*c] != ' ') { // "\n", etc.
|
||
fprintf(f, "\033[31m\\%c%s", escapes[(int)*c], color);
|
||
++escaped;
|
||
} else if (*c >= 0 && !(' ' <= *c && *c <= '~')) { // "\x02", etc.
|
||
fprintf(f, "\033[31m\\x%02X%s", *c, color);
|
||
++escaped;
|
||
} else {
|
||
fputc(*c, f);
|
||
}
|
||
}
|
||
return escaped;
|
||
}
|
||
|
||
/*
|
||
* Returns the color of a file listing, given its mode.
|
||
*/
|
||
const char* color_of(mode_t mode)
|
||
{
|
||
if (S_ISDIR(mode)) return DIR_COLOR;
|
||
else if (S_ISLNK(mode)) return LINK_COLOR;
|
||
else if (mode & (S_IXUSR | S_IXGRP | S_IXOTH))
|
||
return EXECUTABLE_COLOR;
|
||
else return NORMAL_COLOR;
|
||
}
|
||
|
||
/*
|
||
* Set the sorting method used by bb to display files.
|
||
*/
|
||
void set_sort(bb_t *bb, const char *sort)
|
||
{
|
||
char sortbuf[strlen(sort)+1];
|
||
strcpy(sortbuf, sort);
|
||
for (char *s = sortbuf; s[0] && s[1]; s += 2) {
|
||
char *found;
|
||
if ((found = strchr(bb->sort, s[1]))) {
|
||
if (*s == '~')
|
||
*s = found[-1] == '+' ? '-' : '+';
|
||
memmove(found-1, found+1, strlen(found+1)+1);
|
||
} else if (*s == '~')
|
||
*s = '+';
|
||
}
|
||
size_t len = MIN(MAX_SORT, strlen(sort));
|
||
memmove(bb->sort + len, bb->sort, MAX_SORT+1 - len);
|
||
memmove(bb->sort, sortbuf, len);
|
||
}
|
||
|
||
/*
|
||
* Draw everything to the screen.
|
||
* If bb->dirty is false, then use terminal scrolling to move the file listing
|
||
* around and only update the files that have changed.
|
||
*/
|
||
void render(bb_t *bb)
|
||
{
|
||
static int lastcursor = -1, lastscroll = -1;
|
||
char buf[64];
|
||
if (lastcursor == -1 || lastscroll == -1)
|
||
bb->dirty = 1;
|
||
|
||
if (!bb->dirty) {
|
||
// Use terminal scrolling:
|
||
if (lastscroll > bb->scroll) {
|
||
fprintf(tty_out, "\033[3;%dr\033[%dT\033[1;%dr", termheight-1, lastscroll - bb->scroll, termheight);
|
||
} else if (lastscroll < bb->scroll) {
|
||
fprintf(tty_out, "\033[3;%dr\033[%dS\033[1;%dr", termheight-1, bb->scroll - lastscroll, termheight);
|
||
}
|
||
}
|
||
|
||
if (bb->dirty) {
|
||
// Path
|
||
move_cursor(tty_out, 0, 0);
|
||
const char *color = TITLE_COLOR;
|
||
fputs(color, tty_out);
|
||
fputs_escaped(tty_out, bb->path, color);
|
||
fputs(" \033[K\033[0m", tty_out);
|
||
|
||
static const char *help = "Press '?' to see key bindings ";
|
||
move_cursor(tty_out, MAX(0, termwidth - (int)strlen(help)), 0);
|
||
fputs(help, tty_out);
|
||
fputs("\033[K\033[0m", tty_out);
|
||
|
||
// Columns
|
||
move_cursor(tty_out, 0, 1);
|
||
fputs("\033[0;44;30m\033[K", tty_out);
|
||
int x = 0;
|
||
for (int col = 0; bb->columns[col]; col++) {
|
||
const char *title = columns[(int)bb->columns[col]].name;
|
||
if (!title) title = "";
|
||
move_cursor(tty_out, x, 1);
|
||
if (col > 0) {
|
||
fputs("│\033[K", tty_out);
|
||
x += 1;
|
||
}
|
||
const char *indicator = " ";
|
||
if (bb->columns[col] == bb->sort[1])
|
||
indicator = bb->sort[0] == '-' ? RSORT_INDICATOR : SORT_INDICATOR;
|
||
move_cursor(tty_out, x, 1);
|
||
fputs(indicator, tty_out);
|
||
fputs(title, tty_out);
|
||
x += columns[(int)bb->columns[col]].width;
|
||
}
|
||
fputs(" \033[K\033[0m", tty_out);
|
||
}
|
||
|
||
entry_t **files = bb->files;
|
||
for (int i = bb->scroll; i < bb->scroll + ONSCREEN; i++) {
|
||
if (!bb->dirty) {
|
||
if (i == bb->cursor || i == lastcursor)
|
||
goto do_render;
|
||
if (i < lastscroll || i >= lastscroll + ONSCREEN)
|
||
goto do_render;
|
||
continue;
|
||
}
|
||
|
||
int y;
|
||
do_render:
|
||
y = i - bb->scroll + 2;
|
||
move_cursor(tty_out, 0, y);
|
||
|
||
if (i == bb->scroll && bb->nfiles == 0) {
|
||
const char *s = "...no files here...";
|
||
fprintf(tty_out, "\033[37;2m%s\033[0m\033[K\033[J", s);
|
||
break;
|
||
}
|
||
|
||
if (i >= bb->nfiles) {
|
||
fputs("\033[J", tty_out);
|
||
break;
|
||
}
|
||
|
||
entry_t *entry = files[i];
|
||
if (i == bb->cursor) fputs(CURSOR_COLOR, tty_out);
|
||
|
||
int use_fullname = strcmp(bb->path, "<selection>") == 0;
|
||
int x = 0;
|
||
for (int col = 0; bb->columns[col]; col++) {
|
||
fprintf(tty_out, "\033[%d;%dH\033[K", y+1, x+1);
|
||
if (col > 0) {
|
||
if (i == bb->cursor) fputs("│", tty_out);
|
||
else fputs("\033[37;2m│\033[22m", tty_out);
|
||
fputs(i == bb->cursor ? CURSOR_COLOR : "\033[0m", tty_out);
|
||
x += 1;
|
||
}
|
||
move_cursor(tty_out, x, y);
|
||
switch (bb->columns[col]) {
|
||
case COL_SELECTED:
|
||
fputs(IS_SELECTED(entry) ? SELECTED_INDICATOR : NOT_SELECTED_INDICATOR, tty_out);
|
||
fputs(i == bb->cursor ? CURSOR_COLOR : "\033[0m", tty_out);
|
||
break;
|
||
|
||
case COL_RANDOM: {
|
||
double k = (double)entry->shufflepos/(double)bb->nfiles;
|
||
int color = (int)(k*232 + (1.-k)*255);
|
||
fprintf(tty_out, "\033[48;5;%dm \033[0m%s", color,
|
||
i == bb->cursor ? CURSOR_COLOR : "\033[0m");
|
||
break;
|
||
}
|
||
|
||
case COL_SIZE: {
|
||
int j = 0;
|
||
const char* units = "BKMGTPEZY";
|
||
double bytes = (double)entry->info.st_size;
|
||
while (bytes > 1024) {
|
||
bytes /= 1024;
|
||
j++;
|
||
}
|
||
fprintf(tty_out, " %6.*f%c ", j > 0 ? 1 : 0, bytes, units[j]);
|
||
break;
|
||
}
|
||
|
||
case COL_MTIME:
|
||
strftime(buf, sizeof(buf), " %I:%M%p %b %e %Y ", localtime(&(entry->info.st_mtime)));
|
||
fputs(buf, tty_out);
|
||
break;
|
||
|
||
case COL_CTIME:
|
||
strftime(buf, sizeof(buf), " %I:%M%p %b %e %Y ", localtime(&(entry->info.st_ctime)));
|
||
fputs(buf, tty_out);
|
||
break;
|
||
|
||
case COL_ATIME:
|
||
strftime(buf, sizeof(buf), " %I:%M%p %b %e %Y ", localtime(&(entry->info.st_atime)));
|
||
fputs(buf, tty_out);
|
||
break;
|
||
|
||
case COL_PERM:
|
||
fprintf(tty_out, " %03o", entry->info.st_mode & 0777);
|
||
break;
|
||
|
||
case COL_NAME: {
|
||
char color[128];
|
||
strcpy(color, color_of(entry->info.st_mode));
|
||
if (i == bb->cursor) strcat(color, CURSOR_COLOR);
|
||
fputs(color, tty_out);
|
||
|
||
char *name = use_fullname ? entry->fullname : entry->name;
|
||
if (entry->no_esc) fputs(name, tty_out);
|
||
else entry->no_esc |= !fputs_escaped(tty_out, name, color);
|
||
|
||
if (E_ISDIR(entry)) fputs("/", tty_out);
|
||
|
||
if (entry->linkname) {
|
||
if (i != bb->cursor)
|
||
fputs("\033[37m", tty_out);
|
||
fputs("\033[2m -> \033[3m", tty_out);
|
||
strcpy(color, color_of(entry->linkedmode));
|
||
if (i == bb->cursor) strcat(color, CURSOR_COLOR);
|
||
strcat(color, "\033[3;2m");
|
||
fputs(color, tty_out);
|
||
if (entry->link_no_esc) fputs(entry->linkname, tty_out);
|
||
else entry->link_no_esc |= !fputs_escaped(tty_out, entry->linkname, color);
|
||
|
||
if (S_ISDIR(entry->linkedmode))
|
||
fputs("/", tty_out);
|
||
|
||
fputs("\033[22;23m", tty_out);
|
||
}
|
||
fputs(i == bb->cursor ? CURSOR_COLOR : "\033[0m", tty_out);
|
||
fputs("\033[K", tty_out);
|
||
break;
|
||
}
|
||
default: break;
|
||
}
|
||
x += columns[(int)bb->columns[col]].width;
|
||
}
|
||
fputs(" \033[K\033[0m", tty_out); // Reset color and attributes
|
||
}
|
||
|
||
if (bb->firstselected) {
|
||
int n = 0;
|
||
for (entry_t *s = bb->firstselected; s; s = s->selected.next) ++n;
|
||
int x = termwidth - 14;
|
||
for (int k = n; k; k /= 10) x--;
|
||
move_cursor(tty_out, MAX(0, x), termheight - 1);
|
||
fprintf(tty_out, "\033[41;30m %d Selected \033[0m", n);
|
||
} else {
|
||
move_cursor(tty_out, termwidth/2, termheight - 1);
|
||
fputs("\033[0m\033[K", tty_out);
|
||
}
|
||
|
||
lastcursor = bb->cursor;
|
||
lastscroll = bb->scroll;
|
||
fflush(tty_out);
|
||
}
|
||
|
||
/*
|
||
* Used for sorting, this function compares files according to the sorting-related options,
|
||
* like bb->sort
|
||
*/
|
||
#ifdef __APPLE__
|
||
int compare_files(void *v, const void *v1, const void *v2)
|
||
#else
|
||
int compare_files(const void *v1, const void *v2, void *v)
|
||
#endif
|
||
{
|
||
#define COMPARE(a, b) if ((a) != (b)) { return sign*((a) < (b) ? 1 : -1); }
|
||
#define COMPARE_TIME(t1, t2) COMPARE((t1).tv_sec, (t2).tv_sec) COMPARE((t1).tv_nsec, (t2).tv_nsec)
|
||
bb_t *bb = (bb_t*)v;
|
||
const entry_t *e1 = *((const entry_t**)v1), *e2 = *((const entry_t**)v2);
|
||
|
||
int sign = 1;
|
||
if (!bb->interleave_dirs) {
|
||
COMPARE(E_ISDIR(e1), E_ISDIR(e2));
|
||
}
|
||
|
||
for (char *sort = bb->sort + 1; *sort; sort += 2) {
|
||
sign = sort[-1] == '-' ? -1 : 1;
|
||
switch (*sort) {
|
||
case COL_SELECTED: COMPARE(IS_SELECTED(e1), IS_SELECTED(e2)); break;
|
||
case COL_NAME: {
|
||
/* This sorting method is not identical to strverscmp(). Notably, bb's sort
|
||
* will order: [0, 1, 9, 00, 01, 09, 10, 000, 010] instead of strverscmp()'s
|
||
* order: [000, 00, 01, 010, 09, 0, 1, 9, 10]. I believe bb's sort is consistent
|
||
* with how people want their files grouped: all files padded to n digits
|
||
* will be grouped together, and files with the same padding will be sorted
|
||
* ordinally. This version also does case-insensitivity by lowercasing words,
|
||
* so the following characters come before all letters: [\]^_`
|
||
*/
|
||
const char *n1 = e1->name, *n2 = e2->name;
|
||
while (*n1 && *n2) {
|
||
char c1 = LOWERCASE(*n1), c2 = LOWERCASE(*n2);
|
||
if ('0' <= c1 && c1 <= '9' && '0' <= c2 && c2 <= '9') {
|
||
long i1 = strtol(n1, (char**)&n1, 10);
|
||
long i2 = strtol(n2, (char**)&n2, 10);
|
||
// Shorter numbers always go before longer. In practice, I assume
|
||
// filenames padded to the same number of digits should be grouped
|
||
// together, instead of
|
||
// [1.png, 0001.png, 2.png, 0002.png, 3.png], it makes more sense to have:
|
||
// [1.png, 2.png, 3.png, 0001.png, 0002.png]
|
||
COMPARE((n2 - e2->name), (n1 - e1->name));
|
||
COMPARE(i2, i1);
|
||
} else {
|
||
COMPARE(c2, c1);
|
||
++n1; ++n2;
|
||
}
|
||
}
|
||
COMPARE(LOWERCASE(*n2), LOWERCASE(*n1));
|
||
break;
|
||
}
|
||
case COL_PERM: COMPARE((e1->info.st_mode & 0x3FF), (e2->info.st_mode & 0x3FF)); break;
|
||
case COL_SIZE: COMPARE(e1->info.st_size, e2->info.st_size); break;
|
||
case COL_MTIME: COMPARE_TIME(mtime(e1->info), mtime(e2->info)); break;
|
||
case COL_CTIME: COMPARE_TIME(ctime(e1->info), ctime(e2->info)); break;
|
||
case COL_ATIME: COMPARE_TIME(atime(e1->info), atime(e2->info)); break;
|
||
case COL_RANDOM: COMPARE(e1->shufflepos, e2->shufflepos); break;
|
||
}
|
||
}
|
||
return 0;
|
||
#undef COMPARE
|
||
#undef COMPARE_TIME
|
||
}
|
||
|
||
/*
|
||
* Select or deselect a file.
|
||
*/
|
||
void set_selected(bb_t *bb, entry_t *e, int selected)
|
||
{
|
||
if (IS_SELECTED(e) == selected) return;
|
||
|
||
if (bb->nfiles > 0 && e != bb->files[bb->cursor])
|
||
bb->dirty = 1;
|
||
|
||
if (selected) {
|
||
if (bb->firstselected)
|
||
bb->firstselected->selected.atme = &e->selected.next;
|
||
e->selected.next = bb->firstselected;
|
||
e->selected.atme = &bb->firstselected;
|
||
bb->firstselected = e;
|
||
} else {
|
||
if (bb->nfiles > 0 && e != bb->files[bb->cursor])
|
||
bb->dirty = 1;
|
||
if (e->selected.next)
|
||
e->selected.next->selected.atme = e->selected.atme;
|
||
*(e->selected.atme) = e->selected.next;
|
||
e->selected.next = NULL;
|
||
e->selected.atme = NULL;
|
||
try_free_entry(e);
|
||
}
|
||
}
|
||
|
||
/*
|
||
* Set bb's file cursor to the given index (and adjust the scroll as necessary)
|
||
*/
|
||
void set_cursor(bb_t *bb, int newcur)
|
||
{
|
||
int oldcur = bb->cursor;
|
||
if (newcur > bb->nfiles - 1) newcur = bb->nfiles - 1;
|
||
if (newcur < 0) newcur = 0;
|
||
bb->cursor = newcur;
|
||
if (bb->nfiles <= ONSCREEN) {
|
||
bb->scroll = 0;
|
||
return;
|
||
}
|
||
|
||
if (oldcur < bb->cursor) {
|
||
if (bb->scroll > bb->cursor)
|
||
bb->scroll = MAX(0, bb->cursor);
|
||
else if (bb->scroll < bb->cursor - ONSCREEN + 1 + SCROLLOFF)
|
||
bb->scroll = MIN(bb->nfiles - 1 - ONSCREEN + 1,
|
||
bb->scroll + (newcur - oldcur));
|
||
} else {
|
||
if (bb->scroll > bb->cursor - SCROLLOFF)
|
||
bb->scroll = MAX(0, bb->scroll + (newcur - oldcur));//bb->cursor - SCROLLOFF);
|
||
else if (bb->scroll < bb->cursor - ONSCREEN + 1)
|
||
bb->scroll = MIN(bb->cursor - ONSCREEN + 1,
|
||
bb->nfiles - 1 - ONSCREEN + 1);
|
||
}
|
||
}
|
||
|
||
/*
|
||
* Set bb's scroll to the given index (and adjust the cursor as necessary)
|
||
*/
|
||
void set_scroll(bb_t *bb, int newscroll)
|
||
{
|
||
int delta = newscroll - bb->scroll;
|
||
if (bb->nfiles <= ONSCREEN) {
|
||
newscroll = 0;
|
||
} else {
|
||
if (newscroll > bb->nfiles - 1 - ONSCREEN + 1)
|
||
newscroll = bb->nfiles - 1 - ONSCREEN + 1;
|
||
if (newscroll < 0) newscroll = 0;
|
||
}
|
||
|
||
bb->scroll = newscroll;
|
||
bb->cursor += delta;
|
||
if (bb->cursor > bb->nfiles - 1) bb->cursor = bb->nfiles - 1;
|
||
if (bb->cursor < 0) bb->cursor = 0;
|
||
}
|
||
|
||
/*
|
||
* Load a file's info into an entry_t and return it (if found).
|
||
* The returned entry must be free()ed by the caller.
|
||
* Warning: this does not deduplicate entries, and it's best if there aren't
|
||
* duplicate entries hanging around.
|
||
*/
|
||
entry_t* load_entry(bb_t *bb, const char *path, int clear_dots)
|
||
{
|
||
struct stat linkedstat, filestat;
|
||
if (!path || !path[0]) return NULL;
|
||
if (lstat(path, &filestat) == -1) return NULL;
|
||
char pbuf[PATH_MAX];
|
||
normalize_path(bb->path, path, pbuf, clear_dots);
|
||
if (pbuf[strlen(pbuf)-1] == '/' && pbuf[1])
|
||
pbuf[strlen(pbuf)-1] = '\0';
|
||
|
||
// Check for pre-existing:
|
||
for (entry_t *e = bb->hash[(int)filestat.st_ino & HASH_MASK]; e; e = e->hash.next) {
|
||
if (e->info.st_ino == filestat.st_ino && e->info.st_dev == filestat.st_dev
|
||
// Need to check filename in case of hard links
|
||
&& strcmp(pbuf, e->fullname) == 0)
|
||
return e;
|
||
}
|
||
|
||
ssize_t linkpathlen = -1;
|
||
char linkbuf[PATH_MAX];
|
||
if (S_ISLNK(filestat.st_mode)) {
|
||
linkpathlen = readlink(pbuf, linkbuf, sizeof(linkbuf));
|
||
if (linkpathlen < 0) err("Couldn't read link: '%s'", pbuf);
|
||
linkbuf[linkpathlen] = '\0';
|
||
while (linkpathlen > 0 && linkbuf[linkpathlen-1] == '/') linkbuf[--linkpathlen] = '\0';
|
||
if (stat(pbuf, &linkedstat) == -1) memset(&linkedstat, 0, sizeof(linkedstat));
|
||
}
|
||
size_t pathlen = strlen(pbuf);
|
||
size_t entry_size = sizeof(entry_t) + (pathlen + 1) + (size_t)(linkpathlen + 1);
|
||
entry_t *entry = memcheck(calloc(entry_size, 1));
|
||
char *end = stpcpy(entry->fullname, pbuf);
|
||
if (linkpathlen >= 0)
|
||
entry->linkname = strcpy(end + 1, linkbuf);
|
||
if (strcmp(entry->fullname, "/") == 0) {
|
||
entry->name = entry->fullname;
|
||
} else {
|
||
entry->name = strrchr(entry->fullname, '/');
|
||
if (!entry->name) err("No slash found in '%s' from '%s'", entry->fullname, path);
|
||
++entry->name;
|
||
}
|
||
if (S_ISLNK(filestat.st_mode))
|
||
entry->linkedmode = linkedstat.st_mode;
|
||
entry->info = filestat;
|
||
if (bb->hash[(int)filestat.st_ino & HASH_MASK])
|
||
bb->hash[(int)filestat.st_ino & HASH_MASK]->hash.atme = &entry->hash.next;
|
||
entry->hash.next = bb->hash[(int)filestat.st_ino & HASH_MASK];
|
||
entry->hash.atme = &bb->hash[(int)filestat.st_ino & HASH_MASK];
|
||
entry->index = -1;
|
||
bb->hash[(int)filestat.st_ino & HASH_MASK] = entry;
|
||
return entry;
|
||
}
|
||
|
||
/*
|
||
* If the given entry is not viewed or selected, remove it from the
|
||
* hash, free it, and return 1.
|
||
*/
|
||
int try_free_entry(entry_t *e)
|
||
{
|
||
if (IS_SELECTED(e) || IS_VIEWED(e)) return 0;
|
||
if (e->hash.next)
|
||
e->hash.next->hash.atme = e->hash.atme;
|
||
*(e->hash.atme) = e->hash.next;
|
||
e->hash.atme = NULL;
|
||
e->hash.next = NULL;
|
||
free(e);
|
||
return 1;
|
||
}
|
||
|
||
/*
|
||
* Sort the files in bb according to bb's settings.
|
||
*/
|
||
void sort_files(bb_t *bb)
|
||
{
|
||
#ifdef __APPLE__
|
||
qsort_r(bb->files, (size_t)bb->nfiles, sizeof(entry_t*), bb, compare_files);
|
||
#else
|
||
qsort_r(bb->files, (size_t)bb->nfiles, sizeof(entry_t*), compare_files, bb);
|
||
#endif
|
||
for (int i = 0; i < bb->nfiles; i++)
|
||
bb->files[i]->index = i;
|
||
bb->dirty = 1;
|
||
}
|
||
|
||
/*
|
||
* Prepend `root` to relative paths, replace "~" with $HOME.
|
||
* If clear_dots is 1, then also replace "/foo/." with "/foo" and replace "/foo/baz/.." with "/foo".
|
||
* The normalized path is stored in `normalized`.
|
||
*/
|
||
void normalize_path(const char *root, const char *path, char *normalized, int clear_dots)
|
||
{
|
||
if (path[0] == '~' && (path[1] == '\0' || path[1] == '/')) {
|
||
char *home;
|
||
if (!(home = getenv("HOME"))) return;
|
||
strcpy(normalized, home);
|
||
++path;
|
||
} else if (path[0] == '/') {
|
||
normalized[0] = '\0';
|
||
} else {
|
||
strcpy(normalized, root);
|
||
if (root[strlen(root)-1] != '/') err("No trailing slash on root");
|
||
}
|
||
strcat(normalized, path);
|
||
|
||
if (clear_dots) {
|
||
char *src = normalized, *dest = normalized;
|
||
while (*src) {
|
||
while (src[0] == '/' && src[1] == '.') {
|
||
// Replace "foo/./?" with "foo/?"
|
||
if (src[2] == '/' || src[2] == '\0') {
|
||
src += 2;
|
||
} else if (src[2] == '.' && (src[3] == '/' || src[3] == '\0')) {
|
||
// Replace "foo/baz/../asdf" with "foo/asdf"
|
||
src += 3;
|
||
*dest = '\0';
|
||
if (dest[-1] == '/') dest[-1] = '\0';
|
||
while (dest > normalized && *dest != '/') dest--;
|
||
} else break;
|
||
}
|
||
*(dest++) = *(src++);
|
||
}
|
||
*dest = '\0';
|
||
}
|
||
}
|
||
|
||
int cd_to(bb_t *bb, const char *path)
|
||
{
|
||
char pbuf[PATH_MAX], prev[PATH_MAX] = {0};
|
||
strcpy(prev, bb->path);
|
||
if (strcmp(path, "<selection>") == 0) {
|
||
strcpy(pbuf, path);
|
||
} else if (strcmp(path, "..") == 0 && strcmp(bb->path, "<selection>") == 0) {
|
||
if (!bb->prev_path[0]) return -1;
|
||
strcpy(pbuf, bb->prev_path);
|
||
if (chdir(pbuf)) return -1;
|
||
} else {
|
||
normalize_path(bb->path, path, pbuf, 1);
|
||
if (pbuf[strlen(pbuf)-1] != '/')
|
||
strcat(pbuf, "/");
|
||
if (chdir(pbuf)) return -1;
|
||
}
|
||
|
||
if (strcmp(bb->path, "<selection>") != 0) {
|
||
strcpy(bb->prev_path, prev);
|
||
setenv("BBPREVPATH", bb->prev_path, 1);
|
||
}
|
||
|
||
strcpy(bb->path, pbuf);
|
||
populate_files(bb, 0);
|
||
if (prev[0]) {
|
||
entry_t *p = load_entry(bb, prev, 0);
|
||
if (p) {
|
||
if (IS_VIEWED(p)) set_cursor(bb, p->index);
|
||
else try_free_entry(p);
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
/*
|
||
* Remove all the files currently stored in bb->files and if `bb->path` is
|
||
* non-NULL, update `bb` with a listing of the files in `path`
|
||
*/
|
||
void populate_files(bb_t *bb, int samedir)
|
||
{
|
||
bb->dirty = 1;
|
||
|
||
// Clear old files (if any)
|
||
if (bb->files) {
|
||
for (int i = 0; i < bb->nfiles; i++) {
|
||
bb->files[i]->index = -1;
|
||
try_free_entry(bb->files[i]);
|
||
bb->files[i] = NULL;
|
||
}
|
||
free(bb->files);
|
||
bb->files = NULL;
|
||
}
|
||
|
||
int old_scroll = bb->scroll, old_cursor = bb->cursor;
|
||
bb->nfiles = 0;
|
||
bb->cursor = 0;
|
||
bb->scroll = 0;
|
||
|
||
if (!bb->path[0])
|
||
return;
|
||
|
||
size_t space = 0;
|
||
if (strcmp(bb->path, "<selection>") == 0) {
|
||
for (entry_t *e = bb->firstselected; e; e = e->selected.next) {
|
||
if ((size_t)bb->nfiles + 1 > space)
|
||
bb->files = memcheck(realloc(bb->files, (space += 100)*sizeof(void*)));
|
||
e->index = bb->nfiles;
|
||
bb->files[bb->nfiles++] = e;
|
||
}
|
||
} else {
|
||
DIR *dir = opendir(bb->path);
|
||
if (!dir)
|
||
err("Couldn't open dir: %s", bb->path);
|
||
|
||
for (struct dirent *dp; (dp = readdir(dir)) != NULL; ) {
|
||
if (dp->d_name[0] == '.') {
|
||
if (dp->d_name[1] == '.' && dp->d_name[2] == '\0') {
|
||
if (!bb->show_dotdot || strcmp(bb->path, "/") == 0) continue;
|
||
} else if (dp->d_name[1] == '\0') {
|
||
if (!bb->show_dot) continue;
|
||
} else if (!bb->show_dotfiles) continue;
|
||
}
|
||
if ((size_t)bb->nfiles + 1 > space)
|
||
bb->files = memcheck(realloc(bb->files, (space += 100)*sizeof(void*)));
|
||
// Don't normalize path so we can get "." and ".."
|
||
entry_t *entry = load_entry(bb, dp->d_name, 0);
|
||
if (!entry) err("Failed to load entry: '%s'", dp->d_name);
|
||
entry->index = bb->nfiles;
|
||
bb->files[bb->nfiles++] = entry;
|
||
}
|
||
closedir(dir);
|
||
}
|
||
|
||
for (int i = 0; i < bb->nfiles; i++) {
|
||
int j = rand() / (RAND_MAX / (i + 1)); // This is not optimal, but doesn't need to be
|
||
bb->files[i]->shufflepos = bb->files[j]->shufflepos;
|
||
bb->files[j]->shufflepos = i;
|
||
}
|
||
|
||
sort_files(bb);
|
||
if (samedir) {
|
||
set_cursor(bb, old_cursor);
|
||
set_scroll(bb, old_scroll);
|
||
}
|
||
}
|
||
|
||
/*
|
||
* Run a bb internal command (e.g. "+refresh") and return an indicator of what
|
||
* needs to happen next.
|
||
*/
|
||
bb_result_t process_cmd(bb_t *bb, const char *cmd)
|
||
{
|
||
char *value = strchr(cmd, ':');
|
||
if (value) ++value;
|
||
#define set_bool(target) do { if (!value) { target = !target; } else { target = value[0] == '1'; } } while (0)
|
||
if (cmd[0] == '+') ++cmd;
|
||
switch (cmd[0]) {
|
||
case '.': { // +..:, +.:
|
||
if (cmd[1] == '.') // +..:
|
||
set_bool(bb->show_dotdot);
|
||
else // +.:
|
||
set_bool(bb->show_dot);
|
||
populate_files(bb, 1);
|
||
return BB_OK;
|
||
}
|
||
case 'c': { // +cd:, +columns:
|
||
switch (cmd[1]) {
|
||
case 'd': { // +cd:
|
||
if (!value) return BB_INVALID;
|
||
if (cd_to(bb, value)) return BB_INVALID;
|
||
return BB_OK;
|
||
}
|
||
case 'o': { // +columns:
|
||
if (!value) return BB_INVALID;
|
||
strncpy(bb->columns, value, MAX_COLS);
|
||
bb->dirty = 1;
|
||
return BB_OK;
|
||
}
|
||
}
|
||
return BB_INVALID;
|
||
}
|
||
case 'd': { // +deselect:, +dotfiles:
|
||
switch (cmd[1]) {
|
||
case 'e': { // +deselect:
|
||
if (!value && !bb->nfiles) return BB_INVALID;
|
||
if (!value) value = bb->files[bb->cursor]->fullname;
|
||
char pbuf[PATH_MAX];
|
||
normalize_path(bb->path, value, pbuf, 1);
|
||
entry_t *e = load_entry(bb, pbuf, 0);
|
||
if (e) {
|
||
set_selected(bb, e, 0);
|
||
return BB_OK;
|
||
}
|
||
// Filename may no longer exist:
|
||
for (e = bb->firstselected; e; e = e->selected.next) {
|
||
if (strcmp(e->fullname, pbuf) == 0) {
|
||
set_selected(bb, e, 0);
|
||
break;
|
||
}
|
||
}
|
||
return BB_OK;
|
||
}
|
||
case 'o': { // +dotfiles:
|
||
set_bool(bb->show_dotfiles);
|
||
populate_files(bb, 1);
|
||
return BB_OK;
|
||
}
|
||
}
|
||
}
|
||
case 'g': { // +goto:
|
||
if (!value) return BB_INVALID;
|
||
entry_t *e = load_entry(bb, value, 1);
|
||
if (!e) return BB_INVALID;
|
||
if (IS_VIEWED(e)) {
|
||
set_cursor(bb, e->index);
|
||
return BB_OK;
|
||
}
|
||
char pbuf[PATH_MAX];
|
||
strcpy(pbuf, e->fullname);
|
||
char *lastslash = strrchr(pbuf, '/');
|
||
if (!lastslash) return BB_INVALID;
|
||
*lastslash = '\0'; // Split in two
|
||
cd_to(bb, pbuf);
|
||
if (IS_VIEWED(e)) {
|
||
set_cursor(bb, e->index);
|
||
return BB_OK;
|
||
} else try_free_entry(e);
|
||
return BB_OK;
|
||
}
|
||
case 'h': { // +help
|
||
restore_term(&default_termios);
|
||
int fds[2];
|
||
pipe(fds);
|
||
pid_t child = fork();
|
||
void (*old_handler)(int) = signal(SIGINT, SIG_IGN);
|
||
if (child != 0) {
|
||
close(fds[0]);
|
||
print_bindings(fds[1]);
|
||
close(fds[1]);
|
||
waitpid(child, NULL, 0);
|
||
} else {
|
||
close(fds[1]);
|
||
dup2(fds[0], STDIN_FILENO);
|
||
char *args[] = {SH, "-c", "$PAGER -rX", NULL};
|
||
execvp(SH, args);
|
||
}
|
||
init_term();
|
||
signal(SIGINT, old_handler);
|
||
bb->dirty = 1;
|
||
return BB_OK;
|
||
}
|
||
case 'i': { // +interleave
|
||
set_bool(bb->interleave_dirs);
|
||
sort_files(bb);
|
||
return BB_OK;
|
||
}
|
||
case 'm': { // +move:
|
||
int oldcur, isdelta, n;
|
||
move:
|
||
if (!value) return BB_INVALID;
|
||
if (!bb->nfiles) return BB_INVALID;
|
||
oldcur = bb->cursor;
|
||
isdelta = value[0] == '-' || value[0] == '+';
|
||
n = (int)strtol(value, &value, 10);
|
||
if (*value == '%')
|
||
n = (n * (value[1] == 'n' ? bb->nfiles : termheight)) / 100;
|
||
if (isdelta) set_cursor(bb, bb->cursor + n);
|
||
else set_cursor(bb, n);
|
||
if (cmd[0] == 's') { // +spread:
|
||
int sel = IS_SELECTED(bb->files[oldcur]);
|
||
for (int i = bb->cursor; i != oldcur; i += (oldcur > i ? 1 : -1))
|
||
set_selected(bb, bb->files[i], sel);
|
||
}
|
||
return BB_OK;
|
||
}
|
||
case 'q': // +quit
|
||
bb->should_quit = 1;
|
||
return BB_QUIT;
|
||
case 'r': // +refresh
|
||
populate_files(bb, 1);
|
||
return BB_OK;
|
||
case 's': // +scroll:, +select:, +sort:, +spread:
|
||
switch (cmd[1]) {
|
||
case 'c': { // scroll:
|
||
if (!value) return BB_INVALID;
|
||
// TODO: figure out the best version of this
|
||
int isdelta = value[0] == '+' || value[0] == '-';
|
||
int n = (int)strtol(value, &value, 10);
|
||
if (*value == '%')
|
||
n = (n * (value[1] == 'n' ? bb->nfiles : termheight)) / 100;
|
||
if (isdelta)
|
||
set_scroll(bb, bb->scroll + n);
|
||
else
|
||
set_scroll(bb, n);
|
||
return BB_OK;
|
||
}
|
||
|
||
case '\0': case 'e': { // +select:
|
||
if (!value && !bb->nfiles) return BB_INVALID;
|
||
if (!value) value = bb->files[bb->cursor]->fullname;
|
||
entry_t *e = load_entry(bb, value, 1);
|
||
if (e) set_selected(bb, e, 1);
|
||
return BB_OK;
|
||
}
|
||
case 'o': // +sort:
|
||
if (!value) return BB_INVALID;
|
||
set_sort(bb, value);
|
||
sort_files(bb);
|
||
return BB_OK;
|
||
|
||
case 'p': // +spread:
|
||
goto move;
|
||
}
|
||
case 't': { // +toggle:
|
||
if (!value && !bb->nfiles) return BB_INVALID;
|
||
if (!value) value = bb->files[bb->cursor]->fullname;
|
||
entry_t *e = load_entry(bb, value, 1);
|
||
if (e) set_selected(bb, e, !IS_SELECTED(e));
|
||
return BB_OK;
|
||
}
|
||
default: err("UNKNOWN COMMAND: '%s'", cmd); break;
|
||
}
|
||
return BB_INVALID;
|
||
}
|
||
|
||
/*
|
||
* Use bb to browse a path.
|
||
*/
|
||
void bb_browse(bb_t *bb, const char *path)
|
||
{
|
||
static long cmdpos = 0;
|
||
int lastwidth = termwidth, lastheight = termheight;
|
||
int check_cmds = 1;
|
||
|
||
cd_to(bb, path);
|
||
bb->scroll = 0;
|
||
bb->cursor = 0;
|
||
|
||
for (int i = 0; startupcmds[i]; i++) {
|
||
if (startupcmds[i][0] == '+')
|
||
process_cmd(bb, startupcmds[i] + 1);
|
||
else
|
||
run_script(bb, startupcmds[i]);
|
||
if (bb->should_quit)
|
||
goto quit;
|
||
}
|
||
|
||
init_term();
|
||
goto force_check_cmds;
|
||
|
||
redraw:
|
||
render(bb);
|
||
bb->dirty = 0;
|
||
|
||
next_input:
|
||
if (termwidth != lastwidth || termheight != lastheight) {
|
||
lastwidth = termwidth; lastheight = termheight;
|
||
bb->dirty = 1;
|
||
goto redraw;
|
||
}
|
||
|
||
if (check_cmds) {
|
||
FILE *cmdfile;
|
||
force_check_cmds:
|
||
cmdfile = fopen(cmdfilename, "r");
|
||
if (!cmdfile) {
|
||
if (bb->dirty) goto redraw;
|
||
goto get_keyboard_input;
|
||
}
|
||
|
||
if (cmdpos)
|
||
fseek(cmdfile, cmdpos, SEEK_SET);
|
||
|
||
char *cmd = NULL;
|
||
size_t space = 0;
|
||
while (cmdfile && getdelim(&cmd, &space, '\0', cmdfile) >= 0) {
|
||
cmdpos = ftell(cmdfile);
|
||
if (!cmd[0]) continue;
|
||
process_cmd(bb, cmd);
|
||
if (bb->should_quit) {
|
||
free(cmd);
|
||
fclose(cmdfile);
|
||
goto quit;
|
||
}
|
||
}
|
||
free(cmd);
|
||
fclose(cmdfile);
|
||
unlink(cmdfilename);
|
||
cmdpos = 0;
|
||
check_cmds = 0;
|
||
goto redraw;
|
||
}
|
||
|
||
int key;
|
||
get_keyboard_input:
|
||
key = bgetkey(tty_in, &mouse_x, &mouse_y);
|
||
switch (key) {
|
||
case KEY_MOUSE_LEFT: {
|
||
struct timespec clicktime;
|
||
clock_gettime(CLOCK_MONOTONIC, &clicktime);
|
||
double dt_ms = 1e3*(double)(clicktime.tv_sec - lastclick.tv_sec);
|
||
dt_ms += 1e-6*(double)(clicktime.tv_nsec - lastclick.tv_nsec);
|
||
lastclick = clicktime;
|
||
// Get column:
|
||
char column[3] = "+?";
|
||
for (int col = 0, x = 0; bb->columns[col]; col++) {
|
||
if (col > 0) x += 1;
|
||
x += columns[(int)bb->columns[col]].width;
|
||
if (x >= mouse_x) {
|
||
column[1] = bb->columns[col];
|
||
break;
|
||
}
|
||
}
|
||
if (mouse_y == 1) {
|
||
char *pos;
|
||
if ((pos = strstr(bb->sort, column)) && pos == bb->sort)
|
||
column[0] = '-';
|
||
set_sort(bb, column);
|
||
sort_files(bb);
|
||
goto redraw;
|
||
} else if (2 <= mouse_y && mouse_y <= termheight - 2) {
|
||
int clicked = bb->scroll + (mouse_y - 2);
|
||
if (clicked > bb->nfiles - 1) goto next_input;
|
||
if (column[1] == COL_SELECTED) {
|
||
set_selected(bb, bb->files[clicked], !IS_SELECTED(bb->files[clicked]));
|
||
bb->dirty = 1;
|
||
goto redraw;
|
||
}
|
||
set_cursor(bb, clicked);
|
||
if (dt_ms <= 200) {
|
||
key = KEY_MOUSE_DOUBLE_LEFT;
|
||
goto user_bindings;
|
||
}
|
||
goto redraw;
|
||
}
|
||
break;
|
||
}
|
||
|
||
case KEY_CTRL_C:
|
||
cleanup_and_exit(SIGINT);
|
||
|
||
case KEY_CTRL_Z:
|
||
fputs(T_LEAVE_BBMODE, tty_out);
|
||
restore_term(&orig_termios);
|
||
raise(SIGTSTP);
|
||
init_term();
|
||
bb->dirty = 1;
|
||
goto redraw;
|
||
|
||
case -1:
|
||
goto next_input;
|
||
|
||
default: {
|
||
// Search user-defined key bindings from config.h:
|
||
binding_t *binding;
|
||
user_bindings:
|
||
for (int i = 0; bindings[i].keys[0] >= 0; i++) {
|
||
for (int j = 0; bindings[i].keys[j]; j++) {
|
||
if (key == bindings[i].keys[j]) {
|
||
// Move to front optimization:
|
||
if (i > 2) {
|
||
binding_t tmp;
|
||
tmp = bindings[0];
|
||
bindings[0] = bindings[i];
|
||
bindings[i] = tmp;
|
||
i = 0;
|
||
}
|
||
binding = &bindings[i];
|
||
goto run_binding;
|
||
}
|
||
}
|
||
}
|
||
// Nothing matched
|
||
goto next_input;
|
||
|
||
run_binding:
|
||
if (cmdpos != 0)
|
||
err("Command file still open");
|
||
if (binding->script[0] == '+') {
|
||
process_cmd(bb, binding->script + 1);
|
||
} else {
|
||
move_cursor(tty_out, 0, termheight-1);
|
||
fputs(T_ON(T_SHOW_CURSOR), tty_out);
|
||
restore_term(&default_termios);
|
||
run_script(bb, binding->script);
|
||
init_term();
|
||
check_cmds = 1;
|
||
}
|
||
if (bb->should_quit) goto quit;
|
||
goto redraw;
|
||
}
|
||
}
|
||
goto next_input;
|
||
|
||
quit:
|
||
if (tty_out) {
|
||
fputs(T_LEAVE_BBMODE, tty_out);
|
||
cleanup();
|
||
}
|
||
}
|
||
|
||
/*
|
||
* Print the current key bindings
|
||
*/
|
||
void print_bindings(int fd)
|
||
{
|
||
char buf[1000], buf2[1024];
|
||
for (int i = 0; bindings[i].keys[0] >= 0; i++) {
|
||
if (bindings[i].keys[0] == 0) {
|
||
const char *label = bindings[i].description;
|
||
sprintf(buf, "\n\033[33;1;4m\033[%dG%s\033[0m\n", (termwidth-(int)strlen(label))/2, label);
|
||
write(fd, buf, strlen(buf));
|
||
continue;
|
||
}
|
||
char *p = buf;
|
||
for (int j = 0; bindings[i].keys[j]; j++) {
|
||
if (j > 0) p = stpcpy(p, ", ");
|
||
int key = bindings[i].keys[j];
|
||
const char *name = bkeyname(key);
|
||
if (name)
|
||
p = stpcpy(p, name);
|
||
else if (' ' <= key && key <= '~')
|
||
p += sprintf(p, "%c", (char)key);
|
||
else
|
||
p += sprintf(p, "\033[31m\\x%02X", key);
|
||
}
|
||
*p = '\0';
|
||
sprintf(buf2, "\033[1m\033[%dG%s\033[0m", termwidth/2 - 1 - (int)strlen(buf), buf);
|
||
write(fd, buf2, strlen(buf2));
|
||
sprintf(buf2, "\033[0m\033[%dG\033[34m%s\033[0m", termwidth/2 + 1,
|
||
bindings[i].description ? bindings[i].description : bindings[i].script);
|
||
write(fd, buf2, strlen(buf2));
|
||
write(fd, "\033[0m\n", strlen("\033[0m\n"));
|
||
}
|
||
write(fd, "\n", 1);
|
||
}
|
||
|
||
int main(int argc, char *argv[])
|
||
{
|
||
char *initial_path = NULL, depthstr[64] = {0};
|
||
char sep = '\n';
|
||
int print_dir = 0, print_selection = 0;
|
||
|
||
for (int i = 1; i < argc; i++) {
|
||
if (argv[i][0] == '+') {
|
||
char *colon = strchr(argv[i], ':');
|
||
if (colon && !colon[1]) break;
|
||
continue;
|
||
}
|
||
if (strcmp(argv[i], "--") == 0) {
|
||
if (i + 1 < argc) initial_path = argv[i+1];
|
||
break;
|
||
}
|
||
if (argv[i][0] != '-' && !initial_path)
|
||
initial_path = argv[i];
|
||
}
|
||
if (!initial_path)
|
||
initial_path = ".";
|
||
|
||
cmdfilename = memcheck(strdup(CMDFILE_FORMAT));
|
||
int cmdfd;
|
||
if ((cmdfd = mkostemp(cmdfilename, O_APPEND)) == -1)
|
||
err("Couldn't create tmpfile: '%s'", CMDFILE_FORMAT);
|
||
// Set up environment variables
|
||
char *curdepth = getenv("BB_DEPTH");
|
||
int depth = curdepth ? atoi(curdepth) : 0;
|
||
sprintf(depthstr, "%d", depth + 1);
|
||
setenv("BB_DEPTH", depthstr, 1);
|
||
setenv("BBCMD", cmdfilename, 1);
|
||
|
||
int i;
|
||
for (i = 1; i < argc; i++) {
|
||
if (argv[i][0] == '+') {
|
||
char *colon = strchr(argv[i], ':');
|
||
if (colon && !colon[1]) {
|
||
for (int j = i+1; j < argc; j++) {
|
||
write(cmdfd, argv[i]+1, strlen(argv[i]+1));
|
||
write(cmdfd, argv[j], strlen(argv[j])+1);
|
||
}
|
||
} else {
|
||
write(cmdfd, argv[i]+1, strlen(argv[i]+1)+1);
|
||
}
|
||
continue;
|
||
}
|
||
if (strcmp(argv[i], "--") == 0) break;
|
||
if (strcmp(argv[i], "--help") == 0) {
|
||
usage:
|
||
printf("bb - an itty bitty console TUI file browser\n");
|
||
printf("Usage: bb [-h/--help] [-s] [-d] [-0] (+command)* [path]\n");
|
||
return 0;
|
||
}
|
||
if (strcmp(argv[i], "--version") == 0) {
|
||
version:
|
||
printf("bb " BB_VERSION "\n");
|
||
return 0;
|
||
}
|
||
if (argv[i][0] == '-' && argv[i][1] == '-') {
|
||
if (argv[i][2] == '\0') break;
|
||
continue;
|
||
}
|
||
if (argv[i][0] == '-') {
|
||
for (char *c = &argv[i][1]; *c; c++) {
|
||
switch (*c) {
|
||
case 'h':goto usage;
|
||
case 'v': goto version;
|
||
case 'd': print_dir = 1;
|
||
break;
|
||
case '0': sep = '\0';
|
||
break;
|
||
case 's': print_selection = 1;
|
||
break;
|
||
}
|
||
}
|
||
continue;
|
||
}
|
||
}
|
||
|
||
struct pollfd pfd = {STDIN_FILENO, POLLIN, 0};
|
||
if (poll(&pfd, 1, 0) == 1 && pfd.revents & POLLIN) {
|
||
ssize_t len;
|
||
char buf[1024];
|
||
while ((len = read(STDIN_FILENO, buf, sizeof(buf))) > 0)
|
||
write(cmdfd, buf, (size_t)len);
|
||
}
|
||
|
||
if (cmdfd != -1) {
|
||
close(cmdfd);
|
||
cmdfd = -1;
|
||
}
|
||
|
||
if (!initial_path)
|
||
return 0;
|
||
|
||
// Default values
|
||
setenv("SHELL", "bash", 0);
|
||
setenv("EDITOR", "nano", 0);
|
||
setenv("PAGER", "less", 0);
|
||
|
||
atexit(cleanup);
|
||
signal(SIGTERM, cleanup_and_exit);
|
||
signal(SIGINT, cleanup_and_exit);
|
||
signal(SIGXCPU, cleanup_and_exit);
|
||
signal(SIGXFSZ, cleanup_and_exit);
|
||
signal(SIGVTALRM, cleanup_and_exit);
|
||
signal(SIGPROF, cleanup_and_exit);
|
||
signal(SIGSEGV, cleanup_and_exit);
|
||
|
||
char path[PATH_MAX], curdir[PATH_MAX];
|
||
getcwd(curdir, PATH_MAX);
|
||
strcat(curdir, "/");
|
||
normalize_path(curdir, initial_path, path, 1);
|
||
if (chdir(path)) err("Not a valid path: %s\n", path);
|
||
setenv("BBINITIALPATH", path, 1);
|
||
|
||
bb_t *bb = memcheck(calloc(1, sizeof(bb_t)));
|
||
bb->columns[0] = COL_NAME;
|
||
strcpy(bb->sort, "+n");
|
||
bb_browse(bb, path);
|
||
|
||
if (bb->firstselected && print_selection) {
|
||
for (entry_t *e = bb->firstselected; e; e = e->selected.next) {
|
||
const char *p = e->fullname;
|
||
while (*p) {
|
||
const char *p2 = strchr(p, '\n');
|
||
if (!p2) p2 = p + strlen(p);
|
||
write(STDOUT_FILENO, p, (size_t)(p2 - p));
|
||
if (*p2 == '\n' && sep == '\n')
|
||
write(STDOUT_FILENO, "\\", 1);
|
||
p = p2;
|
||
}
|
||
write(STDOUT_FILENO, &sep, 1);
|
||
}
|
||
fflush(stdout);
|
||
}
|
||
if (print_dir)
|
||
printf("%s\n", bb->path);
|
||
|
||
// Cleanup:
|
||
bb->path[0] = '\0';
|
||
populate_files(bb, 0);
|
||
for (entry_t *next, *e = bb->firstselected; e; e = next) {
|
||
next = e->selected.next;
|
||
e->selected.atme = NULL;
|
||
e->selected.next = NULL;
|
||
try_free_entry(e);
|
||
}
|
||
bb->firstselected = NULL;
|
||
free(bb);
|
||
if (cmdfilename) free(cmdfilename);
|
||
|
||
return 0;
|
||
}
|
||
|
||
// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1
|