Mit dem Szenenmodell für den Mac beginnen
In diesem Anwendungsfall entwickelst du aus einer App-Idee das Grundgerüst einer Mac-App. Die Oberfläche soll sich am Desktop vertraut anfühlen, ohne dass du dafür eine auf Touchbedienung ausgelegte Navigation auf ein größeres Fenster überträgst. Lass Codex zuerst das Szenenmodell wählen und dann das Hauptfenster gestalten. Dazu gehören eine Seitenleiste, in der die Auswahl erhalten bleibt, eine Detailansicht und ein Inspektor für zusätzliche Bedienelemente oder Metadaten.

Verwende das Plugin „Build macOS Apps“, wenn Codex diese Desktop-Struktur umsetzen und die App bei jeder Iteration direkt aus der Shell kompilieren und starten soll. Der enthaltene Skill für SwiftUI-Muster unter macOS eignet sich für die Gestaltung von Szenen, Seitenleisten, Inspektoren, Befehlen und Einstellungen. Er hilft auch bei der gezielten Anbindung von AppKit, wenn SwiftUI ein bestimmtes Mac-Verhalten nicht vollständig abdeckt.
Seitenleiste, Detailansicht und Inspektor erstellen
Nutze bevorzugt NavigationSplitView, wenn die Navigation sichtbar bleiben und die Auswahl erhalten bleiben soll. Verwende für die Zeilen der Seitenleiste schlichte native Elemente und für den Hintergrund die Systemvorgabe. Eigene Karten oder umfangreiche Metadaten gehören in die Detailansicht oder den Inspektor.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62import SwiftUI
struct Item: Identifiable, Hashable {
let id: String
let title: String
let systemImage: String
}
let items = [Item(id: "notes", title: "Notes", systemImage: "note.text"), Item(id: "photos", title: "Photos", systemImage: "photo")]
struct ItemDetailView: View {
let selection: String?
var body: some View { Text(selection ?? "Select an item").frame(maxWidth: .infinity, maxHeight: .infinity) }
}
struct ItemInspectorView: View {
let selection: String?
var body: some View { Text("Metadata: \(selection ?? "No selection")").padding().frame(minWidth: 220) }
}
@MainActor final class LibraryStore: ObservableObject {
@Published var entries = items
@Published var selection: String?
@Published var showInspector = true
func addItem() {
let item = Item(id: UUID().uuidString, title: "New Item", systemImage: "doc")
entries.append(item)
selection = item.id
}
}
struct LibraryRootView: View {
@StateObject private var store = LibraryStore()
@SceneStorage("LibraryRootView.selection") private var savedSelection: Item.ID?
@SceneStorage("LibraryRootView.showInspector") private var savedShowInspector = true
var body: some View {
NavigationSplitView {
List(selection: $store.selection) {
ForEach(store.entries) { item in
Label(item.title, systemImage: item.systemImage)
.tag(item.id)
}
}
.listStyle(.sidebar)
.navigationTitle("Library")
} detail: {
ItemDetailView(selection: store.selection)
.inspector(isPresented: $store.showInspector) {
ItemInspectorView(selection: store.selection)
}
}
.focusedSceneObject(store)
.onAppear {
store.selection = savedSelection
store.showInspector = savedShowInspector
}
.onChange(of: store.selection) { _, selection in
savedSelection = selection
}
.onChange(of: store.showInspector) { _, showInspector in
savedShowInspector = showInspector
}
}
}
Braucht die App besondere Regeln für die Breite der Fensterbereiche, eine systemnahe Fensterkoordination oder ein eigenes Verhalten in der Responder-Kette? Bitte Codex in diesem Fall, das SwiftUI-Grundgerüst beizubehalten und nur so viel AppKit-Code zu ergänzen, wie dafür nötig ist.
Befehle, Symbolleisten und Tastaturkurzbefehle für den Desktop einrichten
Wer die App auf dem Mac nutzt, sollte wichtige Aktionen in der Menüleiste und der Symbolleiste leicht finden und die zugehörigen Tastaturkurzbefehle erkennen können. Lass Codex commands auf Szenenebene, kontextabhängige Menüeinträge und Schaltflächen in der Symbolleiste mit denselben App-Aktionen verknüpfen. So muss am Desktop niemand nach Funktionen suchen, die nur per Geste erreichbar sind.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28@main
struct LibraryApp: App {
@FocusedObject private var store: LibraryStore?
var body: some Scene {
WindowGroup {
LibraryRootView()
}
.commands {
CommandMenu("Library") {
Button("New Item") {
store?.addItem()
}
.keyboardShortcut("n")
.disabled(store == nil)
Button("Toggle Inspector") {
store?.showInspector.toggle()
}
.keyboardShortcut("i", modifiers: [.command, .option])
.disabled(store == nil)
}
}
Settings {
LibrarySettingsView()
}
}
}
Nutze FocusedValue, den Szenenzustand oder einen expliziten Auswahlzustand, wenn ein Befehl für den aktuell in der Detailansicht angezeigten Eintrag gelten soll. Würde ein Tastaturkurzbefehl an mehreren Stellen registriert, lass Codex die Zuständigkeit an einer Stelle bündeln, damit die App den Befehl eindeutig zuordnet.
App-Einstellungen in Settings verwalten
Verwende für die App-Einstellungen eine eigene Settings-Szene und speichere Einstellungen, die dauerhaft gelten sollen, mit @AppStorage. Ein separates Einstellungsfenster entspricht auf dem Mac meist eher den Erwartungen als eine Einstellungsansicht, zu der man innerhalb des Hauptfensters navigiert.
1
2
3
4
5
6
7
8
9
10
11
12
13
14struct LibrarySettingsView: View {
@AppStorage("showItemMetadata") private var showItemMetadata = true
var body: some View {
TabView {
Form {
Toggle("Show Item Metadata", isOn: $showItemMetadata)
}
.tabItem { Label("General", systemImage: "gearshape") }
}
.frame(width: 460, height: 260)
.scenePadding()
}
}
Die App-Idee im Prompt beschreiben und das Grundgerüst prüfen
Am besten beschreibst du in deinem Prompt die App-Idee, die wichtigsten Objekte, mit denen die App arbeitet, und die zentralen Aktionen. Bitte Codex dann, zuerst das Grundgerüst der Desktop-App passend zu diesem Ablauf zu erstellen. Lass den Agenten kurz prüfen, ob sich die App kompilieren und starten lässt. Anschließend soll er zusammenfassen, wie die Szenen aufgebaut und die Befehle angebunden sind, welche Komponenten welchen Zustand verwalten und wo eine Anbindung an AppKit nötig war.
Tipps für die Praxis
Die Seitenleiste mit nativen Elementen gestalten
Verwende pro Zeile in der Seitenleiste ein Symbol, eine Titelzeile und höchstens eine kurze Zusatzzeile. Platziere ausführlichere Karten, Zähler und Metadaten in der Detailansicht oder im Inspektor, damit die Liste in der Seitenleiste übersichtlich bleibt.
Einstellungen über das App-Menü zugänglich machen
Gilt eine Einstellung für die gesamte App, lass Codex das zugehörige Bedienelement in Settings platzieren, die Auswahl mit @AppStorage speichern und die Einstellungen über das App-Menü zugänglich machen. So brauchst du keine zusätzliche Einstellungsansicht in der Navigation des Hauptfensters.
AppKit gezielt für einzelne Desktop-Funktionen einsetzen
Benötigt die Funktion Dialoge zum Öffnen oder Speichern, Kontrolle über den First Responder oder eine eigene NSView, binde AppKit nur an dieser Stelle ein. SwiftUI verwaltet weiterhin das Zustandsmodell, und du sparst dir die Neuimplementierung des gesamten Fensters in AppKit.