Mastering NSApplication: The Core of Your macOS App

import AppKit

// Accessing the shared NSApplication instance
let app = NSApplication.shared

// In an AppDelegate, you often interact with it:
class AppDelegate: NSObject, NSApplicationDelegate {

    func applicationDidFinishLaunching(_ notification: Notification) {
        print("Application finished launching!")
        // You can access NSApplication here:
        // let app = NSApplication.shared
        // app.setActivationPolicy(.regular)
    }

    func applicationWillTerminate(_ notification: Notification) {
        // Perform cleanup before the app quits
        print("Application will terminate.")
    }
}

import AppKit

@main
class ProgrammaticAppDelegate: NSObject, NSApplicationDelegate {

    var window: NSWindow! // Example: Keep a strong reference to a window

    func applicationDidFinishLaunching(_ notification: Notification) {
        print("Application finished launching! Setting up initial window.")

        // Create a basic window
        let contentRect = NSRect(x: 0, y: 0, width: 480, height: 300)
        window = NSWindow(
            contentRect: contentRect,
            styleMask: [.titled, .closable, .miniaturizable, .resizable],
            backing: .buffered,
            defer: false
        )
        window.center()
        window.title = "My NSApplication App"
        window.makeKeyAndOrderFront(nil)

        // You can set content view for the window here
        // let viewController = NSViewController()
        // window.contentViewController = viewController
    }

    func applicationWillTerminate(_ notification: Notification) {
        print("Application is about to terminate. Performing cleanup...")
        // Save user data, release resources, etc.
    }

    func applicationShouldTerminateAfterLastWindowClosed(_ sender: NSApplication) -> Bool {
        // Return true if the app should quit when its last window is closed
        // or false to keep it running (like Safari or Xcode)
        return false // Typical macOS behavior
    }

    func applicationDidBecomeActive(_ notification: Notification) {
        print("Application became active.")
    }

    func applicationDidResignActive(_ notification: Notification) {
        print("Application resigned active.")
    }

    // In Xcode 12+ / Swift 5.3+, using @main eliminates the need for main.swift
    // If not using @main, your main.swift would look like this:
    /*
    autoreleasepool {
        let delegate = ProgrammaticAppDelegate()
        NSApplication.shared.delegate = delegate
        _ = NSApplicationMain(CommandLine.argc, CommandLine.unsafeArgv)
    }
    */
}

import AppKit

// Example of monitoring local events within your app
class EventMonitorDelegate: NSObject, NSApplicationDelegate {

    func applicationDidFinishLaunching(_ notification: Notification) {
        print("Application launched. Setting up event monitor.")

        // Monitor all mouse down events *within this application*
        NSEvent.addLocalMonitorForEvents(matching: .leftMouseDown) { event in
            print("Local left mouse down detected at: \(event.locationInWindow)")
            // Return the event to continue normal processing, or nil to consume it
            return event
        }

        // Monitor all key down events *within this application*
        NSEvent.addLocalMonitorForEvents(matching: .keyDown) { event in
            print("Local key down: \(event.charactersIgnoringModifiers ?? "")")
            return event
        }

        // For global monitors, ensure you handle permissions and unregister
        // let monitor = NSEvent.addGlobalMonitorForEvents(matching: .keyDown) { event in
        //     print("Global key down: \(event.charactersIgnoringModifiers ?? "")")
        // }
        // Call removeMonitor(monitor) when no longer needed.
    }

    func applicationWillTerminate(_ notification: Notification) {
        // Any event monitors added globally should be removed here.
    }
}

// Note: To run this example, you'd typically replace your main AppDelegate
// with EventMonitorDelegate or combine their functionalities.
// @main class AppDelegate: EventMonitorDelegate { /* ... */ }

import AppKit

class CustomApplicationDelegate: NSObject, NSApplicationDelegate {

    func applicationDidFinishLaunching(_ notification: Notification) {
        let app = NSApplication.shared

        // Example 1: Standard application behavior (default)
        app.setActivationPolicy(.regular)
        print("Activation policy set to .regular")

        // Example 2: Accessory application (Dock icon, no auto-menu bar)
        // app.setActivationPolicy(.accessory)
        // print("Activation policy set to .accessory")

        // Example 3: Prohibited (no Dock icon, no menu bar)
        // app.setActivationPolicy(.prohibited)
        // print("Activation policy set to .prohibited")

        // To bring the app to the front, e.g., if it was launched in background
        // app.activate(ignoringOtherApps: true)

        // You would typically have a window or menu bar app logic here
    }

    func applicationShouldHandleReopen(_ sender: NSApplication, hasVisibleWindows flag: Bool) -> Bool {
        if !flag { // If no visible windows, you might want to show or create one
            print("App reopened, but no visible windows found. Creating or showing a window.")
            // In a real app, you'd show an existing window or create a new one.
            // NSApplication.shared.windows.first?.makeKeyAndOrderFront(nil)
        }
        return true // Always return true to allow the system to process the reopen event
    }
}

// To integrate this, set it as your app's delegate.
// @main class AppDelegate: CustomApplicationDelegate { /* ... */ }

import AppKit

class MenuAndWindowManager: NSObject, NSApplicationDelegate {

    func applicationDidFinishLaunching(_ notification: Notification) {
        print("Application launched. Checking menu and windows.")
        let app = NSApplication.shared

        // Accessing the main menu
        if let mainMenu = app.mainMenu {
            print("Main menu exists with \(mainMenu.items.count) top-level items.")

            // Example: Add a new custom menu item to the 'File' menu
            if let fileMenu = mainMenu.item(withTitle: "File")?.submenu {
                let customMenuItem = NSMenuItem(title: "My Custom Action", action: #selector(performCustomAction), keyEquivalent: "a")
                customMenuItem.target = self
                fileMenu.addItem(customMenuItem)
                print("Added 'My Custom Action' to File menu.")
            }
        } else {
            print("No main menu present.")
        }

        // Accessing application windows
        if app.windows.isEmpty {
            print("No application windows currently open.")
        } else {
            print("Application has \(app.windows.count) open window(s).")
            app.windows.forEach { window in
                print("  Window title: \(window.title)")
            }
        }

        if let firstWindow = app.windows.first {
            print("First window's ID: \(firstWindow.windowNumber)")
        }
    }

    @objc func performCustomAction() {
        print("Custom action performed from menu!")
        // You could trigger an alert, open a new window, etc.
        let alert = NSAlert()
        alert.messageText = "Menu Action"
        alert.informativeText = "You triggered 'My Custom Action' from the menu!"
        alert.runModal()
    }
}

// To use this, set it as your app's delegate and ensure you have a MainMenu.xib
// or programmatically create a base menu structure.
// @main class AppDelegate: MenuAndWindowManager { /* ... */ }