Publish VCC Plus OSS source distribution for 3.6.2 build 60

This commit is contained in:
Brian Holman committed 2026-11-13 00:14:03 -07:00
commit c652a5276d
1192 files changed
+272368

No files matched your search

+266
View File
@@ -0,0 +1,266 @@
// 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)
}
}