// SPDX-License-Identifier: GPL-3.0-or-later import SwiftUI import MetalKit struct EmulatorDisplay: NSViewRepresentable { @ObservedObject var machine: MachineModel @ObservedObject private var preferences: DisplayPreferences var presentationToken = "display" init(machine: MachineModel, presentationToken: String = "display") { self.machine = machine; self.presentationToken = presentationToken self.preferences = machine.displayPreferences } func makeNSView(context: Context) -> KeyboardDisplay { let view = KeyboardDisplay(frame: .zero, device: MTLCreateSystemDefaultDevice()) view.machine = machine view.input = machine.input machine.input.acceptsInput = { [weak view] in guard let view else { return false } return view.inputEnabled && view.window?.isKeyWindow == true && view.window?.firstResponder === view } view.keyChanged = { [weak machine] in machine?.setKeyboard($0) } view.displayFailed = { [weak machine] message in DispatchQueue.main.async { machine?.displayError = message } } view.configure() return view } func updateNSView(_ view: KeyboardDisplay, context: Context) { if view.presentationToken != presentationToken { let restoreFocus = !view.presentationToken.isEmpty && view.window?.isKeyWindow == true view.releaseKeys(); view.presentationToken = presentationToken if restoreFocus { DispatchQueue.main.async { view.window?.makeFirstResponder(view) } } } view.style = preferences.style view.pixels = machine.pixels #if VCC_UI_TESTING view.setAccessibilityValue(machine.uiTestSession + ",\(view.uiTestKeyDowns),\(machine.videoOutput.rawValue)") #endif view.activeVideoRect = machine.activeVideoRect view.synchronizeInput() view.inputEnabled = machine.state == .running && !machine.busy if view.inputEpoch != machine.inputEpoch { view.inputEpoch = machine.inputEpoch; view.releaseKeys() } if view.focusRequest != machine.focusRequest { view.focusRequest = machine.focusRequest DispatchQueue.main.async { view.window?.makeFirstResponder(view) } } view.requestFrame() } static func dismantleNSView(_ view: KeyboardDisplay, coordinator: ()) { view.releaseKeys() } } final class KeyboardDisplay: MTKView, MTKViewDelegate, NSUserInterfaceValidations { weak var machine: MachineModel? @objc func copy(_ sender: Any?) { machine?.copyScreenText() } @objc func paste(_ sender: Any?) { machine?.pasteClipboard() } func validateUserInterfaceItem(_ item: NSValidatedUserInterfaceItem) -> Bool { if item.action == #selector(paste(_:)) { return machine?.canPaste == true } if item.action == #selector(copy(_:)) { return machine.map { !$0.busy && ($0.state == .running || $0.state == .paused) } ?? false } return false } #if VCC_UI_TESTING private(set) var uiTestKeyDowns: UInt64 = 0 #endif var presentationToken = "" var pixels: Data? var activeVideoRect = VideoGeometry.fullFrame var style = DisplayStyle() var inputEnabled = false { didSet { if !inputEnabled && oldValue { releaseKeys() } } } var inputEpoch: UInt64 = 0, focusRequest: UInt64 = 0 var keyChanged: ((UInt64) -> Void)? var displayFailed: ((String) -> Void)? var input: InputHub? private var settingsEpoch: UInt64 = .max private var tracking: NSTrackingArea? private var capsRelease: DispatchWorkItem? private var keyboard = CocoKeyboard() func synchronizeInput() { if settingsEpoch != input?.epoch { settingsEpoch = input?.epoch ?? 0 releaseKeys(); keyboard.mode = input?.settings.keyboard ?? .natural } } private var renderer: MetalRenderer? private var frameRequested = false private(set) var submittedFrames: UInt64 = 0 // SwiftUI can keep a Metal view layer-backed without servicing AppKit's // needsDisplay invalidation. In that state Core Animation stretches the last // presented drawable as the view resizes, even while the guest keeps running. // Drive MTKView's explicit draw path instead; coalesce updates on the main // queue so drawing never reenters a SwiftUI update or drawable-size callback. func requestFrame() { guard !frameRequested else { return } frameRequested = true DispatchQueue.main.async { [weak self] in guard let self else { return } self.frameRequested = false guard self.window?.isVisible == true, !self.isHiddenOrHasHiddenAncestor, self.bounds.width > 0, self.bounds.height > 0 else { return } self.draw() } } override func layout() { super.layout(); requestFrame() } override func viewDidMoveToWindow() { super.viewDidMoveToWindow(); requestFrame() } override func viewDidChangeBackingProperties() { super.viewDidChangeBackingProperties(); requestFrame() } private var focusObservers: [NSObjectProtocol] = [] override var acceptsFirstResponder: Bool { true } override func accessibilityFrame() -> NSRect { guard let window else { return super.accessibilityFrame() } return window.convertToScreen(convert(bounds, to: nil)) } func configure() { colorPixelFormat = .bgra8Unorm isPaused = true; enableSetNeedsDisplay = false; framebufferOnly = true autoResizeDrawable = true; delegate = self setAccessibilityElement(true) setAccessibilityEnabled(true) setAccessibilityRole(.group) setAccessibilityRoleDescription("Emulator display") setAccessibilityLabel("CoCo display") setAccessibilityIdentifier("coco-display") setAccessibilityHelp("Click here or press Option-Command-K to type into the CoCo. Option-Command-U returns to Mac controls. Escape is Break, Home is Clear. Guest graphics are not available as accessible text.") do { guard let device else { throw MetalRenderer.Failure.unavailable } renderer = try MetalRenderer(device: device, library: MetalRenderer.library(device: device, bundle: Bundle(for: KeyboardDisplay.self))) } catch { displayFailed?(error.localizedDescription) } focusObservers.append(NotificationCenter.default.addObserver(forName: NSApplication.didResignActiveNotification, object: nil, queue: .main) { [weak self] _ in self?.releaseKeys() }) focusObservers.append(NotificationCenter.default.addObserver(forName: NSWindow.didResignKeyNotification, object: nil, queue: .main) { [weak self] note in if let window = note.object as? NSWindow, window === self?.window { self?.releaseKeys() } }) } deinit { for observer in focusObservers { NotificationCenter.default.removeObserver(observer) } } override func updateTrackingAreas() { super.updateTrackingAreas() if let tracking { removeTrackingArea(tracking) } let area = NSTrackingArea(rect: bounds, options: [.mouseMoved, .mouseEnteredAndExited, .activeInKeyWindow, .inVisibleRect], owner: self) addTrackingArea(area); tracking = area } private func moveMouse(_ event: NSEvent) { guard inputEnabled, window?.firstResponder === self else { return } let point = convert(event.locationInWindow, from:nil) guard let normalized = VideoGeometry.mouse(point,in:bounds.size,source:activeVideoRect,scaling:style.scaling,drawableSize:drawableSize) else { input?.mouseLeave(); return } input?.mouseMove(x:normalized.x,y:normalized.y) } override func mouseMoved(with event: NSEvent) { moveMouse(event) } override func mouseDragged(with event: NSEvent) { moveMouse(event) } override func rightMouseDragged(with event: NSEvent) { moveMouse(event) } override func mouseExited(with event: NSEvent) { input?.mouseLeave() } override func mouseDown(with event: NSEvent) { window?.makeFirstResponder(self); moveMouse(event) if inputEnabled { input?.mouseButton(0, down: true) } } override func mouseUp(with event: NSEvent) { input?.mouseButton(0, down: false) } override func rightMouseDown(with event: NSEvent) { window?.makeFirstResponder(self); moveMouse(event) if inputEnabled { input?.mouseButton(1, down: true) } } override func rightMouseUp(with event: NSEvent) { input?.mouseButton(1, down: false) } override func resignFirstResponder() -> Bool { releaseKeys(); return super.resignFirstResponder() } func releaseKeys() { capsRelease?.cancel(); keyboard.releaseAll(); keyChanged?(0); input?.release() } private func updateModifiers(_ event: NSEvent) { keyboard.modifiers(shift: event.modifierFlags.contains(.shift), control: event.modifierFlags.contains(.control), alt: event.modifierFlags.contains(.option)) } override func flagsChanged(with event: NSEvent) { guard inputEnabled, !event.modifierFlags.contains(.command) else { releaseKeys(); return } synchronizeInput(); updateModifiers(event) if event.keyCode == 57 { keyboard.press(code: 57, characters: "") capsRelease?.cancel() let release = DispatchWorkItem { [weak self] in guard let self else { return }; self.keyboard.release(code: 57); self.keyChanged?(self.keyboard.mask) } capsRelease = release; DispatchQueue.main.asyncAfter(deadline: .now() + 0.1, execute: release) } keyChanged?(keyboard.mask) } override func keyDown(with event: NSEvent) { guard inputEnabled, !event.modifierFlags.contains(.command) else { releaseKeys(); super.keyDown(with: event); return } guard !event.isARepeat else { return } synchronizeInput() if input?.key(event.keyCode, down: true) == true { return } updateModifiers(event) let modified = event.modifierFlags.intersection([.control, .option]).isEmpty ? event.characters : event.charactersIgnoringModifiers keyboard.press(code: event.keyCode, characters: modified ?? "") #if VCC_UI_TESTING if keyboard.mask != 0 { uiTestKeyDowns += 1 } #endif keyChanged?(keyboard.mask) } override func keyUp(with event: NSEvent) { _ = input?.key(event.keyCode, down: false) keyboard.release(code: event.keyCode); keyChanged?(keyboard.mask) } func mtkView(_ view: MTKView, drawableSizeWillChange size: CGSize) { requestFrame() } func draw(in view: MTKView) { guard let renderer, let drawable = currentDrawable else { return } do { let scale = bounds.width > 0 ? CGFloat(drawable.texture.width)/bounds.width : 1 if try renderer.encode(pixels:pixels,target:drawable.texture,drawable:drawable,activeArea:activeVideoRect,inset:VideoGeometry.border*scale,style:style) != nil { submittedFrames &+= 1 } } catch { displayFailed?(error.localizedDescription) } } } // Shared with native menus; observes only user-driven appearance changes. struct DisplayAppearanceControls: View { @ObservedObject var preferences: DisplayPreferences var body: some View { Picker("Scaling", selection: $preferences.style.scaling) { ForEach(DisplayScaling.allCases, id: \.self) { Text($0.label).tag($0) } }.accessibilityIdentifier("display-scaling") Toggle("Scanlines", isOn: $preferences.style.scanlines).accessibilityIdentifier("display-scanlines") } } struct DisplayControlsView: View { let machine: MachineModel @ObservedObject private var menu: MachineMenuState init(machine: MachineModel) { self.machine = machine; self.menu = machine.menuState } var body: some View { ScrollView { VStack(alignment: .leading, spacing: 16) { SecondaryHeader(title: "Display Settings", symbol: "display", subtitle: "Adjust the picture without restarting your CoCo.") SecondaryCard { Label("Video Signal", systemImage: "cable.connector").font(.headline) Picker("Video Signal", selection: Binding(get: { menu.values.videoOutput }, set: machine.setVideoOutput)) { ForEach(DisplayOutput.allCases, id: \.self) { Text($0.label).tag($0) } }.disabled(menu.values.busy || menu.values.state == .closed) Text("Composite TV reproduces the artifact colors used by many CoCo games. RGB provides a direct monitor signal.") .font(.callout).foregroundStyle(.secondary).fixedSize(horizontal: false, vertical: true) } SecondaryCard { Label("Appearance", systemImage: "slider.horizontal.3").font(.headline) DisplayAppearanceControls(preferences: machine.displayPreferences) SecondaryHelp(title: "How scaling works") { Text("Sharp and Smooth use the largest picture that fits while preserving its proportions. Integer Pixels keeps exact whole-pixel multiples and can leave a large dark-green border, including inside the expanded monitor. Choose Sharp — Fit Window to use more of the screen. If even 1× cannot fit, Integer Pixels fits proportionally instead. Scanlines fade out at small sizes to keep the picture readable.") Text("These choices are remembered for this Mac and apply to Display, System and the expanded monitor. They do not change machine profiles.") }.accessibilityIdentifier("display-scaling-help") SecondaryAction(title: "Reset Display Appearance", systemImage: "arrow.counterclockwise") { machine.displayPreferences.style = DisplayStyle() } } SecondaryCard { Label("Screenshot", systemImage: "camera").font(.headline) Text("Save the active picture as a PNG at native resolution, without the surrounding window or display effects.") .font(.callout).foregroundStyle(.secondary).fixedSize(horizontal: false, vertical: true) SecondaryAction(title: "Save CoCo Screen…", systemImage: "square.and.arrow.up", action: machine.saveScreenshot) .disabled(menu.values.busy || !(menu.values.state == .running || menu.values.state == .paused)) } }.padding(24).frame(maxWidth: 600, alignment: .leading) }.frame(minWidth: 520, minHeight: 500) } }