267 lines
15 KiB
Swift
267 lines
15 KiB
Swift
// 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)
|
||
}
|
||
}
|