@yufengtadian/freedom-cli 1.12.18 → 1.13.0

package/templates/go/pkg/freedom/center_windows.go

@@ -4,20 +4,22 @@ package freedom
 
 import (
 	"unsafe"
+
+	webview "github.com/webview/webview_go"
 )
 
 const (
-	smCxScreen           = 16
-	smCyScreen           = 17
-	monitorDefaultToNear = 2 // MONITOR_DEFAULTTONEAREST
+	smCxScreen = 16
+	smCyScreen = 17
+
+	monitorDefaultTonearest = 2 // MONITOR_DEFAULTTONEAREST
 )
 
+// rect / monitorInfo 对应 Win32 的 RECT 与 MONITORINFO 结构。
 type rect struct {
 	left, top, right, bottom int32
 }
 
-// monitorInfo 对应 Win32 MONITORINFO（cbSize 置 0 时用 struct 大小填充，
-// 32 位下与 64 位下布局一致，字段对齐与 cbSize 校验兼容）。
 type monitorInfo struct {
 	cbSize    uint32
 	rcMonitor rect
@@ -25,55 +27,63 @@ type monitorInfo struct {
 	dwFlags   uint32
 }
 
-// applyCenter 在 Windows 上把窗口置于屏幕中央（需在 SetSize 之后调用）。
+// applyCenter 在 Windows 上把窗口置于所在显示器的工作区中央（需在 SetSize 之后调用）。
 // webview_go 未提供 SetPosition，这里通过原生 HWND + MoveWindow 定位。
-// 优先居中到窗口当前所在监视器的工作区（rcWork）：多屏副屏（负坐标 /
-// 不同分辨率 / 任务栏遮挡）下也能正确居中；API 失败时回退主屏全屏居中。
-//
-// user32 过程句柄（procGetSystemMetrics / procMoveWindow / procMonitorFromWindow /
-// procGetMonitorInfo）统一声明在 window_windows.go，避免两套重复 NewProc。
+// 使用 MonitorFromWindow + GetMonitorInfo：多显示器下相对窗口实际所在屏幕居中，
+// 且基于工作区（扣除任务栏）计算，不会遮挡任务栏；查询失败时回退主屏全屏尺寸估算。
 func (a *App) applyCenter() {
 	if !a.cfg.Center {
 		return
 	}
-	hwnd := a.WindowHandle()
+	// 与 Emit/Quit/WindowHandle 一致经 withView 访问，维持 view 字段的并发约定。
+	a.withView(func(view webview.WebView) {
+		if hwnd := uintptr(view.Window()); hwnd != 0 {
+			a.centerHWND(hwnd)
+		}
+	})
+}
+
+// centerHWND 把指定原生窗口按其所在显示器工作区居中（M2：次级窗口复用）。
+// 尺寸用窗口当前外框（次级窗口尺寸可能与主窗口配置不同）。
+func (a *App) centerHWND(hwnd uintptr) {
 	if hwnd == 0 {
 		return
 	}
-	mon, _, _ := procMonitorFromWindow.Call(hwnd, monitorDefaultToNear)
-	if mon != 0 {
+	var r rect
+	if rr, _, _ := procGetWindowRect.Call(hwnd, uintptr(unsafe.Pointer(&r))); rr == 0 {
+		return
+	}
+	x, y := centeredForWindow(hwnd, int(r.right-r.left), int(r.bottom-r.top))
+	procMoveWindow.Call(hwnd, uintptr(x), uintptr(y), uintptr(r.right-r.left), uintptr(r.bottom-r.top), 1)
+}
+
+// centeredForWindow 供运行时 window.center 动作使用：以窗口当前实际外框尺寸
+// （而非 Config 初始尺寸）在所在显示器工作区居中。
+func centeredForWindow(hwnd uintptr, w, h int) (int, int) {
+	if mon, _, _ := procMonitorFromWindow.Call(hwnd, monitorDefaultTonearest); mon != 0 {
 		var mi monitorInfo
 		mi.cbSize = uint32(unsafe.Sizeof(mi))
-		if r1, _, _ := procGetMonitorInfo.Call(mon, uintptr(unsafe.Pointer(&mi))); r1 != 0 {
-			work := mi.rcWork
-			sw := int(work.right - work.left)
-			sh := int(work.bottom - work.top)
-			// M5：窗口居中坐标双向 clamp。逻辑抽到 clampCentered 便于无头单测。
-			x, y := clampCentered(a.cfg.Width, a.cfg.Height, int(work.left), int(work.top), sw, sh)
-			procMoveWindow.Call(hwnd, uintptr(x), uintptr(y), uintptr(a.cfg.Width), uintptr(a.cfg.Height), 1)
-			return
+		if r, _, _ := procGetMonitorInfo.Call(mon, uintptr(unsafe.Pointer(&mi))); r != 0 {
+			return centeredInRect(int(mi.rcWork.left), int(mi.rcWork.top),
+				int(mi.rcWork.right-mi.rcWork.left), int(mi.rcWork.bottom-mi.rcWork.top), w, h)
 		}
 	}
-	// 回退：主屏全屏尺寸居中（M5 同双向 clamp，上界不小于下界 0）
 	sw, _, _ := procGetSystemMetrics.Call(smCxScreen)
 	sh, _, _ := procGetSystemMetrics.Call(smCyScreen)
-	// 主屏全屏居中：等价于左上 (0,0) 的工作区，同走 clampCentered 双向 clamp。
-	x, y := clampCentered(a.cfg.Width, a.cfg.Height, 0, 0, int(sw), int(sh))
-	procMoveWindow.Call(hwnd, uintptr(x), uintptr(y), uintptr(a.cfg.Width), uintptr(a.cfg.Height), 1)
+	return centeredInRect(0, 0, int(sw), int(sh), w, h)
 }
 
-// clampCentered 计算窗口在其所在工作区内的居中左上角坐标，并做双向 clamp：
-// 窗口小于工作区时严格居中；窗口大于工作区时贴左上缘，保证窗口整体落在
-// 工作区内、可被拖拽恢复（M5——此前只 clamp 下界，窗口超屏时上界 work.right-w
-// 越过下界 work.left，上下界互打架会把坐标钳回负值；现上界不小于下界）。
-func clampCentered(winW, winH, left, top, workW, workH int) (int, int) {
-	x := left + (workW-winW)/2
-	y := top + (workH-winH)/2
-	upperX := left + workW - winW
+// centeredInRect 在矩形 (left,top,ww,wh) 内居中 w×h，双向 clamp 保证整体落入矩形。
+func centeredInRect(left, top, ww, wh, w, h int) (int, int) {
+	x := left + (ww-w)/2
+	y := top + (wh-h)/2
+	// 上界不得小于下界：窗口大于工作区时 left+ww-w 会越过 left，
+	// 上下界互打架会把坐标钳回负值。此时贴左上缘即可。
+	upperX := left + ww - w
 	if upperX < left {
 		upperX = left
 	}
-	upperY := top + workH - winH
+	upperY := top + wh - h
 	if upperY < top {
 		upperY = top
 	}

package/templates/go/pkg/freedom/dispatch.go

@@ -0,0 +1,60 @@
+package freedom
+
+import (
+	"encoding/json"
+	"strconv"
+
+	webview "github.com/webview/webview_go"
+)
+
+// M1 异步桥接：前端 __freedom_bridge(id, method, params) 只做投递，handler 在
+// worker goroutine 中执行（不再占 UI 线程消息泵），结果经 __freedom__resolve
+// 回写前端 pending Promise。并发契约：不同/相同方法的调用之间可并发执行，
+// 完成顺序不保证——与 Tauri command / Electron IPC 同语义。
+// window/sys/tray 内置桥保持同步（原生操作快、模态对话框语义本就需要泵）。
+
+// bridgeAsync 是 __freedom_bridge 的绑定入口，立即返回。
+func (a *App) bridgeAsync(id float64, method string, paramsJSON string) {
+	a.dispatchBridge(id, method, paramsJSON, a.pushResolve)
+}
+
+// dispatchBridge 把一次桥接调用投进 goroutine，完成时把回写脚本交给 onDone。
+// onDone 参数即测试缝：单测注入捕获函数验证时序，无需真实 webview。
+func (a *App) dispatchBridge(id float64, method, paramsJSON string, onDone func(js string)) {
+	go func() {
+		result, err := a.bridge(method, paramsJSON)
+		onDone(resolveJS(id, result, err))
+	}()
+}
+
+// pushResolve 把 resolve 脚本投递回 UI 线程执行；窗口已销毁时静默丢弃。
+// 判空与 Dispatch 同在 withView 读锁临界区内，与 Run 拆除（写锁内 Destroy）互斥。
+func (a *App) pushResolve(js string) {
+	a.withView(func(view webview.WebView) {
+		view.Dispatch(func() {
+			if !a.viewTearing.Load() {
+				view.Eval(js)
+			}
+		})
+	})
+}
+
+// resolveJS 构造回写脚本。错误按字符串回传（保持 webview_go 旧契约：
+// 前端 catch 到的就是 error message 字符串）。
+func resolveJS(id float64, result json.RawMessage, callErr error) string {
+	env := struct {
+		OK     bool            `json:"ok"`
+		Result json.RawMessage `json:"result,omitempty"`
+		Error  string          `json:"error,omitempty"`
+	}{OK: callErr == nil, Result: result}
+	if callErr != nil {
+		env.Error = callErr.Error()
+	}
+	body, err := json.Marshal(env)
+	if err != nil {
+		env.Result = nil
+		env.Error = "freedom: cannot marshal result: " + err.Error()
+		body, _ = json.Marshal(env)
+	}
+	return "window.freedom&&window.freedom.__resolve(" + strconv.FormatFloat(id, 'f', -1, 64) + "," + string(body) + ")"
+}

package/templates/go/pkg/freedom/events_windows.go

@@ -0,0 +1,319 @@
+//go:build windows
+
+package freedom
+
+import (
+	"fmt"
+	"sync"
+	"syscall"
+	"unsafe"
+)
+
+// Windows 原生窗口子系统（W1 对标 Tauri）：
+//   - 窗口事件：经 comctl32 SetWindowSubclass 子类化 WebView 主窗口，
+//     把 resize/move/focus/blur 转发为前端事件（window.resized 等）。
+//   - 关闭拦截：interceptClose 开启后 WM_CLOSE 不销毁窗口，改为向前端
+//     发送 window.closeRequested；前端确认后以 close({force:true}) 放行。
+//   - 全屏状态：setFullscreen 记录进入前的样式与矩形，退出时还原。
+
+const (
+	wmSize         = 0x0005
+	wmMove           = 0x0003
+	wmExitSizeMove = 0x0212
+	wmSetFocus       = 0x0007
+	wmKillFocus      = 0x0008
+
+	sizeMaximized = 1
+	sizeMinimized = 2
+
+	wsPopup        = 0x80000000
+	wsMinimizeBox  = 0x00020000
+	wsMaximizeBox  = 0x00010000
+	wsExTopmost    = 0x00000008
+	wsExToolwindow = 0x00000080
+
+	hwndTopmost   = uintptr(^uintptr(0)) // HWND_TOPMOST (-1)
+	hwndNotopmost = uintptr(^uintptr(1)) // HWND_NOTOPMOST (-2)
+
+	swpShowWindow = 0x0040
+	swpHideWindow = 0x0080
+)
+
+// windowRuntime 是每个 HWND 的事件/拦截/全屏运行态。
+type windowRuntime struct {
+	app            *App
+	interceptClose atomicBool
+	fsMu           sync.Mutex
+	fsActive       bool
+	fsStyle        uintptr
+	fsExStyle      uintptr
+	fsRect         rect
+}
+
+// atomicBool 用 mutex 保证跨线程读写（桥接 goroutine 写、UI 线程读）。
+type atomicBool struct {
+	mu sync.Mutex
+	v  bool
+}
+
+func (b *atomicBool) Store(v bool) {
+	b.mu.Lock()
+	b.v = v
+	b.mu.Unlock()
+}
+
+func (b *atomicBool) Load() bool {
+	b.mu.Lock()
+	v := b.v
+	b.mu.Unlock()
+	return v
+}
+
+// windowRuntimes 映射 hwnd → 运行态；子类化回调经此找回 App。
+var windowRuntimes sync.Map
+
+// 回调地址在初始化时一次性固化：syscall.NewCallback 每次调用都占用全局句柄表，
+// 在热路径（每次子类化/枚举显示器）里重复 NewCallback 会泄漏且可能溢出。
+var (
+	windowSubclassCB = syscall.NewCallback(windowSubclassProc)
+	enumMonitorsCB   = syscall.NewCallback(enumMonitorsProc)
+)
+
+// freedomSubclassID 是 SetWindowSubclass 的子类标识。
+const freedomSubclassID = 0x46524431 // "FRD1"
+
+// gwlExStyle = GWL_EXSTYLE（-20）。用变量声明，避免 uintptr 常量转换溢出（同 gwlStyle）。
+var gwlExStyle = -20
+
+// windowSubclassProc 是 comctl32 子类化回调：转发窗口事件、实施关闭拦截。
+func windowSubclassProc(hwnd, msg, wParam, lParam, subID, ref uintptr) uintptr {
+	v, ok := windowRuntimes.Load(hwnd)
+	if !ok {
+		r, _, _ := procDefSubclassProc.Call(hwnd, msg, wParam, lParam)
+		return r
+	}
+	rt := v.(*windowRuntime)
+	switch msg {
+	case wmSize:
+		w := int32(uint32(lParam & 0xFFFF))
+		h := int32(uint32((lParam >> 16) & 0xFFFF))
+		rt.app.Emit("window.resized", map[string]any{
+			"width": int(w), "height": int(h),
+			"maximized": wParam == sizeMaximized,
+			"minimized": wParam == sizeMinimized,
+		})
+	case wmMove:
+		x := int32(int16(uint16(lParam & 0xFFFF)))
+		y := int32(int16(uint16((lParam >> 16) & 0xFFFF)))
+		rt.app.Emit("window.moved", map[string]any{"x": int(x), "y": int(y)})
+	case wmSetFocus:
+		rt.app.Emit("window.focused", nil)
+	case wmKillFocus:
+		rt.app.Emit("window.blurred", nil)
+	case wmExitSizeMove:
+		// 用户完成拖拽/缩放/最大化切换——window-state 记忆的落点。
+		// 异步落盘，避免文件 IO 卡 UI 线程。
+		app := rt.app
+		go app.saveWindowStateNow()
+	case wmDestroy:
+		// 同步保存：窗口销毁后几何不可得，且此处仍在 UI 线程消息循环内，
+		// 分发清理尚未开始（cleanup defer 在消息循环退出之后）。
+		rt.app.saveWindowStateNow()
+	case wmClose:
+		if rt.interceptClose.Load() {
+			// 吞掉默认关闭流程（不进 DefSubclassProc → webview 收不到），
+			// 改由前端决策；前端以 close({force:true}) 再次触发时放行。
+			rt.app.Emit("window.closeRequested", nil)
+			return 0
+		}
+	case wmCommand:
+		// 主窗口原生菜单栏的条目点击：WM_COMMAND 发给菜单属主窗口，
+		// 与 tray 隐藏窗口的右键 popup 共用同一 id→前端 id 映射。
+		// 注意：不得在此锁 trayProcMu——属主线程可能正持锁跨线程建窗口，会互等死锁。
+		id := uint32(wParam & 0xFFFF)
+		if ts := trayStateInst; ts != nil {
+			ts.mu.Lock()
+			label, ok := ts.items[id]
+			ts.mu.Unlock()
+			if ok {
+				ts.emit("tray:menu", map[string]interface{}{"id": label})
+			}
+		}
+	}
+	r, _, _ := procDefSubclassProc.Call(hwnd, msg, wParam, lParam)
+	return r
+}
+
+// installWindowEvents 子类化窗口以接收事件与关闭拦截。须在窗口创建后调用。
+func (a *App) installWindowEvents() {
+	hwnd := a.WindowHandle()
+	if hwnd == 0 {
+		return
+	}
+	rt := &windowRuntime{app: a}
+	windowRuntimes.Store(hwnd, rt)
+	// SetWindowSubclass(hwnd, pfnSubclass, uIdSubclass, dwRefData)
+	if r, _, _ := procSetWindowSubclass.Call(hwnd, windowSubclassCB, freedomSubclassID, 0); r == 0 {
+		windowRuntimes.Delete(hwnd)
+	}
+}
+
+// uninstallWindowEvents 摘除子类化并清理运行态映射。
+func (a *App) uninstallWindowEvents() {
+	if hwnd := a.WindowHandle(); hwnd != 0 {
+		procRemoveWindowSubclass.Call(hwnd, windowSubclassCB, freedomSubclassID)
+		windowRuntimes.Delete(hwnd)
+	}
+}
+
+// runtimeFor 返回 hwnd 的运行态（调用方保证窗口已创建）。
+func runtimeFor(hwnd uintptr) (*windowRuntime, error) {
+	v, ok := windowRuntimes.Load(hwnd)
+	if !ok {
+		return nil, fmt.Errorf("freedom: window runtime not installed for hwnd %v", hwnd)
+	}
+	return v.(*windowRuntime), nil
+}
+
+// getFullscreen 读取全屏标志（与 setFullscreen 共用 fsMu）。
+func (rt *windowRuntime) getFullscreen() bool {
+	rt.fsMu.Lock()
+	defer rt.fsMu.Unlock()
+	return rt.fsActive
+}
+
+// getWindowRect / getClientRect 返回窗口外框与客户区矩形（物理像素）。
+func getWindowRect(hwnd uintptr) (rect, error) {
+	var r rect
+	if r0, _, _ := procGetWindowRect.Call(hwnd, uintptr(unsafe.Pointer(&r))); r0 == 0 {
+		return rect{}, fmt.Errorf("GetWindowRect failed")
+	}
+	return r, nil
+}
+
+func getClientRect(hwnd uintptr) rect {
+	var r rect
+	procGetClientRect.Call(hwnd, uintptr(unsafe.Pointer(&r)))
+	return r
+}
+
+// windowScaleFactor 返回 DPI 缩放（GetDpiForWindow / 96；旧系统回退 1）。
+func windowScaleFactor(hwnd uintptr) float64 {
+	if procGetDpiForWindow.Find() != nil {
+		return 1
+	}
+	dpi, _, _ := procGetDpiForWindow.Call(hwnd, 2 /*DPI_AWARENESS_EFFECTIVE*/)
+	if dpi == 0 {
+		return 1
+	}
+	return float64(dpi) / 96
+}
+
+// monitorEntry 描述一个显示器的几何与缩放（物理像素）。
+type monitorEntry struct {
+	X           int     `json:"x"`
+	Y           int     `json:"y"`
+	Width       int     `json:"width"`
+	Height      int     `json:"height"`
+	WorkX       int     `json:"workX"`
+	WorkY       int     `json:"workY"`
+	WorkWidth   int     `json:"workWidth"`
+	WorkHeight  int     `json:"workHeight"`
+	ScaleFactor float64 `json:"scaleFactor"`
+	IsPrimary   bool    `json:"isPrimary"`
+}
+
+const monitorInfofPrimary = 1
+
+// enumMonitorsProc 是 EnumDisplayMonitors 回调（返回 1 继续枚举）。
+func enumMonitorsProc(hmon, hdc, lprci, data uintptr) uintptr {
+	var mi monitorInfo
+	mi.cbSize = uint32(unsafe.Sizeof(mi))
+	if r, _, _ := procGetMonitorInfo.Call(hmon, uintptr(unsafe.Pointer(&mi))); r != 0 {
+		scale := 1.0
+		if procGetDpiForMonitor.Find() == nil {
+			var dx uint32
+			// GetDpiForMonitor(hmonitor, MDT_EFFECTIVE_DPI=0, &dpiX, &dpiY)；S_OK==0。
+			if hr, _, _ := procGetDpiForMonitor.Call(hmon, 0,
+				uintptr(unsafe.Pointer(&dx)), 0); hr == 0 && dx > 0 {
+				scale = float64(dx) / 96
+			}
+		}
+		monitorScan.list = append(monitorScan.list, monitorEntry{
+			X: int(mi.rcMonitor.left), Y: int(mi.rcMonitor.top),
+			Width:  int(mi.rcMonitor.right - mi.rcMonitor.left),
+			Height: int(mi.rcMonitor.bottom - mi.rcMonitor.top),
+			WorkX:  int(mi.rcWork.left), WorkY: int(mi.rcWork.top),
+			WorkWidth:  int(mi.rcWork.right - mi.rcWork.left),
+			WorkHeight: int(mi.rcWork.bottom - mi.rcWork.top),
+			ScaleFactor: scale,
+			IsPrimary:   mi.dwFlags&monitorInfofPrimary != 0,
+		})
+	}
+	return 1
+}
+
+var monitorScan struct {
+	mu   sync.Mutex
+	list []monitorEntry
+}
+
+// listMonitors 枚举全部显示器。
+func listMonitors() []monitorEntry {
+	monitorScan.mu.Lock()
+	defer monitorScan.mu.Unlock()
+	monitorScan.list = nil
+	procEnumDisplayMonitors.Call(0, 0, enumMonitorsCB, 0)
+	return monitorScan.list
+}
+
+// setFullscreen 进入/退出无边框全屏（覆盖整个显示器，含任务栏区域）。
+func setFullscreen(hwnd uintptr, on bool) error {
+	rt, err := runtimeFor(hwnd)
+	if err != nil {
+		return err
+	}
+	rt.fsMu.Lock()
+	defer rt.fsMu.Unlock()
+	if on == rt.fsActive {
+		return nil
+	}
+	mon, _, _ := procMonitorFromWindow.Call(hwnd, monitorDefaultTonearest)
+	if mon == 0 {
+		return fmt.Errorf("MonitorFromWindow failed")
+	}
+	var mi monitorInfo
+	mi.cbSize = uint32(unsafe.Sizeof(mi))
+	if r, _, _ := procGetMonitorInfo.Call(mon, uintptr(unsafe.Pointer(&mi))); r == 0 {
+		return fmt.Errorf("GetMonitorInfo failed")
+	}
+	if !rt.fsActive {
+		// 进入：存档当前样式与矩形；最大化中的窗口先恢复，避免还原矩形失真。
+		if isZoomed(hwnd) {
+			procShowWindow.Call(hwnd, swRestore)
+		}
+		rt.fsStyle = getWindowStyle(hwnd)
+		rt.fsExStyle, _, _ = procGetWindowLongPtr.Call(hwnd, uintptr(int(gwlExStyle)))
+		if cur, err := getWindowRect(hwnd); err == nil {
+			rt.fsRect = cur
+		}
+		style := (rt.fsStyle &^ (wsCaption | wsThickFrame)) | wsPopup
+		setWindowStyle(hwnd, style)
+		procSetWindowLongPtr.Call(hwnd, uintptr(int(gwlExStyle)), rt.fsExStyle|wsExTopmost)
+		procSetWindowPos.Call(hwnd, hwndTopmost,
+			uintptr(int32(mi.rcMonitor.left)), uintptr(int32(mi.rcMonitor.top)),
+			uintptr(mi.rcMonitor.right-mi.rcMonitor.left), uintptr(mi.rcMonitor.bottom-mi.rcMonitor.top),
+			swpFrameChanged|swpShowWindow)
+		rt.fsActive = true
+		return nil
+	}
+	// 退出：还原样式与矩形。
+	setWindowStyle(hwnd, rt.fsStyle)
+	procSetWindowLongPtr.Call(hwnd, uintptr(int(gwlExStyle)), rt.fsExStyle)
+	procSetWindowPos.Call(hwnd, hwndNotopmost,
+		uintptr(int32(rt.fsRect.left)), uintptr(int32(rt.fsRect.top)),
+		uintptr(rt.fsRect.right-rt.fsRect.left), uintptr(rt.fsRect.bottom-rt.fsRect.top),
+		swpFrameChanged|swpShowWindow|swpNoActivate)
+	rt.fsActive = false
+	return nil
+}