luxferre/bananarchy
1
0
Fork 0
Code Issues Actions Activity
Files
9b712dcbcaeea884374d0983e1958833ebfd6488
bananarchy/src/dwm-plugins/files_plugin.cpp
T

1421 lines
46 KiB
C++
Raw Blame History

#include "phone_data.h"
#include "media_utils.h"
#include "../sxmo-dwm/dwm_plugin.h"
#include <X11/Xatom.h>
#include <X11/Xft/Xft.h>
#include <X11/Xutil.h>
#include <pango/pangoxft.h>
#include <poll.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <clocale>
namespace {
using namespace bananarchy;
volatile sig_atomic_t gRunning = 1;
void handleSignal(int) {
gRunning = 0;
}
enum class ViewMode {
Browser = 0,
Actions = 1,
TextView = 2,
ImageView = 3,
PropsView = 4,
InputModal = 5,
ConfirmDelete = 6,
};
enum class SortMode {
Name = 0,
Date = 1,
Size = 2,
};
enum class InputAction {
NewFolder = 0,
NewFile = 1,
Rename = 2,
};
enum class TextCaseMode {
Lower = 0, // abc
Title = 1, // Abc
Upper = 2, // ABC
Num = 3, // 123
};
const char* kMultiTapFile[10] = {
" _-0", // 0
".-_1", // 1
"abc2", // 2
"def3", // 3
"ghi4", // 4
"jkl5", // 5
"mno6", // 6
"pqrs7", // 7
"tuv8", // 8
"wxyz9" // 9
};
struct FileItem {
std::string name;
std::string fullPath;
std::string lowerName;
std::string t9Name;
bool isParent = false;
bool isDir = false;
bool isExec = false;
off_t size = 0;
time_t mtime = 0;
mode_t mode = 0;
};
void popUtf8(std::string& s) {
if (s.empty()) return;
while (!s.empty() && (static_cast<unsigned char>(s.back()) & 0xC0) == 0x80) {
s.pop_back();
}
if (!s.empty()) s.pop_back();
}
std::string getExtLower(const std::string& name) {
size_t dot = name.rfind('.');
if (dot == std::string::npos || dot + 1 >= name.size()) {
return "";
}
return toLowerStr(name.substr(dot + 1));
}
bool isImageExt(const std::string& ext) {
return ext == "jpg" || ext == "jpeg" || ext == "png";
}
bool isMediaExt(const std::string& ext) {
return ext == "mp3" || ext == "wav" || ext == "ogg" || ext == "flac" ||
ext == "m4a" || ext == "mp4" || ext == "mkv" || ext == "webm" ||
ext == "avi";
}
bool isLikelyTextFile(const std::string& path, off_t size) {
if (size == 0) return true;
if (size > 256 * 1024) return false;
std::ifstream in(path, std::ios::binary);
if (!in.is_open()) return false;
char buf[512];
in.read(buf, sizeof(buf));
std::streamsize n = in.gcount();
for (std::streamsize i = 0; i < n; ++i) {
unsigned char c = static_cast<unsigned char>(buf[i]);
if (c == 0) {
return false;
}
}
return true;
}
std::string shortenPath(const std::string& path) {
const char* home = std::getenv("HOME");
std::string h = (home && home[0]) ? home : "/home/user";
std::string out = path;
if (out == h) {
out = "~";
} else if (out.rfind(h + "/", 0) == 0) {
out = "~" + out.substr(h.size());
}
if (out.size() > 18) {
out = "..." + out.substr(out.size() - 15);
}
return out;
}
std::string formatPermissions(mode_t m) {
std::string s(10, '-');
if (S_ISDIR(m)) s[0] = 'd';
else if (S_ISLNK(m)) s[0] = 'l';
if (m & S_IRUSR) s[1] = 'r';
if (m & S_IWUSR) s[2] = 'w';
if (m & S_IXUSR) s[3] = 'x';
if (m & S_IRGRP) s[4] = 'r';
if (m & S_IWGRP) s[5] = 'w';
if (m & S_IXGRP) s[6] = 'x';
if (m & S_IROTH) s[7] = 'r';
if (m & S_IWOTH) s[8] = 'w';
if (m & S_IXOTH) s[9] = 'x';
char oct[16];
std::snprintf(oct, sizeof(oct), " (%04o)", static_cast<unsigned int>(m & 07777));
return s + oct;
}
bool removeRecursive(const std::string& path) {
struct stat st {};
if (::lstat(path.c_str(), &st) != 0) {
return false;
}
if (S_ISDIR(st.st_mode) && !S_ISLNK(st.st_mode)) {
DIR* d = ::opendir(path.c_str());
if (d) {
struct dirent* ent;
while ((ent = ::readdir(d)) != nullptr) {
if (std::strcmp(ent->d_name, ".") == 0 ||
std::strcmp(ent->d_name, "..") == 0) {
continue;
}
removeRecursive(path + "/" + ent->d_name);
}
::closedir(d);
}
return ::rmdir(path.c_str()) == 0;
}
return ::unlink(path.c_str()) == 0;
}
bool copyRecursive(const std::string& src, const std::string& dst) {
pid_t pid = ::fork();
if (pid == 0) {
execlp("cp", "cp", "-a", src.c_str(), dst.c_str(),
static_cast<char*>(nullptr));
_exit(127);
} else if (pid > 0) {
int status = 0;
::waitpid(pid, &status, 0);
return WIFEXITED(status) && WEXITSTATUS(status) == 0;
}
return false;
}
int runFilesApp(int argc, char** argv) {
gRunning = 1;
std::setlocale(LC_ALL, "");
XSetLocaleModifiers("");
bool isPreload = false;
std::string initDir;
for (int i = 1; i < argc; ++i) {
if (!argv[i]) continue;
if (std::strcmp(argv[i], "--preload") == 0) {
isPreload = true;
} else if (argv[i][0] != '-' && initDir.empty()) {
initDir = argv[i];
}
}
std::string daemonPidPath = getPluginDaemonPidPath("files");
std::string activePidPath = getRuntimeFile("xfiles.pid");
if (isPluginDaemonAlive("files")) {
if (!isPreload) {
sendPluginCommand("files", initDir.empty() ? "OPEN" : ("OPEN " + initDir));
}
return 0;
}
writeIntFile(daemonPidPath, static_cast<int>(::getpid()));
int fifoFd = setupPluginDaemonFifo("files");
struct sigaction sa {};
sa.sa_handler = handleSignal;
sigemptyset(&sa.sa_mask);
sigaction(SIGINT, &sa, nullptr);
sigaction(SIGTERM, &sa, nullptr);
Display* dpy = XOpenDisplay(nullptr);
if (!dpy) {
if (fifoFd >= 0) ::close(fifoFd);
::unlink(daemonPidPath.c_str());
return 1;
}
int screen = DefaultScreen(dpy);
Window root = RootWindow(dpy, screen);
Visual* visual = DefaultVisual(dpy, screen);
Colormap cmap = DefaultColormap(dpy, screen);
ThemeSpec initSpec = loadThemeSpec(dpy, screen);
XSetWindowAttributes swa {};
swa.override_redirect = True;
swa.background_pixel = initSpec.bgMain;
swa.border_pixel = initSpec.selBg;
swa.event_mask = ExposureMask | KeyPressMask | KeyReleaseMask |
VisibilityChangeMask | StructureNotifyMask;
Window win = XCreateWindow(
dpy, root, kWinX, kWinY, kWinWidth, kWinHeight, 0,
DefaultDepth(dpy, screen), CopyFromParent, visual,
CWOverrideRedirect | CWBackPixel | CWBorderPixel | CWEventMask, &swa);
XClassHint ch {};
char resName[] = "xfiles";
char resClass[] = "XFiles";
ch.res_name = resName;
ch.res_class = resClass;
XSetClassHint(dpy, win, &ch);
XStoreName(dpy, win, "Files");
Pixmap pix = XCreatePixmap(dpy, win, kWinWidth, kWinHeight,
DefaultDepth(dpy, screen));
GC gc = XCreateGC(dpy, pix, 0, nullptr);
XftDraw* xftDraw = XftDrawCreate(dpy, pix, visual, cmap);
PluginTheme pt;
pt.init(dpy, screen, visual, cmap, win);
auto& layoutMain = pt.layoutMain;
auto& layoutSmall = pt.layoutSmall;
auto& layoutIcon = pt.layoutIcon;
auto& colWhite = pt.colWhite;
auto& colLight = pt.colLight;
auto& colMuted = pt.colMuted;
auto& colYellow = pt.colYellow;
auto& colGreen = pt.colGreen;
auto& colBlue = pt.colBlue;
auto& colOrange = pt.colOrange;
auto& colRed = pt.colRed;
const char* homeEnv = std::getenv("HOME");
std::string homeDir = (homeEnv && homeEnv[0]) ? homeEnv : "/home/user";
std::string currentDir = homeDir;
ViewMode mode = ViewMode::Browser;
SortMode sortMode = SortMode::Name;
bool showHidden = false;
std::string searchQuery;
std::vector<FileItem> allItems;
std::vector<FileItem> filteredItems;
int selected = 0;
int actionSelected = 0;
int confirmSelected = 0;
// Clipboard state
std::string clipPath;
std::string clipName;
bool clipIsCut = false;
// Text viewer state
std::string viewingFilePath;
std::string viewingFileName;
std::vector<std::string> textLines;
int textScrollLine = 0;
// Image viewer state
constexpr int kImgCanvasW = 240;
constexpr int kImgCanvasH = 232;
std::vector<uint32_t> imgCanvas(kImgCanvasW * kImgCanvasH, 0x111111);
XImage* xImgPreview = XCreateImage(
dpy, visual, DefaultDepth(dpy, screen), ZPixmap, 0,
reinterpret_cast<char*>(imgCanvas.data()), kImgCanvasW, kImgCanvasH, 32,
kImgCanvasW * 4);
int imgOrigW = 0;
int imgOrigH = 0;
bool imgValid = false;
// Modal input state (New Folder / New File / Rename)
InputAction inputAction = InputAction::NewFolder;
std::string inputTitle;
std::string inputValue;
std::string inputTargetPath;
TextCaseMode caseMode = TextCaseMode::Lower;
int lastTapDigit = -1;
int lastTapCycle = 0;
int64_t lastTapMs = 0;
std::string statusBanner;
int64_t statusBannerUntilMs = 0;
struct ActionEntry {
int id;
std::string icon;
std::string label;
};
std::vector<ActionEntry> actionsList;
bool visible = false;
int64_t openStartMs = 0;
int64_t startupIgnoreUntilMs = 0;
bool initialSoftkeysReleased = true;
int softkeyPending = 0;
int64_t softkeyDeadlineMs = 0;
auto updateFilter = [&]() {
filteredItems.clear();
if (searchQuery.empty()) {
filteredItems = allItems;
} else {
std::string qLower = toLowerStr(searchQuery);
for (const auto& it : allItems) {
if (it.isParent) continue;
if (it.lowerName.find(qLower) != std::string::npos ||
it.t9Name.find(searchQuery) != std::string::npos) {
filteredItems.push_back(it);
}
}
}
if (selected >= static_cast<int>(filteredItems.size())) {
selected = std::max(0, static_cast<int>(filteredItems.size()) - 1);
}
};
auto loadDirectory = [&](const std::string& targetDir,
const std::string& selectName = "") {
char resolved[4096];
std::string dir = targetDir;
if (::realpath(targetDir.c_str(), resolved) != nullptr) {
dir = resolved;
}
DIR* d = ::opendir(dir.c_str());
if (!d) {
statusBanner = "Cannot open directory";
statusBannerUntilMs = nowMs() + 1800;
return;
}
currentDir = dir;
allItems.clear();
if (currentDir != "/") {
FileItem parent;
parent.name = "..";
size_t slash = currentDir.rfind('/');
parent.fullPath = (slash == 0 || slash == std::string::npos)
? "/"
: currentDir.substr(0, slash);
parent.lowerName = "..";
parent.isParent = true;
parent.isDir = true;
allItems.push_back(parent);
}
std::vector<FileItem> dirs;
std::vector<FileItem> files;
struct dirent* ent;
while ((ent = ::readdir(d)) != nullptr) {
std::string name = ent->d_name;
if (name == "." || name == "..") continue;
if (!showHidden && !name.empty() && name[0] == '.') continue;
FileItem item;
item.name = name;
item.fullPath =
(currentDir == "/") ? ("/" + name) : (currentDir + "/" + name);
item.lowerName = toLowerStr(name);
item.t9Name = toT9Digits(name);
struct stat st {};
if (::stat(item.fullPath.c_str(), &st) == 0) {
item.isDir = S_ISDIR(st.st_mode);
item.isExec = !item.isDir && ((st.st_mode & S_IXUSR) != 0);
item.size = st.st_size;
item.mtime = st.st_mtim.tv_sec;
item.mode = st.st_mode;
}
if (item.isDir) {
dirs.push_back(item);
} else {
files.push_back(item);
}
}
::closedir(d);
auto cmp = [&](const FileItem& a, const FileItem& b) {
if (sortMode == SortMode::Date && a.mtime != b.mtime) {
return a.mtime > b.mtime;
}
if (sortMode == SortMode::Size && a.size != b.size) {
return a.size > b.size;
}
return a.lowerName < b.lowerName;
};
std::sort(dirs.begin(), dirs.end(), cmp);
std::sort(files.begin(), files.end(), cmp);
allItems.insert(allItems.end(), dirs.begin(), dirs.end());
allItems.insert(allItems.end(), files.begin(), files.end());
searchQuery.clear();
updateFilter();
selected = 0;
if (!selectName.empty()) {
for (size_t i = 0; i < filteredItems.size(); ++i) {
if (filteredItems[i].name == selectName) {
selected = static_cast<int>(i);
break;
}
}
}
};
auto openTextViewer = [&](const FileItem& item) {
viewingFilePath = item.fullPath;
viewingFileName = item.name;
textLines.clear();
textScrollLine = 0;
std::ifstream in(item.fullPath);
std::string line;
int maxLines = 1500;
while (maxLines-- > 0 && std::getline(in, line)) {
if (!line.empty() && line.back() == '\r') {
line.pop_back();
}
// Wrap lines longer than 30 chars for clean 240px display
if (line.empty()) {
textLines.push_back("");
} else {
for (size_t pos = 0; pos < line.size(); pos += 30) {
textLines.push_back(line.substr(pos, 30));
}
}
}
if (textLines.empty()) {
textLines.push_back("(Empty file)");
}
mode = ViewMode::TextView;
};
auto openImageViewer = [&](const FileItem& item) {
viewingFilePath = item.fullPath;
viewingFileName = item.name;
std::vector<uint8_t> rgb;
imgOrigW = 0;
imgOrigH = 0;
imgValid = loadImageRgb24(item.fullPath, &rgb, &imgOrigW, &imgOrigH);
if (imgValid) {
scaleRgb24ToBgrxCanvas(rgb.data(), imgOrigW, imgOrigH, imgCanvas.data(),
kImgCanvasW, kImgCanvasH, 0x111111);
} else {
std::fill(imgCanvas.begin(), imgCanvas.end(), 0x111111);
}
mode = ViewMode::ImageView;
};
auto buildActionsList = [&]() {
actionsList.clear();
bool hasSel = !filteredItems.empty();
bool isParent = hasSel && filteredItems[selected].isParent;
if (hasSel) {
actionsList.push_back({1, kIconEye, "Open / View"});
}
if (!clipPath.empty()) {
actionsList.push_back(
{7, kIconCheck,
std::string(clipIsCut ? "Move Here: " : "Paste Here: ") + clipName});
}
actionsList.push_back({3, kIconPlus, "New Folder"});
actionsList.push_back({4, kIconFileText, "New Empty File"});
if (hasSel && !isParent) {
if (!filteredItems[selected].isDir) {
actionsList.push_back({2, kIconEdit, "Edit in nano"});
}
actionsList.push_back({5, kIconEdit, "Rename"});
actionsList.push_back({6, kIconCopy, "Copy"});
actionsList.push_back({8, kIconOutCall, "Cut / Move"});
actionsList.push_back({9, kIconInfo, "Properties / Info"});
actionsList.push_back({13, kIconTrash, "Delete"});
}
actionsList.push_back(
{10, kIconEye,
showHidden ? "Hide Dotfiles (.*)" : "Show Dotfiles (.*)"});
std::string sortLbl = "Sort: ";
if (sortMode == SortMode::Name) sortLbl += "Date (#)";
else if (sortMode == SortMode::Date) sortLbl += "Size (#)";
else sortLbl += "Name (#)";
actionsList.push_back({11, kIconSort, sortLbl});
actionsList.push_back({12, kIconTerm, "Open Terminal Here"});
actionSelected = 0;
};
auto openSelectedItem = [&]() {
if (filteredItems.empty()) return;
const FileItem item = filteredItems[selected];
if (item.isParent) {
std::string prevBase = currentDir;
size_t sl = prevBase.rfind('/');
std::string prevName =
(sl != std::string::npos) ? prevBase.substr(sl + 1) : "";
loadDirectory(item.fullPath, prevName);
return;
}
if (item.isDir) {
loadDirectory(item.fullPath);
return;
}
std::string ext = getExtLower(item.name);
if (isImageExt(ext)) {
openImageViewer(item);
} else if (isMediaExt(ext)) {
runAsyncArgv("sxmo_open.sh", item.fullPath.c_str());
statusBanner = "Opening in media player...";
statusBannerUntilMs = nowMs() + 1800;
} else if (isLikelyTextFile(item.fullPath, item.size)) {
openTextViewer(item);
} else {
buildActionsList();
mode = ViewMode::Actions;
}
};
auto drawPango = [&](PangoLayout* layout, XftColor* color, int x, int y, int h,
const std::string& text, int maxW = -1) {
pango_layout_set_text(layout, text.c_str(), static_cast<int>(text.size()));
if (maxW > 0) {
pango_layout_set_width(layout, maxW * PANGO_SCALE);
pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_END);
} else {
pango_layout_set_width(layout, -1);
pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_NONE);
}
int tw = 0, th = 0;
pango_layout_get_pixel_size(layout, &tw, &th);
int dy = y + std::max(0, (h - th) / 2);
pango_xft_render_layout(xftDraw, color, layout, x * PANGO_SCALE,
dy * PANGO_SCALE);
return tw;
};
auto drawSoftkeyBar = [&](const std::string& leftLabel,
const std::string& centerLabel,
const std::string& rightLabel) {
const int barY = kWinHeight - 26;
XSetForeground(dpy, gc, pt.spec.bgFooter);
XFillRectangle(dpy, pix, gc, 0, barY, kWinWidth, 26);
XSetForeground(dpy, gc, pt.spec.divider);
XDrawLine(dpy, pix, gc, 0, barY, kWinWidth, barY);
drawPango(layoutMain, &colBlue, 6, barY, 26, leftLabel);
pango_layout_set_width(layoutMain, -1);
pango_layout_set_text(layoutMain, centerLabel.c_str(),
static_cast<int>(centerLabel.size()));
int cw = 0, chh = 0;
pango_layout_get_pixel_size(layoutMain, &cw, &chh);
drawPango(layoutMain, &colWhite, (kWinWidth - cw) / 2, barY, 26,
centerLabel);
pango_layout_set_width(layoutMain, -1);
pango_layout_set_text(layoutMain, rightLabel.c_str(),
static_cast<int>(rightLabel.size()));
int rw = 0, rhh = 0;
pango_layout_get_pixel_size(layoutMain, &rw, &rhh);
drawPango(layoutMain, &colLight, kWinWidth - rw - 6, barY, 26, rightLabel);
};
auto drawUI = [&]() {
if (!visible) return;
pt.checkAndReload();
XSetForeground(dpy, gc, pt.spec.bgMain);
XFillRectangle(dpy, pix, gc, 0, 0, kWinWidth, kWinHeight);
if (mode == ViewMode::Browser) {
XSetForeground(dpy, gc, pt.spec.bgHeader);
XFillRectangle(dpy, pix, gc, 0, 0, kWinWidth, 38);
XSetForeground(dpy, gc, pt.spec.border);
XDrawLine(dpy, pix, gc, 0, 37, kWinWidth, 37);
if (searchQuery.empty()) {
drawPango(layoutIcon, &colYellow, 6, 2, 34, kIconFolderOpen);
drawPango(layoutMain, &colWhite, 28, 2, 34, shortenPath(currentDir),
156);
const char* sTag =
(sortMode == SortMode::Name)
? "N"
: (sortMode == SortMode::Date ? "T" : "S");
std::string badge = std::string("[") + sTag + ":" +
std::to_string(filteredItems.size()) + "]";
pango_layout_set_width(layoutSmall, -1);
pango_layout_set_text(layoutSmall, badge.c_str(),
static_cast<int>(badge.size()));
int bw = 0, bhh = 0;
pango_layout_get_pixel_size(layoutSmall, &bw, &bhh);
drawPango(layoutSmall, &colMuted, kWinWidth - bw - 6, 2, 34, badge);
} else {
drawPango(layoutIcon, &colBlue, 6, 2, 34, kIconSearch);
drawPango(layoutMain, &colYellow, 28, 2, 34, searchQuery, 160);
std::string cnt = std::to_string(filteredItems.size());
pango_layout_set_width(layoutSmall, -1);
pango_layout_set_text(layoutSmall, cnt.c_str(),
static_cast<int>(cnt.size()));
int bw = 0, bhh = 0;
pango_layout_get_pixel_size(layoutSmall, &bw, &bhh);
drawPango(layoutSmall, &colMuted, kWinWidth - bw - 6, 2, 34, cnt);
}
const int listY = 38;
const int rowH = 33;
const int visibleRows = 7;
if (filteredItems.empty()) {
drawPango(layoutMain, &colMuted, 16, 120, 24, "Empty folder", 208);
} else {
int scroll = 0;
if (selected >= visibleRows) {
scroll = selected - visibleRows + 1;
}
for (int i = 0; i < visibleRows; ++i) {
int idx = scroll + i;
if (idx >= static_cast<int>(filteredItems.size())) break;
const auto& it = filteredItems[idx];
int ry = listY + i * rowH;
bool isSel = (idx == selected);
if (isSel) {
XSetForeground(dpy, gc, pt.spec.selBg);
XFillRectangle(dpy, pix, gc, 0, ry, kWinWidth, rowH - 1);
XSetForeground(dpy, gc, pt.spec.accentAlt);
XDrawLine(dpy, pix, gc, 0, ry, kWinWidth, ry);
} else {
XSetForeground(dpy, gc,
(i % 2 == 0) ? pt.spec.bgAltEven : pt.spec.bgAltOdd);
XFillRectangle(dpy, pix, gc, 0, ry, kWinWidth, rowH - 1);
}
const char* ic = kIconFile;
XftColor* icCol = &colMuted;
if (it.isParent) {
ic = kIconBackspace;
icCol = &colBlue;
} else if (it.isDir) {
ic = kIconFolder;
icCol = &colYellow;
} else {
std::string ext = getExtLower(it.name);
if (isImageExt(ext)) {
ic = kIconImage;
icCol = &colGreen;
} else if (isMediaExt(ext)) {
ic = kIconMusic;
icCol = &colBlue;
} else if (it.isExec || ext == "sh") {
ic = kIconTerm;
icCol = &colOrange;
} else {
ic = kIconFileText;
icCol = &colLight;
}
}
drawPango(layoutIcon, icCol, 6, ry, rowH, ic);
std::string dispName =
it.isParent ? ".. (Up)" : (it.isDir ? (it.name + "/") : it.name);
drawPango(layoutMain, &colWhite, 28, ry, rowH, dispName, 154);
std::string meta =
it.isParent ? "" : (it.isDir ? "DIR" : formatFileSize(it.size));
if (!meta.empty()) {
pango_layout_set_width(layoutSmall, -1);
pango_layout_set_text(layoutSmall, meta.c_str(),
static_cast<int>(meta.size()));
int mw = 0, mhh = 0;
pango_layout_get_pixel_size(layoutSmall, &mw, &mhh);
drawPango(layoutSmall, isSel ? &colLight : &colMuted,
kWinWidth - mw - 6, ry, rowH, meta);
}
}
}
drawSoftkeyBar("Actions", "Open",
searchQuery.empty() ? "Close" : "Clear");
} else if (mode == ViewMode::Actions) {
XSetForeground(dpy, gc, pt.spec.bgHeader);
XFillRectangle(dpy, pix, gc, 0, 0, kWinWidth, 34);
drawPango(layoutIcon, &colBlue, 6, 0, 34, kIconList);
drawPango(layoutMain, &colWhite, 28, 0, 34, "File Actions", 200);
const int listY = 36;
const int rowH = 33;
const int visibleRows = 7;
int scroll = 0;
if (actionSelected >= visibleRows) {
scroll = actionSelected - visibleRows + 1;
}
for (int i = 0; i < visibleRows; ++i) {
int idx = scroll + i;
if (idx >= static_cast<int>(actionsList.size())) break;
int ry = listY + i * rowH;
bool isSel = (idx == actionSelected);
XSetForeground(dpy, gc, isSel ? pt.spec.selBg : pt.spec.bgMain);
XFillRectangle(dpy, pix, gc, 0, ry, kWinWidth, rowH - 1);
drawPango(layoutIcon, isSel ? &colYellow : &colBlue, 8, ry, rowH,
actionsList[idx].icon);
drawPango(layoutMain, &colWhite, 32, ry, rowH, actionsList[idx].label,
202);
}
drawSoftkeyBar("Select", "Select", "Back");
} else if (mode == ViewMode::TextView) {
XSetForeground(dpy, gc, pt.spec.bgHeader);
XFillRectangle(dpy, pix, gc, 0, 0, kWinWidth, 32);
drawPango(layoutIcon, &colBlue, 6, 0, 32, kIconFileText);
drawPango(layoutMain, &colWhite, 28, 0, 32, viewingFileName, 150);
std::string posStr = std::to_string(textScrollLine + 1) + "/" +
std::to_string(textLines.size());
pango_layout_set_width(layoutSmall, -1);
pango_layout_set_text(layoutSmall, posStr.c_str(),
static_cast<int>(posStr.size()));
int pw = 0, phh = 0;
pango_layout_get_pixel_size(layoutSmall, &pw, &phh);
drawPango(layoutSmall, &colMuted, kWinWidth - pw - 6, 0, 32, posStr);
const int startY = 36;
const int lineH = 18;
const int maxVis = 12;
for (int i = 0; i < maxVis; ++i) {
int idx = textScrollLine + i;
if (idx >= static_cast<int>(textLines.size())) break;
drawPango(layoutSmall, &colLight, 6, startY + i * lineH, lineH,
textLines[idx], kWinWidth - 12);
}
drawSoftkeyBar("Edit", "Down", "Back");
} else if (mode == ViewMode::ImageView) {
XSetForeground(dpy, gc, pt.spec.bgHeader);
XFillRectangle(dpy, pix, gc, 0, 0, kWinWidth, 36);
drawPango(layoutIcon, &colGreen, 6, 1, 18, kIconImage);
drawPango(layoutMain, &colWhite, 28, 0, 20, viewingFileName, 145);
std::string dim = imgValid
? (std::to_string(imgOrigW) + "x" +
std::to_string(imgOrigH))
: "Decode failed";
drawPango(layoutSmall, &colMuted, 28, 19, 15, dim, 200);
XPutImage(dpy, pix, gc, xImgPreview, 0, 0, 0, 36, kImgCanvasW,
kImgCanvasH);
drawSoftkeyBar("Full", "Next", "Back");
} else if (mode == ViewMode::PropsView && !filteredItems.empty()) {
const auto& it = filteredItems[selected];
XSetForeground(dpy, gc, pt.spec.bgHeader);
XFillRectangle(dpy, pix, gc, 0, 0, kWinWidth, 34);
drawPango(layoutIcon, &colBlue, 6, 0, 34, kIconInfo);
drawPango(layoutMain, &colWhite, 28, 0, 34, "Properties", 200);
drawPango(layoutSmall, &colMuted, 8, 42, 16, "Name:");
drawPango(layoutMain, &colWhite, 8, 58, 22, it.name, 224);
drawPango(layoutSmall, &colMuted, 8, 86, 16, "Path:");
drawPango(layoutSmall, &colLight, 8, 102, 20, it.fullPath, 224);
drawPango(layoutSmall, &colMuted, 8, 128, 16, "Size:");
drawPango(layoutMain, &colYellow, 8, 144, 22,
formatFileSize(it.size) + " (" + std::to_string(it.size) +
" B)",
224);
drawPango(layoutSmall, &colMuted, 8, 172, 16, "Permissions:");
drawPango(layoutSmall, &colLight, 8, 188, 20, formatPermissions(it.mode),
224);
struct tm tmM {};
localtime_r(&it.mtime, &tmM);
char tbuf[32];
std::strftime(tbuf, sizeof(tbuf), "%Y-%m-%d %H:%M:%S", &tmM);
drawPango(layoutSmall, &colMuted, 8, 214, 16, "Modified:");
drawPango(layoutSmall, &colLight, 8, 230, 20, tbuf, 224);
drawSoftkeyBar("Back", "Back", "Back");
} else if (mode == ViewMode::InputModal) {
XSetForeground(dpy, gc, pt.spec.bgHeader);
XFillRectangle(dpy, pix, gc, 0, 0, kWinWidth, 36);
drawPango(layoutIcon, &colBlue, 6, 0, 36, kIconEdit);
drawPango(layoutMain, &colWhite, 28, 0, 36, inputTitle, 145);
const char* mBadge = "[abc]";
if (caseMode == TextCaseMode::Title) mBadge = "[Abc]";
else if (caseMode == TextCaseMode::Upper) mBadge = "[ABC]";
else if (caseMode == TextCaseMode::Num) mBadge = "[123]";
drawPango(layoutSmall, &colYellow, kWinWidth - 46, 0, 36, mBadge);
XSetForeground(dpy, gc, pt.spec.bgInputFocus);
XFillRectangle(dpy, pix, gc, 10, 74, kWinWidth - 20, 38);
XSetForeground(dpy, gc, pt.spec.accentAlt);
XDrawRectangle(dpy, pix, gc, 10, 74, kWinWidth - 21, 37);
drawPango(layoutMain, &colWhite, 16, 74, 38, inputValue + "|",
kWinWidth - 32);
drawPango(layoutSmall, &colMuted, 10, 126, 20,
"0-9: multi-tap #: cycle case", 220);
drawSoftkeyBar("Save", "Save",
inputValue.empty() ? "Cancel" : "Del");
} else if (mode == ViewMode::ConfirmDelete && !filteredItems.empty()) {
const auto& it = filteredItems[selected];
XSetForeground(dpy, gc, pt.spec.bgHeader);
XFillRectangle(dpy, pix, gc, 0, 0, kWinWidth, 36);
drawPango(layoutIcon, &colRed, 8, 0, 36, kIconTrash);
drawPango(layoutMain, &colWhite, 30, 0, 36, "Delete Item?", 200);
drawPango(layoutMain, &colWhite, 14, 68, 26, it.name, 212);
drawPango(layoutSmall, &colMuted, 14, 98, 22,
it.isDir ? "Directory and all contents" : "File will be permanently",
212);
drawPango(layoutSmall, &colMuted, 14, 118, 22,
it.isDir ? "will be deleted!" : "deleted.", 212);
for (int i = 0; i < 2; ++i) {
int ry = 164 + i * 40;
bool isSel = (confirmSelected == i);
XSetForeground(
dpy, gc,
isSel ? (i == 1 ? pt.spec.dangerBg : pt.spec.selBg)
: pt.spec.bgButton);
XFillRectangle(dpy, pix, gc, 16, ry, kWinWidth - 32, 34);
drawPango(layoutMain, &colWhite, 28, ry, 34,
i == 0 ? "No, Keep Item" : "Yes, Delete", 184);
}
drawSoftkeyBar("Select", "Confirm", "Cancel");
}
int64_t tNow = nowMs();
if (!statusBanner.empty() && tNow < statusBannerUntilMs) {
XSetForeground(dpy, gc, pt.spec.bgToast);
XFillRectangle(dpy, pix, gc, 8, kWinHeight - 58, kWinWidth - 16, 28);
XSetForeground(dpy, gc, pt.spec.info);
XDrawRectangle(dpy, pix, gc, 8, kWinHeight - 58, kWinWidth - 17, 27);
drawPango(layoutSmall, &colWhite, 14, kWinHeight - 58, 28, statusBanner,
kWinWidth - 28);
}
XCopyArea(dpy, pix, win, gc, 0, 0, kWinWidth, kWinHeight, 0, 0);
XFlush(dpy);
};
auto showWindow = [&](const std::string& dirArg) {
closeOtherPlugins("files");
mode = ViewMode::Browser;
loadDirectory(dirArg.empty() ? currentDir : dirArg);
writeIntFile(activePidPath, static_cast<int>(::getpid()));
if (!visible) {
visible = true;
XMapRaised(dpy, win);
for (int i = 0; i < 20; ++i) {
if (XGrabKeyboard(dpy, win, True, GrabModeAsync, GrabModeAsync,
CurrentTime) == GrabSuccess) {
break;
}
usleep(2000);
}
} else {
XRaiseWindow(dpy, win);
}
XSetInputFocus(dpy, win, RevertToPointerRoot, CurrentTime);
openStartMs = nowMs();
startupIgnoreUntilMs = openStartMs + 180;
initialSoftkeysReleased = (querySoftkeysDown(dpy) == 0);
softkeyPending = 0;
drawUI();
};
auto hideWindow = [&]() {
if (!visible) return;
writeSoftkeySuppress(nowMs() + 450);
XUngrabKeyboard(dpy, CurrentTime);
XUnmapWindow(dpy, win);
XFlush(dpy);
visible = false;
::unlink(activePidPath.c_str());
};
auto commitModalTap = [&](int digit) {
const char* chars = kMultiTapFile[digit];
int len = static_cast<int>(std::strlen(chars));
if (len <= 0) return;
int64_t t = nowMs();
if (caseMode == TextCaseMode::Num) {
inputValue.push_back(static_cast<char>('0' + digit));
lastTapDigit = -1;
return;
}
bool sameKey = (lastTapDigit == digit && (t - lastTapMs) <= 850 &&
!inputValue.empty());
if (sameKey) {
lastTapCycle = (lastTapCycle + 1) % len;
popUtf8(inputValue);
} else {
lastTapDigit = digit;
lastTapCycle = 0;
}
lastTapMs = t;
char ch = chars[lastTapCycle];
if (std::isalpha(static_cast<unsigned char>(ch))) {
if (caseMode == TextCaseMode::Upper) {
ch = static_cast<char>(std::toupper(static_cast<unsigned char>(ch)));
} else if (caseMode == TextCaseMode::Title && inputValue.empty()) {
ch = static_cast<char>(std::toupper(static_cast<unsigned char>(ch)));
}
}
inputValue.push_back(ch);
};
auto executeAction = [&](int actId) {
if (actId == 1) {
mode = ViewMode::Browser;
openSelectedItem();
} else if (actId == 2 && !filteredItems.empty()) {
std::string p = filteredItems[selected].fullPath;
hideWindow();
runAsyncCmd("st -e nano \"" + p + "\"");
} else if (actId == 3) {
inputAction = InputAction::NewFolder;
inputTitle = "New Folder";
inputValue.clear();
lastTapDigit = -1;
mode = ViewMode::InputModal;
} else if (actId == 4) {
inputAction = InputAction::NewFile;
inputTitle = "New File";
inputValue.clear();
lastTapDigit = -1;
mode = ViewMode::InputModal;
} else if (actId == 5 && !filteredItems.empty()) {
inputAction = InputAction::Rename;
inputTitle = "Rename";
inputValue = filteredItems[selected].name;
inputTargetPath = filteredItems[selected].fullPath;
lastTapDigit = -1;
mode = ViewMode::InputModal;
} else if (actId == 6 && !filteredItems.empty()) {
clipPath = filteredItems[selected].fullPath;
clipName = filteredItems[selected].name;
clipIsCut = false;
statusBanner = "Copied: " + clipName;
statusBannerUntilMs = nowMs() + 1800;
mode = ViewMode::Browser;
} else if (actId == 8 && !filteredItems.empty()) {
clipPath = filteredItems[selected].fullPath;
clipName = filteredItems[selected].name;
clipIsCut = true;
statusBanner = "Cut: " + clipName;
statusBannerUntilMs = nowMs() + 1800;
mode = ViewMode::Browser;
} else if (actId == 7 && !clipPath.empty()) {
std::string dst = (currentDir == "/") ? ("/" + clipName)
: (currentDir + "/" + clipName);
bool ok = false;
if (clipIsCut) {
ok = (::rename(clipPath.c_str(), dst.c_str()) == 0);
if (!ok && copyRecursive(clipPath, dst)) {
removeRecursive(clipPath);
ok = true;
}
if (ok) clipPath.clear();
} else {
ok = copyRecursive(clipPath, dst);
}
statusBanner = ok ? "Paste complete" : "Paste failed";
statusBannerUntilMs = nowMs() + 1800;
loadDirectory(currentDir, clipName);
mode = ViewMode::Browser;
} else if (actId == 9 && !filteredItems.empty()) {
mode = ViewMode::PropsView;
} else if (actId == 10) {
showHidden = !showHidden;
loadDirectory(currentDir);
mode = ViewMode::Browser;
} else if (actId == 11) {
sortMode = static_cast<SortMode>((static_cast<int>(sortMode) + 1) % 3);
loadDirectory(currentDir);
mode = ViewMode::Browser;
} else if (actId == 12) {
std::string d = currentDir;
hideWindow();
runAsyncCmd("cd \"" + d + "\" && exec st");
} else if (actId == 13 && !filteredItems.empty()) {
confirmSelected = 0;
mode = ViewMode::ConfirmDelete;
}
};
auto stepImageInFolder = [&](int delta) {
if (filteredItems.empty()) return;
int n = static_cast<int>(filteredItems.size());
for (int step = 1; step <= n; ++step) {
int idx = (selected + delta * step + n * 2) % n;
if (!filteredItems[idx].isDir &&
isImageExt(getExtLower(filteredItems[idx].name))) {
selected = idx;
openImageViewer(filteredItems[selected]);
return;
}
}
};
auto handleSoftkeyAction = [&](bool isLeft) {
if (mode == ViewMode::Browser) {
if (isLeft) {
buildActionsList();
mode = ViewMode::Actions;
} else {
if (!searchQuery.empty()) {
popUtf8(searchQuery);
updateFilter();
} else {
hideWindow();
return;
}
}
} else if (mode == ViewMode::Actions) {
if (isLeft) {
if (!actionsList.empty()) {
executeAction(actionsList[actionSelected].id);
}
} else {
mode = ViewMode::Browser;
}
} else if (mode == ViewMode::TextView) {
if (isLeft) {
std::string p = viewingFilePath;
hideWindow();
runAsyncCmd("st -e nano \"" + p + "\"");
return;
} else {
mode = ViewMode::Browser;
}
} else if (mode == ViewMode::ImageView) {
if (isLeft) {
runAsyncArgv("feh", viewingFilePath.c_str());
} else {
mode = ViewMode::Browser;
}
} else if (mode == ViewMode::PropsView) {
mode = ViewMode::Browser;
} else if (mode == ViewMode::InputModal) {
if (isLeft) {
std::string name = trimStr(inputValue);
if (!name.empty() && name.find('/') == std::string::npos) {
std::string target = (currentDir == "/") ? ("/" + name)
: (currentDir + "/" + name);
if (inputAction == InputAction::NewFolder) {
::mkdir(target.c_str(), 0755);
} else if (inputAction == InputAction::NewFile) {
int fd = ::open(target.c_str(), O_WRONLY | O_CREAT, 0644);
if (fd >= 0) ::close(fd);
} else if (inputAction == InputAction::Rename) {
::rename(inputTargetPath.c_str(), target.c_str());
}
loadDirectory(currentDir, name);
}
mode = ViewMode::Browser;
} else {
if (!inputValue.empty()) {
popUtf8(inputValue);
lastTapDigit = -1;
} else {
mode = ViewMode::Browser;
}
}
} else if (mode == ViewMode::ConfirmDelete) {
if (isLeft) {
if (confirmSelected == 1 && !filteredItems.empty()) {
removeRecursive(filteredItems[selected].fullPath);
loadDirectory(currentDir);
}
mode = ViewMode::Browser;
} else {
mode = ViewMode::Browser;
}
}
drawUI();
};
if (!isPreload) {
showWindow(initDir);
}
int xfd = ConnectionNumber(dpy);
while (gRunning) {
for (const auto& cmd : readFifoLines(fifoFd)) {
if (cmd == "NOP") {
continue;
} else if (cmd == "RELOAD_THEME") {
pt.reload();
if (visible) drawUI();
} else if (cmd == "CLOSE") {
hideWindow();
} else if (cmd == "OPEN") {
showWindow("");
} else if (cmd.rfind("OPEN ", 0) == 0) {
showWindow(trimStr(cmd.substr(5)));
}
}
while (XPending(dpy) > 0) {
XEvent ev;
XNextEvent(dpy, &ev);
if (!visible) continue;
if (ev.type == Expose && ev.xexpose.count == 0) {
drawUI();
} else if (ev.type == KeyPress) {
int64_t tNow = nowMs();
unsigned int kc = ev.xkey.keycode;
KeySym sym = XLookupKeysym(&ev.xkey, 0);
bool isLeftSk =
(kc == 135 || sym == XK_Menu || sym == XF86XK_KbdLcdMenu1 ||
sym == _EVDEVK(0x246) || sym == XK_F1);
bool isRightSk =
(kc == 166 || sym == XF86XK_Back || sym == XF86XK_KbdLcdMenu2 ||
sym == _EVDEVK(0x247) || sym == XK_F2);
if (!initialSoftkeysReleased) {
if (querySoftkeysDown(dpy) == 0) {
initialSoftkeysReleased = true;
} else if (isLeftSk || isRightSk) {
continue;
}
}
if (tNow < startupIgnoreUntilMs && (isLeftSk || isRightSk)) {
continue;
}
if (isLeftSk || isRightSk) {
int bit = isLeftSk ? 1 : 2;
softkeyPending |= bit;
if (softkeyPending == 3 || querySoftkeysDown(dpy) == 3) {
softkeyPending = 0;
sendPluginCommand("xdrawer", "TOGGLE");
continue;
}
softkeyDeadlineMs = tNow + 35;
continue;
}
if (sym == XK_Escape || kc == 124 || sym == XF86XK_PowerOff) {
hideWindow();
continue;
}
if (sym == XK_BackSpace || sym == XK_Delete) {
if (mode == ViewMode::Browser && searchQuery.empty() &&
currentDir != "/") {
std::string prevBase = currentDir;
size_t sl = prevBase.rfind('/');
std::string prevName =
(sl != std::string::npos) ? prevBase.substr(sl + 1) : "";
std::string upDir =
(sl == 0 || sl == std::string::npos) ? "/" : prevBase.substr(0, sl);
loadDirectory(upDir, prevName);
drawUI();
} else {
handleSoftkeyAction(false);
}
continue;
}
if (mode == ViewMode::Browser) {
if (sym == XK_Up || sym == XK_KP_Up) {
if (!filteredItems.empty()) {
selected =
(selected - 1 + static_cast<int>(filteredItems.size())) %
static_cast<int>(filteredItems.size());
drawUI();
}
} else if (sym == XK_Down || sym == XK_KP_Down) {
if (!filteredItems.empty()) {
selected =
(selected + 1) % static_cast<int>(filteredItems.size());
drawUI();
}
} else if (sym == XK_Left || sym == XK_KP_Left) {
if (currentDir != "/") {
std::string prevBase = currentDir;
size_t sl = prevBase.rfind('/');
std::string prevName =
(sl != std::string::npos) ? prevBase.substr(sl + 1) : "";
std::string upDir = (sl == 0 || sl == std::string::npos)
? "/"
: prevBase.substr(0, sl);
loadDirectory(upDir, prevName);
drawUI();
}
} else if (sym == XK_Right || sym == XK_KP_Right ||
sym == XK_Return || sym == XK_KP_Enter) {
openSelectedItem();
drawUI();
} else {
char d = mapDialKey(sym, kc, ev.xkey.state);
if (d == '*') {
showHidden = !showHidden;
loadDirectory(currentDir);
drawUI();
} else if (d == '#') {
sortMode =
static_cast<SortMode>((static_cast<int>(sortMode) + 1) % 3);
loadDirectory(currentDir);
drawUI();
} else if (d >= '0' && d <= '9') {
searchQuery.push_back(d);
updateFilter();
drawUI();
}
}
} else if (mode == ViewMode::Actions) {
if (sym == XK_Up || sym == XK_KP_Up) {
if (!actionsList.empty()) {
actionSelected =
(actionSelected - 1 + static_cast<int>(actionsList.size())) %
static_cast<int>(actionsList.size());
drawUI();
}
} else if (sym == XK_Down || sym == XK_KP_Down) {
if (!actionsList.empty()) {
actionSelected =
(actionSelected + 1) % static_cast<int>(actionsList.size());
drawUI();
}
} else if (sym == XK_Return || sym == XK_KP_Enter) {
handleSoftkeyAction(true);
}
} else if (mode == ViewMode::TextView) {
if (sym == XK_Up || sym == XK_KP_Up) {
textScrollLine = std::max(0, textScrollLine - 1);
drawUI();
} else if (sym == XK_Down || sym == XK_KP_Down ||
sym == XK_Return || sym == XK_KP_Enter) {
textScrollLine = std::min(
std::max(0, static_cast<int>(textLines.size()) - 1),
textScrollLine + 1);
drawUI();
} else if (sym == XK_Left || sym == XK_KP_Left || sym == XK_Prior) {
textScrollLine = std::max(0, textScrollLine - 10);
drawUI();
} else if (sym == XK_Right || sym == XK_KP_Right || sym == XK_Next) {
textScrollLine = std::min(
std::max(0, static_cast<int>(textLines.size()) - 1),
textScrollLine + 10);
drawUI();
}
} else if (mode == ViewMode::ImageView) {
if (sym == XK_Left || sym == XK_KP_Left || sym == XK_Up ||
sym == XK_KP_Up) {
stepImageInFolder(-1);
drawUI();
} else if (sym == XK_Right || sym == XK_KP_Right || sym == XK_Down ||
sym == XK_KP_Down || sym == XK_Return ||
sym == XK_KP_Enter) {
stepImageInFolder(1);
drawUI();
}
} else if (mode == ViewMode::PropsView) {
if (sym == XK_Return || sym == XK_KP_Enter) {
mode = ViewMode::Browser;
drawUI();
}
} else if (mode == ViewMode::InputModal) {
if (sym == XK_Return || sym == XK_KP_Enter) {
handleSoftkeyAction(true);
} else if (sym == XK_Right || sym == XK_KP_Right) {
lastTapDigit = -1;
} else {
char d = mapDialKey(sym, kc, ev.xkey.state);
if (d == '#') {
lastTapDigit = -1;
caseMode = static_cast<TextCaseMode>(
(static_cast<int>(caseMode) + 1) % 4);
drawUI();
} else if (d == '*') {
commitModalTap(1);
drawUI();
} else if (d >= '0' && d <= '9') {
commitModalTap(d - '0');
drawUI();
}
}
} else if (mode == ViewMode::ConfirmDelete) {
if (sym == XK_Up || sym == XK_Down || sym == XK_KP_Up ||
sym == XK_KP_Down) {
confirmSelected = 1 - confirmSelected;
drawUI();
} else if (sym == XK_Return || sym == XK_KP_Enter) {
handleSoftkeyAction(true);
}
}
}
}
int64_t tNow = nowMs();
if (visible && softkeyPending != 0 && tNow >= softkeyDeadlineMs) {
if (querySoftkeysDown(dpy) == 3) {
softkeyPending = 0;
sendPluginCommand("xdrawer", "TOGGLE");
} else {
bool isLeft = (softkeyPending == 1);
softkeyPending = 0;
handleSoftkeyAction(isLeft);
}
}
int timeoutMs = -1;
if (visible && softkeyPending != 0) {
timeoutMs = std::max(1, static_cast<int>(softkeyDeadlineMs - tNow));
}
struct pollfd pfds[2];
int nfds = 0;
pfds[nfds++] = {xfd, POLLIN, 0};
int fifoIdx = -1;
if (fifoFd >= 0) {
fifoIdx = nfds;
pfds[nfds++] = {fifoFd, POLLIN, 0};
}
int pr = ::poll(pfds, nfds, timeoutMs);
if (pr > 0 && fifoIdx >= 0 && (pfds[fifoIdx].revents & POLLIN)) {
for (const auto& cmd : readFifoLines(fifoFd)) {
if (cmd == "RELOAD_THEME") {
pt.reload();
if (visible) drawUI();
} else if (cmd == "CLOSE") {
hideWindow();
} else if (cmd == "OPEN") {
showWindow("");
} else if (cmd.rfind("OPEN ", 0) == 0) {
showWindow(trimStr(cmd.substr(5)));
}
}
}
}
hideWindow();
if (xImgPreview) {
xImgPreview->data = nullptr;
XDestroyImage(xImgPreview);
}
if (fifoFd >= 0) ::close(fifoFd);
::unlink(daemonPidPath.c_str());
return 0;
}
int files_plugin_init(const DwmHostApi* host) {
if (host && host->spawn_plugin) {
host->spawn_plugin("files", "--preload");
}
return 0;
}
} // namespace
extern "C" __attribute__((visibility("default"))) const DwmPlugin dwm_plugin_entry = {
DWM_PLUGIN_API_VERSION,
"files",
"Keypad-driven graphical file manager with text/image preview",
files_plugin_init,
nullptr,
nullptr,
nullptr,
nullptr,
runFilesApp
};
Reference in New Issue View Git Blame Copy Permalink