iPadOS: Windows, Multitasking, Pointer and Apple Pencil

<!-- FieldNotes/Info.plist (excerpt) -->
<key>UIApplicationSceneManifest</key>
<dict>
    <key>UIApplicationSupportsMultipleScenes</key>
    <true/>
</dict>

// FieldNotes/FieldNotesApp.swift (excerpt: the note window group and the menu bar commands)
import SwiftUI
import FieldNotesModel
import FieldNotesServices

@main
struct FieldNotesApp: App {
    @State private var store = AppServices.shared.store   // the single owner, see Background Execution

    var body: some Scene {
        WindowGroup {
            ContentView()
                .environment(store)
        }
        .commands {
            FieldNotesCommands(store: store)   // defined below; shared with the Mac
            SidebarCommands()
            InspectorCommands()
        }
        .defaultAppStorage(.fieldNotesShared)   // as on Preferences, Files and Document-Based Apps

        WindowGroup(id: "note", for: Note.ID.self) { $noteID in
            NoteWindow(noteID: noteID)
                .environment(store)
        }
        .defaultAppStorage(.fieldNotesShared)
        .defaultSize(width: 640, height: 720)
        .windowResizability(.contentMinSize)   // the minimum comes from NoteWindow's frame
    }
}

// FieldNotes/Windows/NoteWindow.swift
import SwiftUI
import FieldNotesModel
import FieldNotesServices
import FieldNotesUI

/// One note in a window of its own, opened with `openWindow(id: "note", value: note.id)`.
struct NoteWindow: View {
    @Environment(NoteStore.self) private var store
    let noteID: Note.ID?
    @State private var showsInspector = false

    private var note: Note? {
        store.notes.first { $0.id == noteID }
    }

    var body: some View {
        if let note {
            NavigationStack {
                NoteDetail(note: note)                 // publishes focusedSceneValue(\.selectedNote, note)
                    .navigationTitle(note.title)       // names the window in the app's window list
                    #if os(visionOS)
                    .sheet(isPresented: $showsInspector) {   // no inspector on visionOS: the same details in a sheet
                        NavigationStack {
                            NoteMetadataInspector(note: note)
                                .navigationTitle("Info")
                                .toolbar {
                                    ToolbarItem(placement: .confirmationAction) {
                                        Button("Done") { showsInspector = false }
                                    }
                                }
                        }
                    }
                    #else
                    .inspector(isPresented: $showsInspector) {
                        NoteMetadataInspector(note: note)
                            .inspectorColumnWidth(min: 220, ideal: 260, max: 340)
                    }
                    #endif
                    .toolbar {
                        Button("Info", systemImage: "info.circle") { showsInspector.toggle() }
                    }
            }
            .frame(minWidth: 420, minHeight: 360)
        } else {
            ContentUnavailableView("Note Not Found", systemImage: "note.text",
                                   description: Text("It may have been deleted in another window."))
        }
    }
}

// Packages/FieldNotesUI/Sources/FieldNotesUI/NoteList.swift (excerpt: open a note in its own window)
@Environment(\.openWindow) private var openWindow
@Environment(\.supportsMultipleWindows) private var supportsMultipleWindows

List(selection: $selection) {
    // rows as on Lists, Tables and Collections
}
.contextMenu(forSelectionType: Note.ID.self) { ids in
    if supportsMultipleWindows, ids.count == 1, let id = ids.first {
        Button("Open in New Window", systemImage: "macwindow.badge.plus") {
            openWindow(id: "note", value: id)
        }
    }
}

// FieldNotes 1.x/SceneDelegate+Geometry.swift
import UIKit

extension SceneDelegate {
    /// Called from scene(_:willConnectTo:options:) once the window exists.
    func configureSize(of windowScene: UIWindowScene) {
        windowScene.sizeRestrictions?.minimumSize = CGSize(width: 420, height: 360)
    }

    func windowScene(_ windowScene: UIWindowScene,
                     didUpdateEffectiveGeometry previousEffectiveGeometry: UIWindowScene.Geometry) {
        let geometry = windowScene.effectiveGeometry
        // Updates arrive continuously while a person drags the resize handle: wait for the drag to end.
        guard !geometry.isInteractivelyResizing else { return }

        let oldWidth = previousEffectiveGeometry.coordinateSpace.bounds.width
        let newWidth = geometry.coordinateSpace.bounds.width
        let dragJustEnded = previousEffectiveGeometry.isInteractivelyResizing
        guard dragJustEnded || oldWidth != newWidth else { return }

        // Rearrange the columns once for the final size, instead of on every intermediate frame.
        let splitViewController = window?.rootViewController as? UISplitViewController
        splitViewController?.preferredDisplayMode = newWidth < 700 ? .oneBesideSecondary : .twoBesideSecondary
    }
}

// FieldNotes 1.x/SketchViewController.swift (excerpt)
import UIKit

extension SketchViewController {
    func updateClosureConfirmation(hasUnsavedStrokes: Bool) {
        guard #available(iOS 27, *), let windowScene = view.window?.windowScene else { return }
        if hasUnsavedStrokes {
            let discard = UIAlertAction(title: String(localized: "Discard Sketch"), style: .destructive)
            let keep = UIAlertAction(title: String(localized: "Keep Editing"), style: .cancel)
            windowScene.closureConfirmation = UISceneClosureConfirmation(
                title: String(localized: "Close this window?"),
                message: String(localized: "The sketch hasn't been saved to the note yet."),
                actions: [discard, keep])
        } else {
            windowScene.closureConfirmation = nil
        }
    }
}

// FieldNotes/Commands/FocusedValues+Commands.swift
import SwiftUI

extension FocusedValues {
    /// Set by ContentView: presents NoteComposer in the focused main window.
    @Entry var captureSheetPresented: Binding<Bool>?
    /// Set by ContentView: shows and focuses the search field of the focused main window.
    @Entry var noteSearchPresented: Binding<Bool>?
}

// FieldNotes/ContentView.swift (excerpt, updated: the state the menu bar reads)
struct ContentView: View {
    @Environment(NoteStore.self) private var store
    @State private var isCapturing = false
    @State private var isSearching = false
    @State private var searchText = ""
    @State private var selectedNotebook: Notebook.ID?
    // ... column and selection state from Navigation and Presentation ...

    var body: some View {
        splitView                                  // the NavigationSplitView from Navigation and Presentation
            .searchable(text: $searchText, isPresented: $isSearching,
                        placement: .sidebar, prompt: "Search notes")
            .sheet(isPresented: $isCapturing) {
                NoteComposer(notebookID: selectedNotebook)
            }
            .focusedSceneValue(\.captureSheetPresented, $isCapturing)
            .focusedSceneValue(\.noteSearchPresented, $isSearching)
    }
}

// FieldNotes/Commands/FieldNotesCommands.swift
import SwiftUI
import FieldNotesModel
import FieldNotesServices
import FieldNotesUI

/// FieldNotes' menu bar items, shared by the iPad and Mac apps.
struct FieldNotesCommands: Commands {
    let store: NoteStore

    @Environment(\.openWindow) private var openWindow
    @Environment(\.supportsMultipleWindows) private var supportsMultipleWindows
    @FocusedValue(\.selectedNote) private var selectedNote            // published by NoteDetail
    @FocusedBinding(\.captureSheetPresented) private var isCapturing   // published by ContentView
    @FocusedBinding(\.noteSearchPresented) private var isSearching     // published by ContentView

    var body: some Commands {
        // File menu: FieldNotes' "new" items replace the default New Window item.
        CommandGroup(replacing: .newItem) {
            Button("New Note", systemImage: "square.and.pencil") {
                isCapturing = true
            }
            .keyboardShortcut("n", modifiers: .command)
            .disabled(isCapturing == nil)

            Button("New Window for Note", systemImage: "macwindow.badge.plus") {
                if let selectedNote { openWindow(id: "note", value: selectedNote.id) }
            }
            .keyboardShortcut("n", modifiers: [.command, .option])
            .disabled(selectedNote == nil || !supportsMultipleWindows)
        }

        // FieldNotes doesn't print; removing Print frees Command-P for pinning.
        CommandGroup(replacing: .printItem) {}

        CommandMenu("Notes") {
            Button(selectedNote?.isPinned == true ? "Unpin Note" : "Pin Note", systemImage: "pin") {
                if let selectedNote { store.togglePin(selectedNote) }
            }
            .keyboardShortcut("p", modifiers: .command)
            .disabled(selectedNote == nil)

            Divider()

            Button("Find Notes…", systemImage: "magnifyingglass") {
                isSearching = true
            }
            .keyboardShortcut("f", modifiers: .command)
            .disabled(isSearching == nil)
        }
    }
}

// A Notebooks menu in FieldNotesCommands: the icons identify notebooks, so they stay visible in 27.
CommandMenu("Notebooks") {
    ForEach(store.notebooks) { notebook in
        Button {
            // select the notebook in the focused window
        } label: {
            Label(notebook.name, systemImage: notebook.symbolName)
                .labelStyle(.titleAndIcon)
        }
    }
}

// FieldNotes 1.x/AppDelegate+MainMenu.swift
import UIKit

extension AppDelegate {
    func configureMainMenu() {
        let configuration = UIMainMenuSystem.Configuration()
        configuration.printingPreference = .removed

        UIMainMenuSystem.shared.setBuildConfiguration(configuration) { builder in
            let pin = UIKeyCommand(title: String(localized: "Pin Note"),
                                   action: #selector(NoteDetailViewController.togglePin(_:)),
                                   input: "p", modifierFlags: .command)
            let find = UIKeyCommand(title: String(localized: "Find Notes…"),
                                    action: #selector(NotesSplitViewController.findNotes(_:)),
                                    input: "f", modifierFlags: .command)
            let notes = UIMenu(title: String(localized: "Notes"), children: [pin, find])
            builder.insertChild(notes, atStartOfMenu: .file)
        }
    }
}

// Packages/FieldNotesUI/Sources/FieldNotesUI/TagChipRow.swift (excerpt)
ForEach(tags, id: \.self) { tag in
    Button { select(tag) } label: {
        TagChip(tag, isSelected: tag == selectedTag)
    }
    .buttonStyle(.plain)
    #if os(iOS) || os(visionOS)
    .contentShape(.hoverEffect, .capsule)
    .hoverEffect(.highlight)
    #elseif os(macOS)
    .pointerStyle(.link)
    #endif
}

// FieldNotes/Sketch/SketchPointer.swift
#if os(iOS) || os(visionOS)
import UIKit

/// Shows a 6-point dot instead of the arrow while the pointer is over the sketch canvas.
final class SketchPointerDelegate: NSObject, UIPointerInteractionDelegate {
    func pointerInteraction(_ interaction: UIPointerInteraction,
                            styleFor region: UIPointerRegion) -> UIPointerStyle? {
        UIPointerStyle(shape: .roundedRect(CGRect(x: -3, y: -3, width: 6, height: 6), radius: 3))
    }
}
#endif

// FieldNotes/Sketch/NoteSketchView.swift
#if os(iOS) || os(visionOS)
import SwiftUI
import PencilKit

enum SketchTool: Hashable {
    case pen, marker, eraser

    var pencilKitTool: any PKTool {
        switch self {
        case .pen: PKInkingTool(.pen, color: .label, width: 3)
        case .marker: PKInkingTool(.marker, color: .systemYellow, width: 12)
        case .eraser: PKEraserTool(.vector)
        }
    }
}

/// A PencilKit canvas for a note's field sketch. The Pencil draws; fingers scroll and zoom.
struct NoteSketchView: UIViewRepresentable {
    @Binding var drawing: PKDrawing
    var tool: SketchTool
    var onHover: (CGFloat?) -> Void = { _ in }   // Pencil height above the glass, nil when out of range

    func makeCoordinator() -> Coordinator { Coordinator(parent: self) }

    func makeUIView(context: Context) -> PKCanvasView {
        let canvas = PKCanvasView()
        canvas.drawing = drawing
        canvas.drawingPolicy = .pencilOnly
        canvas.delegate = context.coordinator
        canvas.addInteraction(UIPointerInteraction(delegate: context.coordinator.pointerDelegate))
        canvas.addGestureRecognizer(UIHoverGestureRecognizer(
            target: context.coordinator, action: #selector(Coordinator.hoverChanged(_:))))
        return canvas
    }

    func updateUIView(_ canvas: PKCanvasView, context: Context) {
        context.coordinator.parent = self
        canvas.tool = tool.pencilKitTool
        if canvas.drawing != drawing {   // an external change, such as loading from disk
            canvas.drawing = drawing
        }
    }

    final class Coordinator: NSObject, PKCanvasViewDelegate {
        var parent: NoteSketchView
        let pointerDelegate = SketchPointerDelegate()   // UIPointerInteraction holds its delegate weakly

        init(parent: NoteSketchView) { self.parent = parent }

        func canvasViewDrawingDidChange(_ canvasView: PKCanvasView) {
            parent.drawing = canvasView.drawing
        }

        @objc func hoverChanged(_ recognizer: UIHoverGestureRecognizer) {
            switch recognizer.state {
            case .began, .changed: parent.onHover(recognizer.zOffset)   // 0 at the glass, 1 at the edge of range
            default: parent.onHover(nil)
            }
        }
    }
}
#endif

// FieldNotes/Sketch/NoteSketchEditor.swift
#if os(iOS) || os(visionOS)
import SwiftUI
import PencilKit
import OSLog
import FieldNotesModel

/// The sketch screen of a note: canvas, tool picker, Pencil gestures and autosave.
struct NoteSketchEditor: View {
    let noteID: Note.ID
    @State private var drawing = PKDrawing()
    @State private var tool: SketchTool = .pen
    @State private var previousTool: SketchTool = .pen
    @State private var showsPalette = false
    @State private var paletteAnchor: UnitPoint = .center
    @State private var saveError: String?
    @Environment(\.preferredPencilDoubleTapAction) private var doubleTapAction
    @Environment(\.preferredPencilSqueezeAction) private var squeezeAction
    private let log = Logger(subsystem: "com.example.fieldnotes", category: "ui")

    var body: some View {
        NoteSketchView(drawing: $drawing, tool: tool)
            .onPencilDoubleTap { value in
                perform(doubleTapAction, at: value.hoverPose)
            }
            .onPencilSqueeze { phase in
                if case .ended(let value) = phase {
                    perform(squeezeAction, at: value.hoverPose)
                }
            }
            .popover(isPresented: $showsPalette, attachmentAnchor: .point(paletteAnchor)) {
                Picker("Tool", selection: $tool) {
                    Label("Pen", systemImage: "pencil.tip").tag(SketchTool.pen)
                    Label("Marker", systemImage: "highlighter").tag(SketchTool.marker)
                    Label("Eraser", systemImage: "eraser").tag(SketchTool.eraser)
                }
                .pickerStyle(.inline)
                .padding()
            }
            .task(id: noteID) { load() }
            .onChange(of: drawing) { _, newDrawing in save(newDrawing) }
            .alert("Sketch Error", isPresented: showsError) {
                Button("OK") { saveError = nil }
            } message: {
                Text(saveError ?? "")
            }
    }

    private var showsError: Binding<Bool> {
        Binding(get: { saveError != nil }, set: { if !$0 { saveError = nil } })
    }

    private func perform(_ action: PencilPreferredAction, at pose: PencilHoverPose?) {
        switch action {
        case .switchEraser:
            (tool, previousTool) = tool == .eraser ? (previousTool, tool) : (.eraser, tool)
        case .switchPrevious:
            (tool, previousTool) = (previousTool, tool)
        case .showColorPalette, .showInkAttributes, .showContextualPalette:
            paletteAnchor = pose?.anchor ?? .center   // show the palette under the hovering tip
            showsPalette = true
        default:
            break   // .ignore, .runSystemShortcut and future actions: the system handles them
        }
    }

    private func load() {
        do {
            drawing = try NoteSketchFile.load(noteID: noteID) ?? PKDrawing()
        } catch {
            log.error("Loading sketch failed: \(error.localizedDescription)")
            saveError = error.localizedDescription
        }
    }

    private func save(_ drawing: PKDrawing) {
        do {
            try NoteSketchFile.save(drawing, noteID: noteID)
        } catch {
            log.error("Saving sketch failed: \(error.localizedDescription)")
            saveError = error.localizedDescription
        }
    }
}
#endif

// FieldNotes/Sketch/NoteSketchFile.swift
import Foundation
import PencilKit
import FieldNotesModel

enum NoteSketchFile {
    private static var folder: URL {
        URL.applicationSupportDirectory.appending(path: "Sketches", directoryHint: .isDirectory)
    }

    static func load(noteID: Note.ID) throws -> PKDrawing? {
        let url = folder.appending(path: "\(noteID.uuidString).drawing")
        guard FileManager.default.fileExists(atPath: url.path(percentEncoded: false)) else { return nil }
        return try PKDrawing(data: Data(contentsOf: url))
    }

    static func save(_ drawing: PKDrawing, noteID: Note.ID) throws {
        try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
        try drawing.dataRepresentation()
            .write(to: folder.appending(path: "\(noteID.uuidString).drawing"), options: .atomic)
    }
}

// FieldNotes 1.x/SketchViewController.swift (excerpt)
import UIKit

final class SketchViewController: UIViewController, UIPencilInteractionDelegate {
    override func viewDidLoad() {
        super.viewDidLoad()
        let pencilInteraction = UIPencilInteraction(delegate: self)
        view.addInteraction(pencilInteraction)
    }

    func pencilInteraction(_ interaction: UIPencilInteraction,
                           didReceiveTap tap: UIPencilInteraction.Tap) {
        if UIPencilInteraction.preferredTapAction == .switchEraser {
            toggleEraser()
        }
    }

    func pencilInteraction(_ interaction: UIPencilInteraction,
                           didReceiveSqueeze squeeze: UIPencilInteraction.Squeeze) {
        guard squeeze.phase == .ended else { return }
        let location = squeeze.hoverPose?.location ?? view.center
        showToolPalette(at: location)
    }
}