Files
uu-remote-linux/c_engine/viewer_tools.c
T
809ce1697d Add the experimental native viewer (uuremote-viewer) (#36)
* Add the experimental native viewer (uuremote-viewer)

A Linux viewer/controller for UU Remote hosts, built separately with
--features native-viewer,viewer-sdl; the host build and behaviour are
unchanged.

- Cloud join by device and remote assistance by share ID + code (code
  via stdin only), WebRTC offer side, SDL desktop window with ffmpeg CLI
  H.264 decoding, Opus sound, keyboard/mouse, view-only mode, text
  clipboard on TEXT_DATA_CHANNEL.
- Tools: file browser/transfer (zero- and one-based download blocks),
  terminal and terminal session list, port mapping (127.0.0.1 only),
  reboot/shutdown; tools reuse the desktop peer while one is open.
- GTK launcher with device list and tool windows.
- CI builds and tests the viewer; release tarballs include it.

Logs carry field numbers, sizes and states only.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

* ci: install the ffmpeg CLI for the viewer audio tests

Co-Authored-By: Claude Opus 5.5 <[email protected]>

---------

Co-authored-by: VallierDev <[email protected]>
Co-authored-by: Claude Opus 5.5 <[email protected]>
2026-10-17 15:41:20 +08:00

495 lines
33 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// GTK3 tool windows for the native viewer: file transfer (`files-ui`) and port mapping (`portmap-ui`).
// One tool window per process; desktop files reuse the desktop peer. GTK runs on its own thread; Rust pushes state with g_idle_add and polls commands. Paths and
// names stay inside this window; nothing here logs.
#include <gtk/gtk.h>
#include <pthread.h>
#include <stdatomic.h>
#include <string.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
#define QSIZE 64
static char queue[QSIZE][4096];
static int q_head, q_len;
static pthread_mutex_t q_lock = PTHREAD_MUTEX_INITIALIZER;
static atomic_int closed;
static int init_state;
static pthread_mutex_t init_lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t init_cond = PTHREAD_COND_INITIALIZER;
static GtkWidget *window, *toast;
static char remote_name[256];
static void push(const char *cmd) {
pthread_mutex_lock(&q_lock);
if (q_len < QSIZE) { snprintf(queue[(q_head + q_len) % QSIZE], sizeof queue[0], "%s", cmd); q_len++; }
pthread_mutex_unlock(&q_lock);
}
int uu_tools_ui_take(char *out, size_t len) {
pthread_mutex_lock(&q_lock);
int got = q_len > 0;
if (got) { snprintf(out, len, "%s", queue[q_head]); q_head = (q_head + 1) % QSIZE; q_len--; }
pthread_mutex_unlock(&q_lock);
return got;
}
int uu_tools_ui_closed(void) { return atomic_load(&closed); }
static void add_class(GtkWidget *w, const char *cls) { gtk_style_context_add_class(gtk_widget_get_style_context(w), cls); }
static GtkWidget *hbox(int s) { return gtk_box_new(GTK_ORIENTATION_HORIZONTAL, s); }
static GtkWidget *vbox(int s) { return gtk_box_new(GTK_ORIENTATION_VERTICAL, s); }
static GtkWidget *label(const char *text, const char *cls) { GtkWidget *l = gtk_label_new(text); if (cls) add_class(l, cls); gtk_label_set_xalign(GTK_LABEL(l), 0); return l; }
static GtkWidget *button(const char *text, const char *cls) { GtkWidget *b = gtk_button_new_with_label(text); if (cls) add_class(b, cls); return b; }
static gboolean hide_toast(gpointer d) { (void)d; gtk_widget_hide(toast); return G_SOURCE_REMOVE; }
static void show_toast(const char *text) { gtk_label_set_text(GTK_LABEL(toast), text); gtk_widget_show(toast); g_timeout_add(3500, hide_toast, NULL); }
static gboolean toast_idle(gpointer d) { show_toast(d); g_free(d); return G_SOURCE_REMOVE; }
void uu_tools_ui_toast(const char *text) { g_idle_add(toast_idle, g_strdup(text)); }
static gboolean on_delete(GtkWidget *w, GdkEvent *e, gpointer d) { (void)e; (void)d; gtk_widget_hide(w); atomic_store(&closed, 1); return TRUE; }
static const char *css =
"window { background: #f5f6f8; }\n"
".title { font-size: 22px; font-weight: bold; color: #111827; }\n"
".tag { background: #e5e7eb; color: #4b5563; border-radius: 6px; padding: 2px 8px; }\n"
".tag.remote { background: #d1fae5; color: #047857; }\n"
".card { background: white; border: 1px solid #e5e7eb; border-radius: 10px; padding: 8px; }\n"
".section { font-size: 17px; font-weight: bold; }\n"
".toast { background: rgba(17,24,39,0.88); color: white; border-radius: 8px; padding: 10px 18px; }\n"
".primary { background-image: none; background-color: #10b981; color: white; border: none; }\n"
".empty { color: #6b7280; font-size: 15px; }\n"
".online { color: #10b981; }\n";
static GtkWidget *frame(const char *title, GtkWidget **content) {
GtkCssProvider *p = gtk_css_provider_new(); gtk_css_provider_load_from_data(p, css, -1, NULL);
gtk_style_context_add_provider_for_screen(gdk_screen_get_default(), GTK_STYLE_PROVIDER(p), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), title);
g_signal_connect(window, "delete-event", G_CALLBACK(on_delete), NULL);
GtkWidget *overlay = gtk_overlay_new(); *content = vbox(14);
gtk_container_set_border_width(GTK_CONTAINER(*content), 22);
gtk_container_add(GTK_CONTAINER(overlay), *content);
toast = label("", "toast"); gtk_widget_set_halign(toast, GTK_ALIGN_CENTER); gtk_widget_set_valign(toast, GTK_ALIGN_END);
gtk_widget_set_margin_bottom(toast, 30); gtk_widget_set_no_show_all(toast, TRUE);
gtk_overlay_add_overlay(GTK_OVERLAY(overlay), toast);
gtk_container_add(GTK_CONTAINER(window), overlay);
return overlay;
}
static GtkWidget *add_column(GtkWidget *view, const char *title, int col, int expand) {
GtkCellRenderer *r = gtk_cell_renderer_text_new();
if (expand) g_object_set(r, "ellipsize", PANGO_ELLIPSIZE_MIDDLE, NULL);
GtkTreeViewColumn *c = gtk_tree_view_column_new_with_attributes(title, r, "text", col, NULL);
gtk_tree_view_column_set_resizable(c, TRUE); gtk_tree_view_column_set_expand(c, expand);
if (expand) gtk_tree_view_column_set_min_width(c, 160);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), c);
return view;
}
static GtkWidget *scrolled(GtkWidget *child, int height) {
GtkWidget *s = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(s), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_set_size_request(s, -1, height); gtk_container_add(GTK_CONTAINER(s), child);
return s;
}
static void format_size(guint64 size, int kind, char *out, size_t len) {
if (kind != 4) { snprintf(out, len, "--"); return; }
if (size < 1024) snprintf(out, len, "%llu B", (unsigned long long)size);
else if (size < 1024 * 1024) snprintf(out, len, "%.2f KB", size / 1024.0);
else if (size < 1024ull * 1024 * 1024) snprintf(out, len, "%.2f MB", size / 1048576.0);
else snprintf(out, len, "%.2f GB", size / 1073741824.0);
}
static void format_time(guint64 secs, char *out, size_t len) {
if (!secs) { snprintf(out, len, "--"); return; }
time_t t = (time_t)secs; struct tm tm; localtime_r(&t, &tm);
strftime(out, len, "%Y年%m月%d日", &tm);
}
static const char *kind_name(int kind) { return kind == 4 ? "文件" : kind == 3 ? "磁盘" : "文件夹"; }
/* ---------------- file transfer ---------------- */
enum { C_NAME, C_TIME, C_TYPE, C_SIZE, C_PATH, C_KIND, C_N };
enum { T_ID, T_NAME, T_STATUS, T_SIZE, T_FROM, T_TO, T_DONE, T_N };
static GtkListStore *local_store, *remote_store, *task_store;
static GtkWidget *local_view, *remote_view, *local_path, *remote_path;
static char local_dir[2048] = "", remote_dir[2048] = ":/";
static void load_local(const char *path) {
char *dir = g_strdup(path); /* path may alias local_dir */
GDir *d = g_dir_open(dir, 0, NULL);
if (!d) { show_toast("无法打开本机目录"); g_free(dir); return; }
snprintf(local_dir, sizeof local_dir, "%s", dir); g_free(dir);
gtk_entry_set_text(GTK_ENTRY(local_path), local_dir);
gtk_list_store_clear(local_store);
const char *name;
GPtrArray *names = g_ptr_array_new_with_free_func(g_free);
while ((name = g_dir_read_name(d))) if (name[0] != '.') g_ptr_array_add(names, g_strdup(name));
g_dir_close(d);
for (int pass = 0; pass < 2; pass++) for (guint i = 0; i < names->len; i++) {
char *full = g_build_filename(local_dir, names->pdata[i], NULL); struct stat st;
if (stat(full, &st) == 0 && (S_ISDIR(st.st_mode) ? pass == 0 : pass == 1)) {
int kind = S_ISDIR(st.st_mode) ? 0 : 4; char size[32], when[64];
format_size(st.st_size, kind, size, sizeof size); format_time(st.st_mtime, when, sizeof when);
GtkTreeIter it; gtk_list_store_append(local_store, &it);
gtk_list_store_set(local_store, &it, C_NAME, names->pdata[i], C_TIME, when, C_TYPE, kind_name(kind), C_SIZE, size, C_PATH, full, C_KIND, kind, -1);
}
g_free(full);
}
g_ptr_array_free(names, TRUE);
}
static void request_remote(const char *path) { char cmd[2100]; snprintf(cmd, sizeof cmd, "ls\t%s", path); push(cmd); }
static void on_local_up(GtkButton *b, gpointer d) { (void)b; (void)d; char *p = g_path_get_dirname(local_dir); load_local(p); g_free(p); }
static void on_local_refresh(GtkButton *b, gpointer d) { (void)b; (void)d; load_local(local_dir); }
static void on_local_path(GtkEntry *e, gpointer d) { (void)d; load_local(gtk_entry_get_text(e)); }
static void on_remote_up(GtkButton *b, gpointer d) {
(void)b; (void)d;
if (!strcmp(remote_dir, ":/") || !strcmp(remote_dir, "/")) { request_remote(":/"); return; }
char *p = g_path_get_dirname(remote_dir); request_remote(p); g_free(p);
}
static void on_remote_refresh(GtkButton *b, gpointer d) { (void)b; (void)d; request_remote(remote_dir); }
static void on_remote_path(GtkEntry *e, gpointer d) { (void)d; request_remote(gtk_entry_get_text(e)); }
static void on_row_activated(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColumn *col, gpointer remote) {
(void)col; GtkTreeModel *m = gtk_tree_view_get_model(view); GtkTreeIter it; char *full; int kind;
if (!gtk_tree_model_get_iter(m, &it, path)) return;
gtk_tree_model_get(m, &it, C_PATH, &full, C_KIND, &kind, -1);
if (kind != 4) { if (remote) request_remote(full); else load_local(full); }
g_free(full);
}
static char *ask_name(const char *title) {
GtkWidget *dlg = gtk_dialog_new_with_buttons(title, GTK_WINDOW(window), GTK_DIALOG_MODAL, "取消", GTK_RESPONSE_CANCEL, "确定", GTK_RESPONSE_OK, NULL);
GtkWidget *entry = gtk_entry_new(); gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);
gtk_dialog_set_default_response(GTK_DIALOG(dlg), GTK_RESPONSE_OK);
GtkWidget *area = gtk_dialog_get_content_area(GTK_DIALOG(dlg)); gtk_container_set_border_width(GTK_CONTAINER(area), 16);
gtk_box_pack_start(GTK_BOX(area), entry, FALSE, FALSE, 0); gtk_widget_show_all(dlg);
char *name = NULL;
if (gtk_dialog_run(GTK_DIALOG(dlg)) == GTK_RESPONSE_OK) {
const char *t = gtk_entry_get_text(GTK_ENTRY(entry));
if (*t && !strchr(t, '/') && strcmp(t, ".") && strcmp(t, "..")) name = g_strdup(t); else if (*t) show_toast("名称无效");
}
gtk_widget_destroy(dlg);
return name;
}
static void on_local_mkdir(GtkButton *b, gpointer d) {
(void)b; (void)d; char *name = ask_name("新建文件夹"); if (!name) return;
char *full = g_build_filename(local_dir, name, NULL);
if (mkdir(full, 0755) != 0) show_toast("无法创建文件夹"); else load_local(local_dir);
g_free(full); g_free(name);
}
static void on_remote_mkdir(GtkButton *b, gpointer d) {
(void)b; (void)d;
if (!strcmp(remote_dir, ":/")) { show_toast("请先进入一个文件夹"); return; }
char *name = ask_name("新建文件夹"); if (!name) return;
char *full = g_build_filename(remote_dir, name, NULL); char cmd[2200];
snprintf(cmd, sizeof cmd, "mkdir\t%s", full); push(cmd); g_free(full); g_free(name);
}
/* Each selected row becomes one queued transfer. Remote folders download recursively; local folders
* are not supported by the upload RPC sequence implemented here. */
static void on_send(GtkButton *b, gpointer upload) {
(void)b; GtkTreeView *view = GTK_TREE_VIEW(upload ? local_view : remote_view);
GtkTreeModel *m; GList *rows = gtk_tree_selection_get_selected_rows(gtk_tree_view_get_selection(view), &m);
if (!rows) { show_toast("请先选择要发送的文件"); return; }
if (upload && !strcmp(remote_dir, ":/")) { show_toast("请先在远端进入目标文件夹"); g_list_free_full(rows, (GDestroyNotify)gtk_tree_path_free); return; }
int skipped = 0;
for (GList *r = rows; r; r = r->next) {
GtkTreeIter it; char *full, *name; int kind;
if (!gtk_tree_model_get_iter(m, &it, r->data)) continue;
gtk_tree_model_get(m, &it, C_PATH, &full, C_NAME, &name, C_KIND, &kind, -1);
char cmd[4096];
if (upload && kind != 4) skipped++;
else if (!upload && kind == 3) skipped++;
else {
if (upload) snprintf(cmd, sizeof cmd, "put\t%s\t%s", full, remote_dir);
else snprintf(cmd, sizeof cmd, "get\t%s\t%s", full, local_dir);
push(cmd);
}
g_free(full); g_free(name);
}
g_list_free_full(rows, (GDestroyNotify)gtk_tree_path_free);
if (skipped) show_toast(upload ? "暂不支持上传文件夹,已跳过" : "不能下载整个磁盘,已跳过");
}
static void on_cancel_all(GtkButton *b, gpointer d) { (void)b; (void)d; push("cancel"); }
static void on_clear_done(GtkButton *b, gpointer d) {
(void)b; (void)d; GtkTreeIter it; gboolean ok = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(task_store), &it);
while (ok) { int done; gtk_tree_model_get(GTK_TREE_MODEL(task_store), &it, T_DONE, &done, -1);
ok = done ? gtk_list_store_remove(task_store, &it) : gtk_tree_model_iter_next(GTK_TREE_MODEL(task_store), &it); }
}
static GtkWidget *pane(int remote) {
GtkWidget *card = vbox(6); add_class(card, "card");
GtkWidget *bar = hbox(6), *up = button("↑", NULL), *refresh = button("刷新", NULL), *mk = button("新建文件夹", NULL), *path = gtk_entry_new();
gtk_widget_set_tooltip_text(up, "上一级"); gtk_widget_set_tooltip_text(refresh, "刷新");
gtk_box_pack_start(GTK_BOX(bar), up, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(bar), refresh, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(bar), mk, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(bar), path, TRUE, TRUE, 0);
GtkListStore *store = gtk_list_store_new(C_N, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
GtkWidget *view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
add_column(view, "名称", C_NAME, 1); add_column(view, "修改日期", C_TIME, 0); add_column(view, "类型", C_TYPE, 0); add_column(view, "大小", C_SIZE, 0);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(view)), GTK_SELECTION_MULTIPLE);
g_signal_connect(view, "row-activated", G_CALLBACK(on_row_activated), GINT_TO_POINTER(remote));
g_signal_connect(up, "clicked", G_CALLBACK(remote ? on_remote_up : on_local_up), NULL);
g_signal_connect(refresh, "clicked", G_CALLBACK(remote ? on_remote_refresh : on_local_refresh), NULL);
g_signal_connect(mk, "clicked", G_CALLBACK(remote ? on_remote_mkdir : on_local_mkdir), NULL);
g_signal_connect(path, "activate", G_CALLBACK(remote ? on_remote_path : on_local_path), NULL);
gtk_box_pack_start(GTK_BOX(card), bar, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(card), scrolled(view, 300), TRUE, TRUE, 0);
if (remote) { remote_store = store; remote_view = view; remote_path = path; }
else { local_store = store; local_view = view; local_path = path; }
return card;
}
static void build_files(void) {
GtkWidget *content; frame("文件传输", &content);
gtk_window_set_default_size(GTK_WINDOW(window), 1100, 760);
GtkWidget *head = gtk_grid_new(); gtk_grid_set_column_homogeneous(GTK_GRID(head), TRUE); gtk_grid_set_column_spacing(GTK_GRID(head), 24);
GtkWidget *left = hbox(10), *right = hbox(10);
char host[256]; if (gethostname(host, sizeof host) != 0) snprintf(host, sizeof host, "本机"); host[sizeof host - 1] = 0;
GtkWidget *tag_l = label("本机", "tag"), *tag_r = label("远端", "tag"); add_class(tag_r, "remote");
GtkWidget *send_r = button("发送 →", NULL), *send_l = button("← 发送", NULL);
g_signal_connect(send_r, "clicked", G_CALLBACK(on_send), GINT_TO_POINTER(1));
g_signal_connect(send_l, "clicked", G_CALLBACK(on_send), NULL);
gtk_box_pack_start(GTK_BOX(left), label(host, "title"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(left), tag_l, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(left), send_r, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(right), send_l, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(right), label(remote_name, "title"), FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(right), tag_r, FALSE, FALSE, 0);
gtk_grid_attach(GTK_GRID(head), left, 0, 0, 1, 1); gtk_grid_attach(GTK_GRID(head), right, 1, 0, 1, 1);
gtk_grid_attach(GTK_GRID(head), pane(0), 0, 1, 1, 1); gtk_grid_attach(GTK_GRID(head), pane(1), 1, 1, 1, 1);
gtk_grid_set_row_spacing(GTK_GRID(head), 14);
gtk_box_pack_start(GTK_BOX(content), head, TRUE, TRUE, 0);
GtkWidget *tasks = vbox(8); add_class(tasks, "card");
GtkWidget *tbar = hbox(8), *cancel = button("全部取消", NULL), *clear = button("清除完结任务", NULL);
g_signal_connect(cancel, "clicked", G_CALLBACK(on_cancel_all), NULL); g_signal_connect(clear, "clicked", G_CALLBACK(on_clear_done), NULL);
gtk_box_pack_start(GTK_BOX(tbar), label("传输列表", "section"), FALSE, FALSE, 4);
gtk_box_pack_end(GTK_BOX(tbar), clear, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(tbar), cancel, FALSE, FALSE, 0);
task_store = gtk_list_store_new(T_N, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
GtkWidget *tview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(task_store));
add_column(tview, "名称", T_NAME, 1); add_column(tview, "状态", T_STATUS, 0); add_column(tview, "大小", T_SIZE, 0);
add_column(tview, "发送路径", T_FROM, 1); add_column(tview, "接收路径", T_TO, 1);
gtk_box_pack_start(GTK_BOX(tasks), tbar, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(tasks), scrolled(tview, 180), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(content), tasks, TRUE, TRUE, 0);
const char *home = g_get_home_dir(); load_local(home ? home : "/");
gtk_entry_set_text(GTK_ENTRY(remote_path), "此电脑");
}
struct listing { char *path; char *rows; };
static gboolean remote_idle(gpointer d) {
struct listing *l = d;
snprintf(remote_dir, sizeof remote_dir, "%s", l->path);
gtk_entry_set_text(GTK_ENTRY(remote_path), strcmp(remote_dir, ":/") ? remote_dir : "此电脑");
gtk_list_store_clear(remote_store);
char **lines = g_strsplit(l->rows, "\n", -1);
for (char **line = lines; *line; line++) {
char **f = g_strsplit(*line, "\t", 5);
if (g_strv_length(f) == 5) {
int kind = atoi(f[0]); char size[32], when[64];
format_size(g_ascii_strtoull(f[2], NULL, 10), kind, size, sizeof size); format_time(g_ascii_strtoull(f[3], NULL, 10), when, sizeof when);
GtkTreeIter it; gtk_list_store_append(remote_store, &it);
gtk_list_store_set(remote_store, &it, C_NAME, f[1], C_TIME, when, C_TYPE, kind_name(kind), C_SIZE, size, C_PATH, f[4], C_KIND, kind, -1);
}
g_strfreev(f);
}
g_strfreev(lines); g_free(l->path); g_free(l->rows); g_free(l);
return G_SOURCE_REMOVE;
}
/* rows: "kind\tname\tsize\tmodified\tpath\n" */
void uu_files_ui_set_remote(const char *path, const char *rows) {
struct listing *l = g_new0(struct listing, 1); l->path = g_strdup(path); l->rows = g_strdup(rows); g_idle_add(remote_idle, l);
}
struct task { int id, done; char *name, *status, *size, *from, *to; };
static gboolean task_idle(gpointer d) {
struct task *t = d; GtkTreeIter it; gboolean ok = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(task_store), &it), found = FALSE;
while (ok) { int id; gtk_tree_model_get(GTK_TREE_MODEL(task_store), &it, T_ID, &id, -1); if (id == t->id) { found = TRUE; break; } ok = gtk_tree_model_iter_next(GTK_TREE_MODEL(task_store), &it); }
if (!found) { gtk_list_store_append(task_store, &it); gtk_list_store_set(task_store, &it, T_ID, t->id, T_NAME, t->name, -1); }
gtk_list_store_set(task_store, &it, T_STATUS, t->status, T_SIZE, t->size, T_FROM, t->from, T_TO, t->to, T_DONE, t->done, -1);
g_free(t->name); g_free(t->status); g_free(t->size); g_free(t->from); g_free(t->to); g_free(t);
return G_SOURCE_REMOVE;
}
/* total == 0 means unknown size; done: 0 running/queued, 1 finished (success), 2 finished (failed/canceled). */
void uu_files_ui_task(int id, const char *name, const char *status, unsigned long long transferred, unsigned long long total, const char *from, const char *to, int done) {
struct task *t = g_new0(struct task, 1); char a[32], b[32];
t->id = id; t->done = done;
format_size(transferred, 4, a, sizeof a); format_size(total, 4, b, sizeof b);
t->name = g_strdup(name); t->status = g_strdup(status); t->from = g_strdup(from); t->to = g_strdup(to);
t->size = total ? g_strdup_printf("%s / %s", a, b) : g_strdup(transferred ? a : "--");
g_idle_add(task_idle, t);
}
static gboolean refresh_local_idle(gpointer d) { (void)d; load_local(local_dir); return G_SOURCE_REMOVE; }
void uu_files_ui_refresh_local(void) { g_idle_add(refresh_local_idle, NULL); }
/* ---------------- port mapping ---------------- */
enum { P_ID, P_NAME, P_LOCAL, P_TARGET, P_STATUS, P_N };
static GtkListStore *rule_store;
static GtkWidget *rule_stack;
static void on_add_rule(GtkButton *b, gpointer d) {
(void)b; (void)d;
GtkWidget *dlg = gtk_dialog_new_with_buttons("添加映射规则", GTK_WINDOW(window), GTK_DIALOG_MODAL, "取消", GTK_RESPONSE_CANCEL, "保存后立即启用", GTK_RESPONSE_OK, NULL);
GtkWidget *grid = gtk_grid_new(); gtk_grid_set_row_spacing(GTK_GRID(grid), 12); gtk_grid_set_column_spacing(GTK_GRID(grid), 24);
gtk_container_set_border_width(GTK_CONTAINER(grid), 20);
const char *labels[] = {"名称", "本地端口", "目标地址", "目标端口"}, *hints[] = {"名称", "请输入端口", "", "请输入端口"};
GtkWidget *entries[4];
for (int i = 0; i < 4; i++) {
entries[i] = gtk_entry_new(); gtk_entry_set_placeholder_text(GTK_ENTRY(entries[i]), hints[i]); gtk_widget_set_hexpand(entries[i], TRUE);
gtk_grid_attach(GTK_GRID(grid), label(labels[i], NULL), 0, i, 1, 1); gtk_grid_attach(GTK_GRID(grid), entries[i], 1, i, 1, 1);
}
gtk_entry_set_text(GTK_ENTRY(entries[2]), "127.0.0.1");
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dlg))), grid, TRUE, TRUE, 0);
gtk_window_set_default_size(GTK_WINDOW(dlg), 480, -1); gtk_widget_show_all(dlg);
while (gtk_dialog_run(GTK_DIALOG(dlg)) == GTK_RESPONSE_OK) {
const char *name = gtk_entry_get_text(GTK_ENTRY(entries[0])), *host = gtk_entry_get_text(GTK_ENTRY(entries[2]));
char *end; long local = strtol(gtk_entry_get_text(GTK_ENTRY(entries[1])), &end, 10); int bad_local = *end || local < 0 || local > 65535;
long port = strtol(gtk_entry_get_text(GTK_ENTRY(entries[3])), &end, 10); int bad_port = *end || port < 1 || port > 65535;
if (!*name || strchr(name, '\t') || !*host || strchr(host, '\t') || bad_local || bad_port) { show_toast("请填写名称、有效端口和目标地址"); continue; }
char cmd[1024]; snprintf(cmd, sizeof cmd, "add\t%s\t%ld\t%s\t%ld", name, local, host, port); push(cmd);
break;
}
gtk_widget_destroy(dlg);
}
static void on_remove_rule(GtkButton *b, gpointer view) {
(void)b; GtkTreeModel *m; GtkTreeIter it;
if (!gtk_tree_selection_get_selected(gtk_tree_view_get_selection(view), &m, &it)) { show_toast("请先选择一条规则"); return; }
int id; gtk_tree_model_get(m, &it, P_ID, &id, -1); char cmd[64]; snprintf(cmd, sizeof cmd, "remove\t%d", id); push(cmd);
}
static void build_portmap(void) {
GtkWidget *content; frame("端口映射", &content);
gtk_window_set_default_size(GTK_WINDOW(window), 820, 560);
GtkWidget *head = hbox(12), *add = button("添加规则", "primary"), *del = button("删除", NULL);
GtkWidget *dot = label("● 已连接", "online");
gtk_box_pack_start(GTK_BOX(head), label(remote_name, "title"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(head), dot, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(head), add, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(head), del, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(content), head, FALSE, FALSE, 0);
rule_store = gtk_list_store_new(P_N, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
GtkWidget *view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(rule_store));
add_column(view, "名称", P_NAME, 1); add_column(view, "本地地址", P_LOCAL, 0); add_column(view, "目标地址", P_TARGET, 1); add_column(view, "状态", P_STATUS, 0);
rule_stack = gtk_stack_new();
GtkWidget *empty = label("当前没有端口映射规则,点击「添加规则」把远端端口映射到本机", "empty"); gtk_widget_set_halign(empty, GTK_ALIGN_CENTER);
gtk_stack_add_named(GTK_STACK(rule_stack), empty, "empty");
gtk_stack_add_named(GTK_STACK(rule_stack), scrolled(view, 360), "list");
GtkWidget *card = vbox(0); add_class(card, "card"); gtk_box_pack_start(GTK_BOX(card), rule_stack, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(content), card, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(content), label("本地端口只监听 127.0.0.1;本地端口填 0 时自动分配。", "empty"), FALSE, FALSE, 0);
g_signal_connect(add, "clicked", G_CALLBACK(on_add_rule), NULL);
g_signal_connect(del, "clicked", G_CALLBACK(on_remove_rule), view);
}
static gboolean rules_idle(gpointer d) {
char *rows = d; gtk_list_store_clear(rule_store); int n = 0;
char **lines = g_strsplit(rows, "\n", -1);
for (char **line = lines; *line; line++) {
char **f = g_strsplit(*line, "\t", 5);
if (g_strv_length(f) == 5) { GtkTreeIter it; gtk_list_store_append(rule_store, &it);
gtk_list_store_set(rule_store, &it, P_ID, atoi(f[0]), P_NAME, f[1], P_LOCAL, f[2], P_TARGET, f[3], P_STATUS, f[4], -1); n++; }
g_strfreev(f);
}
g_strfreev(lines); g_free(rows);
gtk_stack_set_visible_child_name(GTK_STACK(rule_stack), n ? "list" : "empty");
return G_SOURCE_REMOVE;
}
/* rows: "id\tname\tlocal\ttarget\tstatus\n" */
void uu_portmap_ui_set_rules(const char *rows) { g_idle_add(rules_idle, g_strdup(rows)); }
/* ---------------- terminal sessions ---------------- */
enum { S_ID, S_SHELL, S_TIME, S_STATE, S_N };
static GtkListStore *session_store;
static GtkWidget *session_view, *session_stack, *session_dot, *session_create, *session_kill;
static guint selected_session(void) {
GtkTreeModel *m; GtkTreeIter it; guint id = 0;
if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(session_view)), &m, &it)) gtk_tree_model_get(m, &it, S_ID, &id, -1);
return id;
}
static void on_create_session(GtkButton *b, gpointer d) { (void)b; (void)d; push("create"); }
static void on_open_session(GtkTreeView *v, GtkTreePath *path, GtkTreeViewColumn *col, gpointer d) {
(void)col; (void)d; GtkTreeIter it; guint id;
if (!gtk_widget_get_sensitive(GTK_WIDGET(v)) || !gtk_tree_model_get_iter(GTK_TREE_MODEL(session_store), &it, path)) return;
gtk_tree_model_get(GTK_TREE_MODEL(session_store), &it, S_ID, &id, -1);
char cmd[64]; snprintf(cmd, sizeof cmd, "open\t%u", id); push(cmd);
}
static void on_kill_session(GtkButton *b, gpointer d) {
(void)b; (void)d; guint id = selected_session();
if (!id) { show_toast("请先选择一个会话"); return; }
GtkWidget *dlg = gtk_message_dialog_new(GTK_WINDOW(window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE, "确定结束会话 %u?", id);
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dlg), "会话内正在运行的程序将被终止。");
gtk_dialog_add_buttons(GTK_DIALOG(dlg), "取消", GTK_RESPONSE_CANCEL, "结束会话", GTK_RESPONSE_OK, NULL);
gtk_dialog_set_default_response(GTK_DIALOG(dlg), GTK_RESPONSE_CANCEL);
if (gtk_dialog_run(GTK_DIALOG(dlg)) == GTK_RESPONSE_OK) { char cmd[64]; snprintf(cmd, sizeof cmd, "kill\t%u", id); push(cmd); }
gtk_widget_destroy(dlg);
}
static void build_terminal(void) {
GtkWidget *content; frame("终端远控", &content); gtk_window_set_default_size(GTK_WINDOW(window), 820, 560);
GtkWidget *head = hbox(12); session_dot = label("● 正在读取会话", "online");
session_create = button("创建会话", "primary"); session_kill = button("结束会话", NULL);
gtk_box_pack_start(GTK_BOX(head), label(remote_name, "title"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(head), session_dot, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(head), session_create, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(head), session_kill, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(content), head, FALSE, FALSE, 0);
session_store = gtk_list_store_new(S_N, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
session_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(session_store));
add_column(session_view, "会话 ID", S_ID, 0); add_column(session_view, "Shell", S_SHELL, 1);
add_column(session_view, "创建时间", S_TIME, 0); add_column(session_view, "状态", S_STATE, 0);
session_stack = gtk_stack_new();
GtkWidget *empty = label("当前无正在运行的终端会话", "empty"); gtk_widget_set_halign(empty, GTK_ALIGN_CENTER);
gtk_stack_add_named(GTK_STACK(session_stack), empty, "empty");
gtk_stack_add_named(GTK_STACK(session_stack), label("正在读取会话…", "empty"), "loading");
gtk_stack_add_named(GTK_STACK(session_stack), label("连接已断开,请关闭窗口后重试", "empty"), "offline");
gtk_stack_add_named(GTK_STACK(session_stack), scrolled(session_view, 360), "list");
gtk_stack_set_visible_child_name(GTK_STACK(session_stack), "loading");
gtk_box_pack_start(GTK_BOX(content), session_stack, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(content), label("双击接回会话;创建会话将在本机终端程序中打开。", "empty"), FALSE, FALSE, 0);
gtk_widget_set_sensitive(session_create, FALSE); gtk_widget_set_sensitive(session_kill, FALSE);
g_signal_connect(session_create, "clicked", G_CALLBACK(on_create_session), NULL);
g_signal_connect(session_kill, "clicked", G_CALLBACK(on_kill_session), NULL);
g_signal_connect(session_view, "row-activated", G_CALLBACK(on_open_session), NULL);
}
struct sessions { char *rows; int connected; };
static gboolean sessions_idle(gpointer d) {
struct sessions *s = d;
if (atomic_load(&closed)) { g_free(s->rows); g_free(s); return G_SOURCE_REMOVE; }
guint selected = selected_session(); gtk_list_store_clear(session_store); int n = 0;
char **lines = g_strsplit(s->rows, "\n", -1);
for (char **line = lines; *line; line++) {
char **f = g_strsplit(*line, "\t", 4);
if (g_strv_length(f) == 4) {
guint id = (guint)g_ascii_strtoull(f[0], NULL, 10); GtkTreeIter it; char date[64] = "--";
gint64 ms = g_ascii_strtoll(f[2], NULL, 10);
GDateTime *time = ms > 0 ? g_date_time_new_from_unix_local(ms / 1000) : NULL;
if (time) { char *text = g_date_time_format(time, "%Y-%m-%d %H:%M:%S"); g_strlcpy(date, text, sizeof date); g_free(text); g_date_time_unref(time); }
gtk_list_store_append(session_store, &it);
gtk_list_store_set(session_store, &it, S_ID, id, S_SHELL, f[1], S_TIME, date, S_STATE, f[3], -1); n++;
if (id == selected) gtk_tree_selection_select_iter(gtk_tree_view_get_selection(GTK_TREE_VIEW(session_view)), &it);
}
g_strfreev(f);
}
g_strfreev(lines);
gtk_label_set_text(GTK_LABEL(session_dot), s->connected ? "● 已连接" : "● 已断开");
gtk_widget_set_sensitive(session_create, s->connected); gtk_widget_set_sensitive(session_kill, s->connected);
gtk_widget_set_sensitive(session_view, s->connected);
gtk_stack_set_visible_child_name(GTK_STACK(session_stack), s->connected ? (n ? "list" : "empty") : "offline");
g_free(s->rows); g_free(s); return G_SOURCE_REMOVE;
}
/* rows: "id\tshell\tcreated_at_ms\tstate\n"; copied before returning to Rust. */
void uu_terminal_ui_set(const char *rows, int connected) {
struct sessions *s = g_new0(struct sessions, 1); s->rows = g_strdup(rows); s->connected = connected; g_idle_add(sessions_idle, s);
}
/* ---------------- startup ---------------- */
static char tool_kind[16];
static gboolean show_window(gpointer d) {
(void)d;
if (!window) {
if (!strcmp(tool_kind, "files")) build_files(); else if (!strcmp(tool_kind, "terminal")) build_terminal(); else build_portmap();
}
atomic_store(&closed, 0); gtk_widget_show_all(window); gtk_window_present(GTK_WINDOW(window));
pthread_mutex_lock(&init_lock); init_state = 1; pthread_cond_signal(&init_cond); pthread_mutex_unlock(&init_lock);
return G_SOURCE_REMOVE;
}
static void *ui_thread(void *d) {
(void)d;
if (!gtk_init_check(NULL, NULL)) { pthread_mutex_lock(&init_lock); init_state = -1; pthread_cond_signal(&init_cond); pthread_mutex_unlock(&init_lock); return NULL; }
show_window(NULL); gtk_main(); return NULL;
}
/* Hidden windows retain their widgets so queued idle callbacks stay valid. */
int uu_tools_ui_start(const char *kind, const char *name) {
static int started;
pthread_mutex_lock(&init_lock); if (init_state < 0) { pthread_mutex_unlock(&init_lock); return -1; } init_state = 0;
snprintf(tool_kind, sizeof tool_kind, "%s", kind); snprintf(remote_name, sizeof remote_name, "%s", name);
pthread_mutex_lock(&q_lock); q_head = q_len = 0; pthread_mutex_unlock(&q_lock);
if (!started) {
pthread_t t; if (pthread_create(&t, NULL, ui_thread, NULL) != 0) { pthread_mutex_unlock(&init_lock); return -1; }
pthread_detach(t); started = 1;
} else g_idle_add(show_window, NULL);
while (!init_state) pthread_cond_wait(&init_cond, &init_lock);
int s = init_state; pthread_mutex_unlock(&init_lock); return s == 1 ? 0 : -1;
}
static gboolean hide_window(gpointer d) { (void)d; if (window) gtk_widget_hide(window); atomic_store(&closed, 1); return G_SOURCE_REMOVE; }
void uu_tools_ui_hide(void) { g_idle_add(hide_window, NULL); }
void uu_tools_ui_present(void) { pthread_mutex_lock(&init_lock); if (init_state == 1) g_idle_add(show_window, NULL); pthread_mutex_unlock(&init_lock); }