436 lines
15 KiB
C++
436 lines
15 KiB
C++
/*
|
|
* fileop.cpp
|
|
* Background copy/move/delete worker + progress dialog for the embedded
|
|
* desktop file manager. Long file operations run on a worker thread so the
|
|
* desktop UI never freezes; a modal progress dialog shows the current item,
|
|
* a determinate bar, and a Cancel button.
|
|
* Copyright (c) 2026 Daniel Hammer
|
|
*/
|
|
|
|
#include "filemanager_internal.hpp"
|
|
#include <gui/mtk/hosts.hpp>
|
|
#include <montauk/thread.h>
|
|
|
|
namespace filemanager {
|
|
|
|
// Inline (synchronous, no dialog) threshold for a single plain file paste.
|
|
// Anything larger -- or any directory / multi-item operation -- runs async.
|
|
static constexpr uint64_t FILEOP_INLINE_MAX_BYTES = 16ull * 1024 * 1024;
|
|
|
|
struct FileOpJob {
|
|
int kind; // FileOpKind: copy / move / delete
|
|
char (*paths)[256]; // owned: source paths (copy/move) or targets (delete)
|
|
int count;
|
|
char dest_dir[256]; // destination directory (copy/move); empty for delete
|
|
|
|
DesktopState* desktop;
|
|
FileManagerState* owner; // for the post-op refresh (liveness-checked)
|
|
Color accent;
|
|
|
|
volatile int files_total;
|
|
volatile int files_done;
|
|
volatile int cancel; // UI -> worker
|
|
volatile int finished; // worker -> UI
|
|
volatile char current[128]; // basename of the item in progress (worker writes)
|
|
|
|
int tid;
|
|
int last_drawn_done; // dialog redraw tracking
|
|
int mouse_x, mouse_y;
|
|
};
|
|
|
|
// ============================================================================
|
|
// Helpers
|
|
// ============================================================================
|
|
|
|
static bool fileop_path_same_or_descendant(const char* path, const char* root) {
|
|
if (!path || !root) return false;
|
|
int root_len = montauk::slen(root);
|
|
while (root_len > 0 && root[root_len - 1] == '/') root_len--;
|
|
if (root_len <= 0) return false;
|
|
for (int i = 0; i < root_len; i++) {
|
|
if (path[i] == '\0' || path[i] != root[i]) return false;
|
|
}
|
|
return path[root_len] == '\0' || path[root_len] == '/';
|
|
}
|
|
|
|
static void fileop_set_current(FileOpJob* job, const char* name) {
|
|
if (!job || !name) return;
|
|
int i = 0;
|
|
for (; name[i] && i < 127; i++) job->current[i] = name[i];
|
|
job->current[i] = '\0';
|
|
}
|
|
|
|
static bool fileop_path_is_dir(const char* path) {
|
|
const char* probe[1];
|
|
return montauk::readdir(path, probe, 1) >= 0;
|
|
}
|
|
|
|
// ============================================================================
|
|
// Worker thread
|
|
// ============================================================================
|
|
|
|
static int fileop_worker(void* arg) {
|
|
FileOpJob* job = (FileOpJob*)arg;
|
|
|
|
for (int i = 0; i < job->count && !job->cancel; i++) {
|
|
const char* src = job->paths[i];
|
|
const char* base = path_basename(src);
|
|
fileop_set_current(job, base);
|
|
|
|
if (job->kind == FILE_OP_DELETE) {
|
|
filemanager_delete_recursive(src);
|
|
job->files_done = i + 1;
|
|
continue;
|
|
}
|
|
|
|
// Copy or move into dest_dir.
|
|
char dst[512];
|
|
filemanager_build_fullpath(dst, 512, job->dest_dir, base);
|
|
if (montauk::streq(dst, src)) { job->files_done = i + 1; continue; }
|
|
|
|
bool is_dir = fileop_path_is_dir(src);
|
|
if (is_dir && fileop_path_same_or_descendant(dst, src)) {
|
|
job->files_done = i + 1;
|
|
continue; // refuse to copy a directory into itself
|
|
}
|
|
|
|
if (job->kind == FILE_OP_MOVE) {
|
|
// Try a rename first: an instant same-volume move with no copying.
|
|
if (montauk::frename(src, dst) == 0) { job->files_done = i + 1; continue; }
|
|
// Cross-volume (or driver without rename): fall back to copy + delete.
|
|
bool ok = is_dir ? filemanager_copy_dir_recursive(src, dst)
|
|
: filemanager_copy_file(src, dst);
|
|
if (ok) {
|
|
if (is_dir) filemanager_delete_recursive(src);
|
|
else montauk::fdelete(src);
|
|
}
|
|
} else { // FILE_OP_COPY
|
|
if (is_dir) filemanager_copy_dir_recursive(src, dst);
|
|
else filemanager_copy_file(src, dst);
|
|
}
|
|
job->files_done = i + 1;
|
|
}
|
|
|
|
job->finished = 1;
|
|
return 0;
|
|
}
|
|
|
|
// ============================================================================
|
|
// Progress dialog
|
|
// ============================================================================
|
|
|
|
static const char* fileop_verb(int kind) {
|
|
switch (kind) {
|
|
case FILE_OP_COPY: return "Copying";
|
|
case FILE_OP_MOVE: return "Moving";
|
|
case FILE_OP_DELETE: return "Deleting";
|
|
default: return "Working";
|
|
}
|
|
}
|
|
|
|
static void fileop_cancel_button_rect(int cw, int ch, Rect* out) {
|
|
int btn_w = 88, btn_h = 28;
|
|
*out = { cw - btn_w - 16, ch - btn_h - 14, btn_w, btn_h };
|
|
}
|
|
|
|
static FileManagerState* fileop_live_owner(FileOpJob* job) {
|
|
if (!job || !job->desktop || !job->owner) return nullptr;
|
|
for (int i = 0; i < job->desktop->window_count; i++) {
|
|
Window& win = job->desktop->windows[i];
|
|
if (win.app_data == job->owner && win.on_draw == filemanager_on_draw)
|
|
return job->owner;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
static void fileop_close_self(DesktopState* ds, FileOpJob* job) {
|
|
if (!ds) return;
|
|
for (int i = 0; i < ds->window_count; i++) {
|
|
if (ds->windows[i].app_data == job) {
|
|
desktop_close_window(ds, i);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void fileop_dialog_on_draw(Window* win, Framebuffer& fb) {
|
|
(void)fb;
|
|
FileOpJob* job = (FileOpJob*)win->app_data;
|
|
if (!job) return;
|
|
|
|
Canvas c(win);
|
|
mtk::Theme theme = mtk::make_theme(job->accent);
|
|
c.fill(theme.window_bg);
|
|
|
|
int pad = 16;
|
|
int fh = system_font_height();
|
|
int y = 18;
|
|
|
|
// Title: "Copying 3 of 12"
|
|
char title[96];
|
|
int done = job->files_done;
|
|
int total = job->files_total;
|
|
if (total > 1)
|
|
snprintf(title, sizeof(title), "%s %d of %d", fileop_verb(job->kind),
|
|
done < total ? done + 1 : total, total);
|
|
else
|
|
snprintf(title, sizeof(title), "%s...", fileop_verb(job->kind));
|
|
c.text(pad, y, title, theme.text);
|
|
y += fh + 10;
|
|
|
|
// Current item name (copied out of the volatile buffer).
|
|
char cur[128];
|
|
int k = 0;
|
|
for (; k < 127 && job->current[k]; k++) cur[k] = job->current[k];
|
|
cur[k] = '\0';
|
|
if (cur[0]) {
|
|
char fit[128];
|
|
// Trim to width using the shared helper if available; otherwise show raw.
|
|
montauk::strncpy(fit, cur, sizeof(fit) - 1);
|
|
fit[sizeof(fit) - 1] = '\0';
|
|
c.text(pad, y, fit, theme.text_muted);
|
|
}
|
|
y += fh + 12;
|
|
|
|
// Progress bar.
|
|
int bar_x = pad;
|
|
int bar_w = c.w - pad * 2;
|
|
int bar_h = 10;
|
|
c.fill_rounded_rect(bar_x, y, bar_w, bar_h, 5,
|
|
Color::from_rgb(0xE0, 0xE0, 0xE0));
|
|
int frac_w = 0;
|
|
if (total > 0) {
|
|
if (done > total) done = total;
|
|
frac_w = (int)(((int64_t)bar_w * done) / total);
|
|
}
|
|
if (frac_w > 0)
|
|
c.fill_rounded_rect(bar_x, y, frac_w, bar_h, 5, job->accent);
|
|
|
|
// Cancel button.
|
|
Rect cancel_btn;
|
|
fileop_cancel_button_rect(c.w, c.h, &cancel_btn);
|
|
bool hover = cancel_btn.contains(job->mouse_x, job->mouse_y);
|
|
mtk::draw_button(c, cancel_btn, job->finished ? "Close" : "Cancel",
|
|
mtk::BUTTON_SECONDARY,
|
|
mtk::widget_state(false, hover, true), theme);
|
|
}
|
|
|
|
static void fileop_dialog_on_mouse(Window* win, MouseEvent& ev) {
|
|
FileOpJob* job = (FileOpJob*)win->app_data;
|
|
if (!job) return;
|
|
|
|
mtk::DesktopHost host(win);
|
|
int mx = 0, my = 0;
|
|
if (!host.map_mouse(ev, &mx, &my)) return;
|
|
|
|
Rect cancel_btn;
|
|
fileop_cancel_button_rect(win->content_w, win->content_h, &cancel_btn);
|
|
bool old_hover = cancel_btn.contains(job->mouse_x, job->mouse_y);
|
|
bool new_hover = cancel_btn.contains(mx, my);
|
|
job->mouse_x = mx;
|
|
job->mouse_y = my;
|
|
if (old_hover != new_hover) host.invalidate();
|
|
|
|
if (ev.left_pressed() && new_hover) {
|
|
// Request cancel; the dialog closes once the worker observes it.
|
|
job->cancel = 1;
|
|
if (job->finished) fileop_close_self(job->desktop, job);
|
|
}
|
|
}
|
|
|
|
static void fileop_dialog_on_key(Window* win, const Montauk::KeyEvent& key) {
|
|
FileOpJob* job = (FileOpJob*)win->app_data;
|
|
if (!job || !key.pressed) return;
|
|
if (key.scancode == 0x01) job->cancel = 1; // Escape requests cancel
|
|
}
|
|
|
|
static void fileop_dialog_on_poll(Window* win) {
|
|
FileOpJob* job = (FileOpJob*)win->app_data;
|
|
if (!job) return;
|
|
|
|
if (job->files_done != job->last_drawn_done) {
|
|
job->last_drawn_done = job->files_done;
|
|
win->dirty = true;
|
|
}
|
|
|
|
if (job->finished) {
|
|
// Hand off to on_close, which joins the worker, refreshes the file
|
|
// manager, and frees the job exactly once.
|
|
fileop_close_self(job->desktop, job);
|
|
}
|
|
}
|
|
|
|
static void fileop_dialog_on_close(Window* win) {
|
|
FileOpJob* job = (FileOpJob*)win->app_data;
|
|
if (!job) return;
|
|
|
|
// Make sure the worker has stopped before we free anything it touches.
|
|
if (job->tid > 0) {
|
|
if (!job->finished) job->cancel = 1;
|
|
montauk::thread_join(job->tid, nullptr);
|
|
job->tid = 0;
|
|
}
|
|
|
|
FileManagerState* owner = fileop_live_owner(job);
|
|
if (owner) {
|
|
if (owner->active_fileop == job) owner->active_fileop = nullptr;
|
|
filemanager_clear_multi_selection(owner);
|
|
filemanager_read_dir(owner);
|
|
}
|
|
|
|
if (job->paths) montauk::mfree(job->paths);
|
|
montauk::mfree(job);
|
|
win->app_data = nullptr;
|
|
}
|
|
|
|
static bool fileop_show_dialog(FileOpJob* job) {
|
|
DesktopState* ds = job->desktop;
|
|
int w = 380, h = 150;
|
|
int wx = 0, wy = 0;
|
|
props_center_dialog(ds, job->owner, w, h, &wx, &wy);
|
|
|
|
const char* dlg_title = (job->kind == FILE_OP_DELETE) ? "Deleting"
|
|
: (job->kind == FILE_OP_MOVE) ? "Moving"
|
|
: "Copying";
|
|
int idx = desktop_create_window(ds, dlg_title, wx, wy, w, h);
|
|
if (idx < 0) return false;
|
|
|
|
Window* win = &ds->windows[idx];
|
|
win->app_data = job;
|
|
win->on_draw = fileop_dialog_on_draw;
|
|
win->on_mouse = fileop_dialog_on_mouse;
|
|
win->on_key = fileop_dialog_on_key;
|
|
win->on_close = fileop_dialog_on_close;
|
|
win->on_poll = fileop_dialog_on_poll;
|
|
return true;
|
|
}
|
|
|
|
// Spawn the worker + dialog. Takes ownership of `job` on success. On failure
|
|
// (no thread / no window) runs the work synchronously and frees the job.
|
|
static bool fileop_launch(FileOpJob* job) {
|
|
if (job->owner) job->owner->active_fileop = job;
|
|
|
|
// Generous stack: copy/delete recurse with ~2.5 KiB of buffers per directory
|
|
// level, so this comfortably handles deeply nested trees.
|
|
int tid = montauk::thread_spawn(fileop_worker, job, 256 * 1024);
|
|
if (tid <= 0) {
|
|
// Degraded path: do it inline (UI blocks), then refresh.
|
|
fileop_worker(job);
|
|
FileManagerState* owner = fileop_live_owner(job);
|
|
if (owner) {
|
|
owner->active_fileop = nullptr;
|
|
filemanager_clear_multi_selection(owner);
|
|
filemanager_read_dir(owner);
|
|
}
|
|
if (job->paths) montauk::mfree(job->paths);
|
|
montauk::mfree(job);
|
|
return true;
|
|
}
|
|
job->tid = tid;
|
|
|
|
if (!fileop_show_dialog(job)) {
|
|
// Window creation failed: let the worker finish, then reap + refresh
|
|
// without a dialog.
|
|
montauk::thread_join(job->tid, nullptr);
|
|
FileManagerState* owner = fileop_live_owner(job);
|
|
if (owner) {
|
|
owner->active_fileop = nullptr;
|
|
filemanager_clear_multi_selection(owner);
|
|
filemanager_read_dir(owner);
|
|
}
|
|
if (job->paths) montauk::mfree(job->paths);
|
|
montauk::mfree(job);
|
|
return true;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static FileOpJob* fileop_alloc_job(int kind, int count) {
|
|
if (count <= 0) return nullptr;
|
|
FileOpJob* job = (FileOpJob*)montauk::malloc(sizeof(FileOpJob));
|
|
if (!job) return nullptr;
|
|
montauk::memset(job, 0, sizeof(FileOpJob));
|
|
job->paths = (char(*)[256])montauk::malloc((uint64_t)count * 256);
|
|
if (!job->paths) { montauk::mfree(job); return nullptr; }
|
|
job->kind = kind;
|
|
job->count = count;
|
|
job->files_total = count;
|
|
return job;
|
|
}
|
|
|
|
// ============================================================================
|
|
// Public entry points
|
|
// ============================================================================
|
|
|
|
bool filemanager_start_paste_job(FileManagerState* fm) {
|
|
if (!fm || fm->active_fileop) return false;
|
|
if (fm->clipboard_count <= 0) return false;
|
|
if (filemanager_is_computer_view(fm) || filemanager_is_virtual_view(fm)) return false;
|
|
|
|
bool is_cut = fm->clipboard_is_cut;
|
|
|
|
// Fast path: a single small plain file pastes inline so quick copies stay
|
|
// snappy (no thread, no dialog flash).
|
|
if (fm->clipboard_count == 1 && !fileop_path_is_dir(fm->clipboard_paths[0])) {
|
|
const char* src = fm->clipboard_paths[0];
|
|
uint64_t sz = 0;
|
|
int fd = montauk::open(src);
|
|
if (fd >= 0) { sz = montauk::getsize(fd); montauk::close(fd); }
|
|
if (sz <= FILEOP_INLINE_MAX_BYTES) {
|
|
char dst[512];
|
|
filemanager_build_fullpath(dst, 512, fm->current_path, path_basename(src));
|
|
if (!montauk::streq(dst, src)) {
|
|
if (is_cut) {
|
|
if (montauk::frename(src, dst) != 0) {
|
|
if (filemanager_copy_file(src, dst)) montauk::fdelete(src);
|
|
}
|
|
} else {
|
|
filemanager_copy_file(src, dst);
|
|
}
|
|
}
|
|
if (is_cut) fm->clipboard_count = 0;
|
|
filemanager_read_dir(fm);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
FileOpJob* job = fileop_alloc_job(is_cut ? FILE_OP_MOVE : FILE_OP_COPY,
|
|
fm->clipboard_count);
|
|
if (!job) return false;
|
|
for (int i = 0; i < fm->clipboard_count; i++) {
|
|
montauk::strncpy(job->paths[i], fm->clipboard_paths[i], 255);
|
|
job->paths[i][255] = '\0';
|
|
}
|
|
montauk::strncpy(job->dest_dir, fm->current_path, sizeof(job->dest_dir) - 1);
|
|
job->dest_dir[sizeof(job->dest_dir) - 1] = '\0';
|
|
job->desktop = fm->desktop;
|
|
job->owner = fm;
|
|
job->accent = fm->desktop ? fm->desktop->settings.accent_color : Color{};
|
|
|
|
// A cut is consumed when the paste starts (paths are already copied in).
|
|
if (is_cut) fm->clipboard_count = 0;
|
|
|
|
return fileop_launch(job);
|
|
}
|
|
|
|
bool filemanager_start_delete_job(FileManagerState* fm,
|
|
const char* const* paths, int count) {
|
|
if (!fm || fm->active_fileop) return false;
|
|
if (!paths || count <= 0) return false;
|
|
|
|
FileOpJob* job = fileop_alloc_job(FILE_OP_DELETE, count);
|
|
if (!job) return false;
|
|
for (int i = 0; i < count; i++) {
|
|
montauk::strncpy(job->paths[i], paths[i] ? paths[i] : "", 255);
|
|
job->paths[i][255] = '\0';
|
|
}
|
|
job->dest_dir[0] = '\0';
|
|
job->desktop = fm->desktop;
|
|
job->owner = fm;
|
|
job->accent = fm->desktop ? fm->desktop->settings.accent_color : Color{};
|
|
|
|
return fileop_launch(job);
|
|
}
|
|
|
|
} // namespace filemanager
|