| import SwiftUI |
| import AppKit |
| import UniformTypeIdentifiers |
|
|
| func pretty(_ x: Any) -> String { guard let d = try? JSONSerialization.data(withJSONObject: x, options: [.prettyPrinted, .sortedKeys, .withoutEscapingSlashes]) else { return "{}" }; return String(decoding:d,as:UTF8.self) } |
| @MainActor final class Studio: ObservableObject { |
| @Published var geometries: [[String:Any]] = [] |
| @Published var geometry: [String:Any] = [:] |
| @Published var editor = "" |
| @Published var showWeights = false |
| @Published var source = "" |
| @Published var output = "" |
| @Published var report = "" |
| @Published var status = "Starting AFFECTOR…" |
| @Published var busy = false |
| @Published var backend = "Local Qwen" |
| @Published var rewriteStyle = "Restrained" |
| @Published var model = "gpt-6-luna" |
| @Published var key = "" |
| @Published var evaluator = "Local Qwen" |
| @Published var evalModel = "gpt-6-luna" |
| @Published var evalKey = "" |
| @Published var temperature = 0.0 |
| @Published var topP = 0.95 |
| @Published var topK = 40 |
| @Published var tokens = 512 |
| @Published var verification: [String:Any] = [:] |
| @Published var hasRun = false |
| @Published var runSummary = "" |
| @Published var support = "" |
| @Published var error: String? |
| private var process: Process? |
| private var input: FileHandle? |
| private var buffer = Data() |
| func start() { |
| let resources = Bundle.main.resourceURL! |
| let p = Process(); let stdin = Pipe(); let stdout = Pipe(); let stderr = Pipe() |
| p.executableURL = resources.appendingPathComponent("Python.framework/Versions/3.14/bin/python3.14") |
| p.arguments = ["-u",resources.appendingPathComponent("engine/bridge.py").path] |
| p.currentDirectoryURL = resources.appendingPathComponent("engine") |
| var env = ProcessInfo.processInfo.environment |
| env["PYTHONHOME"] = resources.appendingPathComponent("Python.framework/Versions/3.14").path |
| env["PYTHONPATH"] = resources.appendingPathComponent("packages").path |
| env["HF_HOME"] = FileManager.default.urls(for:.cachesDirectory,in:.userDomainMask)[0].appendingPathComponent("AFFECTOR/huggingface").path |
| env["AFFECTOR_MODEL"] = resources.appendingPathComponent("engine/.hf/hub/models--Qwen--Qwen3.5-0.8B/snapshots/2fc06364715b967f1860aea9cf38778875588b17").path |
| env["PYTHONNOUSERSITE"] = "1"; env["PYTHONDONTWRITEBYTECODE"] = "1"; env["PYTORCH_ENABLE_MPS_FALLBACK"] = "1" |
| p.environment = env; p.standardInput = stdin; p.standardOutput = stdout; p.standardError = stderr |
| input = stdin.fileHandleForWriting; process = p |
| stdout.fileHandleForReading.readabilityHandler = { [weak self] h in |
| let d = h.availableData |
| if !d.isEmpty { Task { @MainActor in self?.receive(d) } } |
| } |
| stderr.fileHandleForReading.readabilityHandler = { h in _ = h.availableData } |
| p.terminationHandler = { [weak self] p in Task { @MainActor in self?.busy = false; self?.status = "Engine stopped (\(p.terminationStatus)). Reopen AFFECTOR to restart." } } |
| do { try p.run() } catch { self.error = error.localizedDescription } |
| } |
| func stopProcess() { input?.closeFile(); process?.terminate() } |
| func receive(_ d:Data) { |
| buffer.append(d) |
| while let end = buffer.firstIndex(of:10) { |
| let line = buffer[..<end]; buffer.removeSubrange(...end) |
| guard let obj = (try? JSONSerialization.jsonObject(with:Data(line))) as? [String:Any] else { continue } |
| let data = obj["data"] as? [String:Any] ?? [:] |
| switch obj["event"] as? String { |
| case "ready", "result": |
| if data["reset_text"] as? Bool == true { source = ""; output = ""; report = ""; verification = [:]; runSummary = ""; hasRun = false; error = nil } |
| if let a = data["geometries"] as? [[String:Any]] { geometries = a; if geometry.isEmpty, let first = a.first { select(first) } } |
| if let g = data["geometry"] as? [String:Any] { select(g) } |
| if let s = data["support"] as? String { support = s } |
| if let t = data["text"] as? String { source = t } |
| if let t = data["input"] as? String { source = t } |
| if let style = data["rewrite_style"] as? String { rewriteStyle = style } |
| if let b = data["backend"] as? String { backend = b } |
| if let m = data["model"] as? String { model = m } |
| if let s = data["sampling"] as? [String:Any] { temperature = s["temperature"] as? Double ?? 0; topP = s["top_p"] as? Double ?? 0.95; topK = s["top_k"] as? Int ?? 40; tokens = s["max_tokens"] as? Int ?? 512 } |
| status = data["message"] as? String ?? "Ready" |
| case "geometry": |
| select(data) |
| if let i=geometries.firstIndex(where:{($0["id"] as? String)==(data["id"] as? String)}) {geometries[i]=data} |
| case "progress": status = obj["message"] as? String ?? "Working…" |
| case "run": runSummary = (data["summary"] as? [String:Any])?["message"] as? String ?? ""; output = obj["output"] as? String ?? ""; report = displayReport(data); verification = data["verification"] as? [String:Any] ?? [:]; hasRun = true |
| case "error": error = obj["message"] as? String; status = error ?? "Error" |
| case "saved": status = "Transfer checkpoint saved." |
| case "idle": busy = false |
| default: break |
| } |
| } |
| } |
| func select(_ g:[String:Any]) { geometry = g; showWeights = false; var display=g; display.removeValue(forKey:"basis"); editor = pretty(display) } |
| func toggleWeights() { |
| guard var g=edited() else {return} |
| showWeights.toggle() |
| if !showWeights {geometry["basis"]=g["basis"];g.removeValue(forKey:"basis")} |
| editor=pretty(g) |
| } |
| func displayReport(_ data:[String:Any])->String { |
| var d=data |
| if var g=d["geometry"] as? [String:Any] {g["basis"]="Compiled weights included in exported JSON; edit in Geometry + weights.";d["geometry"]=g} |
| let result=pretty(d) |
| return result.count > 80000 ? String(result.prefix(80000))+"\n… Export the report to view all passages." : result |
| } |
| func edited() -> [String:Any]? { |
| guard let d = editor.data(using:.utf8), var g = (try? JSONSerialization.jsonObject(with:d)) as? [String:Any] else { error = "Geometry must be valid JSON. Check commas and brackets."; return nil } |
| if g["basis"] == nil {g["basis"] = geometry["basis"] ?? NSNull()} |
| return g |
| } |
| func send(_ q:[String:Any]) { |
| guard let input, let d = try? JSONSerialization.data(withJSONObject:q) else { return } |
| if q["op"] as? String != "cancel" && q["op"] as? String != "save_run" { busy = true } |
| do { try input.write(contentsOf:d + Data([10])) } catch { busy = false; self.error = error.localizedDescription } |
| } |
| func open(_ op:String, document:Bool = false) { |
| let panel = NSOpenPanel(); panel.canChooseDirectories = false; panel.allowsMultipleSelection = false |
| panel.allowedContentTypes = document ? [UTType.plainText,UTType.rtf,UTType(filenameExtension:"docx")!] : [.json] |
| if panel.runModal() == .OK, let url = panel.url { send(["op":op,"path":url.path]) } |
| } |
| func save(_ op:String, document:Bool = false) { |
| let panel = NSSavePanel(); panel.nameFieldStringValue = document ? "transformed.txt" : (op == "export_geometry" ? "emotional-shape.json" : "affector-transfer.json") |
| panel.allowedContentTypes = document ? [.plainText,.rtf,UTType(filenameExtension:"docx")!] : [.json] |
| panel.allowsOtherFileTypes = false |
| if panel.runModal() == .OK, let url = panel.url { |
| var q:[String:Any] = ["op":op,"path":url.path] |
| if op == "export_geometry" { guard let g = edited() else { return }; q["geometry"] = g } |
| send(q) |
| } |
| } |
| func transform() { |
| guard let g = edited() else { return } |
| send(["op":"transform","rewrite_style":rewriteStyle,"geometry":g,"text":source,"backend":backend,"model":model,"key":key,"sampling":["temperature":temperature,"top_p":topP,"top_k":topK,"max_tokens":tokens]]) |
| } |
| func geometryAction(_ op:String) { if let g = edited() { send(["op":op,"geometry":g]) } } |
| } |
|
|
| struct Trajectory: View { |
| @Environment(\.colorScheme) private var colorScheme |
| let geometry:[String:Any] |
| var body: some View { |
| Canvas { ctx,size in |
| let points = geometry["points"] as? [[String:Double]] ?? [] |
| func project(_ x:Double,_ y:Double,_ z:Double)->CGPoint { CGPoint(x:size.width*0.48 + CGFloat(x-y*0.45)*size.width*0.28,y:size.height*0.52 - CGFloat(z+y*0.35)*size.height*0.32) } |
| let axes:[(String,(Double,Double,Double))] = [("X · valence",(1.35,0,0)),("Y · direction",(0,1.35,0)),("Z · intensity",(0,0,1.35))] |
| for (name,a) in axes { var p=Path(); p.move(to:project(0,0,0)); p.addLine(to:project(a.0,a.1,a.2)); ctx.stroke(p,with:.color(.gray.opacity(0.6)),lineWidth:1); ctx.draw(Text(name).font(.system(size:10,design:.monospaced)),at:project(a.0,a.1,a.2),anchor:a.0 > 0 ? .trailing : .bottom) } |
| var path=Path() |
| for (i,p) in points.enumerated() { let pos=project(p["v"] ?? 0,p["d"] ?? 0,2*(p["i"] ?? 0.5)-1); if i==0 {path.move(to:pos)} else {path.addLine(to:pos)}; ctx.fill(Path(ellipseIn:CGRect(x:pos.x-3,y:pos.y-3,width:6,height:6)),with:.color(.primary)) } |
| ctx.stroke(path,with:.color(.primary),lineWidth:2) |
| }.frame(height:205).background(colorScheme == .dark ? Color.black : Color.white).overlay(Rectangle().stroke(.primary.opacity(0.15))) |
| } |
| } |
| struct ContentView: View { |
| @EnvironmentObject var s:Studio |
| @AppStorage("appearance") private var appearance = "light" |
| private var darkMode: Bool { appearance == "dark" } |
| @State private var tab = 0 |
| @State private var confirmDelete = false |
| let providers = ["Local Qwen","OpenAI","VT ARC"] |
| var body: some View { |
| VStack(alignment:.leading,spacing:0) { |
| HStack(alignment:.top) { |
| VStack(alignment:.leading,spacing:1) { Text("AFFECTOR").font(.system(size:53,weight:.black,design:.default)).tracking(-3); Text("EMOTIONAL GEOMETRY → WRITTEN FORM").font(.system(size:10,design:.monospaced)).tracking(2) } |
| Spacer() |
| VStack(alignment:.trailing,spacing:8) { Text(s.status).font(.system(size:12,design:.monospaced)).multilineTextAlignment(.trailing).frame(maxWidth:390,minHeight:35); if s.busy { Button("Stop") { s.send(["op":"cancel"]) } } |
| Picker("Appearance",selection:$appearance) {Text("Light").tag("light");Text("Dark").tag("dark")}.pickerStyle(.segmented).labelsHidden().frame(width:170).accessibilityLabel("Appearance") |
| } |
| }.padding(24) |
| Divider().background(.primary) |
| HStack(alignment:.top,spacing:0) { |
| VStack(alignment:.leading,spacing:12) { |
| label("SHAPE LIBRARY") |
| ScrollView { VStack(alignment:.leading,spacing:3) { ForEach(s.geometries.indices,id:\.self) { i in |
| let g=s.geometries[i] |
| Button { s.select(g) } label: { VStack(alignment:.leading,spacing:5) { Text(g["name"] as? String ?? "Untitled").font(.system(size:13,weight:.medium)); Text(String((g["updated_at"] as? String ?? "").prefix(19))).font(.system(size:9,design:.monospaced)) }.frame(maxWidth:.infinity,alignment:.leading).padding(10).background((g["id"] as? String)==(s.geometry["id"] as? String) ? Color.primary.opacity(0.10):Color.clear) }.buttonStyle(.plain).disabled(s.busy) |
| } } }.frame(minHeight:100,maxHeight:240) |
| HStack { Button("New") { s.send(["op":"new"]) }; Button("Open…") { s.open("import") } }.disabled(s.busy) |
| HStack { Button("Export…") { s.save("export_geometry") }; Button("Delete") { confirmDelete=true } }.disabled(s.busy || s.geometry.isEmpty) |
| Trajectory(geometry:s.geometry) |
| Text("Import Emotional Atlas sessions or object/evolution JSON with emotional coordinates. The line follows the text from beginning to end.").font(.system(size:11)).foregroundStyle(.secondary) |
| Spacer() |
| Text("LOCAL STEERING · API TRANSFER\nQWEN3.5 / 0.8B\nEXPERIMENTAL RESEARCH SOFTWARE").font(.system(size:9,design:.monospaced)).lineSpacing(4) |
| }.padding(20).frame(width:255) |
| Divider() |
| VStack(alignment:.leading,spacing:16) { |
| Picker("Workspace",selection:$tab) { Text("01 Document").tag(0); Text("02 Geometry + weights").tag(1); Text("03 Verification").tag(2) }.pickerStyle(.segmented) |
| if tab==0 { document } |
| if tab==1 { geometry } |
| if tab==2 { verification } |
| }.padding(22).frame(maxWidth:.infinity,maxHeight:.infinity,alignment:.top) |
| } |
| }.background(darkMode ? Color.black : Color.white).foregroundStyle(.primary).preferredColorScheme(darkMode ? .dark : .light).frame(minWidth:1080,minHeight:770) |
| .alert("AFFECTOR",isPresented:Binding(get:{s.error != nil},set:{if !$0 {s.error=nil}})) { Button("OK") {s.error=nil} } message: {Text(s.error ?? "")} |
| .alert("Delete this geometry?",isPresented:$confirmDelete) { Button("Delete",role:.destructive) {s.send(["op":"delete","id":s.geometry["id"] ?? ""]);s.geometry=[:];s.editor=""};Button("Cancel",role:.cancel){} } message:{Text("Export a copy first if you want to retain its trajectory and calibrated weights.")} |
| } |
| func label(_ text:String)->some View { Text(text).font(.system(size:10,weight:.semibold,design:.monospaced)).tracking(1.5) } |
| var document: some View { |
| VStack(alignment:.leading,spacing:14) { |
| HStack { Button("Open document…") {s.open("read_doc",document:true)}; Button("Open transfer…") {s.open("load_run")}; Button("Save transfer…") {s.save("save_run")}.disabled(!s.hasRun); Button("Reset text") {s.send(["op":"reset_text"])}.help("Clear both texts and the automatic checkpoint without saving. Keeps geometry, settings and manually saved files."); Spacer();Button("Export output…") {s.save("export_doc",document:true)}.disabled(!s.hasRun) }.disabled(s.busy) |
| if !s.runSummary.isEmpty { Text(s.runSummary).font(.system(size:11,design:.monospaced)).textSelection(.enabled) } |
| HStack(alignment:.top,spacing:18) { |
| VStack(alignment:.leading) {label("INPUT");TextEditor(text:$s.source).font(.system(size:15,design:.serif)).padding(6).overlay(Rectangle().stroke(.gray.opacity(0.4))).disabled(s.busy)} |
| VStack(alignment:.leading) {label("TRANSFORMED TEXT");ScrollView {Text(s.output.isEmpty ? "Your transformed document will appear here." : s.output).font(.system(size:15,design:.serif)).textSelection(.enabled).frame(maxWidth:.infinity,alignment:.leading).padding(12)}.frame(maxWidth:.infinity,maxHeight:.infinity).overlay(Rectangle().stroke(.gray.opacity(0.4)))} |
| }.frame(minHeight:190) |
| Picker("Rewrite style", selection:$s.rewriteStyle) { Text("Minimal").tag("Minimal"); Text("Restrained").tag("Restrained"); Text("Balanced").tag("Balanced"); Text("Creative").tag("Creative") }.pickerStyle(.segmented).disabled(s.busy) |
| Text(["Minimal":"Light edits to a few words or phrases; preserve nearly all original wording.", "Restrained":"Preserve meaning and details; adjust emotional tone through wording and rhythm.", "Balanced":"Reshape phrasing and structure with modest imagery; preserve facts and events.", "Creative":"Allow new imagery, perspectives and events; meaning may change."][s.rewriteStyle] ?? "").font(.system(size:11)).foregroundStyle(.secondary) |
| Text("TXT / RTF / DOCX formatting is not preserved. Generated drafts are saved, including repetitions and incomplete endings. Requested steering is preserved. Incomplete and repetitive endings are trimmed to complete sentences; raw drafts remain in the report. Output aims for the original length; paragraphs share a 125% ceiling.").font(.system(size:10,design:.monospaced)).foregroundStyle(.secondary) |
| Divider() |
| HStack { Picker("Transform with",selection:$s.backend) {ForEach(providers,id:\.self){Text($0)}}.frame(width:260);Spacer();Button("Transform / resume") {s.transform()}.buttonStyle(.bordered).foregroundStyle(.primary).disabled(s.busy || s.geometry.isEmpty) }.disabled(s.busy) |
| if s.backend != "Local Qwen" { HStack {TextField("Model",text:$s.model);SecureField("API key · kept in memory only",text:$s.key)}.textFieldStyle(.roundedBorder).disabled(s.busy);Text("API mode uses coordinate instructions. Hosted APIs do not expose transformer activations.").font(.system(size:11)) } |
| else { HStack {Text("Sampling").font(.system(size:11,design:.monospaced));Text("Temperature");TextField("Temperature",value:$s.temperature,format:.number).frame(width:55);Text("Top-p").padding(.leading,12);TextField("Top-p",value:$s.topP,format:.number).frame(width:55);Text("Top-k").padding(.leading,12);TextField("Top-k",value:$s.topK,format:.number).frame(width:50)}.font(.system(size:11)).disabled(s.busy) } |
| HStack {Text("Output tokens").font(.system(size:11));TextField("Output tokens",value:$s.tokens,format:.number).frame(width:65);Text("base token allowance (32–2048); expanded automatically for longer passages").font(.system(size:11));Spacer();Button("Save progress…") {s.save("save_run")}.disabled(!s.hasRun)} |
| }.onChange(of:s.backend) { _,b in if b=="VT ARC" {s.model="gpt-oss-120b"} else if b=="OpenAI" {s.model="gpt-6-luna"} } |
| } |
| var geometry: some View { |
| VStack(alignment:.leading,spacing:12) { |
| Text("A shape is a trajectory and a transformer module.").font(.system(size:24,weight:.semibold)) |
| Text("Edit the name, points, selected layers (0–23), controls, or compiled basis vectors below. Save to update the preview. Recalibrate after changing layers or model identity.").font(.system(size:12)) |
| Text("t = position · v = valence [−1,1] · d = direction [−1,1] · i = intensity [0,1]\nstrength = injection scale · budget = maximum relative RMS · inertia = temporal smoothing\naxis_top_k / axis_mass / axis_temperature select and reshape activation coefficients, independently of token sampling.").font(.system(size:11,design:.monospaced)).lineSpacing(5) |
| Text("Extreme values for strength, budget, and inertia may cause generation failures.").font(.system(size:12)).foregroundStyle(.red) |
| HStack { |
| control("Strength", "strength", 0...1) |
| control("Budget", "budget", 0...1) |
| control("Inertia", "inertia", 0...0.99) |
| }.disabled(s.busy) |
| TextEditor(text:$s.editor).font(.system(size:11,design:.monospaced)).padding(6).overlay(Rectangle().stroke(.gray.opacity(0.4))).disabled(s.busy) |
| HStack {Button("Save geometry") {s.geometryAction("save")};Button("Calibrate local module") {s.geometryAction("calibrate")};Button(s.showWeights ? "Hide numerical weights" : "Edit numerical weights") {s.toggleWeights()};Spacer();Text("Calibration is experimental; emotional fit is measured separately.").font(.system(size:10)).foregroundStyle(.secondary)}.disabled(s.busy || s.geometry.isEmpty) |
| } |
| } |
| func control(_ title:String,_ key:String,_ range:ClosedRange<Double>)->some View { |
| let binding=Binding<Double>(get:{ |
| let obj=(try? JSONSerialization.jsonObject(with:Data(s.editor.utf8))) as? [String:Any] |
| return (obj?["controls"] as? [String:Any])?[key] as? Double ?? 0 |
| },set:{ value in |
| guard var g=(try? JSONSerialization.jsonObject(with:Data(s.editor.utf8))) as? [String:Any],var c=g["controls"] as? [String:Any] else {return} |
| c[key]=value;g["controls"]=c;s.editor=pretty(g) |
| }) |
| return VStack(alignment:.leading){Text("\(title) \(binding.wrappedValue, specifier:"%.2f")").font(.system(size:11,design:.monospaced));Slider(value:binding,in:range).tint(.primary)} |
| } |
| var verification: some View { |
| VStack(alignment:.leading,spacing:14) { |
| Text("Measure the change, passage by passage.").font(.system(size:24,weight:.semibold)) |
| Text("Evaluate original and revised text with the Emotional Atlas scoring prompt. Similarity measures proximity to the requested coordinates; it is not a probability or a measure of semantic fidelity.").font(.system(size:12)) |
| HStack {Picker("Evaluator",selection:$s.evaluator){ForEach(providers,id:\.self){Text($0)}}.frame(width:260);Spacer();Button("Verify output") {s.send(["op":"verify","provider":s.evaluator,"model":s.evalModel,"key":s.evalKey])}.disabled(s.busy || !s.hasRun);Button("Export report…") {s.save("export_report")}.disabled(s.busy || !s.hasRun)} |
| if s.evaluator != "Local Qwen" {HStack {TextField("Evaluator model",text:$s.evalModel);SecureField("Evaluator API key",text:$s.evalKey)}.textFieldStyle(.roundedBorder)} |
| HStack(spacing:30) { score("ORIGINAL",s.verification["before_similarity"] as? Double);score("TRANSFORMED",s.verification["after_similarity"] as? Double);score("IMPROVEMENT",s.verification["improvement"] as? Double);VStack(alignment:.leading){label("PAIRED COVERAGE");Text("\(s.verification["paired_count"] as? Int ?? 0) / \(s.verification["total_count"] as? Int ?? 0)").font(.system(size:26,weight:.light))} }.padding(.vertical,12) |
| Text("Similarity = 1 − distance / (2√3), with z = 2 × intensity − 1. Unknown directions and failed evaluations are excluded. Local 0.8B scoring may be unreliable; compare with an independent API evaluator.").font(.system(size:11)).foregroundStyle(.secondary) |
| label("TRANSFER + EVALUATION RECORD · FULL WEIGHTS IN EXPORT") |
| ScrollView {Text(s.report.isEmpty ? "Run a transfer, then verify its output." : s.report).font(.system(size:11,design:.monospaced)).textSelection(.enabled).frame(maxWidth:.infinity,alignment:.leading).padding(12)}.frame(maxWidth:.infinity,maxHeight:.infinity).overlay(Rectangle().stroke(.gray.opacity(0.4))) |
| }.onChange(of:s.evaluator) {_,b in if b=="VT ARC" {s.evalModel="gpt-oss-120b"} else if b=="OpenAI" {s.evalModel="gpt-6-luna"} } |
| } |
| func score(_ name:String,_ value:Double?)->some View {VStack(alignment:.leading){label(name);Text(value.map{String(format:"%.3f",$0)} ?? "—").font(.system(size:26,weight:.light,design:.monospaced))}} |
| } |
| final class AppDelegate: NSObject, NSApplicationDelegate { |
| var studio:Studio? |
| func applicationShouldTerminate(_ sender:NSApplication)->NSApplication.TerminateReply { |
| if studio?.busy == true {let a=NSAlert();a.messageText="Stop the active operation and quit?";a.informativeText="Generated drafts are saved, including repetitions and incomplete endings. Requested steering is preserved. Incomplete and repetitive endings are trimmed to complete sentences; raw drafts remain in the report. Output aims for the original length; paragraphs share a 125% ceiling. The current passage may need to be repeated.";a.addButton(withTitle:"Quit");a.addButton(withTitle:"Keep working");if a.runModal() != .alertFirstButtonReturn{return .terminateCancel}} |
| studio?.stopProcess();return .terminateNow |
| } |
| func applicationShouldTerminateAfterLastWindowClosed(_ sender:NSApplication)->Bool {true} |
| } |
| @main struct AffectorApp: App { |
| @NSApplicationDelegateAdaptor(AppDelegate.self) var delegate |
| @StateObject private var studio=Studio() |
| var body: some Scene {WindowGroup {ContentView().environmentObject(studio).onAppear{if delegate.studio == nil {delegate.studio=studio;studio.start()}}}.defaultSize(width:1230,height:850).commands {CommandGroup(replacing:.newItem){};CommandGroup(after:.saveItem){Button("Save transfer…"){studio.save("save_run")}.keyboardShortcut("s").disabled(!studio.hasRun)}}} |
|
|
| } |
|
|
