// 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 #include #include #include #include #include #include #include #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; } gtk_window_set_default_icon_name("uu-remote-linux"); // same taskbar icon as the host (#13) // Light palette in CSS; keep a dark system theme from making unstyled text white on white (#43). g_object_set(gtk_settings_get_default(), "gtk-theme-name", "Adwaita", "gtk-application-prefer-dark-theme", FALSE, 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); }