Mastering macOS Window Lifecycle with AppKit and SwiftUI

import Cocoa

class CustomWindowController: NSWindowController, NSWindowDelegate {

    convenience init() {
        let window = NSWindow(
            contentRect: NSRect(x: 0, y: 0, width: 400, height: 300),
            styleMask: [.titled, .closable, .miniaturizable, .resizable],
            backing: .buffered,
            defer: false
        )
        window.center()
        window.title = "My Custom AppKit Window"
        
        self.init(window: window)
        // Set the delegate to self to receive lifecycle events
        self.window?.delegate = self
        
        // Create and set a content view controller
        let viewController = NSViewController()
        viewController.view = NSView(frame: window.contentView!.bounds)
        viewController.view.wantsLayer = true
        viewController.view.layer?.backgroundColor = NSColor.systemIndigo.cgColor
        self.contentViewController = viewController
    }

    override func windowDidLoad() {
        super.windowDidLoad()
        print("\(window?.title ?? "") did load.")
        // Implement any additional setup after the window has been loaded.
    }
    
    // MARK: - NSWindowDelegate Methods
    
    func windowShouldClose(_ sender: NSWindow) -> Bool {
        print("\(sender.title) should close. Performing cleanup...")
        // Ask user for confirmation or save state
        return true // Return false to prevent closing
    }
    
    func windowWillClose(_ notification: Notification) {
        if let window = notification.object as? NSWindow {
            print("\(window.title) will close. Releasing resources...")
            // Perform final cleanup, invalidate timers, release delegates
        }
    }
    
    func windowDidBecomeKey(_ notification: Notification) {
        if let window = notification.object as? NSWindow {
            print("\(window.title) did become key.")
        }
    }
    
    func windowDidResignKey(_ notification: Notification) {
        if let window = notification.object as? NSWindow {
            print("\(window.title) did resign key.")
        }
    }
    
    func windowWillMiniaturize(_ notification: Notification) {
        if let window = notification.object as? NSWindow {
            print("\(window.title) will miniaturize.")
        }
    }
    
    func windowDidDeminiaturize(_ notification: Notification) {
        if let window = notification.object as? NSWindow {
            print("\(window.title) did deminiaturize.")
        }
    }

    deinit {
        print("CustomWindowController deallocated.")
    }
}

// How to use it in your NSApplicationDelegate or wherever you manage windows:
/*
class AppDelegate: NSObject, NSApplicationDelegate {
    var customWindowController: CustomWindowController?

    func applicationDidFinishLaunching(_ aNotification: Notification) {
        customWindowController = CustomWindowController()
        customWindowController?.showWindow(nil)
    }

    func applicationWillTerminate(_ aNotification: Notification) {
        // Insert code here to tear down your application
    }

    func applicationShouldTerminateAfterLastWindowClosed(_ sender: NSApplication) -> Bool {
        return true // Or false if you want the app to stay open with no windows
    }
}
*/

import SwiftUI

@main
struct MySwiftUIApp: App {
    @State private var showingPreferences = false

    var body: some Scene {
        // Main document window group
        WindowGroup {
            ContentView()
                .onAppear { print("Main Window Content appeared") }
                .onDisappear { print("Main Window Content disappeared") }
        }
        .commands {
            CommandMenu("Window Controls") {
                Button("Show Preferences") {
                    showingPreferences.toggle()
                }
                .keyboardShortcut(",", modifiers: .command)
            }
        }

        // Single instance preferences window
        Window("Preferences", id: "preferences") {
            PreferencesView()
        }
        .keyboardShortcut(",", modifiers: [.command, .shift]) // Example shortcut
    }
}

struct ContentView: View {
    @Environment(\.openWindow) private var openWindow

    var body: some View {
        VStack {
            Image(systemName: "globe")
                .imageScale(.large)
                .foregroundColor(.accentColor)
            Text("Hello, SwiftUI World!")
            Button("Open New Main Window") {
                // Each call opens a new instance of the WindowGroup
                openWindow(id: "mainWindow")
            }
            .padding()
        }
        .frame(minWidth: 400, minHeight: 300)
        .windowToolbarStyle(.unifiedCompact)
        // This modifier allows you to hook into window-level events indirectly
        .navigationTitle("Main App Window")
    }
}

struct PreferencesView: View {
    @Environment(\.dismiss) private var dismiss

    var body: some View {
        VStack {
            Text("App Preferences")
                .font(.title)
            Toggle("Enable Dark Mode", isOn: .constant(true))
                .padding()
            Button("Close Preferences") {
                dismiss()
            }
        }
        .frame(width: 300, height: 200)
        .onAppear { print("Preferences Window appeared") }
        .onDisappear { print("Preferences Window disappeared") }
    }
}

import SwiftUI
import AppKit

// 1. Define your SwiftUI content view
struct BridgedContentView: View {
    var message: String
    var body: some View {
        VStack {
            Text("This is a SwiftUI view nested in an AppKit window!")
                .font(.headline)
            Text(message)
                .padding()
        }
        .frame(minWidth: 300, minHeight: 200)
        .background(Color.yellow.opacity(0.2))
    }
}

// 2. Create an NSWindowController to manage the AppKit window
class BridgedWindowController: NSWindowController, NSWindowDelegate {
    convenience init(message: String) {
        let window = NSWindow(
            contentRect: NSRect(x: 0, y: 0, width: 500, height: 400),
            styleMask: [.titled, .closable, .miniaturizable, .resizable],
            backing: .buffered,
            defer: false
        )
        window.center()
        window.title = "AppKit Window with SwiftUI Content"
        
        self.init(window: window)
        self.window?.delegate = self
        
        // 3. Embed the SwiftUI view using NSHostingController
        let hostingController = NSHostingController(rootView: BridgedContentView(message: message))
        self.contentViewController = hostingController
    }

    override func windowDidLoad() {
        super.windowDidLoad()
        print("Bridged window did load.")
    }
    
    // MARK: - NSWindowDelegate Methods
    
    func windowWillClose(_ notification: Notification) {
        print("Bridged window will close - performing AppKit cleanup.")
    }
    
    deinit {
        print("BridgedWindowController deallocated.")
    }
}

// Example of how you might use this in an AppKit delegate or command:
/*
class AppKitAppDelegate: NSObject, NSApplicationDelegate {
    var explicitWindowController: BridgedWindowController? // Keep a strong reference

    func applicationDidFinishLaunching(_ aNotification: Notification) {
        explicitWindowController = BridgedWindowController(message: "Shared state or data here!")
        explicitWindowController?.showWindow(nil)
    }

    func createAnotherBridgedWindow() {
        let anotherController = BridgedWindowController(message: "Another window, another message!")
        anotherController.showWindow(nil)
        // You'll need to manage multiple 'explicitWindowController' if you want to keep them all around.
        // For simplicity, this example only shows one.
    }
}
*/