1185 lines
36 KiB
C
1185 lines
36 KiB
C
#define _XOPEN_SOURCE 600
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <string.h>
|
|
#include <dirent.h> /* directories etc. */
|
|
#include <sys/stat.h>
|
|
#include <errno.h>
|
|
#include <ftw.h>
|
|
#include <time.h>
|
|
#include <ncurses.h>
|
|
#include <locale.h>
|
|
#include <wchar.h>
|
|
|
|
#include "config.h"
|
|
#include "file.h"
|
|
#include "icons.h"
|
|
#include "util.h"
|
|
|
|
/* functions' definitions */
|
|
void show_help();
|
|
void start_ccc();
|
|
char *check_trash_dir();
|
|
void change_dir(const char *buf, int selection, int ftype);
|
|
void mkdir_p(const char *destdir);
|
|
void populate_files(const char *path, int ftype);
|
|
int get_directory_size(const char *fpath, const struct stat *sb, int typeflag, struct FTW *ftwbuf);
|
|
void add_file_stat(char *filename, char *path, int ftype);
|
|
char *get_file_mode(mode_t mode);
|
|
void highlight_current_line();
|
|
void show_file_content();
|
|
void edit_file();
|
|
void toggle_executable();
|
|
char *replace_home(char *str);
|
|
int write_last_d();
|
|
void sort_files();
|
|
char *get_panel_string(char *prompt);
|
|
void rename_file();
|
|
void goto_dir();
|
|
void create_dir();
|
|
void create_file();
|
|
void delete_files();
|
|
void wpprintw(const char *fmt, ...);
|
|
void init_windows();
|
|
void draw_border_title(WINDOW *window, bool active);
|
|
|
|
/* global variables */
|
|
unsigned int focus = 0;
|
|
long current_selection = 0;
|
|
bool file_picker = false;
|
|
bool to_open_file = false;
|
|
bool dirs_size = DIRS_SIZE;
|
|
bool show_hidden = SHOW_HIDDEN;
|
|
bool file_details = SHOW_DETAILS;
|
|
bool show_icons = SHOW_ICONS;
|
|
char *argv_cp;
|
|
char *cwd;
|
|
char *p_cwd; /* previous cwd */
|
|
int half_width;
|
|
ArrayList *files;
|
|
ArrayList *marked;
|
|
ArrayList *tmp1;
|
|
ArrayList *tmp2;
|
|
WINDOW *directory_border;
|
|
WINDOW *directory_content;
|
|
WINDOW *preview_border;
|
|
WINDOW *preview_content;
|
|
WINDOW *panel;
|
|
|
|
unsigned long total_dir_size;
|
|
|
|
int main(int argc, char** argv)
|
|
{
|
|
if (argc == 3) {
|
|
if (strncmp(argv[2], "-p", 2) == 0)
|
|
file_picker = true;
|
|
}
|
|
if (argc <= 3 && argc != 1) {
|
|
if (strncmp(argv[1], "-h", 2) == 0)
|
|
die("Usage: ccc filename");
|
|
|
|
struct stat st;
|
|
if (lstat(argv[1], &st)) {
|
|
perror("ccc");
|
|
die("Error from lstat");
|
|
}
|
|
/* chdir to directory from argument */
|
|
if (S_ISDIR(st.st_mode) && chdir(argv[1])) {
|
|
perror("ccc");
|
|
die("Error from chdir");
|
|
} else if (S_ISREG(st.st_mode)) {
|
|
argv_cp = estrdup(argv[1]);
|
|
char *last_slash = strrchr(argv_cp, '/');
|
|
*last_slash = '\0';
|
|
if (chdir(argv[1])) {
|
|
perror("ccc");
|
|
die("Error from chdir");
|
|
}
|
|
to_open_file = true;
|
|
}
|
|
}
|
|
|
|
/* check if it is interactive shell */
|
|
if (!isatty(STDIN_FILENO))
|
|
die("ccc: No tty detected. ccc requires an interactive shell to run.\n");
|
|
|
|
/* initialize screen, don't print special chars,
|
|
* make ctrl + c work, don't show cursor
|
|
* enable arrow keys */
|
|
setlocale(LC_ALL, "");
|
|
initscr();
|
|
noecho();
|
|
cbreak();
|
|
curs_set(0);
|
|
keypad(stdscr, TRUE);
|
|
|
|
/* check terminal has colors */
|
|
if (!has_colors()) {
|
|
endwin();
|
|
die("ccc: Color is not supported in your terminal.\n");
|
|
} else {
|
|
use_default_colors();
|
|
start_color();
|
|
}
|
|
|
|
/* colors */
|
|
init_pair(1, COLOR_BLACK, -1); /* */
|
|
init_pair(2, COLOR_RED, -1); /* */
|
|
init_pair(3, COLOR_GREEN, -1); /* LNK */
|
|
init_pair(4, COLOR_YELLOW, -1); /* BLK */
|
|
init_pair(5, COLOR_BLUE, -1); /* DIR */
|
|
init_pair(6, COLOR_MAGENTA, -1); /* */
|
|
init_pair(7, COLOR_CYAN, -1); /* MARKED FILES */
|
|
init_pair(8, COLOR_WHITE, -1); /* REG */
|
|
|
|
/* init files and marked arrays */
|
|
marked = arraylist_init(100);
|
|
hashtable_init();
|
|
|
|
cwd = memalloc(PATH_MAX * sizeof(char));
|
|
getcwd(cwd, PATH_MAX);
|
|
p_cwd = memalloc(PATH_MAX * sizeof(char));
|
|
start_ccc();
|
|
|
|
populate_files(cwd, 0);
|
|
if (to_open_file) {
|
|
current_selection = arraylist_search(files, argv_cp, true);
|
|
highlight_current_line();
|
|
}
|
|
|
|
int ch, ch2;
|
|
while (1) {
|
|
if (COLS < 80 || LINES < 24) {
|
|
endwin();
|
|
die("ccc: Terminal size needs to be at least 80x24\n");
|
|
}
|
|
ch = getch();
|
|
switch (ch) {
|
|
/* quit */
|
|
case 'q':
|
|
if (write_last_d() == -1) {
|
|
/* prompt user so error message can be shown to user */
|
|
getch();
|
|
}
|
|
goto cleanup;
|
|
|
|
/* reload using z */
|
|
case 'z':
|
|
change_dir(cwd, 0, 0);
|
|
break;
|
|
|
|
/* go back by backspace or h or left arrow */
|
|
case BACKSPACE: /* PASSTHROUGH */
|
|
case LEFT: /* PASSTHROUGH */
|
|
case 'h':;
|
|
/* get parent directory */
|
|
strcpy(p_cwd, cwd);
|
|
char *last_slash = strrchr(cwd, '/');
|
|
if (last_slash != NULL) {
|
|
if (last_slash == cwd) {
|
|
change_dir("/", 0, 0);
|
|
break;
|
|
}
|
|
*last_slash = '\0';
|
|
change_dir(cwd, 0, 0);
|
|
}
|
|
break;
|
|
|
|
/* enter directory/open a file using enter or l or right arrow */
|
|
case ENTER: /* PASSTHROUGH */
|
|
case RIGHT: /* PASSTHROUGH */
|
|
case 'l':
|
|
strcpy(p_cwd, cwd);
|
|
file c_file = files->items[current_selection];
|
|
|
|
/* check if it is directory or a regular file */
|
|
if (strncmp(c_file.type, "DIR", 3) == 0) {
|
|
/* change cwd to directory */
|
|
change_dir(c_file.path, 0, 0);
|
|
} else if (strncmp(c_file.type, "REG", 3) == 0) {
|
|
/* write opened file to a file for file pickers */
|
|
if (file_picker) {
|
|
char *opened_file_path = memalloc(PATH_MAX * sizeof(char));
|
|
strcpy(opened_file_path, "~/.cache/ccc/opened_file");
|
|
opened_file_path = replace_home(opened_file_path);
|
|
FILE *opened_file = fopen(opened_file_path, "w+");
|
|
fprintf(opened_file, "%s\n", c_file.path);
|
|
fclose(opened_file);
|
|
endwin();
|
|
return 0;
|
|
} else {
|
|
edit_file();
|
|
}
|
|
}
|
|
break;
|
|
|
|
/* jump up (ctrl u) */
|
|
case CTRLU:
|
|
if ((current_selection - JUMP_NUM) > 0)
|
|
current_selection -= JUMP_NUM;
|
|
else
|
|
current_selection = 0;
|
|
|
|
highlight_current_line();
|
|
break;
|
|
|
|
/* go up by k or up arrow */
|
|
case UP: /* PASSTHROUGH */
|
|
case 'k':
|
|
if (current_selection > 0)
|
|
current_selection--;
|
|
|
|
highlight_current_line();
|
|
break;
|
|
|
|
/* jump down (ctrl d) */
|
|
case CTRLD:
|
|
if ((current_selection + JUMP_NUM) < (files->length - 1))
|
|
current_selection += JUMP_NUM;
|
|
else
|
|
current_selection = (files->length - 1);
|
|
|
|
highlight_current_line();
|
|
break;
|
|
|
|
/* go down by j or down arrow */
|
|
case DOWN: /* PASSTHROUGH */
|
|
case 'j':
|
|
if (current_selection < (files->length - 1))
|
|
current_selection++;
|
|
|
|
highlight_current_line();
|
|
break;
|
|
|
|
/* jump to the bottom */
|
|
case 'G':
|
|
current_selection = (files->length - 1);
|
|
highlight_current_line();
|
|
break;
|
|
|
|
/* jump to the top */
|
|
case 'g':
|
|
ch2 = getch();
|
|
switch (ch2) {
|
|
case 'g':
|
|
current_selection = 0;
|
|
highlight_current_line();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
/* '~' go to $HOME */
|
|
case TILDE:;
|
|
char *home = getenv("HOME");
|
|
if (home == NULL) {
|
|
wpprintw("$HOME not defined");
|
|
} else {
|
|
change_dir(home, 0, 0);
|
|
}
|
|
break;
|
|
|
|
/* go to the trash dir */
|
|
case 't':;
|
|
char *trash_dir = check_trash_dir();
|
|
if (trash_dir != NULL) {
|
|
strcpy(p_cwd, cwd);
|
|
change_dir(trash_dir, 0, 0);
|
|
}
|
|
break;
|
|
|
|
/* sort files */
|
|
case 'u':
|
|
sort_files();
|
|
break;
|
|
|
|
/* show directories' sizes */
|
|
case 'A':
|
|
dirs_size = !dirs_size;
|
|
change_dir(cwd, 0, 0);
|
|
break;
|
|
|
|
/* go to previous dir */
|
|
case '-':
|
|
change_dir(p_cwd, 0, 0);
|
|
break;
|
|
|
|
/* show help */
|
|
case '?':
|
|
show_help();
|
|
break;
|
|
|
|
/* toggle hidden files */
|
|
case '.':
|
|
show_hidden = !show_hidden;
|
|
change_dir(cwd, 0, 0);
|
|
break;
|
|
|
|
/* toggle file details */
|
|
case 'i':
|
|
file_details = !file_details;
|
|
change_dir(cwd, 0, 0);
|
|
break;
|
|
|
|
case 'w':
|
|
show_icons = !show_icons;
|
|
change_dir(cwd, 0, 0);
|
|
break;
|
|
|
|
case 'f':
|
|
create_file();
|
|
break;
|
|
|
|
case 'n':
|
|
create_dir();
|
|
break;
|
|
|
|
case 'r':
|
|
rename_file();
|
|
break;
|
|
|
|
case ':':
|
|
goto_dir();
|
|
break;
|
|
|
|
case 'X':
|
|
toggle_executable();
|
|
break;
|
|
|
|
/* mark one file */
|
|
case SPACE:
|
|
add_file_stat(files->items[current_selection].name, files->items[current_selection].path, 1);
|
|
highlight_current_line();
|
|
break;
|
|
|
|
/* mark all files in directory */
|
|
case 'a':
|
|
change_dir(cwd, current_selection, 2); /* reload current dir */
|
|
break;
|
|
|
|
/* mark actions: */
|
|
/* delete */
|
|
case 'd':
|
|
delete_files();
|
|
break;
|
|
|
|
/* move */
|
|
case 'm':
|
|
if (marked->length) {
|
|
;
|
|
}
|
|
break;
|
|
|
|
/* copy */
|
|
case 'c':
|
|
if (marked->length) {
|
|
;
|
|
}
|
|
break;
|
|
|
|
/* symbolic link */
|
|
case 's':
|
|
if (marked->length) {
|
|
;
|
|
}
|
|
break;
|
|
|
|
/* bulk rename */
|
|
case 'b':
|
|
if (marked->length) {
|
|
;
|
|
}
|
|
break;
|
|
|
|
/* escape */
|
|
case ESC:
|
|
break;
|
|
|
|
case KEY_RESIZE:
|
|
delwin(directory_border);
|
|
delwin(directory_content);
|
|
delwin(preview_border);
|
|
delwin(preview_content);
|
|
delwin(panel);
|
|
endwin();
|
|
start_ccc();
|
|
highlight_current_line();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
cleanup:
|
|
free(argv_cp);
|
|
arraylist_free(files);
|
|
arraylist_free(marked);
|
|
endwin();
|
|
return 0;
|
|
}
|
|
|
|
void show_help()
|
|
{
|
|
wclear(directory_content);
|
|
wclear(preview_content);
|
|
wprintw(directory_content,"h: go to parent dir\nj: scroll down\nk: scroll up\nl: go to child dir\n\nleft: go to parent dir\ndown: scroll down\nup: scroll up\nright: go to child dir\n\nenter: go to child dir/open file\nbackspace: go to parent dir\n\ngg: go to top\nG: go to bottom\n\nctrl+u: jump up\nctrl+d: jump down\n\nt: go to trash dir\n~: go to home dir\n-: go to previous dir\nz: refresh current dir\n:: go to a directory by typing\nu: sort files\n\n.: toggle hidden files\ni: toggle file details\nX: toggle executable\n\nA: show directory disk usage/block size\n\nf: new file\nn: new dir\nr: rename\n\nspace: mark file\na: mark all files in directory\nd: trash\n\n?: show help\nq: exit with last dir written to file\nctrl+c exit without writing last dir");
|
|
wpprintw("Visit https://github.com/night0721/ccc or use 'man ccc' for help");
|
|
wrefresh(directory_content);
|
|
wrefresh(preview_content);
|
|
}
|
|
|
|
void start_ccc()
|
|
{
|
|
half_width = COLS / 2;
|
|
init_windows();
|
|
}
|
|
|
|
/*
|
|
* Checks if the trash directory is set and returns it
|
|
*/
|
|
char *check_trash_dir()
|
|
{
|
|
char *path = memalloc(PATH_MAX * sizeof(char));
|
|
|
|
char *trash_dir;
|
|
#ifdef TRASH_DIR
|
|
trash_dir = TRASH_DIR;
|
|
strcpy(path, trash_dir);
|
|
#endif
|
|
|
|
/* check if there is trash_dir */
|
|
if (trash_dir == NULL) {
|
|
wpprintw("Trash directory not defined");
|
|
return NULL;
|
|
} else {
|
|
/* if trash_dir has ~ then make it $HOME */
|
|
/* use path as trash_dir */
|
|
if (trash_dir[0] == '~') {
|
|
path = replace_home(path);
|
|
}
|
|
|
|
/* if has access to trash_dir */
|
|
if (access(path, F_OK) != 0) {
|
|
/* create the directory with 755 permissions if it doesn't exist */
|
|
mkdir_p(path);
|
|
}
|
|
}
|
|
return path;
|
|
}
|
|
|
|
/*
|
|
* Change directory in window with selection
|
|
*/
|
|
void change_dir(const char *buf, int selection, int ftype)
|
|
{
|
|
if (cwd != buf)
|
|
strcpy(cwd, buf);
|
|
if (ftype == 0)
|
|
arraylist_free(files);
|
|
chdir(cwd);
|
|
current_selection = selection;
|
|
populate_files(cwd, ftype);
|
|
}
|
|
|
|
/*
|
|
* Recursively create directory by creating each subdirectory
|
|
* like mkdir -p
|
|
*/
|
|
void mkdir_p(const char *destdir)
|
|
{
|
|
char *path = memalloc(PATH_MAX * sizeof(char));
|
|
char dir_path[PATH_MAX] = "";
|
|
|
|
if (destdir[0] == '~') {
|
|
char *home = getenv("HOME");
|
|
if (home == NULL) {
|
|
wpprintw("$HOME not defined");
|
|
return;
|
|
}
|
|
/* replace ~ with home */
|
|
snprintf(path, PATH_MAX, "%s%s", home, destdir + 1);
|
|
} else {
|
|
strcpy(path, destdir);
|
|
}
|
|
|
|
/* fix first / not appearing in the string */
|
|
if (path[0] == '/')
|
|
strcat(dir_path, "/");
|
|
|
|
char *token = strtok(path, "/");
|
|
while (token != NULL) {
|
|
strcat(dir_path, token);
|
|
strcat(dir_path, "/");
|
|
|
|
if (mkdir(dir_path, 0755) == -1) {
|
|
struct stat st;
|
|
if (stat(dir_path, &st) == 0 && S_ISDIR(st.st_mode)) {
|
|
/* Directory already exists, continue to the next dir */
|
|
token = strtok(NULL, "/");
|
|
continue;
|
|
}
|
|
|
|
wpprintw("mkdir failed: %s\n", strerror(errno));
|
|
free(path);
|
|
return;
|
|
}
|
|
token = strtok(NULL, "/");
|
|
}
|
|
|
|
free(path);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Read the provided directory and add all files in directory to an Arraylist
|
|
* ftype: normal files = 0, marked = 1, marking ALL = 2
|
|
*/
|
|
void populate_files(const char *path, int ftype)
|
|
{
|
|
DIR *dp;
|
|
struct dirent *ep;
|
|
|
|
if ((dp = opendir(path)) != NULL) {
|
|
/* clear directory window to ready for printing */
|
|
wclear(directory_content);
|
|
if (ftype == 0) {
|
|
tmp1 = arraylist_init(10);
|
|
tmp2 = arraylist_init(10);
|
|
}
|
|
|
|
while ((ep = readdir(dp)) != NULL) {
|
|
char *filename = estrdup(ep->d_name);
|
|
|
|
/* use strncmp to filter out dotfiles */
|
|
if ((!show_hidden && strncmp(filename, ".", 1) && strncmp(filename, "..", 2)) || (show_hidden && strcmp(filename, ".") && strcmp(filename, ".."))) {
|
|
/* construct full file path */
|
|
char *path = memalloc((strlen(cwd) + strlen(filename) + 2) * sizeof(char));
|
|
strcpy(path, cwd);
|
|
strcat(path, "/");
|
|
strcat(path, filename); /* add filename */
|
|
|
|
add_file_stat(filename, path, ftype);
|
|
}
|
|
else free(filename);
|
|
}
|
|
if (ftype == 0) {
|
|
files = arraylist_init(tmp1->length + tmp2->length);
|
|
files->length = tmp1->length + tmp2->length;
|
|
memcpy(files->items, tmp1->items, tmp1->length * sizeof(file));
|
|
memcpy(files->items + tmp1->length, tmp2->items, tmp2->length * sizeof(file));
|
|
free(tmp1->items);
|
|
free(tmp2->items);
|
|
free(tmp1);
|
|
free(tmp2);
|
|
}
|
|
closedir(dp);
|
|
wrefresh(directory_content);
|
|
highlight_current_line();
|
|
} else {
|
|
wpprintw("stat failed: %s\n", strerror(errno));
|
|
}
|
|
}
|
|
|
|
int get_directory_size(const char *fpath, const struct stat *sb, int typeflag, struct FTW *ftwbuf)
|
|
{
|
|
total_dir_size += sb->st_size;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Get file's last modified time, size, type
|
|
* Add that file into list
|
|
* ftype: normal file = 0, normal marked = 1, marked ALL = 2
|
|
*/
|
|
void add_file_stat(char *filename, char *path, int ftype)
|
|
{
|
|
struct stat file_stat;
|
|
if (stat(path, &file_stat) == -1) {
|
|
/* can't be triggered? */
|
|
if (errno == EACCES)
|
|
arraylist_add(files, filename, path, NULL, NULL, NULL, 8, false, false);
|
|
}
|
|
|
|
/* get file type and color, 4 chars for the type and icon */
|
|
size_t type_size = 4 * sizeof(char);
|
|
size_t icon_size = 2 * sizeof(wchar_t);
|
|
|
|
char *type = memalloc(type_size);
|
|
wchar_t *icon_str = memalloc(icon_size);
|
|
|
|
filename[strlen(filename)] = '\0';
|
|
/* handle file without extension
|
|
* ext is the extension if . exist in filename
|
|
* otherwise is nothing and handled through tenery operator */
|
|
char *ext = strrchr(filename, '.');
|
|
if (ext != NULL) {
|
|
ext += 1;
|
|
}
|
|
/* add file extension */
|
|
icon *ext_icon = hashtable_search(ext != NULL ? ext : filename);
|
|
if (ext_icon == NULL)
|
|
wcsncpy(icon_str, L"", 2);
|
|
else
|
|
wcsncpy(icon_str, ext_icon->icon, 2);
|
|
|
|
int color;
|
|
|
|
if (S_ISDIR(file_stat.st_mode)) {
|
|
strncpy(type, "DIR", 4); /* directory type */
|
|
color = 5; /* blue color */
|
|
wcsncpy(icon_str, L"", 2);
|
|
} else if (S_ISREG(file_stat.st_mode)) {
|
|
strncpy(type, "REG", 4); /* regular file */
|
|
color = 8; /* white color */
|
|
} else if (S_ISLNK(file_stat.st_mode)) {
|
|
strncpy(type, "LNK", 4); /* symbolic link */
|
|
color = 3; /* green color */
|
|
} else if (S_ISCHR(file_stat.st_mode)) {
|
|
strncpy(type, "CHR", 4); /* character device */
|
|
color = 8; /* white color */
|
|
} else if (S_ISSOCK(file_stat.st_mode)) {
|
|
strncpy(type, "SOC", 4); /* socket */
|
|
color = 8; /* white color */
|
|
} else if (S_ISBLK(file_stat.st_mode)) {
|
|
strncpy(type, "BLK", 4); /* block device */
|
|
color = 4; /* yellow color */
|
|
} else if (S_ISFIFO(file_stat.st_mode)) {
|
|
strncpy(type, "FIF", 4); /* FIFO */
|
|
color = 8; /* white color */
|
|
} else {
|
|
color = 8; /* white color */
|
|
}
|
|
|
|
/* if file is to be marked */
|
|
if (ftype == 1 || ftype == 2) {
|
|
/* force if user is marking all files */
|
|
bool force = ftype == 2 ? true : false;
|
|
arraylist_add(marked, filename, path, NULL, type, icon_str, 8, true, force);
|
|
/* free type and return without allocating more stuff */
|
|
return;
|
|
}
|
|
|
|
/* get last modified time */
|
|
size_t time_size = 17 * sizeof(char);
|
|
char *time = memalloc(time_size);
|
|
/* format last modified time to a string */
|
|
strftime(time, time_size, "%Y-%m-%d %H:%M", localtime(&file_stat.st_mtime));
|
|
|
|
/* get file size */
|
|
double bytes = file_stat.st_size;
|
|
|
|
if (dirs_size) {
|
|
/* dirs_size is true, so calculate disk usage */
|
|
if (S_ISDIR(file_stat.st_mode)) {
|
|
/* at most 15 fd opened */
|
|
total_dir_size = 0;
|
|
nftw(path, &get_directory_size, 15, FTW_PHYS);
|
|
bytes = total_dir_size;
|
|
}
|
|
}
|
|
/* 4 before decimal + 1 dot + DECIMAL_PLACES (after decimal) +
|
|
unit length (1 for K, 3 for KiB, taking units[1] as B never changes) + 1 space + 1 null */
|
|
int size_size = 4 + 1 + DECIMAL_PLACES + strlen(units[1]) + 1 + 1;
|
|
char *size = memalloc(size_size * sizeof(char));
|
|
int unit = 0;
|
|
while (bytes > 1024) {
|
|
bytes /= 1024;
|
|
unit++;
|
|
}
|
|
/* display sizes and check if there are decimal places */
|
|
if (bytes == (unsigned int) bytes) {
|
|
sprintf(size, "%d%s", (unsigned int) bytes, units[unit]);
|
|
} else {
|
|
sprintf(size, "%.*f%s", DECIMAL_PLACES, bytes, units[unit]);
|
|
}
|
|
/* get file mode string */
|
|
char *mode_str = get_file_mode(file_stat.st_mode);
|
|
if (mode_str[0] == '-' && (mode_str[3] == 'x' || mode_str[6] == 'x' || mode_str[9] == 'x')) {
|
|
|
|
}
|
|
|
|
/* mode_str(11) + time(17) + size_size + 2 spaces + 1 null */
|
|
size_t stat_size = 11 * sizeof(char) + time_size + size_size + 3 * sizeof(char);
|
|
char *total_stat = memalloc(stat_size);
|
|
snprintf(total_stat, stat_size, "%s %s %-*s", mode_str, time, size_size, size);
|
|
|
|
/* DIR if color is 5 */
|
|
if (color == 5)
|
|
arraylist_add(tmp1, filename, path, total_stat, type, icon_str, color, false, false);
|
|
else
|
|
arraylist_add(tmp2, filename, path, total_stat, type, icon_str, color, false, false);
|
|
|
|
free(time);
|
|
free(size);
|
|
free(mode_str);
|
|
}
|
|
|
|
/*
|
|
* get file mode string from stat mode
|
|
* eg: drwxr-sr-x
|
|
*/
|
|
char *get_file_mode(mode_t mode)
|
|
{
|
|
char *mode_str = memalloc(11 * sizeof(char));
|
|
mode_str[0] = S_ISDIR(mode) ? 'd' : '-'; /* Check if it's a directory */
|
|
mode_str[1] = (mode & S_IRUSR) ? 'r' : '-';
|
|
mode_str[2] = (mode & S_IWUSR) ? 'w' : '-';
|
|
mode_str[3] = (mode & S_IXUSR) ? 'x' : '-';
|
|
mode_str[4] = (mode & S_IRGRP) ? 'r' : '-';
|
|
mode_str[5] = (mode & S_IWGRP) ? 'w' : '-';
|
|
mode_str[6] = (mode & S_IXGRP) ? 'x' : '-';
|
|
mode_str[7] = (mode & S_IROTH) ? 'r' : '-';
|
|
mode_str[8] = (mode & S_IWOTH) ? 'w' : '-';
|
|
mode_str[9] = (mode & S_IXOTH) ? 'x' : '-';
|
|
mode_str[10] = '\0';
|
|
return mode_str;
|
|
}
|
|
|
|
/*
|
|
* Highlight current line by reversing the color
|
|
*/
|
|
void highlight_current_line()
|
|
{
|
|
#if DRAW_BORDERS
|
|
draw_border_title(directory_border, true);
|
|
#endif
|
|
|
|
long overflow = 0;
|
|
if (current_selection > LINES - 4) {
|
|
/* overflown */
|
|
overflow = current_selection - (LINES - 4);
|
|
}
|
|
|
|
/* calculate range of files to show */
|
|
long range = files->length;
|
|
/* not highlight if no files in directory */
|
|
if (range == 0 && errno == 0) {
|
|
#if DRAW_PREVIEW
|
|
wprintw(preview_content, "empty directory");
|
|
wrefresh(preview_content);
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
if (range > LINES - 3) {
|
|
/* if there are more files than lines available to display
|
|
* shrink range to avaiable lines to display with
|
|
* overflow to keep the number of iterations to be constant */
|
|
range = LINES - 3 + overflow;
|
|
}
|
|
|
|
wclear(directory_content);
|
|
long line_count = 0;
|
|
for (long i = overflow; i < range; i++) {
|
|
if ((overflow == 0 && i == current_selection) || (overflow != 0 && i == current_selection)) {
|
|
wattron(directory_content, A_REVERSE);
|
|
|
|
/* check for marked files */
|
|
long num_marked = marked->length;
|
|
if (num_marked > 0) {
|
|
/* Determine length of formatted string */
|
|
int m_len = snprintf(NULL, 0, "[%ld] selected", num_marked);
|
|
char *selected = memalloc((m_len + 1) * sizeof(char));
|
|
|
|
snprintf(selected, m_len + 1, "[%ld] selected", num_marked);
|
|
wpprintw("(%ld/%ld) %s %s", current_selection + 1, files->length, selected, cwd);
|
|
} else {
|
|
wpprintw("(%ld/%ld) %s", current_selection + 1, files->length, cwd);
|
|
}
|
|
}
|
|
/* print the actual filename and stats */
|
|
char *line = get_line(files, i, file_details, show_icons);
|
|
int color = files->items[i].color;
|
|
/* check is file marked for action */
|
|
bool is_marked = arraylist_search(marked, files->items[i].path, false) != -1;
|
|
if (is_marked) {
|
|
/* show file is selected */
|
|
wattron(directory_content, COLOR_PAIR(7));
|
|
} else {
|
|
/* print the whole directory with default colors */
|
|
wattron(directory_content, COLOR_PAIR(color));
|
|
}
|
|
|
|
if (overflow > 0)
|
|
mvwprintw(directory_content, line_count, 0, "%s", line);
|
|
else
|
|
mvwprintw(directory_content, i, 0, "%s", line);
|
|
|
|
if (is_marked) {
|
|
wattroff(directory_content, COLOR_PAIR(7));
|
|
} else {
|
|
wattroff(directory_content, COLOR_PAIR(color));
|
|
}
|
|
|
|
wattroff(directory_content, A_REVERSE);
|
|
free(line);
|
|
line_count++;
|
|
}
|
|
|
|
wrefresh(directory_content);
|
|
wrefresh(panel);
|
|
/* show file content every time cursor changes */
|
|
#if DRAW_PREVIEW
|
|
show_file_content();
|
|
#endif
|
|
#if DRAW_BORDERS
|
|
draw_border_title(preview_border, true);
|
|
#endif
|
|
wrefresh(preview_content);
|
|
}
|
|
|
|
/*
|
|
* Get file content into buffer and show it to preview window
|
|
*/
|
|
void show_file_content()
|
|
{
|
|
file current_file = files->items[current_selection];
|
|
|
|
wclear(preview_content);
|
|
if (strncmp(current_file.type, "DIR", 3) == 0)
|
|
/* Print dir content */
|
|
return;
|
|
|
|
|
|
FILE *file = fopen(current_file.path, "r");
|
|
if (file == NULL) {
|
|
mvwprintw(preview_content, 0, 0, "Unable to read %s", current_file.name);
|
|
return;
|
|
}
|
|
|
|
int c;
|
|
/* check if its binary */
|
|
while ((c = fgetc(file)) != EOF) {
|
|
if (c == '\0') {
|
|
mvwprintw(preview_content, 0, 0, "binary");
|
|
return;
|
|
}
|
|
}
|
|
|
|
fseek(file, 0, SEEK_END);
|
|
long length = ftell(file);
|
|
/* check if file isn't empty */
|
|
if (length != 0) {
|
|
fseek(file, 0, SEEK_SET); /* set cursor back to start of file */
|
|
int max_length = (LINES - 3) * (COLS / 2 - 2);
|
|
char *buffer = memalloc(max_length * sizeof(char));
|
|
fread(buffer, 1, max_length, file);
|
|
mvwprintw(preview_content, 0, 0, "%s", buffer);
|
|
free(buffer);
|
|
} else {
|
|
wclear(preview_content);
|
|
}
|
|
fclose(file);
|
|
}
|
|
|
|
/*
|
|
* Opens $EDITOR to edit the file
|
|
*/
|
|
void edit_file()
|
|
{
|
|
#ifdef EDITOR
|
|
char *editor = EDITOR;
|
|
#else
|
|
char *editor = getenv("EDITOR");
|
|
#endif
|
|
|
|
if (editor == NULL) {
|
|
wpprintw("$EDITOR not defined");
|
|
return;
|
|
} else {
|
|
def_prog_mode(); /* save the tty modes */
|
|
endwin(); /* end curses mode temporarily */
|
|
|
|
char *filename = files->items[current_selection].path;
|
|
int length = strlen(editor) + strlen(filename) + 2; /* one for space one for null */
|
|
char command[length];
|
|
|
|
snprintf(command, length, "%s %s", editor, filename);
|
|
system(command);
|
|
reset_prog_mode(); /* return to previous tty mode */
|
|
refresh(); /* store the screen contents */
|
|
}
|
|
}
|
|
|
|
void toggle_executable()
|
|
{
|
|
file current_file = files->items[current_selection];
|
|
struct stat st;
|
|
if (stat(current_file.path, &st) == -1) {
|
|
wpprintw("stat failed: %s\n", strerror(errno));
|
|
}
|
|
if (strncmp(current_file.type, "DIR", 3) == 0)
|
|
return;
|
|
/* chmod by xor executable bits */
|
|
if (chmod(current_file.path, st.st_mode ^ (S_IXUSR | S_IXGRP | S_IXOTH)) == -1) {
|
|
wpprintw("Error toggling executable: %s", strerror(errno));
|
|
}
|
|
|
|
}
|
|
|
|
char *replace_home(char *str)
|
|
{
|
|
char *home = getenv("HOME");
|
|
if (home == NULL) {
|
|
wpprintw("$HOME not defined");
|
|
return str;
|
|
}
|
|
char *newstr = memalloc((strlen(str) + strlen(home)) * sizeof(char));
|
|
/* replace ~ with home */
|
|
snprintf(newstr, strlen(str) + strlen(home), "%s%s", home, str + 1);
|
|
free(str);
|
|
return newstr;
|
|
}
|
|
|
|
int write_last_d()
|
|
{
|
|
#ifdef LAST_D
|
|
char *last_d = estrdup(LAST_D);
|
|
#else
|
|
char *last_d = getenv("CCC_LAST_D");
|
|
#endif
|
|
if (last_d == NULL) {
|
|
wpprintw("$CCC_LAST_D not defined (Press enter to continue)");
|
|
return -1;
|
|
} else {
|
|
if (last_d[0] == '~') {
|
|
last_d = replace_home(last_d);
|
|
}
|
|
char *last_ddup = estrdup(last_d);
|
|
|
|
char *last_d_dir = strrchr(last_ddup, '/');
|
|
if (last_d_dir != NULL) {
|
|
*last_d_dir = '\0'; /* truncate string */
|
|
}
|
|
mkdir_p(last_ddup);
|
|
FILE *last_d_file = fopen(last_d, "w");
|
|
if (last_d_file == NULL) {
|
|
wpprintw("Cannot open last directory file (Press enter to continue)");
|
|
return -1;
|
|
}
|
|
fwrite(cwd, strlen(cwd), sizeof(char), last_d_file);
|
|
fclose(last_d_file);
|
|
free(last_ddup);
|
|
free(last_d);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int sort_compare(const void *a, const void *b) {
|
|
return strcmp(((file *) a)->name, ((file *) b)->name);
|
|
}
|
|
|
|
void sort_files()
|
|
{
|
|
qsort(files->items, files->length, sizeof(file), sort_compare);
|
|
highlight_current_line();
|
|
}
|
|
|
|
char *get_panel_string(char *prompt)
|
|
{
|
|
echo();
|
|
wpprintw(prompt);
|
|
char *input = memalloc(PATH_MAX * sizeof(char));
|
|
/* get string at y=0, x=length of prompt */
|
|
mvwgetstr(panel, 0, strlen(prompt), input);
|
|
noecho();
|
|
if (input[0] == '~') {
|
|
input = replace_home(input);
|
|
}
|
|
return input;
|
|
}
|
|
|
|
void rename_file()
|
|
{
|
|
char *filename = files->items[current_selection].path;
|
|
char *input = get_panel_string("Rename file: ");
|
|
char *newfilename = estrdup(filename);
|
|
/* remove basename of newfilename */
|
|
char *last_slash = strrchr(newfilename, '/');
|
|
*last_slash = '\0';
|
|
/* add the slash back to newfilename */
|
|
strcat(newfilename, "/");
|
|
strcat(newfilename, input);
|
|
if (rename(filename, newfilename)) {
|
|
wpprintw("rename failed: %s (Press enter to continue)", strerror(errno));
|
|
getch();
|
|
} else {
|
|
change_dir(cwd, 0, 0);
|
|
wpprintw("Renamed %s to %s", filename, newfilename);
|
|
}
|
|
free(input);
|
|
free(newfilename);
|
|
}
|
|
|
|
void goto_dir()
|
|
{
|
|
char *input = get_panel_string("Goto dir: ");
|
|
struct stat st;
|
|
if (lstat(input, &st)) {
|
|
wpprintw("lstat failed: %s (Press enter to continue)", strerror(errno));
|
|
getch();
|
|
}
|
|
/* chdir to directory from argument */
|
|
if (S_ISDIR(st.st_mode) && chdir(input)) {
|
|
wpprintw("chdir failed: %s (Press enter to continue)", strerror(errno));
|
|
getch();
|
|
}
|
|
getcwd(cwd, PATH_MAX);
|
|
change_dir(cwd, 0, 0);
|
|
free(input);
|
|
}
|
|
|
|
void create_dir()
|
|
{
|
|
char *input = get_panel_string("New dir: ");
|
|
char *newfilename = memalloc(PATH_MAX * sizeof(char));
|
|
strcpy(newfilename, cwd);
|
|
strcat(newfilename, "/");
|
|
strcat(newfilename, input);
|
|
if (access(newfilename, F_OK) != 0) {
|
|
mkdir_p(newfilename);
|
|
change_dir(cwd, 0, 0);
|
|
wpprintw("Created %s", input);
|
|
} else {
|
|
wpprintw("Directory already exist");
|
|
}
|
|
free(input);
|
|
free(newfilename);
|
|
}
|
|
|
|
void create_file()
|
|
{
|
|
char *input = get_panel_string("New file: ");
|
|
FILE *f = fopen(input, "w+");
|
|
fclose(f);
|
|
change_dir(cwd, 0, 0);
|
|
wpprintw("Created %s", input);
|
|
free(input);
|
|
}
|
|
|
|
void delete_files()
|
|
{
|
|
if (marked->length) {
|
|
char *trash_dir = check_trash_dir();
|
|
if (trash_dir != NULL) {
|
|
for (int i = 0; i < marked->length; i++) {
|
|
char *new_path = memalloc(PATH_MAX * sizeof(char));
|
|
strcpy(new_path, trash_dir);
|
|
strcat(new_path, "/");
|
|
strcat(new_path, marked->items[i].name);
|
|
if (rename(marked->items[i].path, new_path)) {
|
|
wpprintw("delete failed: %s\n", strerror(errno));
|
|
} else {
|
|
change_dir(cwd, 0, 0);
|
|
}
|
|
}
|
|
for (int i = 0; i < marked->length; i++) {
|
|
arraylist_remove(marked, 0);
|
|
}
|
|
} else {
|
|
wpprintw("TODO: implement hard delete");
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Print line to the panel
|
|
*/
|
|
void wpprintw(const char *fmt, ...)
|
|
{
|
|
va_list args;
|
|
va_start(args, fmt);
|
|
wclear(panel);
|
|
vw_printw(panel, fmt, args);
|
|
va_end(args);
|
|
wrefresh(panel);
|
|
}
|
|
|
|
void init_windows()
|
|
{
|
|
/* offset for width of the content 1 and 2 */
|
|
int width_left = half_width;
|
|
int width_right = half_width;
|
|
#ifdef WINDOW_OFFSET
|
|
width_left += WINDOW_OFFSET;
|
|
width_right -= WINDOW_OFFSET;
|
|
#endif
|
|
|
|
/*------------------------------+
|
|
|----border(0)--||--border(2)--||
|
|
|| || ||
|
|
|| content (1) || content (3) ||
|
|
|| (directory) || (preview) ||
|
|
|| || ||
|
|
|---------------||-------------||
|
|
+==========panel (4)===========*/
|
|
|
|
/* lines, cols, y, x */
|
|
panel = newwin(PH, COLS, LINES - PH, 0 );
|
|
/* draw border around windows */
|
|
#if DRAW_BORDERS
|
|
directory_border = newwin(LINES - PH, width_left, 0, 0 );
|
|
directory_content = newwin(LINES - PH - 2, width_left - 2, 1, 1 );
|
|
|
|
preview_border = newwin(LINES - PH, width_right, 0, width_left );
|
|
preview_content = newwin(LINES - PH - 2, width_right - 2, 1, width_left + 1);
|
|
|
|
draw_border_title(directory_border, true);
|
|
draw_border_title(preview_border, true);
|
|
#else
|
|
/* if there are no borders, then draw content in their places */
|
|
directory_border = newwin(0, 0, COLS, LINES );
|
|
preview_border = newwin(0, 0, COLS, LINES );
|
|
/* -1 for the one space to the left */
|
|
directory_content = newwin(LINES - PH - 1, width_left, 0, 1 );
|
|
preview_content = newwin(LINES - PH, width_right, 0, width_left );
|
|
#endif
|
|
|
|
scrollok(directory_content, true);
|
|
refresh();
|
|
}
|
|
|
|
/*
|
|
* Draw the border of the window depending if it's active or not,
|
|
*/
|
|
void draw_border_title(WINDOW *window, bool active)
|
|
{
|
|
/* check if the window is directory of preview */
|
|
int width = half_width;
|
|
if (window == directory_border) { /* left */
|
|
width += WINDOW_OFFSET;
|
|
} else if (window == preview_border) { /* right */
|
|
width -= WINDOW_OFFSET;
|
|
}
|
|
|
|
/* turn on color depends on active */
|
|
if (active) {
|
|
wattron(window, COLOR_PAIR(7));
|
|
} else {
|
|
wattron(window, COLOR_PAIR(5));
|
|
}
|
|
/* draw top border */
|
|
mvwaddch(window, 0, 0, ACS_ULCORNER); /* upper left corner */
|
|
mvwhline(window, 0, 1, ACS_HLINE, width - 2); /* top horizontal line */
|
|
mvwaddch(window, 0, width - 1, ACS_URCORNER); /* upper right corner */
|
|
|
|
/* draw side border */
|
|
mvwvline(window, 1, 0, ACS_VLINE, LINES - 2); /* left vertical line */
|
|
mvwvline(window, 1, width - 1, ACS_VLINE, LINES - 2); /* right vertical line */
|
|
|
|
/* draw bottom border
|
|
* make space for the panel */
|
|
mvwaddch(window, LINES - PH - 1, 0, ACS_LLCORNER); /* lower left corner */
|
|
mvwhline(window, LINES - PH - 1, 1, ACS_HLINE, width - 2); /* bottom horizontal line */
|
|
mvwaddch(window, LINES - PH - 1, width - 1, ACS_LRCORNER); /* lower right corner */
|
|
|
|
/* turn color off after turning it on */
|
|
if (active) {
|
|
wattroff(window, COLOR_PAIR(7));
|
|
} else {
|
|
wattroff(window, COLOR_PAIR(5));
|
|
}
|
|
wrefresh(window); /* Refresh the window to see the colored border and title */
|
|
}
|