// SPDX-License-Identifier: GPL-3.0-or-later import SwiftUI enum SystemTarget: Hashable, Identifiable { case computer, keyboard, joystick, cassette, printer, library, manuals, monitor, selector, slot(Int), sdc(Int), floppy(Int), hard(Int) var id: String { String(describing: self) } var title: String { switch self { case .manuals: return "Help — Manual Library" case .library: return "Software Library" case .monitor: return "Monitor video signal" case .computer: return "Color Computer 3" case .keyboard: return "Keyboard" case .joystick: return "Joystick ports" case .cassette: return "Cassette" case .printer: return "Tandy TP-10 printer" case .selector: return "Multi-Pak startup selector" case .slot(let n): return "Multi-Pak slot \(n)" case .sdc(let n): return "CoCo SDC in slot \(n)" case .floppy(let n): return "Floppy FD\(n)" case .hard(let n): return "Hard disk HD\(n)" } } var action: String { switch self { case .manuals: return "Open the offline manual index" case .library: return "Open the Software Library" case .printer: return "Open Printer Output" case .monitor: return "Choose the monitor video signal" default: return "Show " + title + " controls" } } var mediaDestination: MediaDestination? { switch self { case .computer: return .systemROM case .cassette: return .cassette case .slot(let n), .sdc(let n): return .cartridge(n) case .floppy(let n): return .floppy(n) case .hard(let n): return .hardDisk(n) default: return nil } } // Scene coordinates shared with runtime-system.svg. The slot targets follow // the sockets and their numbered shelf, independent of cartridge occupancy. var rect: CGRect { switch self { case .manuals: return CGRect(x: 453, y: 400, width: 58, height: 50.025) case .library: return CGRect(x: 430, y: 19, width: 285, height: 115) case .monitor: return CGRect(x: 54, y: 219, width: 272, height: 23) case .computer: return CGRect(x: 52, y: 279, width: 284, height: 24) case .keyboard: return CGRect(x: 49, y: 324, width: 284, height: 84) case .joystick: return CGRect(x: -100, y: 354, width: 112, height: 94) case .cassette: return CGRect(x: -111, y: 205, width: 150, height: 138) case .printer: return CGRect(x: -113, y: 89, width: 159, height: 93) case .selector: return CGRect(x: 367, y: 368, width: 195, height: 21) case .sdc(let n): return SystemTarget.slot(n).rect case .slot(let n): return [CGRect(x: 366, y: 313, width: 173, height: 16), CGRect(x: 358, y: 295, width: 170, height: 15), CGRect(x: 352, y: 278, width: 166, height: 14), CGRect(x: 349, y: 260, width: 158, height: 16)][n - 1] case .floppy(let n): return Self.driveFace(y: [339.966641, 308.442122, 268.911376, 237.386856][n]) case .hard(let n): return Self.driveFace(y: n == 0 ? 411.021906 : 379.497387) } } private static func driveFace(y: Double) -> CGRect { // Exact outer black face bounds after the SVG's vertical bay transform. // Equal insets plus strokeBorder keep every highlight inside the face. CGRect(x: 649.35728, y: y, width: 174.13544, height: 31.79139 * 0.96012592) .insetBy(dx: 1.25, dy: 1.25) } } struct MachineStage: View { @Environment(\.openWindow) private var openWindow @ObservedObject var machine: MachineModel @ObservedObject var presentation: PresentationSettings let system: Bool let openManualIndex: () -> Void @State private var target: SystemTarget? @State private var list = false @State private var hovered: SystemTarget? @FocusState private var focused: SystemTarget? private var targets: [SystemTarget] { var result: [SystemTarget] = [.computer, .keyboard, .printer, .cassette, .joystick, .monitor, .library, .manuals] if machine.hardware.values["mpi"] == "on" { result += [.selector] + (1...4).map { .slot($0) } } if machine.hardware.values["floppyCase"] == "on" { result += (0..<4).map { .floppy($0) } } if machine.hardware.values["hardCase"] == "on" { result += (0..<2).map { .hard($0) } } return result } var body: some View { GeometryReader { proxy in let geometry = SystemGeometry(size: proxy.size, system: system, expanded: presentation.expanded, contentBounds: HardwareArtwork.shared.layoutBounds(machine.hardware.values)) ZStack(alignment: .topLeading) { if system { HardwareCanvas(values: machine.hardware.values, part: "scene") .frame(width: geometry.scene.width, height: geometry.scene.height) .position(x: geometry.scene.midX, y: geometry.scene.midY) .opacity(presentation.expanded ? 0.20 : 1).accessibilityHidden(true).allowsHitTesting(false) if let image = HardwareArtwork.shared.image("software-library-shelf.png") { let shelf = geometry.rect(SystemGeometry.libraryArtwork) Image(nsImage: image).resizable().scaledToFit() .frame(width: shelf.width, height: shelf.height) .position(x: shelf.midX, y: shelf.midY) .opacity(presentation.expanded ? 0.20 : 1) .accessibilityHidden(true).allowsHitTesting(false) } if let image = HardwareArtwork.shared.image("manual-help.pdf") { let button = geometry.rect(SystemTarget.manuals.rect) Image(nsImage: image).resizable().scaledToFit() .frame(width: button.width, height: button.height) .position(x: button.midX, y: button.midY) .opacity(presentation.expanded ? 0.20 : 1) .accessibilityHidden(true).allowsHitTesting(false) } if !presentation.expanded { connectionOverlay(geometry) ForEach(["floppy", "hard"], id: \.self) { kind in if machine.hardware.values[kind + "Case"] == "on" && machine.hardware.values[kind] != "on" { let r = geometry.rect(CGRect(x: 649, y: kind == "floppy" ? 300 : 400, width: 176, height: 20)) Text("\(kind == "floppy" ? "Floppy" : "Hard-disk") controller disconnected") .font(.caption).foregroundStyle(.black).padding(4) .background(.white.opacity(0.9), in: RoundedRectangle(cornerRadius: 4)) .position(x: r.midX, y: r.midY).allowsHitTesting(false) } } ForEach(targets.filter { $0 != .monitor }) { item in hotspot(item, frame: geometry.rect(item.rect)) } ForEach(1...4, id: \.self) { n in if machine.hardware.values["mpi"] == "on", machine.hardware.values["slot\(n)"] == "sdc", let rect = HardwareArtwork.shared.cartridgeHitRect(slot: n, values: machine.hardware.values) { hotspot(.sdc(n), frame: geometry.rect(rect)) } } } HardwareCanvas(values: machine.hardware.values, part: "monitor") .frame(width: geometry.monitor.width, height: geometry.monitor.height) .position(x: geometry.monitor.midX, y: geometry.monitor.midY).accessibilityHidden(true).allowsHitTesting(false) hotspot(.monitor, frame: geometry.monitorRect(SystemTarget.monitor.rect)) } // This representable occupies the same structural position in // every presentation: one MTKView, one input owner, one session. EmulatorDisplay(machine: machine, presentationToken: "\(system)-\(presentation.expanded)") .frame(width: geometry.screen.width, height: geometry.screen.height) .position(x: geometry.screen.midX, y: geometry.screen.midY) if machine.pixels == nil { VStack(spacing: 8) { Text("VCC").font(.headline) Text(machine.state == .empty ? "Open a CoCo 3 ROM to begin" : "Press Run to generate a frame") .font(.callout).multilineTextAlignment(.center) }.foregroundStyle(.white.opacity(0.85)) .frame(width: geometry.screen.width, height: geometry.screen.height) .position(x: geometry.screen.midX, y: geometry.screen.midY).allowsHitTesting(false) } if system { HStack { Button { list.toggle() } label: { Label("Devices", systemImage: "list.bullet") } .popover(isPresented: $list) { ScrollView { VStack(alignment: .leading, spacing: 8) { Text("System devices").font(.headline) Text("All illustrated objects are available here, including obscured slots.").font(.caption).foregroundStyle(.secondary) ForEach(targets) { item in if item == .manuals { Button { list = false; openManualIndex() } label: { Label("Open Manual Library", systemImage: "books.vertical") } } else { DisclosureGroup(item.title + " — " + description(item)) { SystemDeviceControls(machine: machine, target: item).padding(.vertical, 8) } } } }.padding(16) }.frame(width: 430, height: 520) } Toggle("Connections", isOn: $presentation.showConnections).toggleStyle(.button) .help("Show which controller connects to each set of drives") Spacer(minLength: 16) Toggle("Show Clickable Areas", isOn: $presentation.showClickableAreas) .toggleStyle(.checkbox).accessibilityIdentifier("show-clickable-areas") .help("Outline available controls with dashed gray lines. Hover or focus highlights one in blue.") }.controlSize(.small).environment(\.colorScheme, .light).padding(10) } } .onChange(of: presentation.mode) { _, _ in target = nil; list = false; hovered = nil; focused = nil } .onChange(of: presentation.expanded) { _, _ in target = nil; list = false; hovered = nil; focused = nil } } } private func hotspot(_ item: SystemTarget, frame: CGRect) -> some View { let active = focused == item || hovered == item return Button { if item == .manuals { target = nil; openManualIndex() } else if item == .library { target = nil; openWindow(id: "software-library") } else if item == .printer { target = nil; openWindow(id: "printer") } else { target = item } } label: { RoundedRectangle(cornerRadius: 4).fill(Color.white.opacity(0.001)) .contentShape(Rectangle()) .overlay(alignment: .topTrailing) { if unavailable(item) { Image(systemName: "exclamationmark.triangle.fill").foregroundStyle(.orange).font(.caption) } } .overlay { RoundedRectangle(cornerRadius: 4) .strokeBorder(active ? Color.accentColor : presentation.showClickableAreas ? Color.gray.opacity(0.7) : .clear, style: StrokeStyle(lineWidth: active ? 2 : 1, dash: active ? [] : [4, 3])) .allowsHitTesting(false) } }.buttonStyle(.plain) // Do not grow narrow MPI rows into their neighbours at small sizes. // Devices supplies a larger, accessible alternative for every target. .frame(width: frame.width, height: frame.height) .modifier(MediaDropTarget(machine: machine, destination: item.mediaDestination)) .focused($focused, equals: item) .onHover { hovered = $0 ? item : nil } .accessibilityIdentifier("system-\(item.id)") .accessibilityLabel(item.title).accessibilityValue(description(item)) .help(item.action) .popover(isPresented: Binding(get: { target == item }, set: { if !$0 && target == item { target = nil } })) { SystemDeviceControls(machine: machine, target: item) } // Attach the popover to the device bounds, before scene positioning. .position(x: frame.midX, y: frame.midY) } private func unavailable(_ item: SystemTarget) -> Bool { switch item { case .slot(let n), .sdc(let n): return machine.cartridgeAssignments.slots[n].kind != .empty && machine.cartridgeNames[n].isEmpty case .floppy(let n): return machine.diskRestoreErrors[n] != nil case .hard(let n): return machine.hardRestoreErrors[n] != nil case .printer: return machine.printer.dropped > 0 default: return false } } private func description(_ item: SystemTarget) -> String { switch item { case .manuals: return "Offline books for VCC Plus" case .library: return "Browse, install and play Color Computer software" case .monitor: return machine.videoOutput.label case .printer: return "\(machine.printer.enabled ? "Capturing" : "Capture stopped") · \(machine.printer.byteCount.formatted()) bytes\(machine.printer.unsaved ? " · Not saved" : "")" case .computer: return "\(MachineSettings.memoryLabels[machine.settings.ram]), \(machine.use6309 ? "Hitachi 6309" : "Motorola 6809")" case .cassette: return machine.tapeMounted ? machine.tapeName + " · " + machine.tapeTransportDescription : "Empty" case .slot(let n), .sdc(let n): let slot = machine.cartridgeAssignments.slots[n] if slot.kind == .sdc, !machine.cartridgeNames[n].isEmpty { return "CoCo SDC · \(slot.sdcFolderURL?.lastPathComponent ?? "No SD card folder") · \(machine.hardware.values["sdcActivity"] ?? "empty") · \(machine.sdcReadOnly ? "Read-only" : "Writable")" } return slot.kind == .empty ? "Empty" : machine.cartridgeNames[n].isEmpty ? "Unavailable — open controls to repair" : machine.cartridgeNames[n] case .selector: return "Startup \(machine.cartridgeAssignments.physicalSlot); live ROM \(machine.romSlot), I/O \(machine.ioSlot)" case .floppy(let n): return diskDescription(machine.disks, n, activity: n) case .hard(let n): return diskDescription(machine.hardDisks, n, activity: n+4) case .joystick: return "Assignments for both CoCo ports" case .keyboard: return "Host key mappings and input help" } } private func diskDescription(_ disks: [VCCDiskSnapshot], _ n: Int, activity: Int) -> String { guard disks.indices.contains(n), disks[n].mounted else { let error = activity < 4 ? machine.diskRestoreErrors[n] : machine.hardRestoreErrors[n] return error == nil ? "Empty" : "Unavailable — open controls to repair the file location" } let d = disks[n] return "\(d.name) · \(machine.hardware.activities[activity].rawValue)\(d.dirty ? " · Unsaved" : "")\(d.writeProtected ? " · Write protected" : "")" } @ViewBuilder private func connectionOverlay(_ geometry: SystemGeometry) -> some View { let selection = focused ?? hovered ?? target ForEach(1...4, id: \.self) { n in let kind = machine.hardware.values["slot\(n)"] ?? "empty" if (kind == "floppy" || kind == "hard") && (presentation.showConnections || selection == .slot(n)) { let from = geometry.rect(SystemTarget.slot(n).rect) let to = geometry.rect((kind == "floppy" ? SystemTarget.floppy(2) : SystemTarget.hard(1)).rect) Path { p in p.move(to: CGPoint(x: from.midX, y: from.minY)) p.addCurve(to: CGPoint(x: to.minX, y: to.midY), control1: CGPoint(x: from.midX+30, y: from.minY-55), control2: CGPoint(x: to.minX-40, y: to.midY-50)) }.stroke(Color.accentColor.opacity(0.65), style: StrokeStyle(lineWidth: 2, dash: [5,4])) .allowsHitTesting(false).accessibilityHidden(true) Text("Slot \(n) → \(kind == "floppy" ? "FD0–FD3" : "HD0–HD1")") .font(.caption).padding(4).background(.regularMaterial, in: RoundedRectangle(cornerRadius: 4)) .position(x: (from.midX+to.minX)/2, y: min(from.minY,to.minY)-22).allowsHitTesting(false) } } } } struct SystemDeviceControls: View { @ObservedObject var machine: MachineModel let target: SystemTarget @Environment(\.openWindow) private var openWindow var body: some View { VStack(alignment: .leading, spacing: 12) { Text(target.title).font(.headline) controls if let error = machine.fileError ?? machine.error { Text(error).foregroundStyle(.red).textSelection(.enabled) } }.padding(16).frame(width: 375) } @ViewBuilder private var controls: some View { switch target { case .manuals: EmptyView() // Opens the reader directly. case .library: Text("Explore the software collection, read manuals, and choose something to play.") Button { openWindow(id: "software-library") } label: { Label("Open Software Library", systemImage: "books.vertical") } .accessibilityIdentifier("system-library-open") case .printer: SystemPrinterControls(printer: machine.printer) case .monitor: SystemVideoControls(machine: machine).equatable() case .computer: Text("Memory holds your working program. CPU or memory changes restart the computer and clear RAM.") Text("\(MachineSettings.memoryLabels[machine.settings.ram]) · \(machine.use6309 ? "Hitachi 6309" : "Motorola 6809")") Button("Machine Settings…") { openWindow(id: "machine-settings") } case .keyboard, .joystick: Text("Your Mac controller, mouse or keyboard can operate either CoCo joystick port. The pictured joystick's position does not assign a port.") Text("Click the monitor to type. Escape is Break; Home is Clear. Leaving the display releases held keys and buttons.") Button("Keyboard and Joysticks…") { openWindow(id: "input") } case .cassette: Text(machine.tapeName).textSelection(.enabled) Text(machine.tapeTransportDescription) Text("Play prepares the tape; the computer controls movement. Record creates a new tape in memory. Export keeps a recording on your Mac.").font(.callout).foregroundStyle(.secondary) HStack { Button("Play") { machine.tapeAction(1) }.disabled(!machine.tapeMounted || machine.tapeMode == 2) Button("Stop") { machine.tapeAction(0) }.disabled(!machine.tapeMounted) Button("Rewind") { machine.tapeAction(2) }.disabled(!machine.tapeMounted) }.disabled(machine.busy || machine.state == .closed) if machine.tapeDirty || machine.tapeMode == 2 { Label("Unsaved recording — export to keep", systemImage: "exclamationmark.circle").foregroundStyle(.orange) } Button("Cassette Controls…") { openWindow(id: "cassette") } case .selector: Text("Startup selection takes effect with a cold restart and clears RAM. Software can route ROM and disk I/O independently afterward.").font(.callout) Picker("Startup slot", selection: Binding(get: { machine.cartridgeAssignments.physicalSlot }, set: machine.selectPhysicalSlot)) { ForEach(1...4,id: \.self) { Text("\($0)").tag($0) } }.pickerStyle(.segmented).disabled(machine.busy || machine.diskSaving || machine.diskBusy) Text("Live ROM slot \(machine.romSlot) · Disk I/O slot \(machine.ioSlot)").foregroundStyle(.secondary) case .slot(let n), .sdc(let n): let slot = machine.cartridgeAssignments.slots[n] if slot.kind == .sdc { SystemSDCControls(machine: machine, slot: n) } else { Text(slot.url?.lastPathComponent ?? (slot.kind == .floppy ? "Floppy controller (FD-502)" : slot.kind == .hardDisk ? "Virtual hard-disk controller" : slot.kind == .orchestra90 ? "Orchestra-90" : slot.kind == .speechSound ? "Speech/Sound Cartridge" : "Empty")) .textSelection(.enabled) Text(slot.kind == .speechSound ? "Speech/Sound adds speech and music for supporting programs. Both internal chip ROMs are required. It has no boot ROM; keep the disk controller as your startup slot." : slot.kind == .orchestra90 ? "Orchestra-90 provides stereo sound to supporting software. Its optional 8 KiB ROM adds the music program; choose it in Cartridge Settings and select this startup slot to boot it. Sound ports work independently of the live ROM selection." : slot.kind == .floppy ? "One controller serves FD0–FD3 in two enclosures. The FD-502 badges identify the emulated floppy controller." : slot.kind == .hardDisk ? "This separate virtual controller serves HD0–HD1. It has no boot ROM; use a compatible floppy ROM or OS-9 boot disk." : "A ROM cartridge contains a program. A storage controller connects the computer to disks; it does not contain the disks' files.").font(.callout).foregroundStyle(.secondary) Text("Changing this slot cold-restarts the computer and clears its working program.").font(.caption) VStack(alignment: .leading, spacing: 8) { Button("Choose ROM…") { machine.openCartridgeROM(n) } Button("Use Floppy Controller…") { machine.requestCartridge(.floppy, slot: n) }.disabled(slot.kind == .floppy) Button("Use Hard-Disk Controller…") { machine.requestCartridge(.hardDisk, slot: n) }.disabled(slot.kind == .hardDisk) Button("Use Speech/Sound…") { machine.requestCartridge(.speechSound, slot: n) }.disabled(slot.kind == .speechSound) Button("Use Orchestra-90…") { machine.requestCartridge(.orchestra90, slot: n) }.disabled(slot.kind == .orchestra90) Button("Use CoCo SDC…") { machine.requestCartridge(.sdc, slot: n) }.disabled(slot.kind == .sdc) Button("Use RAM Disk…") { machine.requestCartridge(.ramDisk, slot: n) }.disabled(slot.kind == .ramDisk) Button("Remove Cartridge…") { machine.requestCartridge(.empty, slot: n) }.disabled(slot.kind == .empty) }.disabled(machine.busy || machine.diskSaving || machine.diskBusy || machine.state == .closed) } if let error = machine.cartridgeRestoreErrors[n] { Text(error).foregroundStyle(.orange) } Button("All Cartridge Settings…") { openWindow(id: "cartridges") } case .floppy(let n): diskControls(n, hard: false) case .hard(let n): diskControls(n, hard: true) } } @ViewBuilder private func diskControls(_ n: Int, hard: Bool) -> some View { let disks = hard ? machine.hardDisks : machine.disks if !(hard ? machine.hardDiskConnected : machine.diskConnected) { Text("Controller disconnected. Retained media remains available here; connect the controller in Cartridges to use it.").foregroundStyle(.orange) Button("Cartridges…") { openWindow(id: "cartridges") } } if disks.indices.contains(n) { let disk = disks[n] let remembered = hard ? machine.hardSettings.drives[n]?.url : machine.diskAssignments.drives[n]?.url Text(disk.mounted ? disk.name : remembered.map { "Unavailable — " + $0.lastPathComponent } ?? "Empty").textSelection(.enabled) if let error = hard ? machine.hardRestoreErrors[n] ?? machine.hardSaveErrors[n] : machine.diskRestoreErrors[n] ?? machine.diskSaveErrors[n] { Text(error).foregroundStyle(.orange).textSelection(.enabled) } Text("\(hard ? "HD" : "FD")\(n) · \(machine.hardware.activities[hard ? n+4 : n].rawValue.capitalized)").foregroundStyle(.secondary) if disk.dirty { Label("Unsaved changes", systemImage: "exclamationmark.circle").foregroundStyle(.orange) } let temporary = hard ? machine.hardTemporary[n] : machine.diskTemporary[n] Text(disk.writeProtected ? "Write protected" : temporary ? "Temporary changes — Save As to keep" : "Writable backed images save automatically") .font(.callout).foregroundStyle(.secondary) HStack { Button("Insert…") { if hard { machine.openHardDisk(n) } else { machine.openDisk(n) } }.disabled(disk.dirty) Button("Eject") { if hard { machine.ejectHardDisk(n) } else { machine.ejectDisk(n) } }.disabled(disk.dirty || !disk.mounted) Button("Save As…") { if hard { machine.exportHardDisk(n) } else { machine.exportDisk(n) } }.disabled(!disk.mounted) }.disabled(machine.busy || machine.diskSaving || (!hard && machine.diskBusy) || machine.state == .closed) Text("The pictured medium is a file on your Mac. Insertion does not run its software. Media changes pause emulation.").font(.callout).foregroundStyle(.secondary) } Button("\(hard ? "Hard Disk" : "Floppy") Controls…") { openWindow(id: hard ? "hard-disks" : "disks") } } } // Keep a native signal picker stable while its surrounding popover refreshes. private struct SystemVideoControls: View, Equatable { @Environment(\.openWindow) private var openWindow let machine: MachineModel @ObservedObject private var menu: MachineMenuState init(machine: MachineModel) { self.machine = machine; self.menu = machine.menuState } static func == (lhs: Self, rhs: Self) -> Bool { lhs.machine === rhs.machine } var body: some View { VStack(alignment: .leading, spacing: 12) { Picker("Video Signal", selection: Binding(get: { menu.values.videoOutput }, set: machine.setVideoOutput)) { ForEach(DisplayOutput.allCases, id: \.rawValue) { Text($0.label).tag($0) } }.accessibilityIdentifier("monitor-video-signal") .disabled(menu.values.busy || menu.values.state == .closed) Text("Composite TV reproduces the artifact colors used by many CoCo games. Alternate Colors swaps their color phase. RGB gives a direct monitor signal.") .font(.callout).foregroundStyle(.secondary) Button("Display Settings…") { openWindow(id: "display-settings") } Text("Changing the signal preserves the running session.").font(.caption).foregroundStyle(.secondary) } } } // The accessible Devices alternative uses the same capture model and commands // as the dedicated window. Paper feed on the illustration is not a second UI. private struct SystemPrinterControls: View { @ObservedObject var printer: PrinterModel @Environment(\.openWindow) private var openWindow var body: some View { VStack(alignment: .leading, spacing: 10) { Text("\(printer.byteCount.formatted()) captured bytes\(printer.unsaved ? " · Not saved" : "")") Text("The power light shows capture is enabled. Marks on the paper show that output has been collected. Open Printer Output to read, save or print it.") .font(.callout).foregroundStyle(.secondary) HStack { Button { printer.setCapture(!printer.enabled) } label: { Label(printer.enabled ? "Stop Capture" : "Start Capture", systemImage: printer.enabled ? "stop.fill" : "record.circle") }.disabled(printer.busy) Button("Printer Output…") { openWindow(id: "printer") } } } } } // Shares the same queued commands and restart/media protections as Cartridges. private struct SystemSDCControls: View { @ObservedObject var machine: MachineModel let slot: Int var body: some View { VStack(alignment: .leading, spacing: 8) { Label("CoCo SDC", systemImage: "sdcard").font(.headline) Text(machine.cartridgeAssignments.slots[slot].sdcFolderURL?.lastPathComponent ?? "No SD card folder") .textSelection(.enabled) if let folder = machine.cartridgeAssignments.slots[slot].sdcFolderURL { Button { NSWorkspace.shared.activateFileViewerSelecting([folder]) } label: { Label("Show SD Card Folder in Finder", systemImage: "folder") } } Text(machine.sdcReadOnly ? "Read-only SD card" : "Writable SD card — changes save directly") Text("Current folder: \(machine.sdcDirectory.isEmpty ? "/" : machine.sdcDirectory)").font(.callout) ForEach(0..<2, id: \.self) { drive in Text("SDC\(drive): \(machine.sdcDriveNames.indices.contains(drive) && !machine.sdcDriveNames[drive].isEmpty ? machine.sdcDriveNames[drive] : "No image mounted")") .textSelection(.enabled) } Text("Transfers · Read \(machine.sdcReadCount) · Written \(machine.sdcWriteCount)") .monospacedDigit().accessibilityIdentifier("system-sdc-transfers") if let error = machine.sdcError { Text(error).foregroundStyle(.orange) } Button { machine.openSDCFolder(slot) } label: { Label("Choose SD Card Folder…", systemImage: "folder") } .disabled(machine.busy || machine.diskSaving || machine.diskBusy || machine.state == .closed) Button { machine.openCartridgeROM(slot, kind: .sdc) } label: { Label("Choose SDC-DOS ROM…", systemImage: "memorychip") } .disabled(machine.busy || machine.diskSaving || machine.diskBusy || machine.state == .closed) Text("Changing the folder or ROM cold-restarts the CoCo. Use Cartridge Settings for write protection and slot changes.") .font(.caption).foregroundStyle(.secondary) Text("Green means an image is mounted; amber and red show actual reads and writes. Closing these controls keeps the session running.") .font(.caption).foregroundStyle(.secondary) } } }