@yufengtadian/freedom-cli 1.12.18 → 1.13.0

package/templates/go/pkg/freedom/window_mgr.go

@@ -0,0 +1,385 @@
+package freedom
+
+import (
+	"encoding/json"
+	"fmt"
+	"runtime"
+	"sort"
+	"sync"
+	"sync/atomic"
+
+	webview "github.com/webview/webview_go"
+)
+
+// M2 多窗口：主窗口跑在 Run() 的 UI 线程（现状不变），次级窗口各自持有一条
+// LockOSThread 的 goroutine 跑独立消息泵（webview.h 每实例自带 GetMessage 循环）。
+// 生命周期：主窗口关闭 = 应用退出（Run 返回前回收全部次级窗口）；次级窗口可独立
+// 关闭。限制：托盘/热键/单实例/窗口事件子类化/状态记忆等平台层单例仍只挂主窗口，
+// 次级窗口的页面里 __freedom_sys/__freedom_tray 桥缺席（SDK 给出可读拒绝）。
+
+// WindowSpec 描述一个次级窗口的创建参数。零值可用，全部有默认值。
+type WindowSpec struct {
+	Title  string // 空则用主窗口标题
+	Width  int    // <=0 用主窗口配置值
+	Height int    // <=0 用主窗口配置值
+	Center bool   // 屏幕居中（Windows 生效）
+	// URL 非空时加载该地址（Navigate）；否则依次尝试 HTML（Go 侧函数）、
+	// Page（前端 create 传来的内联字符串）、主窗口 Config.HTML。全空且主页面
+	// 含开窗脚本会级联——前端 create 务必带 html 或 url。
+	URL string
+	// Page 是内联 HTML 字符串。前端 window.create 经 JSON 传参，无法携带
+	// Go 闭包，故序列化通道用本字段；Go 侧 NewWindow 优先用 HTML 函数。
+	Page  string `json:"html"`
+	HTML  func() (string, error)
+	Debug bool
+}
+
+// Window 是一个窗口句柄：主窗口（id "main"）与 NewWindow 创建的次级窗口同型。
+// 方法对并发调用安全。
+type Window struct {
+	id     string
+	app    *App
+	spec   WindowSpec
+	doneCh chan struct{} // 窗口线程回收后 close
+
+	mu      sync.Mutex
+	view    webview.WebView // 未创建/已销毁为 nil
+	closing bool            // Close 早于 view 就绪时置位，runWindow 见后即撤
+	// tearing 在 Destroy 前置位。Dispatch 只是入队：webview2 的销毁路径会在
+	// 拆除线程上把排队回调泵出来执行（此刻 w.mu 仍被 destroyView 持有，闭包
+	// 只能读原子量），无守卫即对半销毁实例 Eval → 0xc0000005（CI 实测崩溃）。
+	tearing atomic.Bool
+}
+
+// ID 返回窗口标识（"main" 或 "w1"…）。
+func (w *Window) ID() string { return w.id }
+
+// WaitClosed 阻塞直到该窗口消息循环退出（被关闭或进程退出）。
+func (w *Window) WaitClosed() { <-w.doneCh }
+
+// live 报告窗口 webview 是否仍存活。
+func (w *Window) live() bool {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	return w.view != nil
+}
+
+// Close 请求关闭窗口：投递 Terminate 到该窗口消息泵；对尚在启动中的窗口，
+// 置 closing 标志由创建线程自行退出。幂等。主窗口 Close 等价 App.Quit
+// （主窗口关闭 = 应用退出，与 Run 的回收语义一致）。
+func (w *Window) Close() {
+	if w.id == mainWindowID {
+		w.app.Quit()
+		return
+	}
+	// Dispatch 在 w.mu 临界区内发起：与销毁侧 destroyView（同锁内 Destroy）互斥，
+	// 不会对已销毁实例投递（否则 use-after-free）。
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	w.closing = true
+	if view := w.view; view != nil {
+		view.Dispatch(func() {
+			if !w.tearing.Load() {
+				view.Terminate()
+			}
+		})
+	}
+}
+
+// SetTitle 修改窗口标题（投递到该窗口消息泵）。
+func (w *Window) SetTitle(title string) {
+	if w.id == mainWindowID {
+		w.app.withView(func(view webview.WebView) {
+			view.Dispatch(func() {
+				if !w.app.viewTearing.Load() {
+					view.SetTitle(title)
+				}
+			})
+		})
+		return
+	}
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	if view := w.view; view != nil {
+		// 闭包捕获局部引用：延迟执行时不再读共享字段 w.view（可能已摘除）。
+		view.Dispatch(func() {
+			if !w.tearing.Load() {
+				view.SetTitle(title)
+			}
+		})
+	}
+}
+
+func (w *Window) handle() uintptr {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	if w.view == nil {
+		return 0
+	}
+	return uintptr(w.view.Window())
+}
+
+// evalJS 在本窗口消息泵上执行脚本；窗口未存活时静默丢弃。
+func (w *Window) evalJS(js string) {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	if view := w.view; view != nil {
+		view.Dispatch(func() {
+			if !w.tearing.Load() {
+				view.Eval(js)
+			}
+		})
+	}
+}
+
+// destroyView 由窗口线程在消息循环退出后调用：摘引用与 Destroy 同处 w.mu
+// 临界区，之后一切读引用+Dispatch 的方法（Close/SetTitle/evalJS/handle）自动失活。
+// tearing 先于 Destroy 置位：Destroy 会把队列里已入队的 dispatch 回调泵出来执行，
+// 闭包凭该原子量自我作废（不能读 w.mu——回调就跑在本临界区内）。
+func (w *Window) destroyView(view webview.WebView) {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	w.tearing.Store(true)
+	if w.view == view {
+		w.view = nil
+	}
+	view.Destroy()
+}
+
+// NewWindow 异步创建一个次级窗口并立即返回句柄。必须在 App.Run() 已启动后
+// 调用（任意 goroutine 皆可，含 OnReady 与 Bind handler）。
+func (a *App) NewWindow(spec WindowSpec) (*Window, error) {
+	a.winMu.Lock()
+	if !a.running {
+		a.winMu.Unlock()
+		return nil, fmt.Errorf("freedom: NewWindow requires the app to be running (App.Run)")
+	}
+	a.winSeq++
+	w := &Window{id: fmt.Sprintf("w%d", a.winSeq), app: a, spec: spec, doneCh: make(chan struct{})}
+	if spec.Title == "" {
+		w.spec.Title = a.cfg.Title
+	}
+	if spec.Width <= 0 {
+		w.spec.Width = a.cfg.Width
+	}
+	if spec.Height <= 0 {
+		w.spec.Height = a.cfg.Height
+	}
+	a.windows[w.id] = w
+	a.winMu.Unlock()
+	go a.runWindow(w)
+	return w, nil
+}
+
+// Window 按 id 查找窗口；不存在或已关闭返回 nil。"main" 返回主窗口句柄。
+func (a *App) Window(id string) *Window {
+	a.winMu.Lock()
+	defer a.winMu.Unlock()
+	return a.windows[id]
+}
+
+// Windows 返回存活次级窗口 id（升序，不含 "main"）。
+func (a *App) Windows() []string {
+	a.winMu.Lock()
+	defer a.winMu.Unlock()
+	ids := make([]string, 0, len(a.windows))
+	for id := range a.windows {
+		if id != mainWindowID {
+			ids = append(ids, id)
+		}
+	}
+	sort.Strings(ids)
+	return ids
+}
+
+// CloseWindows 关闭全部次级窗口并等待其线程回收；主窗口不受影响。
+func (a *App) CloseWindows() {
+	a.winMu.Lock()
+	pending := make([]*Window, 0, len(a.windows))
+	for id, w := range a.windows {
+		if id != mainWindowID {
+			pending = append(pending, w)
+		}
+	}
+	a.winMu.Unlock()
+	for _, w := range pending {
+		w.Close()
+	}
+	for _, w := range pending {
+		w.WaitClosed()
+	}
+}
+
+// runWindow 在独立 OS 线程上创建并运行一个次级窗口的完整消息循环。
+func (a *App) runWindow(w *Window) {
+	runtime.LockOSThread()
+	defer func() {
+		a.winMu.Lock()
+		delete(a.windows, w.id)
+		a.winMu.Unlock()
+		close(w.doneCh)
+	}()
+
+	if stop := func() bool { w.mu.Lock(); defer w.mu.Unlock(); return w.closing }(); stop {
+		return // Close 早于创建完成：直接退场
+	}
+
+	view := webview.New(w.spec.Debug)
+	if view == nil {
+		fmt.Printf("freedom: window %q: failed to create webview\n", w.id)
+		return
+	}
+	defer w.destroyView(view)
+	w.mu.Lock()
+	if w.closing {
+		w.mu.Unlock()
+		return
+	}
+	w.view = view
+	w.mu.Unlock()
+
+	view.SetTitle(w.spec.Title)
+	view.SetSize(w.spec.Width, w.spec.Height, webview.HintNone)
+	if w.spec.Center {
+		a.centerHWND(uintptr(view.Window()))
+	}
+
+	view.Init(jsSDK)
+	// 每窗口独立桥：调用路由同一后端，但结果回写与窗口动作作用于本窗口。
+	if err := view.Bind("__freedom_bridge", func(id float64, method, paramsJSON string) {
+		a.dispatchBridge(id, method, paramsJSON, w.evalJS)
+	}); err != nil {
+		fmt.Printf("freedom: window %q: bind bridge: %v\n", w.id, err)
+		return
+	}
+	if err := view.Bind("__freedom_window", func(action, paramsJSON string) (interface{}, error) {
+		return a.windowControlFor(w, action, paramsJSON)
+	}); err != nil {
+		fmt.Printf("freedom: window %q: bind window control: %v\n", w.id, err)
+		return
+	}
+	if w.spec.URL != "" {
+		view.Navigate(w.spec.URL)
+	} else {
+		html, err := a.resolvePage(w.spec)
+		if err != nil {
+			fmt.Printf("freedom: window %q: resolve html: %v\n", w.id, err)
+			return
+		}
+		view.SetHtml(html)
+	}
+	view.Run()
+}
+
+// resolvePage 按声明优先序解析次级窗口页面源（URL 分支不走本函数）：
+// HTML（Go 侧函数）> Page（前端 create 内联 JSON）> 主窗口 Config.HTML。
+func (a *App) resolvePage(spec WindowSpec) (string, error) {
+	if spec.HTML != nil {
+		return spec.HTML()
+	}
+	if spec.Page != "" {
+		return spec.Page, nil
+	}
+	return a.resolveHTML()
+}
+
+// windowControlFor 处理次级窗口动作：窗口级动作在此拦截，其余下沉平台层
+// （以本窗口 HWND 为目标）。
+func (a *App) windowControlFor(w *Window, action, paramsJSON string) (result interface{}, err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			result = nil
+			err = fmt.Errorf("freedom: window action %q panicked: %v", action, r)
+		}
+	}()
+	// M3 能力闸：与主窗口同闸（action 补 window. 前缀判定）。
+	if err := a.capCheckWindow(action); err != nil {
+		return nil, err
+	}
+	switch action {
+	case "id":
+		// 本窗口身份优先于 windowManage 的 main 应答。
+		return w.id, nil
+	case "close":
+		w.Close()
+		return nil, nil
+	}
+	// 管理动作（id/list/create/closeWindow/focusWindow）任意窗口皆可发起。
+	if res, ok, merr := a.windowManage(action, paramsJSON); ok {
+		return res, merr
+	}
+	return windowControl(w.handle(), action, a.cfg.TitleBar, paramsJSON)
+}
+
+// windowManage 处理窗口管理动作（create/list/closeWindow/focusWindow/id）；
+// 主窗口经 a.windowControl 前置调用，次级窗口经 windowControlFor 调用。
+// 返回 ok=false 表示不是管理动作，交回普通窗口控制。
+func (a *App) windowManage(action, paramsJSON string) (result interface{}, ok bool, err error) {
+	switch action {
+	case "id":
+		return mainWindowID, true, nil
+	case "create":
+		var spec WindowSpec
+		if err := json.Unmarshal([]byte(orEmptyJSON(paramsJSON)), &spec); err != nil {
+			return nil, true, fmt.Errorf("freedom: window.create params: %w", err)
+		}
+		w, err := a.NewWindow(spec)
+		if err != nil {
+			return nil, true, err
+		}
+		return map[string]string{"id": w.id}, true, nil
+	case "list":
+		return append(a.Windows(), mainWindowID), true, nil
+	case "closeWindow", "focusWindow":
+		var p struct {
+			ID string `json:"id"`
+		}
+		_ = json.Unmarshal([]byte(orEmptyJSON(paramsJSON)), &p)
+		w := a.Window(p.ID)
+		if w == nil {
+			return nil, true, fmt.Errorf("freedom: no such window: %q", p.ID)
+		}
+		if w.id == mainWindowID {
+			// 主窗口：closeWindow 仍拒绝（关主窗口=退应用，走 App.Quit/用户关窗）；
+			// focusWindow 允许——M2 前主窗口是唯一窗口，聚焦即置顶主窗。
+			if action == "closeWindow" {
+				return nil, true, fmt.Errorf("freedom: cannot closeWindow main window")
+			}
+			_, err := windowControl(a.WindowHandle(), "focus", a.cfg.TitleBar, "{}")
+			return nil, true, err
+		}
+		if action == "closeWindow" {
+			w.Close()
+			return nil, true, nil
+		}
+		_, err := windowControl(w.handle(), "focus", a.cfg.TitleBar, "{}")
+		return nil, true, err
+	}
+	return nil, false, nil
+}
+
+func orEmptyJSON(s string) string {
+	if s == "" || s == "null" {
+		return "{}"
+	}
+	return s
+}
+
+// ---- 主窗口/广播接线 ----
+
+const mainWindowID = "main"
+
+// emitSecondary 把事件推给全部次级窗口（主窗口走既有 view 路径）。
+func (a *App) emitSecondary(js string) {
+	a.winMu.Lock()
+	ws := make([]*Window, 0, len(a.windows))
+	for id, w := range a.windows {
+		if id != mainWindowID {
+			ws = append(ws, w)
+		}
+	}
+	a.winMu.Unlock()
+	for _, w := range ws {
+		w.evalJS(js)
+	}
+}

package/templates/go/pkg/freedom/window_other.go

@@ -2,80 +2,46 @@
 
 package freedom
 
-import (
-	"fmt"
+import "fmt"
 
-	webview "github.com/webview/webview_go"
-)
+// applyTitleBar 在 macOS / Linux 上为空实现：
+// 原生标题栏由窗口管理器接管，hidden / frameless 模式暂回退为原生标题栏，
+// 前端仍可通过 window.freedom.window.isFrameless() 感知当前是否无边框。
+func (a *App) applyTitleBar() {}
 
-// applyTitleBar 在 macOS / Linux 上通过 webview 层的 set_decorated 控制原生标题栏：
-//   - frameless：GTK 走 gtk_window_set_decorated(FALSE)，Cocoa 走隐藏标题栏 + 透明标题栏
-//     + 移除原生最小化/关闭按钮，彻底去除"UI 上方残留原生标题栏"问题；
-//   - native：恢复系统原生标题栏。
-//
-// 窗口在 webview.New() 时已创建，故此处可安全调用（须在 UI 线程，即 Run 流程内）。
-func (a *App) applyTitleBar() {
-	if a.view == nil {
-		return
-	}
-	a.view.SetDecorated(a.cfg.TitleBar != TitleBarFrameless)
-}
-
-// setWindowIcon 在 macOS / Linux 上为空实现（图标由应用包 / 窗口管理器决定）。
-func (a *App) setWindowIcon() {}
-
-// webview2Available 非 Windows 平台恒返回 true（macOS WKWebView / Linux WebKitGTK，
-// 不依赖 WebView2 Runtime）。
-func webview2Available() bool { return true }
+// installWindowEvents / uninstallWindowEvents 在非 Windows 平台为空实现
+// （窗口事件与关闭拦截依赖 WndProc 子类化，仅 Windows 提供）。
+func (a *App) installWindowEvents()   {}
+func (a *App) uninstallWindowEvents()  {}
 
-// windowControl 处理前端 window.freedom.window.* 请求（macOS / Linux 实现）。
-//
-// 窗口控制类动作（最小化/最大化/还原/关闭/查询）直接转发到 webview 层的原生
-// 窗口控制（GTK GtkWindow / Cocoa NSWindow），前端自绘标题栏三按钮因此可用：
-//   - GTK: gtk_window_iconify / maximize / unmaximize / close / is_maximized
-//   - Cocoa: performMiniaturize: / zoom: / performClose: / isZoomed
-//
-// 注意：webview 层窗口控制动作在 UI 线程执行（前端桥接本身运行于 UI 线程回调中，
-// webview_go 的 binding 回调在主线程派发），无需额外 Dispatch。
-func windowControl(a *App, action string) (interface{}, error) {
-	if a.view == nil {
-		return nil, fmt.Errorf("window not ready")
-	}
-	var act webview.WindowAction
+// windowControl 处理前端 window.freedom.window.* 请求（macOS / Linux 占位实现）。
+// 动作集与 window_windows.go 保持一致：查询类返回中性值，动作类静默 no-op，
+// 保证前端在任一平台调用同一方法不致因"未知动作"报错。
+func windowControl(hwnd uintptr, action string, mode TitleBarMode, paramsJSON string) (interface{}, error) {
 	switch action {
-	case "minimize":
-		act = webview.WindowMinimize
-	case "maximize":
-		act = webview.WindowMaximize
-	case "unmaximize", "restore":
-		act = webview.WindowRestore
-	case "toggleMaximize":
-		act = webview.WindowToggleMaximize
-	case "close":
-		act = webview.WindowClose
-	case "isMaximized":
-		act = webview.WindowIsMaximized
 	case "isFrameless":
-		return a.cfg.TitleBar == TitleBarFrameless, nil
-	case "appIcon":
-		// macOS / Linux 暂不提供 exe 内嵌图标提取，前端隐藏标题栏图标。
-		return "", nil
-	case "startDrag":
-		// 无边框窗口拖动：GTK 走 gtk_window_begin_move_drag（root_x/y=-1 用当前指针），
-		// Cocoa 走 performWindowDragWithEvent:（用当前鼠标位置合成事件）。
-		// 与 Windows 的 WM_NCLBUTTONDOWN+HTCAPTION 语义等价，保留页面双击/右键事件。
-		if a.view.BeginMoveDrag() != 0 {
-			return nil, fmt.Errorf("window drag is not supported on this platform")
+		// 仅 frameless 返回 true（与 window_windows.go 语义一致）；
+		// hidden 模式回退原生标题栏，前端不应自绘按钮。
+		return mode == TitleBarFrameless, nil
+	case "isMaximized", "isMinimized", "isVisible", "isFocused", "isFullscreen":
+		if action == "isVisible" {
+			return true, nil
 		}
+		return false, nil
+	case "getInfo":
+		return map[string]interface{}{
+			"outerWidth": 0, "outerHeight": 0,
+			"innerWidth": 0, "innerHeight": 0,
+			"scaleFactor": 1.0,
+			"visible":     true,
+		}, nil
+	case "minimize", "maximize", "unmaximize", "restore", "toggleMaximize", "close",
+		"setPosition", "setSize", "getPosition", "getSize", "innerSize", "center",
+		"setTitle", "show", "hide", "focus", "setAlwaysOnTop", "setSkipTaskbar",
+		"setResizable", "setMaximizable", "setMinimizable", "setFullscreen", "interceptClose":
+		// 非 Windows 平台暂不提供底层窗口控制，前端自绘按钮可对事件静默处理
 		return nil, nil
 	default:
 		return nil, fmt.Errorf("unknown window action %q", action)
 	}
-	if act == webview.WindowIsMaximized {
-		return a.view.WindowControl(act) == 1, nil
-	}
-	if r := a.view.WindowControl(act); r != 0 {
-		return nil, fmt.Errorf("window action %q is not supported on this platform", action)
-	}
-	return nil, nil
 }