@yufengtadian/freedom-cli 1.12.18 → 1.13.0

package/templates/go/pkg/freedom/tray_linux.go

@@ -0,0 +1,302 @@
+//go:build linux
+
+package freedom
+
+/*
+#cgo pkg-config: gtk+-3.0
+#cgo CFLAGS: -Wno-deprecated-declarations
+#include <gtk/gtk.h>
+
+extern void goTrayClick(void);
+extern void goTrayMenuItemActivate(int idx);
+
+// GtkStatusIcon 自 GTK3.14 起标记 deprecated，但 legacy tray 协议在 KDE/XFCE/
+// WSLg 仍广泛可用；AppIndicator(GDBus) 适配在未来自成一档。
+static int ensureGtk(void) { return gtk_init_check(NULL, NULL) ? 1 : 0; }
+
+static void onTrayActivate(GtkStatusIcon *icon, gpointer data) {
+	(void)icon; (void)data;
+	goTrayClick();
+}
+
+// 右键：弹出前端注册的菜单（popup-menu 信号），返回 TRUE 抑制默认行为。
+static gboolean onTrayPopupMenu(GtkStatusIcon *icon, guint button, guint activate_time, gpointer data) {
+	(void)button; (void)activate_time; (void)data;
+	GtkWidget *menu = (GtkWidget*) g_object_get_data(G_OBJECT(icon), "freedom-menu");
+	if (menu != NULL) gtk_menu_popup_at_pointer(GTK_MENU(menu), NULL);
+	return TRUE;
+}
+
+static void onMenuItemClick(GtkMenuItem *item, gpointer data) {
+	(void)item;
+	goTrayMenuItemActivate(GPOINTER_TO_INT(data));
+}
+
+static GtkStatusIcon* trayNewFromPng(const guint8 *png, gsize len) {
+	GdkPixbufLoader *loader = gdk_pixbuf_loader_new();
+	gboolean ok = gdk_pixbuf_loader_write(loader, png, len, NULL);
+	ok = ok && gdk_pixbuf_loader_close(loader, NULL);
+	GdkPixbuf *pb = ok ? gdk_pixbuf_loader_get_pixbuf(loader) : NULL;
+	GtkStatusIcon *icon = pb ? gtk_status_icon_new_from_pixbuf(pb) : NULL;
+	g_object_unref(loader);
+	if (icon == NULL) return NULL;
+	g_signal_connect(icon, "activate", G_CALLBACK(onTrayActivate), NULL);
+	g_signal_connect(icon, "popup-menu", G_CALLBACK(onTrayPopupMenu), NULL);
+	gtk_status_icon_set_visible(icon, TRUE);
+	return icon;
+}
+
+static GtkStatusIcon* trayNewNamed(const char *name) {
+	GtkStatusIcon *icon = gtk_status_icon_new_from_icon_name(name);
+	g_signal_connect(icon, "activate", G_CALLBACK(onTrayActivate), NULL);
+	g_signal_connect(icon, "popup-menu", G_CALLBACK(onTrayPopupMenu), NULL);
+	gtk_status_icon_set_visible(icon, TRUE);
+	return icon;
+}
+
+static void traySetTooltip(GtkStatusIcon *icon, const char *tip) {
+	gtk_status_icon_set_tooltip_text(icon, tip);
+}
+
+static void trayDestroy(GtkStatusIcon *icon) {
+	gtk_status_icon_set_visible(icon, FALSE);
+	g_object_unref(icon);
+}
+
+// 菜单所有权：attach 时 ref_sink + set_data_full，重复 attach 自动释放旧菜单。
+static void trayAttachMenu(GtkStatusIcon *icon, GtkWidget *menu) {
+	g_object_ref_sink(menu);
+	g_object_set_data_full(G_OBJECT(icon), "freedom-menu", menu, (GDestroyNotify) g_object_unref);
+	gtk_widget_show_all(menu);
+}
+
+static GtkWidget* menuNew(void) { return gtk_menu_new(); }
+
+static GtkWidget* menuSubmenu(GtkWidget *parent, const char *label) {
+	GtkWidget *item = gtk_menu_item_new_with_label(label);
+	GtkWidget *sub = gtk_menu_new();
+	gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), sub);
+	gtk_menu_shell_append(GTK_MENU_SHELL(parent), item);
+	return sub;
+}
+
+static void menuAppendItem(GtkWidget *menu, const char *label, int idx, gboolean sensitive) {
+	GtkWidget *item = gtk_menu_item_new_with_label(label);
+	gtk_widget_set_sensitive(item, sensitive);
+	g_signal_connect(item, "activate", G_CALLBACK(onMenuItemClick), GINT_TO_POINTER(idx));
+	gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
+}
+
+static void menuAppendCheck(GtkWidget *menu, const char *label, int idx, gboolean checked, gboolean sensitive) {
+	GtkWidget *item = gtk_check_menu_item_new_with_label(label);
+	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), checked);
+	gtk_widget_set_sensitive(item, sensitive);
+	g_signal_connect(item, "activate", G_CALLBACK(onMenuItemClick), GINT_TO_POINTER(idx));
+	gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
+}
+
+static void menuAppendSeparator(GtkWidget *menu) {
+	gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());
+}
+*/
+import "C"
+
+import (
+	"encoding/json"
+	"fmt"
+	"sync"
+	"unsafe"
+)
+
+// M4 Linux 托盘（GtkStatusIcon，cgo）：与 Windows 侧 trayCall 同一前端契约
+// （tray.create/destroy/tooltip/menu；事件 tray:click / tray:menu({id})）。
+// 限制：GtkStatusIcon 无双击信号（tray:double-click 不触发）；menu.set（主窗口
+// 原生菜单栏）与 GDBus StatusNotifierItem 适配未实装，托盘图标走 legacy
+// system tray 协议（KDE/xfce/wmctrl 系支持；GNOME 需 AppIndicator 扩展）。
+// GTK 调用须发生在 main线程：__freedom_tray 桥回调经 WebKit 消息处理器在
+// GTK main loop 线程执行，天然满足；单测须先 gtk_init_check 且有 DISPLAY。
+
+type linuxTrayState struct {
+	mu    sync.Mutex
+	icon  *C.GtkStatusIcon
+	items map[int32]string // 菜单条目序号 → 前端 id
+	emit  func(event string, data interface{})
+}
+
+var linuxTray = &linuxTrayState{items: map[int32]string{}}
+
+//export goTrayClick
+func goTrayClick() {
+	linuxTray.mu.Lock()
+	emit := linuxTray.emit
+	linuxTray.mu.Unlock()
+	if emit != nil {
+		emit("tray:click", map[string]interface{}{"button": "left"})
+	}
+}
+
+//export goTrayMenuItemActivate
+func goTrayMenuItemActivate(idx C.int) {
+	linuxTray.mu.Lock()
+	id := linuxTray.items[int32(idx)]
+	emit := linuxTray.emit
+	linuxTray.mu.Unlock()
+	if emit != nil {
+		emit("tray:menu", map[string]interface{}{"id": id})
+	}
+}
+
+// trayCall 处理前端 __freedom_tray 请求（Linux 实现，方法面与 Windows 对齐）。
+func (a *App) trayCall(method string, paramsJSON string) (result interface{}, err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			result = nil
+			err = fmt.Errorf("freedom: tray method %q panicked: %v", method, r)
+		}
+	}()
+
+	var args map[string]json.RawMessage
+	if len(paramsJSON) > 0 && paramsJSON != "null" {
+		if err := json.Unmarshal([]byte(paramsJSON), &args); err != nil {
+			return nil, fmt.Errorf("freedom: tray method %q: invalid args: %w", method, err)
+		}
+	}
+	argStr := func(k string) string {
+		if v, ok := args[k]; ok {
+			var s string
+			if json.Unmarshal(v, &s) == nil {
+				return s
+			}
+		}
+		return ""
+	}
+
+	switch method {
+	case "tray.create":
+		return nil, linuxTrayCreate(a, argStr("icon"), argStr("tooltip"))
+	case "tray.destroy":
+		linuxTrayDestroy()
+		return nil, nil
+	case "tray.tooltip":
+		linuxTray.mu.Lock()
+		icon := linuxTray.icon
+		linuxTray.mu.Unlock()
+		if icon == nil {
+			return nil, fmt.Errorf("tray: 托盘未创建")
+		}
+		tip := C.CString(argStr("tooltip"))
+		C.traySetTooltip(icon, tip)
+		C.free(unsafe.Pointer(tip))
+		return nil, nil
+	case "tray.menu":
+		linuxTray.mu.Lock()
+		icon := linuxTray.icon
+		linuxTray.mu.Unlock()
+		if icon == nil {
+			return nil, fmt.Errorf("tray: 托盘未创建")
+		}
+		var items []menuItem
+		if v, ok := args["items"]; ok {
+			if err := json.Unmarshal(v, &items); err != nil {
+				return nil, fmt.Errorf("tray: 菜单格式错误: %w", err)
+			}
+		}
+		linuxTraySetMenu(icon, items)
+		return nil, nil
+	case "menu.set":
+		return nil, fmt.Errorf("freedom: menu.set 在 linux 暂不支持（GTK 菜单栏待补）")
+	default:
+		return nil, fmt.Errorf("freedom: unknown tray method %q", method)
+	}
+}
+
+func linuxTrayCreate(a *App, iconDataURL, tooltip string) error {
+	if C.ensureGtk() == 0 {
+		return fmt.Errorf("freedom: 无可用显示服务（DISPLAY/Wayland），无法创建托盘")
+	}
+	png := dataURLToBytes(iconDataURL)
+	var icon *C.GtkStatusIcon
+	if len(png) > 0 {
+		icon = C.trayNewFromPng((*C.guint8)(unsafe.Pointer(&png[0])), C.gsize(len(png)))
+	} else {
+		name := C.CString("application-x-executable")
+		icon = C.trayNewNamed(name)
+		C.free(unsafe.Pointer(name))
+	}
+	if icon == nil {
+		return fmt.Errorf("freedom: 托盘图标创建失败（PNG 无法解析或无托盘协议支持）")
+	}
+	if tooltip != "" {
+		tip := C.CString(tooltip)
+		C.traySetTooltip(icon, tip)
+		C.free(unsafe.Pointer(tip))
+	}
+	linuxTray.mu.Lock()
+	old := linuxTray.icon
+	linuxTray.icon = icon
+	linuxTray.emit = a.Emit
+	linuxTray.mu.Unlock()
+	if old != nil {
+		C.trayDestroy(old)
+	}
+	return nil
+}
+
+func linuxTrayDestroy() {
+	linuxTray.mu.Lock()
+	icon := linuxTray.icon
+	linuxTray.icon = nil
+	linuxTray.items = map[int32]string{}
+	linuxTray.mu.Unlock()
+	if icon != nil {
+		C.trayDestroy(icon)
+	}
+}
+
+// linuxTraySetMenu 重建右键菜单并接管 icon 上的旧菜单释放（set_data_full）。
+func linuxTraySetMenu(icon *C.GtkStatusIcon, items []menuItem) {
+	linuxTray.mu.Lock()
+	linuxTray.items = map[int32]string{}
+	var next int32
+	assign := func(id string) int32 {
+		h := next
+		next++
+		linuxTray.items[h] = id
+		return h
+	}
+	var build func(menu *C.GtkWidget, list []menuItem)
+	build = func(menu *C.GtkWidget, list []menuItem) {
+		for _, it := range list {
+			label := C.CString(it.Label)
+			switch {
+			case it.Type == "separator":
+				C.menuAppendSeparator(menu)
+			case it.Type == "submenu" || len(it.Submenu) > 0:
+				sub := C.menuSubmenu(menu, label)
+				// 父条目无动作，仅展开；子条目递归编号。
+				assign(it.ID)
+				build(sub, it.Submenu)
+			default:
+				idx := assign(it.ID)
+				sensitive := C.gboolean(1)
+				if it.Enabled != nil && !*it.Enabled {
+					sensitive = 0
+				}
+				if it.Checked != nil {
+					checked := C.gboolean(0)
+					if *it.Checked {
+						checked = 1
+					}
+					C.menuAppendCheck(menu, label, C.int(idx), checked, sensitive)
+				} else {
+					C.menuAppendItem(menu, label, C.int(idx), sensitive)
+				}
+			}
+			C.free(unsafe.Pointer(label))
+		}
+	}
+	menu := C.menuNew()
+	build(menu, items)
+	C.trayAttachMenu(icon, menu)
+	linuxTray.mu.Unlock()
+}

package/templates/go/pkg/freedom/tray_other.go

@@ -1,10 +1,10 @@
-//go:build !windows
+//go:build !windows && !linux
 
 package freedom
 
 import "fmt"
 
-// trayCall 非 Windows 平台暂不提供系统托盘与原生菜单栏。
+// trayCall 非 Windows/Linux 平台暂不提供系统托盘与原生菜单栏。Linux 实装见 tray_linux.go（M4）。
 func (a *App) trayCall(method string, paramsJSON string) (interface{}, error) {
 	return nil, fmt.Errorf("freedom: tray method %q is not supported on this platform", method)
 }

package/templates/go/pkg/freedom/tray_windows.go

@@ -108,26 +108,18 @@ type notifyIconDataW struct {
 	HBalloonIcon     uintptr
 }
 
-// menuItem 描述一个托盘/菜单栏条目（JSON 透传）。
-type menuItem struct {
-	ID      string     `json:"id"`
-	Label   string     `json:"label"`
-	Type    string     `json:"type"`    // "item"（默认）/ "separator" / "submenu"
-	Enabled *bool      `json:"enabled"` // nil=默认启用
-	Checked *bool      `json:"checked"`
-	Submenu []menuItem `json:"submenu"`
-}
-
 // trayState 保存当前托盘实例（单窗口框架内为单例）。
 type trayState struct {
-	mu      sync.Mutex
-	hwnd    uintptr           // 隐藏消息窗口
-	menu    uintptr           // 右键 popup 菜单
-	menuBar uintptr           // 原生菜单栏 HMENU
-	items   map[uint32]string // menu id -> 前端 id
-	nextID  uint32
-	emit    func(event string, data interface{})
-	icon    uintptr // 当前托盘图标 HICON
+	mu         sync.Mutex
+	hwnd       uintptr           // 隐藏消息窗口
+	menu       uintptr           // 右键 popup 菜单
+	menuIDs    []uint32          // menu 占用的条目 id（重建时清理映射）
+	menuBar    uintptr           // 原生菜单栏 HMENU
+	menuBarIDs []uint32          // menuBar 占用的条目 id
+	items      map[uint32]string // menu id -> 前端 id
+	nextID     uint32
+	emit       func(event string, data interface{})
+	icon       uintptr // 当前托盘图标 HICON
 }
 
 var (
@@ -282,32 +274,41 @@ func trayShowMenu(ts *trayState) {
 }
 
 // buildMenu 递归构建 HMENU（用于托盘右键与菜单栏子菜单）。
-// 返回菜单句柄与 id 映射（追加到 ts.items）。
-func buildMenu(ts *trayState, items []menuItem) uintptr {
+// 返回菜单句柄与本次分配的全部条目 id（供整体替换时清理旧映射）。
+func buildMenu(ts *trayState, items []menuItem) (uintptr, []uint32) {
 	hMenu, _, _ := procCreatePopupMenu.Call()
 	if hMenu == 0 {
-		return 0
+		return 0, nil
 	}
-	appendMenuItems(ts, hMenu, items, false)
-	return hMenu
+	var ids []uint32
+	appendMenuItems(ts, hMenu, items, false, &ids)
+	return hMenu, ids
 }
 
-// appendMenuItems 把条目追加到指定菜单。
-func appendMenuItems(ts *trayState, hMenu uintptr, items []menuItem, isMenuBar bool) {
-	for i, it := range items {
+// appendMenuItems 把条目追加到指定菜单；新分配的 id 记入 *ids。
+func appendMenuItems(ts *trayState, hMenu uintptr, items []menuItem, isMenuBar bool, ids *[]uint32) {
+	for _, it := range items {
 		if it.Type == "separator" {
 			procAppendMenuW.Call(hMenu, mfSeparator, 0, 0)
 			continue
 		}
 		if it.Type == "submenu" || (isMenuBar && len(it.Submenu) > 0) {
-			sub := buildMenu(ts, it.Submenu)
+			label, err := syscall.UTF16PtrFromString(it.Label)
+			if err != nil {
+				continue // 标签含 NUL：跳过该条目
+			}
+			sub, subIDs := buildMenu(ts, it.Submenu)
 			if sub == 0 {
 				continue
 			}
-			label, _ := syscall.UTF16PtrFromString(it.Label)
+			*ids = append(*ids, subIDs...)
 			procAppendMenuW.Call(hMenu, mfPopup|mfEnabled, sub, uintptr(unsafe.Pointer(label)))
 			continue
 		}
+		label, err := syscall.UTF16PtrFromString(it.Label)
+		if err != nil {
+			continue // 标签含 NUL：跳过该条目（id 不消耗）
+		}
 		var flags uintptr = mfString | mfEnabled
 		if it.Checked != nil && *it.Checked {
 			flags |= mfChecked
@@ -315,46 +316,62 @@ func appendMenuItems(ts *trayState, hMenu uintptr, items []menuItem, isMenuBar b
 		if it.Enabled != nil && !*it.Enabled {
 			flags |= mfGrayed
 		}
+		ts.mu.Lock()
 		id := ts.nextID
 		ts.nextID++
-		ts.mu.Lock()
 		ts.items[id] = it.ID
 		ts.mu.Unlock()
-		label, _ := syscall.UTF16PtrFromString(it.Label)
-		if isMenuBar && i == 0 {
-			// 菜单栏首个条目用 MF_BYPOSITION 占位（顶层菜单由 SetMenu 接管）。
-		}
+		*ids = append(*ids, id)
 		procAppendMenuW.Call(hMenu, flags, uintptr(id), uintptr(unsafe.Pointer(label)))
 	}
 }
 
-// traySetMenu 设置托盘右键菜单（整体替换）。
+// traySetMenu 设置托盘右键菜单（整体替换，旧 id 映射随之清理）。
 func traySetMenu(ts *trayState, items []menuItem) {
 	ts.mu.Lock()
 	old := ts.menu
+	oldIDs := ts.menuIDs
 	ts.menu = 0
+	ts.menuIDs = nil
 	ts.mu.Unlock()
 	if old != 0 {
 		procDestroyMenu.Call(old)
 	}
+	releaseItemIDs(ts, oldIDs)
 	if len(items) == 0 {
 		return
 	}
-	h := buildMenu(ts, items)
+	h, ids := buildMenu(ts, items)
 	ts.mu.Lock()
 	ts.menu = h
+	ts.menuIDs = ids
 	ts.mu.Unlock()
 }
 
-// menuBarSet 设置主窗口原生菜单栏（整体替换）。
+// releaseItemIDs 从 id→前端 id 映射中移除一批条目（防重建后残留无主映射无限增长）。
+func releaseItemIDs(ts *trayState, ids []uint32) {
+	if len(ids) == 0 {
+		return
+	}
+	ts.mu.Lock()
+	for _, id := range ids {
+		delete(ts.items, id)
+	}
+	ts.mu.Unlock()
+}
+
+// menuBarSet 设置主窗口原生菜单栏（整体替换，旧 id 映射随之清理）。
 func menuBarSet(hwnd uintptr, ts *trayState, items []menuItem) {
 	ts.mu.Lock()
 	old := ts.menuBar
+	oldIDs := ts.menuBarIDs
 	ts.menuBar = 0
+	ts.menuBarIDs = nil
 	ts.mu.Unlock()
 	if old != 0 {
 		procDestroyMenu.Call(old)
 	}
+	releaseItemIDs(ts, oldIDs)
 	if len(items) == 0 {
 		procSetMenu.Call(hwnd, 0)
 		procDrawMenuBar.Call(hwnd)
@@ -364,13 +381,21 @@ func menuBarSet(hwnd uintptr, ts *trayState, items []menuItem) {
 	if hBar == 0 {
 		return
 	}
+	var ids []uint32
 	for _, top := range items {
-		label, _ := syscall.UTF16PtrFromString(top.Label)
 		if top.Type == "separator" {
 			continue
 		}
+		label, err := syscall.UTF16PtrFromString(top.Label)
+		if err != nil {
+			continue // 标签含 NUL：跳过该条目
+		}
 		if len(top.Submenu) > 0 {
-			sub := buildMenu(ts, top.Submenu)
+			sub, subIDs := buildMenu(ts, top.Submenu)
+			if sub == 0 {
+				continue
+			}
+			ids = append(ids, subIDs...)
 			procAppendMenuW.Call(hBar, mfPopup|mfEnabled, sub, uintptr(unsafe.Pointer(label)))
 		} else {
 			// 顶层无子菜单：视为可点击菜单项。
@@ -378,16 +403,18 @@ func menuBarSet(hwnd uintptr, ts *trayState, items []menuItem) {
 			if top.Checked != nil && *top.Checked {
 				flags |= mfChecked
 			}
+			ts.mu.Lock()
 			id := ts.nextID
 			ts.nextID++
-			ts.mu.Lock()
 			ts.items[id] = top.ID
 			ts.mu.Unlock()
+			ids = append(ids, id)
 			procAppendMenuW.Call(hBar, flags, uintptr(id), uintptr(unsafe.Pointer(label)))
 		}
 	}
 	ts.mu.Lock()
 	ts.menuBar = hBar
+	ts.menuBarIDs = ids
 	ts.mu.Unlock()
 	procSetMenu.Call(hwnd, hBar)
 	procDrawMenuBar.Call(hwnd)
@@ -413,6 +440,9 @@ func trayDestroy(ts *trayState) {
 		procDestroyMenu.Call(ts.menuBar)
 		ts.menuBar = 0
 	}
+	ts.menuIDs = nil
+	ts.menuBarIDs = nil
+	ts.items = map[uint32]string{} // 已持锁：直接重建映射，不留无主条目
 	if ts.icon != 0 {
 		procDestroyIcon.Call(ts.icon)
 		ts.icon = 0