SwiftUI中如何检测NSWindowTab的关闭事件以触发保存确认

嘿，我来帮你搞定这个标签页关闭检测的问题！你遇到的情况确实挺典型的——SwiftUI对NSWindowTab的原生支持不够细致，直接用windowShouldClose或者onDisappear都没法满足需求，不过我们可以通过桥接AppKit的自定义窗口控制器来解决。

先说说你之前尝试的方法为什么不行：

• windowShouldClose只在最后一个标签被关闭时触发，单个标签移除时不会调用这个方法
• onDisappear是视图销毁时的回调，没法拦截关闭操作（用户点了关闭就没法取消了）
• DocumentGroup确实只适合文档型App，你的数据库场景完全不适用

那正确的思路是什么呢？核心是通过自定义NSWindowController来监听标签页的变化，并且给每个标签窗口绑定代理，拦截关闭请求。下面是具体的实现步骤：

第一步：创建自定义窗口控制器 #

我们需要一个继承自NSWindowController的子类，负责监听标签页变化、给每个标签绑定代理，以及处理关闭确认逻辑：

import SwiftUI
import AppKit

class CustomWindowController: NSWindowController, NSWindowDelegate {
    // 绑定视图的"是否有未保存更改"状态
    @Binding var isDirty: Bool
    
    init(window: NSWindow?, isDirty: Binding<Bool>) {
        self._isDirty = isDirty
        super.init(window: window)
    }
    
    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
    
    override func windowDidLoad() {
        super.windowDidLoad()
        window?.delegate = self
        
        // 监听标签页集合变化的通知，给新标签绑定代理
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(tabbedWindowsChanged),
            name: NSWindow.didChangeTabbedWindowsNotification,
            object: window
        )
    }
    
    @objc private func tabbedWindowsChanged() {
        guard let tabbedWindows = window?.tabbedWindows else { return }
        // 确保每个标签窗口的代理都是当前控制器
        for tabWindow in tabbedWindows {
            if tabWindow.delegate !== self {
                tabWindow.delegate = self
            }
        }
    }
    
    // 拦截窗口关闭请求
    func windowShouldClose(_ sender: NSWindow) -> Bool {
        guard let mainWindow = self.window, let tabbedWindows = mainWindow.tabbedWindows else { return true }
        
        // 只有当关闭的是单个标签（不是最后一个）且有未保存更改时，才弹出确认
        if tabbedWindows.count > 1 && sender != mainWindow && isDirty {
            let alert = NSAlert()
            alert.messageText = "是否保存当前标签的更改？"
            alert.addButton(withTitle: "保存")
            alert.addButton(withTitle: "不保存")
            alert.addButton(withTitle: "取消")
            
            let response = alert.runModal()
            switch response {
            case .alertFirstButtonReturn:
                // 这里执行你的保存逻辑，比如写入数据库
                print("保存当前标签的更改到数据库")
                isDirty = false // 保存后标记为已同步
                return true
            case .alertSecondButtonReturn:
                isDirty = false // 放弃更改，标记为已同步
                return true
            case .alertThirdButtonReturn:
                // 用户取消关闭，返回false阻止窗口关闭
                return false
            default:
                return true
            }
        }
        
        // 最后一个标签关闭，或者没有未保存更改，默认允许关闭
        return true
    }
    
    deinit {
        // 移除通知监听，避免内存泄漏
        NotificationCenter.default.removeObserver(self)
    }
}

第二步：在SwiftUI视图中绑定控制器 #

接下来我们需要把自定义控制器和ContentView绑定，传递"是否有未保存更改"的状态：

struct ContentView: View {
    // 标记当前视图是否有未保存的更改
    @State private var isDirty = false
    
    var body: some View {
        VStack {
            Text("标签页内容")
            Button("修改数据") {
                // 模拟数据修改，标记为未保存
                isDirty = true
            }
        }
        .padding()
        // 通过隐藏的NSView传递绑定到窗口控制器
        .background(WindowControllerBinding(isDirty: $isDirty))
    }
}

// 用于将SwiftUI的绑定传递给NSWindowController的桥接视图
struct WindowControllerBinding: NSViewRepresentable {
    @Binding var isDirty: Bool
    
    func makeNSView(context: Context) -> NSView {
        let view = NSView()
        DispatchQueue.main.async {
            // 给当前窗口设置自定义控制器
            if let window = view.window, window.windowController is CustomWindowController == false {
                window.windowController = CustomWindowController(window: window, isDirty: $isDirty)
            }
        }
        return view
    }
    
    func updateNSView(_ nsView: NSView, context: Context) {
        // 更新控制器的绑定状态
        if let controller = nsView.window?.windowController as? CustomWindowController {
            controller._isDirty = $isDirty
        }
    }
}

第三步：在App入口中配置窗口 #

最后，在你的App结构体中保持原有的标签创建逻辑即可，不需要额外修改：

@main
struct TabTestApp: App {
    var body: some Scene {
        WindowGroup{
            ContentView()
        }.commands{
            CommandGroup(after: .newItem) {
                Button("New Tab") {
                    guard let currentWindow = NSApp.keyWindow, let windowController = currentWindow.windowController else { return }
                    windowController.newWindowForTab(nil)
                    guard let newWindow = NSApp.keyWindow else { return }
                    if currentWindow != newWindow {
                        currentWindow.addTabbedWindow(newWindow, ordered: .above)
                    }
                }.keyboardShortcut(.init("t", modifiers: [.command]))
            }
        }
    }
}

额外说明 #

• 这个方案会处理所有标签关闭场景：包括点击标签栏的"关闭标签"、使用CMD+W、"Close Other Tabs"命令
• 如果需要批量关闭多个标签时只弹出一次确认，可以在控制器中添加逻辑，检测是否有多个标签要关闭，然后合并确认流程
• 你可以根据自己的业务逻辑修改保存确认的对话框内容和保存逻辑

备注：内容来源于stack exchange，提问作者Sebastian