UIKit and AppKit Essentials, and Mixing Them with SwiftUI

import UIKit
import FieldNotesModel
import FieldNotesServices

final class NotebookSummaryViewController: UIViewController {
    private let store: NoteStore
    private let countLabel = UILabel()

    init(store: NoteStore) {
        self.store = store
        super.init(nibName: nil, bundle: nil)
    }

    required init?(coder: NSCoder) { fatalError("init(coder:) is not used") }

    override func viewDidLoad() {
        super.viewDidLoad()
        view.backgroundColor = .systemBackground
        countLabel.font = .preferredFont(forTextStyle: .title2)
        countLabel.adjustsFontForContentSizeCategory = true
        countLabel.translatesAutoresizingMaskIntoConstraints = false
        view.addSubview(countLabel)
        NSLayoutConstraint.activate([
            countLabel.centerXAnchor.constraint(equalTo: view.safeAreaLayoutGuide.centerXAnchor),
            countLabel.centerYAnchor.constraint(equalTo: view.safeAreaLayoutGuide.centerYAnchor),
        ])
    }

    // Called again automatically whenever store.notes changes (iOS 26 observation tracking).
    override func updateProperties() {
        super.updateProperties()
        countLabel.text = "\(store.notes.count) notes"
    }
}

final class TagChipRowLayout {
    @MainActor
    static func constraints(for chip: UIView, in container: UIView, leading: NSLayoutXAxisAnchor) -> [NSLayoutConstraint] {
        chip.translatesAutoresizingMaskIntoConstraints = false
        return [
            chip.leadingAnchor.constraint(equalTo: leading, constant: 8),
            chip.centerYAnchor.constraint(equalTo: container.centerYAnchor),
            chip.heightAnchor.constraint(equalToConstant: 28),
        ]
    }
}

// Later, once every chip's constraints are collected:
NSLayoutConstraint.activate(allChipConstraints)

final class LegacyNoteDetailViewController: UIViewController {
    @IBOutlet private var titleField: UITextField!
    @IBOutlet private var bodyTextView: UITextView!

    @IBAction private func pinButtonTapped(_ sender: UIButton) {
        // Wired from a button in Main.storyboard to this action.
    }
}

// Elsewhere, instantiating that scene by its storyboard identifier:
let storyboard = UIStoryboard(name: "Main", bundle: nil)
let detail = storyboard.instantiateViewController(
    identifier: "LegacyNoteDetailViewController"
) as! LegacyNoteDetailViewController

import UIKit
import FieldNotesServices

final class SceneDelegate: UIResponder, UIWindowSceneDelegate {
    var window: UIWindow?
    private let store = NoteStore()

    func scene(_ scene: UIScene,
               willConnectTo session: UISceneSession,
               options connectionOptions: UIScene.ConnectionOptions) {
        guard let windowScene = scene as? UIWindowScene else { return }
        let window = UIWindow(windowScene: windowScene)
        let navigation = UINavigationController(rootViewController: NoteListViewController(store: store))
        navigation.navigationBar.prefersLargeTitles = true
        window.rootViewController = navigation
        window.makeKeyAndVisible()
        self.window = window
    }
}

import UIKit
import FieldNotesModel
import FieldNotesServices

final class NoteListViewController: UICollectionViewController {
    enum Section { case pinned, all }

    let store: NoteStore
    var dataSource: UICollectionViewDiffableDataSource<Section, Note.ID>!

    init(store: NoteStore) {
        self.store = store
        let layout = UICollectionViewCompositionalLayout.list(
            using: UICollectionLayoutListConfiguration(appearance: .insetGrouped))
        super.init(collectionViewLayout: layout)
    }

    required init?(coder: NSCoder) { fatalError("init(coder:) is not used") }

    override func viewDidLoad() {
        super.viewDidLoad()
        title = "Notes"

        let registration = UICollectionView.CellRegistration<UICollectionViewListCell, Note.ID> {
            [unowned self] cell, _, id in
            guard let note = store.notes.first(where: { $0.id == id }) else { return }
            var content = cell.defaultContentConfiguration()
            content.text = note.title
            content.secondaryText = note.createdAt.formatted(date: .abbreviated, time: .omitted)
            content.image = note.isPinned ? UIImage(systemName: "pin.fill") : nil
            cell.contentConfiguration = content
        }

        dataSource = UICollectionViewDiffableDataSource(collectionView: collectionView) {
            collectionView, indexPath, id in
            collectionView.dequeueConfiguredReusableCell(using: registration, for: indexPath, item: id)
        }
    }

    // The notes last applied, so edits to an existing note can be detected.
    private var appliedNotes: [Note.ID: Note] = [:]

    // Rebuilt automatically when store.notes changes (observation tracking). Reading the whole
    // array here also tracks edits to titles and other fields, not just inserts and deletes.
    override func updateProperties() {
        super.updateProperties()
        let notes = store.notes
        var snapshot = NSDiffableDataSourceSnapshot<Section, Note.ID>()
        snapshot.appendSections([.pinned, .all])
        snapshot.appendItems(notes.filter(\.isPinned).map(\.id), toSection: .pinned)
        snapshot.appendItems(notes.filter { !$0.isPinned }.map(\.id), toSection: .all)

        // An edited note keeps its ID, so the diff sees no change; reconfigure those items explicitly.
        let edited = notes.filter { note in
            guard let previous = appliedNotes[note.id] else { return false }
            return previous != note
        }
        snapshot.reconfigureItems(edited.map(\.id))
        appliedNotes = Dictionary(uniqueKeysWithValues: notes.map { ($0.id, $0) })

        dataSource.apply(snapshot, animatingDifferences: true)
    }
}

import UIKit
import FieldNotesUI   // NoteDensity

struct NoteDensityTrait: UITraitDefinition {
    static let defaultValue = NoteDensity.comfortable
    static let name = "NoteDensity"
}

extension UITraitCollection {
    var noteDensity: NoteDensity { self[NoteDensityTrait.self] }
}

extension UIMutableTraits {
    var noteDensity: NoteDensity {
        get { self[NoteDensityTrait.self] }
        set { self[NoteDensityTrait.self] = newValue }
    }
}

extension NoteListViewController {
    func observeTraits() {
        // Override the trait for this view controller's subtree.
        traitOverrides.noteDensity = .compact

        // React when the size class or the custom trait changes.
        registerForTraitChanges([UITraitHorizontalSizeClass.self, NoteDensityTrait.self]) {
            (self: Self, previousTraitCollection: UITraitCollection) in
            self.collectionView.collectionViewLayout.invalidateLayout()
        }
    }
}

import AppKit
import SwiftUI
import FieldNotesModel
import FieldNotesServices

final class NoteInspectorWindowController: NSWindowController {
    convenience init(note: Note, store: NoteStore) {
        let hosting = NSHostingController(rootView: NoteDetail(note: note).environment(store))
        let window = NSWindow(contentViewController: hosting)
        window.title = note.title
        window.styleMask.insert(.resizable)
        window.setContentSize(NSSize(width: 420, height: 560))
        window.setFrameAutosaveName("FieldNotes.NoteInspector")
        self.init(window: window)
    }
}

// Showing it from an action:
// let controller = NoteInspectorWindowController(note: note, store: store)
// controller.showWindow(nil)

import AppKit

@objc protocol NoteCommands {
    func newNote(_ sender: Any?)
    func togglePin(_ sender: Any?)
}

@MainActor
func installNotesMenu() {
    let notesMenu = NSMenu(title: "Notes")
    notesMenu.addItem(withTitle: "New Note",
                      action: #selector(NoteCommands.newNote(_:)),
                      keyEquivalent: "n")

    let pinItem = NSMenuItem(title: "Pin Note",
                             action: #selector(NoteCommands.togglePin(_:)),
                             keyEquivalent: "p")
    pinItem.keyEquivalentModifierMask = [.command, .shift]
    notesMenu.addItem(pinItem)

    let notesItem = NSMenuItem(title: "Notes", action: nil, keyEquivalent: "")
    notesItem.submenu = notesMenu
    NSApplication.shared.mainMenu?.addItem(notesItem)
}

import UIKit
import SwiftUI

extension NoteListViewController {
    override func collectionView(_ collectionView: UICollectionView, didSelectItemAt indexPath: IndexPath) {
        guard let id = dataSource.itemIdentifier(for: indexPath),
              let note = store.notes.first(where: { $0.id == id }) else { return }

        let detail = UIHostingController(rootView: NoteDetail(note: note).environment(store))
        detail.title = note.title
        navigationController?.pushViewController(detail, animated: true)
    }

    func presentTagPicker(for note: Note, from sourceItem: UIBarButtonItem) {
        let picker = UIHostingController(rootView: TagPicker(note: note).environment(store))
        // Keep preferredContentSize in sync with the SwiftUI content, so the popover fits it.
        picker.sizingOptions = [.preferredContentSize]
        picker.modalPresentationStyle = .popover
        picker.popoverPresentationController?.sourceItem = sourceItem
        present(picker, animated: true)
    }
}

import UIKit
import SwiftUI

@MainActor
let rowRegistration = UICollectionView.CellRegistration<UICollectionViewListCell, Note> { cell, _, note in
    cell.contentConfiguration = UIHostingConfiguration {
        NoteRow(note: note)
    }
    .margins(.horizontal, 16)
}

import AppKit
import SwiftUI

// `store` is the app's shared NoteStore; SettingsView reads it from the environment.
let hosting = NSHostingController(rootView: SettingsView().environment(store))
hosting.sizingOptions = [.minSize, .intrinsicContentSize]
let settingsWindow = NSWindow(contentViewController: hosting)
settingsWindow.title = "FieldNotes Settings"

import AppKit
import SwiftUI

final class NoteTableController: NSObject, NSTableViewDelegate {
    let store: NoteStore

    init(store: NoteStore) {
        self.store = store
        super.init()
    }

    func tableView(_ tableView: NSTableView, viewFor tableColumn: NSTableColumn?, row: Int) -> NSView? {
        let note = store.notes[row]
        let rowView = NSHostingView(rootView: NoteRow(note: note))
        // Only publish the intrinsic size; the table decides the width.
        rowView.sizingOptions = [.intrinsicContentSize]
        return rowView
    }
}

import AppKit
import SwiftUI
import FieldNotesModel
import FieldNotesServices

struct NoteContextMenu: View {
    let note: Note
    let store: NoteStore

    var body: some View {
        Section {
            Button(note.isPinned ? "Unpin" : "Pin") { store.togglePin(note) }
        }
        Section {
            Button("Delete", role: .destructive) { store.delete(note) }
        }
    }
}

// AppKit side: one menu for the table, updated for the clicked row before it opens.
@MainActor
final class NoteTableMenuController: NSObject, NSMenuDelegate {
    let store: NoteStore
    let tableView: NSTableView
    let menu: NSHostingMenu<NoteContextMenu>

    init(store: NoteStore, tableView: NSTableView, placeholder: Note) {
        self.store = store
        self.tableView = tableView
        self.menu = NSHostingMenu(rootView: NoteContextMenu(note: placeholder, store: store))
        super.init()
        menu.delegate = self
        tableView.menu = menu
    }

    func menuNeedsUpdate(_ menu: NSMenu) {
        guard tableView.clickedRow >= 0 else { return }
        self.menu.rootView = NoteContextMenu(note: store.notes[tableView.clickedRow], store: store)
    }
}

#if canImport(UIKit)
import SwiftUI
import UIKit

struct NoteBodyTextView: UIViewRepresentable {
    @Binding var text: String

    func makeCoordinator() -> Coordinator {
        Coordinator(text: $text)
    }

    func makeUIView(context: Context) -> UITextView {
        let textView = UITextView()
        textView.font = .preferredFont(forTextStyle: .body)
        textView.adjustsFontForContentSizeCategory = true
        textView.isFindInteractionEnabled = true
        textView.isScrollEnabled = false
        textView.delegate = context.coordinator
        return textView
    }

    func updateUIView(_ textView: UITextView, context: Context) {
        context.coordinator.text = $text          // the binding may be a new value each update
        if textView.text != text {                // avoid resetting the cursor on every keystroke
            textView.text = text
        }
    }

    static func dismantleUIView(_ textView: UITextView, coordinator: Coordinator) {
        textView.delegate = nil
    }

    func sizeThatFits(_ proposal: ProposedViewSize, uiView: UITextView, context: Context) -> CGSize? {
        guard let width = proposal.width else { return nil }
        let fitting = uiView.sizeThatFits(CGSize(width: width, height: .greatestFiniteMagnitude))
        return CGSize(width: width, height: fitting.height)
    }

    final class Coordinator: NSObject, UITextViewDelegate {
        var text: Binding<String>

        init(text: Binding<String>) {
            self.text = text
        }

        func textViewDidChange(_ textView: UITextView) {
            text.wrappedValue = textView.text
        }
    }
}
#endif

#if canImport(UIKit)
import SwiftUI
import UIKit
import UniformTypeIdentifiers

struct AttachmentPicker: UIViewControllerRepresentable {
    var onPick: ([URL]) -> Void

    func makeCoordinator() -> Coordinator {
        Coordinator(onPick: onPick)
    }

    func makeUIViewController(context: Context) -> UIDocumentPickerViewController {
        let picker = UIDocumentPickerViewController(forOpeningContentTypes: [.image, .pdf], asCopy: true)
        picker.allowsMultipleSelection = true
        picker.delegate = context.coordinator
        return picker
    }

    func updateUIViewController(_ picker: UIDocumentPickerViewController, context: Context) {
        context.coordinator.onPick = onPick
    }

    final class Coordinator: NSObject, UIDocumentPickerDelegate {
        var onPick: ([URL]) -> Void

        init(onPick: @escaping ([URL]) -> Void) {
            self.onPick = onPick
        }

        func documentPicker(_ controller: UIDocumentPickerViewController, didPickDocumentsAt urls: [URL]) {
            onPick(urls)
        }
    }
}
#endif

#if os(macOS)
import AppKit
import SwiftUI

struct NoteBodyTextView: NSViewRepresentable {
    @Binding var text: String

    func makeCoordinator() -> Coordinator {
        Coordinator(text: $text)
    }

    func makeNSView(context: Context) -> NSScrollView {
        let scrollView = NSTextView.scrollableTextView()
        let textView = scrollView.documentView as! NSTextView
        textView.isRichText = false
        textView.usesFindBar = true
        textView.font = .preferredFont(forTextStyle: .body)
        textView.delegate = context.coordinator
        return scrollView
    }

    func updateNSView(_ scrollView: NSScrollView, context: Context) {
        context.coordinator.text = $text
        guard let textView = scrollView.documentView as? NSTextView else { return }
        if textView.string != text {
            textView.string = text
        }
    }

    static func dismantleNSView(_ scrollView: NSScrollView, coordinator: Coordinator) {
        (scrollView.documentView as? NSTextView)?.delegate = nil
    }

    final class Coordinator: NSObject, NSTextViewDelegate {
        var text: Binding<String>

        init(text: Binding<String>) {
            self.text = text
        }

        func textDidChange(_ notification: Notification) {
            guard let textView = notification.object as? NSTextView else { return }
            text.wrappedValue = textView.string
        }
    }
}
#endif