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

@@ -0,0 +1,820 @@
// SPDX-License-Identifier: GPL-3.0-or-later
import SwiftUI
import AppKit
struct BASICDevelopmentView: View {
@ObservedObject var model: BASICDevelopmentModel
@StateObject private var finder = SourceFind()
let reference: BASICReferenceModel?
@ObservedObject private var menu: MachineMenuState
@Environment(\.openWindow) private var openWindow
@State private var exportKind: BASICExportKind?
@State private var editingSheet: BASICEditingSheet?
@State private var diagnosticsExpanded = true
@State private var pendingEditingAction: (() -> Void)?
@State private var pendingExport: (kind: BASICExportKind, name: String, dosBoot: Bool)?
init(model: BASICDevelopmentModel, reference: BASICReferenceModel? = nil) {
self.model = model; self.reference = reference; menu = model.machine.menuState
}
private func quickHelp(_ keyword: String?) {
if let keyword { reference?.show(keyword: keyword, dialect: model.machine.basicReferenceDialect) }
openWindow(id: "basic-reference")
}
private var unavailable: Bool { model.busy || menu.values.busy || ![VCCMachineState.running, .paused].contains(menu.values.state) }
var body: some View {
GeometryReader { geometry in
VStack(alignment: .leading, spacing: 0) {
HStack(spacing: 12) {
Image(systemName: "terminal").font(.largeTitle).foregroundStyle(.tint)
VStack(alignment: .leading, spacing: 3) {
Text("BASIC Development").font(.title2.bold())
Text("Edit on your Mac · Run in your CoCo").font(.callout).foregroundStyle(.secondary)
}
Spacer()
Button { openWindow(id: "basic-reference") } label: { Label("Reference", systemImage: "book.closed") }
.accessibilityIdentifier("basic.reference.open")
Button { openWindow(id: "machine") } label: { Label("Show CoCo", systemImage: "desktopcomputer") }
.accessibilityIdentifier("basic.show-machine")
}.padding(16)
Divider()
HStack(spacing: 10) {
Button { model.newProgram() } label: { Label("New", systemImage: "doc.badge.plus") }.accessibilityIdentifier("basic.new")
Button { model.open() } label: { Label("Open…", systemImage: "folder") }.accessibilityIdentifier("basic.open")
Button { model.save() } label: { Label("Save", systemImage: "square.and.arrow.down") }
.keyboardShortcut("s", modifiers: .command).accessibilityIdentifier("basic.save")
Menu {
Button("Save As…") { model.save(as: true) }
Button("Local Assistant Access…", systemImage: "link") { MCPAccess.shared.show(for: model) }
.accessibilityIdentifier("basic.assistant.access")
Divider()
Button("Export Disk…", systemImage: "externaldrive") { exportKind = .disk }
.disabled(unavailable).accessibilityIdentifier("basic.export-disk")
Button("Export Cassette…", systemImage: "recordingtape") { exportKind = .cassette }
.disabled(unavailable).accessibilityIdentifier("basic.export-cassette")
} label: { Image(systemName: "ellipsis.circle") }.menuStyle(.borderlessButton).frame(width: 25).help("Show more BASIC file actions").accessibilityLabel("More file actions").accessibilityIdentifier("basic.file-actions")
Spacer(minLength: 12)
Button { model.readFromCoCo() } label: { Label("Read from CoCo", systemImage: "arrow.down.doc") }
.disabled(unavailable).accessibilityIdentifier("basic.read")
Button { model.transfer(run: false) } label: { Label("Load into CoCo", systemImage: "arrow.up.doc") }
.disabled(unavailable).accessibilityIdentifier("basic.load")
Button { model.transfer(run: true) } label: { Label("Run", systemImage: "play.fill") }
.buttonStyle(.borderedProminent).disabled(unavailable).accessibilityIdentifier("basic.run")
}.controlSize(.regular).padding(.horizontal,16).padding(.vertical,10).disabled(model.editorLocked)
HStack {
Label(model.title, systemImage: "doc.text").fontWeight(.medium).lineLimit(1)
if model.dirty { Text("Edited").foregroundStyle(.secondary) }
Spacer()
SourceFindButton(finder: finder)
Button { model.toggleBreakpointAtCursor() } label: { Image(systemName: "record.circle") }
.help(model.cursorBreakpointHelp)
.accessibilityLabel(model.cursorBreakpointHelp)
.accessibilityIdentifier("basic.toggle-breakpoint").disabled(model.editorLocked)
Button { model.continueProgram() } label: { Label("Continue", systemImage: "play.fill") }
.disabled(!model.canContinue).accessibilityIdentifier("basic.continue")
Button { model.stepProgram(over: false) } label: { Image(systemName: "arrow.down.to.line") }
.help("Run one BASIC statement, following GOSUB into its subroutine")
.accessibilityLabel("Step Into BASIC statement").accessibilityIdentifier("basic.step-into")
.disabled(!model.canStep)
Button { model.stepProgram(over: true) } label: { Image(systemName: "arrow.turn.up.right") }
.help("Run one BASIC statement, continuing through a GOSUB unless a breakpoint is hit")
.accessibilityLabel("Step Over BASIC subroutine").accessibilityIdentifier("basic.step-over")
.disabled(!model.canStep)
Button { model.stepProgram(over: false, out: true) } label: { Image(systemName: "arrow.up.to.line") }
.help("Run until this GOSUB returns to its caller or a breakpoint is hit")
.accessibilityLabel("Step Out of BASIC subroutine").accessibilityIdentifier("basic.step-out")
.disabled(!model.canStepOut)
if model.stepping {
Button { model.cancelStep() } label: { Image(systemName: "pause.fill") }
.help("Pause the current BASIC step").accessibilityLabel("Pause BASIC step")
.accessibilityIdentifier("basic.pause-step")
}
Menu {
Button("Clear All Breakpoints", systemImage: "record.circle") { model.clearBreakpoints() }
.disabled(model.breakpoints.isEmpty).accessibilityIdentifier("basic.clear-breakpoints")
Divider()
Button("Check Source", systemImage: "checkmark.circle") { model.checkSource(); diagnosticsExpanded = true }
.accessibilityIdentifier("basic.check-source")
Button("Go to Line…", systemImage: "arrow.turn.down.right") { editingSheet = .goToLine }
.accessibilityIdentifier("basic.go-to-line")
Button("Renumber…", systemImage: "list.number") { editingSheet = .renumber }
.accessibilityIdentifier("basic.renumber")
} label: { Label("Editing", systemImage: "pencil.line") }
.disabled(model.editorLocked).accessibilityIdentifier("basic.editing-actions")
Button { model.completionRequest = UUID() } label: { Label("Complete", systemImage: "text.badge.plus") }
.help("Complete a BASIC keyword (Control–Space)").accessibilityIdentifier("basic.complete")
.disabled(model.editorLocked)
}.font(.callout).padding(.horizontal,16).padding(.bottom,8)
Divider()
if let message = model.message {
Label(message, systemImage: "exclamationmark.triangle").font(.callout).foregroundStyle(.orange)
.textSelection(.enabled).padding(10).frame(maxWidth:.infinity,alignment:.leading)
.background(.orange.opacity(0.08)).accessibilityIdentifier("basic.message")
}
if let line = model.runtimeErrorLine {
HStack(spacing: 10) {
Label("BASIC \(model.runtimeErrorCode.isEmpty ? "runtime" : model.runtimeErrorCode) error on line \(line)", systemImage: "exclamationmark.circle.fill")
.foregroundStyle(.red).accessibilityIdentifier("basic.runtime-error")
Text("The program ended. Continue returns to the prompt.").foregroundStyle(.secondary)
Spacer(minLength: 0)
Button { reference?.showError(code: model.runtimeErrorCode); openWindow(id: "basic-reference") } label: {
Image(systemName: "questionmark.circle")
}.help("Explain this BASIC error").accessibilityLabel("Explain BASIC error")
.accessibilityIdentifier("basic.reference.error")
Button("Show Line \(line)") { model.goToLine(line) }
.disabled(model.editorLocked).accessibilityIdentifier("basic.show-runtime-error")
}.font(.callout).padding(10).background(.red.opacity(0.06))
}
SourceFindBar(finder: finder, source: model.source, readOnly: model.editorLocked)
BASICSourceEditor(finder: finder, text: $model.source, readOnly: model.editorLocked, completionRequest: model.completionRequest,
editorAction: model.editorAction, breakpoints: model.breakpoints, stoppedLine: model.stoppedLine, stoppedToken: model.stoppedToken,
toggleBreakpoint: model.toggleBreakpoint,
actionHandled: { id, applied in model.editorActionHandled(id: id, applied: applied) },
cursorChanged: model.cursorChanged, assistance: { model.statusMessage($0) }, quickHelp: quickHelp,
attach: { model.assistantEditor = $0 })
.id(model.documentID).frame(minHeight:120).accessibilityIdentifier("basic.editor")
HStack(spacing: 8) {
Image(systemName: model.stoppedLine == nil ? "record.circle" : "arrow.right.circle.fill")
.foregroundStyle(model.stoppedLine == nil ? Color.secondary : Color.orange)
Text(model.debugStatus).font(.caption).lineLimit(2)
.accessibilityIdentifier("basic.debug-status")
Spacer()
if !model.breakpoints.isEmpty {
Text("\(model.breakpoints.count) breakpoint\(model.breakpoints.count == 1 ? "" : "s")")
.font(.caption).foregroundStyle(.secondary)
}
}.padding(.horizontal, 12).padding(.vertical, 7)
// Reserve the window chrome and a useful editor height before
// allocating rows to the independently scrolling inspector.
BASICInspectionView(model: model, valuesHeight: max(36, min(160,
geometry.size.height - 560 - (!model.diagnostics.isEmpty && diagnosticsExpanded ? 130 : 0))))
if !model.diagnostics.isEmpty {
Divider()
DisclosureGroup(isExpanded: $diagnosticsExpanded) {
ScrollView {
LazyVStack(alignment: .leading, spacing: 5) {
ForEach(model.diagnostics) { diagnostic in
Button { model.selectDiagnostic(diagnostic) } label: {
HStack(alignment: .top, spacing: 8) {
Image(systemName: diagnostic.severity == .error ? "exclamationmark.circle" : "exclamationmark.triangle")
.foregroundStyle(diagnostic.severity == .error ? Color.red : Color.orange)
Text("Row \(diagnostic.row)").monospacedDigit().fontWeight(.medium)
Text(diagnostic.message).frame(maxWidth: .infinity, alignment: .leading)
}.contentShape(Rectangle())
}.buttonStyle(.plain).font(.callout).disabled(model.editorLocked)
.accessibilityLabel("Source row \(diagnostic.row): \(diagnostic.message). Go to source.")
.accessibilityIdentifier("basic.diagnostic.\(diagnostic.id)")
}
}.padding(.vertical, 6)
}.frame(maxHeight: 100)
} label: {
Text("Source checks · \(model.diagnostics.count)").font(.callout.bold())
}.padding(.horizontal, 14).padding(.vertical, 8)
.accessibilityIdentifier("basic.diagnostics")
}
HStack(alignment:.top,spacing:8) {
Image(systemName: "info.circle").foregroundStyle(.secondary)
Text(model.hint ?? "Return continues line numbering. Tab accepts a faint keyword suggestion; Control–Space shows all matches.")
.font(.system(.caption,design:.monospaced)).textSelection(.enabled)
.frame(maxWidth:.infinity,alignment:.leading).accessibilityIdentifier("basic.hint")
Button { quickHelp(BASICReferenceContext.keyword(in: model.source, at: model.editorOffset)) } label: {
Label("Quick Help", systemImage: "questionmark.circle")
}.keyboardShortcut("h", modifiers: [.control, .shift])
.help("Look up the command at the insertion point (Control–Shift–H)")
.accessibilityIdentifier("basic.reference.context")
}.padding(10).frame(minHeight:42,alignment:.top)
Divider()
VStack(alignment:.leading,spacing:5) {
HStack(alignment:.top) {
if model.busy { ProgressView().controlSize(.small) }
Text(model.status).font(.callout).textSelection(.enabled).accessibilityIdentifier("basic.status")
}
Text("Direct loading supports Disk BASIC, Hard Drive BASIC and CoCo SDC at the BASIC OK prompt. Use CoCo Break to stop before replacing a running program. Read from CoCo retrieves program text, not variables.")
.font(.caption).foregroundStyle(.secondary).fixedSize(horizontal:false,vertical:true)
.accessibilityIdentifier("basic.preset-support")
}.padding(14)
}.frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .top)
}.frame(minWidth:850,minHeight:560)
.focusedSceneValue(\.sourceFind, finder)
.onDisappear { model.persistDraft() }
.sheet(item: $editingSheet, onDismiss: {
let action = pendingEditingAction; pendingEditingAction = nil; action?()
}) { kind in
BASICEditingOptions(kind: kind,
goToLine: { number in
pendingEditingAction = { model.goToLine(number) }; editingSheet = nil
},
renumber: { start, increment in
pendingEditingAction = { model.renumber(start: start, increment: increment) }; editingSheet = nil
},
cancel: { editingSheet = nil })
}
.sheet(item: $exportKind, onDismiss: {
if let request = pendingExport {
pendingExport = nil; model.chooseExport(request.kind, name: request.name, dosBoot: request.dosBoot)
}
}) { kind in
BASICExportOptions(kind: kind, initialName: model.suggestedExportName,
confirm: { name, boot in pendingExport = (kind, name, boot); exportKind = nil },
cancel: { exportKind = nil })
}
}
}
private enum BASICEditingSheet: String, Identifiable {
case goToLine, renumber
var id: String { rawValue }
}
private struct BASICEditingOptions: View {
let kind: BASICEditingSheet
let goToLine: (Int) -> Void
let renumber: (Int, Int) -> Void
let cancel: () -> Void
@State private var line = "10"
@State private var increment = "10"
@FocusState private var firstFieldFocused: Bool
private var firstNumber: Int? { Int(line.trimmingCharacters(in: .whitespaces)) }
private var step: Int? { Int(increment.trimmingCharacters(in: .whitespaces)) }
private var valid: Bool {
guard let firstNumber, (0...63999).contains(firstNumber) else { return false }
return kind == .goToLine || step.map { (1...63999).contains($0) } == true
}
var body: some View {
VStack(alignment: .leading, spacing: 16) {
Label(kind == .goToLine ? "Go to BASIC Line" : "Renumber Program",
systemImage: kind == .goToLine ? "arrow.turn.down.right" : "list.number").font(.title2.bold())
if kind == .goToLine {
Text("Find a BASIC line number in your editor source. This does not move the running CoCo program.")
.foregroundStyle(.secondary).fixedSize(horizontal: false, vertical: true)
TextField("BASIC line number", text: $line).textFieldStyle(.roundedBorder)
.focused($firstFieldFocused).accessibilityIdentifier("basic.go-line-number")
} else {
Text("Renumber the entire editor program and update its recognized line references. Strings, comments, and DATA values stay unchanged.")
.foregroundStyle(.secondary).fixedSize(horizontal: false, vertical: true)
Grid(alignment: .leading, horizontalSpacing: 12, verticalSpacing: 10) {
GridRow {
Text("Start at")
TextField("Starting line number", text: $line).textFieldStyle(.roundedBorder)
.focused($firstFieldFocused).accessibilityIdentifier("basic.renumber-start")
}
GridRow {
Text("Increment")
TextField("Line number increment", text: $increment).textFieldStyle(.roundedBorder)
.accessibilityIdentifier("basic.renumber-increment")
}
}
Text("The CoCo program is not changed. You can undo this edit with ⌘Z.")
.font(.callout).fixedSize(horizontal: false, vertical: true)
}
Text(kind == .goToLine ? "BASIC line numbers range from 0 to 63999." : "Use line numbers from 0 to 63999 and a positive increment. Source problems must be corrected before renumbering.")
.font(.caption).foregroundStyle(.secondary).fixedSize(horizontal: false, vertical: true)
HStack {
Spacer()
Button("Cancel", action: cancel).keyboardShortcut(.cancelAction)
Button(kind == .goToLine ? "Go to Line" : "Renumber") {
guard let firstNumber, valid else { return }
if kind == .goToLine { goToLine(firstNumber) }
else if let step { renumber(firstNumber, step) }
}.keyboardShortcut(.defaultAction).disabled(!valid)
.accessibilityIdentifier("basic.editing-confirm")
}
}.padding(22).frame(width: 430).task { firstFieldFocused = true }
}
}
private struct BASICExportOptions: View {
let kind: BASICExportKind
let confirm: (String, Bool) -> Void
let cancel: () -> Void
@State private var name: String
@State private var dosBoot = false
@FocusState private var nameFocused: Bool
init(kind: BASICExportKind, initialName: String, confirm: @escaping (String, Bool) -> Void, cancel: @escaping () -> Void) {
self.kind = kind; self.confirm = confirm; self.cancel = cancel
_name = State(initialValue: initialName)
}
private var validName: String? { BASICExportName.normalized(name) }
var body: some View {
VStack(alignment: .leading, spacing: 16) {
Label(kind.title, systemImage: kind.symbol).font(.title2.bold())
Text(kind == .disk
? "Create a fresh 35-track Disk BASIC disk with your current editor program."
: "Create a cassette image with your current editor program.")
.foregroundStyle(.secondary).fixedSize(horizontal: false, vertical: true)
VStack(alignment: .leading, spacing: 6) {
TextField("CoCo program name", text: $name).textFieldStyle(.roundedBorder)
.focused($nameFocused).accessibilityIdentifier("basic.export-name")
Text("Use 1–8 letters or numbers, without an extension. The CoCo name will be uppercase.")
.font(.caption).foregroundStyle(.secondary)
}
if let validName {
Label(kind == .disk ? validName + ".BAS" : validName, systemImage: "doc.text")
.font(.system(.callout, design: .monospaced))
}
if kind == .disk {
Toggle("Install DOS bootloader", isOn: $dosBoot)
.accessibilityIdentifier("basic.export-dos")
}
if let validName {
Text(kind.instructions(name: validName, dosBoot: dosBoot))
.accessibilityIdentifier("basic.export-commands")
.font(.callout).fixedSize(horizontal: false, vertical: true)
}
HStack {
Spacer()
Button("Cancel", action: cancel).keyboardShortcut(.cancelAction)
Button("Choose Location…") { if let validName { confirm(validName, dosBoot) } }
.keyboardShortcut(.defaultAction).disabled(validName == nil)
.accessibilityIdentifier("basic.export-location")
}
}.padding(22).frame(width: 430).task { nameFocused = true }
}
}
/// Stable AppKit text editor: only explicit document changes reset Undo.
struct BASICSourceEditor: NSViewRepresentable {
let finder: SourceFind
@Binding var text: String
let readOnly: Bool
let completionRequest: UUID
let editorAction: BASICEditorAction?
let breakpoints: Set<Int>
let stoppedLine: Int?
let stoppedToken: NSRange?
let toggleBreakpoint: (Int) -> Void
let actionHandled: (UUID, Bool) -> Void
let cursorChanged: (Int) -> Void
let assistance: (String) -> Void
let quickHelp: (String?) -> Void
var attach: (BASICTextView) -> Void = { _ in }
func makeCoordinator() -> Coordinator { Coordinator(self) }
func makeNSView(context: Context) -> NSScrollView {
let scroll=NSScrollView(); scroll.hasVerticalScroller=true; scroll.hasHorizontalScroller=true; scroll.autohidesScrollers=true
// AppKit ruler decorations must not paint into the surrounding SwiftUI
// toolbar, inspector or footer when this representable resizes.
scroll.wantsLayer = true; scroll.layer?.masksToBounds = true
let editor=BASICTextView(frame:.zero)
// Highlighting and breakpoint geometry use TextKit 1. Establish it
// before setting up the unwrapped container, even for an empty draft.
_ = editor.layoutManager
attach(editor)
editor.delegate=context.coordinator; editor.string=text; editor.allowsUndo=true; editor.isRichText=false
editor.isAutomaticQuoteSubstitutionEnabled=false; editor.isAutomaticDashSubstitutionEnabled=false
editor.isAutomaticTextReplacementEnabled=false; editor.isAutomaticSpellingCorrectionEnabled=false
editor.isContinuousSpellCheckingEnabled=false; editor.isGrammarCheckingEnabled=false
editor.isVerticallyResizable=true; editor.isHorizontallyResizable=true
editor.minSize=NSSize(width:0,height:0); editor.maxSize=NSSize(width:CGFloat.greatestFiniteMagnitude,height:CGFloat.greatestFiniteMagnitude)
editor.textContainer?.widthTracksTextView=false
editor.textContainer?.containerSize=editor.maxSize
editor.autoresizingMask = [.width]
editor.textContainerInset=NSSize(width:16,height:14)
editor.font = .monospacedSystemFont(ofSize:14,weight:.regular)
editor.backgroundColor = .textBackgroundColor; editor.textColor = .textColor
finder.editor = editor
editor.setAccessibilityLabel("BASIC source editor")
editor.setAccessibilityIdentifier("basic.source-text")
editor.assistance=assistance; editor.quickHelp = quickHelp; scroll.documentView=editor
scroll.verticalRulerView = BASICBreakpointRuler(textView: editor)
scroll.hasVerticalRuler = true; scroll.rulersVisible = true
editor.configureDebug(points: breakpoints, stoppedLine: stoppedLine, token: stoppedToken, toggle: toggleBreakpoint)
context.coordinator.highlight(editor)
return scroll
}
func updateNSView(_ scroll:NSScrollView,context:Context) {
context.coordinator.parent=self
guard let editor=scroll.documentView as? BASICTextView else { return }
finder.editor = editor
editor.assistance=assistance; editor.quickHelp = quickHelp; editor.isEditable = !readOnly
editor.refreshInlineSuggestion()
if !editor.string.utf8.elementsEqual(text.utf8) {
editor.string=text; editor.undoManager?.removeAllActions(); context.coordinator.highlight(editor)
}
editor.configureDebug(points: breakpoints, stoppedLine: stoppedLine, token: stoppedToken, toggle: toggleBreakpoint)
if let action = editorAction, context.coordinator.actionID != action.id {
context.coordinator.actionID = action.id
let coordinator = context.coordinator
DispatchQueue.main.async { [weak editor, weak coordinator] in
guard let coordinator else { return }
let applied = editor?.applyEditorAction(action) ?? false
coordinator.parent.actionHandled(action.id, applied)
}
}
if context.coordinator.completionRequest != completionRequest {
context.coordinator.completionRequest=completionRequest
DispatchQueue.main.async { [weak editor] in
guard let editor, editor.isEditable else { return }
editor.window?.makeFirstResponder(editor); editor.complete(nil)
}
}
}
@MainActor final class Coordinator: NSObject,NSTextViewDelegate {
var parent:BASICSourceEditor
var completionRequest:UUID
var actionID:UUID?
init(_ parent:BASICSourceEditor) { self.parent=parent; completionRequest=parent.completionRequest }
func textDidChange(_ notification:Notification) {
guard let editor=notification.object as? BASICTextView else { return }
parent.text=editor.string; highlight(editor); reportCursor(editor)
editor.configureDebug(points: parent.breakpoints, stoppedLine: parent.stoppedLine, token: parent.stoppedToken, toggle: parent.toggleBreakpoint)
}
func textViewDidChangeSelection(_ notification:Notification) {
guard let editor=notification.object as? BASICTextView else { return }; reportCursor(editor)
}
func reportCursor(_ editor:NSTextView) {
let offset=editor.selectedRange().location
DispatchQueue.main.async { [weak self,weak editor] in
guard let self,let editor,editor.selectedRange().location == offset else { return }; self.parent.cursorChanged(offset)
}
}
func textView(_ textView:NSTextView,shouldChangeTextIn affectedCharRange:NSRange,replacementString:String?) -> Bool {
guard let replacementString else { return true }
let current=textView.string as NSString
guard affectedCharRange.location <= current.length, NSMaxRange(affectedCharRange) <= current.length else { return false }
guard current.replacingCharacters(in:affectedCharRange,with:replacementString).utf8.count <= BASICLanguage.maximumSourceBytes else {
parent.assistance("BASIC source is limited to 1 MB."); return false
}; return true
}
func highlight(_ editor:NSTextView) {
guard let storage=editor.textStorage else { return }
storage.beginEditing()
let full=NSRange(location:0,length:storage.length)
storage.addAttributes([.foregroundColor:NSColor.textColor,.font:NSFont.monospacedSystemFont(ofSize:14,weight:.regular)],range:full)
for span in BASICLanguage.spans(editor.string) {
let color:NSColor
switch span.kind {
case .keyword: color = .systemPurple
case .number: color = .systemBlue
case .string: color = .systemRed
case .comment: color = .secondaryLabelColor
case .data: color = .systemBrown
}
storage.addAttribute(.foregroundColor,value:color,range:span.range)
}
storage.endEditing()
editor.typingAttributes=[.foregroundColor:NSColor.textColor,.font:NSFont.monospacedSystemFont(ofSize:14,weight:.regular)]
}
}
}
/// Native completion with an explicit acceptance operation, so Escape and moving
/// through candidates never alter the source or its Undo history.
final class BASICTextView: NSTextView, SourceFindEditor {
weak var sourceFind: SourceFind?
var assistance:((String)->Void)?
var quickHelp: ((String?) -> Void)?
private var helpOffset: Int?
override func menu(for event: NSEvent) -> NSMenu? {
let menu = super.menu(for: event) ?? NSMenu()
helpOffset = characterIndexForInsertion(at: convert(event.locationInWindow, from: nil))
let item = NSMenuItem(title: "Quick Help for BASIC Command", action: #selector(showCommandHelp), keyEquivalent: "")
item.target = self
menu.insertItem(.separator(), at: 0); menu.insertItem(item, at: 0)
return menu
}
@objc private func showCommandHelp() {
quickHelp?(BASICReferenceContext.keyword(in: string, at: helpOffset ?? selectedRange().location))
helpOffset = nil
}
override func mouseDown(with event: NSEvent) {
if event.modifierFlags.contains(.option), event.clickCount == 1 {
let offset = characterIndexForInsertion(at: convert(event.locationInWindow, from: nil))
if let keyword = BASICReferenceContext.keyword(in: string, at: offset) {
quickHelp?(keyword); return
}
}
super.mouseDown(with: event)
}
private var sourceForCompletion:String?
private var completion:BASICLanguage.Completion?
private var completionOffset=0
private(set) var numberedRows: [BASICLanguage.NumberedLine] = []
private(set) var breakpointLines: Set<Int> = []
private var decoratedSource = ""
private var executionLine: Int?
private var executionToken: NSRange?
func configureDebug(points: Set<Int>, stoppedLine: Int?, token: NSRange? = nil, toggle: @escaping (Int) -> Void) {
let ruler = enclosingScrollView?.verticalRulerView as? BASICBreakpointRuler
ruler?.onClick = toggle
ruler?.active = isEditable
ruler?.points = points
let sourceChanged = decoratedSource != string
let lineChanged = executionLine != stoppedLine || executionToken != token
guard sourceChanged || lineChanged || breakpointLines != points else { return }
decoratedSource = string; breakpointLines = points; executionLine = stoppedLine; executionToken = token
if sourceChanged { numberedRows = BASICLanguage.analyze(string).lines }
let full = NSRange(location: 0, length: (string as NSString).length)
layoutManager?.removeTemporaryAttribute(.backgroundColor, forCharacterRange: full)
if let stoppedLine, let row = numberedRows.first(where: { $0.number == stoppedLine }) {
layoutManager?.addTemporaryAttribute(.backgroundColor, value: NSColor.systemYellow.withAlphaComponent(0.2), forCharacterRange: row.range)
if let token, token.location >= row.range.location, NSMaxRange(token) <= NSMaxRange(row.range) {
layoutManager?.addTemporaryAttribute(.backgroundColor, value: NSColor.systemOrange.withAlphaComponent(0.5), forCharacterRange: token)
}
if lineChanged { scrollRangeToVisible(token ?? row.range) }
}
ruler?.invalidateMarkers()
}
private(set) var inlineSuggestion: BASICLanguage.InlineCompletion?
private var inlineSource = ""
private var inlineSelection = NSRange(location: NSNotFound, length: 0)
private var inlineDismissed = false
func refreshInlineSuggestion() {
let selection = selectedRange()
if let sourceForCompletion,
sourceForCompletion != string || selection != NSRange(location: completionOffset, length: 0) {
self.sourceForCompletion = nil; completion = nil
}
if inlineSource != string || inlineSelection != selection {
inlineDismissed = false
inlineSource = string; inlineSelection = selection
}
inlineSuggestion = isEditable && !hasMarkedText() && selection.length == 0 && !inlineDismissed && sourceForCompletion == nil
? BASICLanguage.inlineCompletion(string, at: selection.location) : nil
setAccessibilityHelp(inlineSuggestion.map { "Suggested keyword \($0.word). Press Tab to accept or Escape to dismiss." }
?? "Numbered BASIC source. Return continues line numbering. Control–Space shows keyword completions.")
needsDisplay = true
}
override func didChangeText() {
super.didChangeText()
refreshInlineSuggestion()
}
override func setSelectedRange(_ charRange: NSRange, affinity: NSSelectionAffinity, stillSelecting flag: Bool) {
super.setSelectedRange(charRange, affinity: affinity, stillSelecting: flag)
refreshInlineSuggestion()
}
override func becomeFirstResponder() -> Bool {
let result = super.becomeFirstResponder(); refreshInlineSuggestion(); return result
}
override func resignFirstResponder() -> Bool {
let result = super.resignFirstResponder(); needsDisplay = true; return result
}
override func draw(_ dirtyRect: NSRect) {
super.draw(dirtyRect)
guard isEditable, !hasMarkedText(), window?.firstResponder === self,
let window, let suggestion = inlineSuggestion,
inlineSource == string, inlineSelection == selectedRange() else { return }
// Draw separately: previews never enter text storage, saves, transfers,
// accessibility's source value, or the Undo history.
let screenRect = firstRect(forCharacterRange: selectedRange(), actualRange: nil)
let rect = convert(window.convertFromScreen(screenRect), from: nil)
(suggestion.suffix as NSString).draw(at: rect.origin, withAttributes: [
.font: font ?? NSFont.monospacedSystemFont(ofSize: 14, weight: .regular),
.foregroundColor: NSColor.secondaryLabelColor
])
}
override func insertTab(_ sender: Any?) {
refreshInlineSuggestion()
guard let suggestion = inlineSuggestion else { super.insertTab(sender); return }
breakUndoCoalescing()
insertText(suggestion.word, replacementRange: suggestion.range)
breakUndoCoalescing()
undoManager?.setActionName("Complete BASIC Keyword")
}
override func cancelOperation(_ sender: Any?) {
if inlineSuggestion != nil {
inlineDismissed = true; refreshInlineSuggestion()
} else {
// AppKit owns a native completion popup's Escape. Cached candidates
// alone do not mean that a popup is still handling the command.
sourceForCompletion = nil; completion = nil
if sourceFind?.cancel(from: self) != true {
// cancelOperation is optional; NSTextView need not implement a
// superclass method for this standard text command.
_ = nextResponder?.tryToPerform(#selector(NSResponder.cancelOperation(_:)), with: sender)
}
}
}
override func insertNewline(_ sender: Any?) {
guard isEditable, !hasMarkedText(), selectedRange().length == 0,
let insertion = BASICLanguage.nextLineInsertion(string, at: selectedRange().location) else {
super.insertNewline(sender); return
}
breakUndoCoalescing()
insertText(insertion, replacementRange: selectedRange())
breakUndoCoalescing()
undoManager?.setActionName("Insert BASIC Line")
}
/// Apply an explicit source edit through AppKit so the ordinary Undo stack,
/// source binding, selection and syntax highlighting remain synchronized.
@discardableResult func applyEditorAction(_ action: BASICEditorAction, revealReplacementAt offset: Int? = nil) -> Bool {
guard isEditable, !hasMarkedText(), string == action.expectedSource else { return false }
switch action.operation {
case .replace(let source, let undoName):
guard source.utf8.count <= BASICLanguage.maximumSourceBytes else { return false }
if source != string {
breakUndoCoalescing()
insertText(source, replacementRange: NSRange(location: 0, length: (string as NSString).length))
breakUndoCoalescing()
guard string == source else { return false }
undoManager?.setActionName(undoName)
}
if let offset {
setSelectedRange(NSRange(location: min(max(0, offset), (source as NSString).length), length: 0))
}
case .select(let range):
let length = (string as NSString).length
guard range.location >= 0, range.location <= length,
range.length >= 0, range.length <= length - range.location else { return false }
setSelectedRange(range)
}
scrollRangeToVisible(selectedRange())
window?.makeFirstResponder(self)
return true
}
override func complete(_ sender:Any?) {
guard prepareCompletion() else { return }; super.complete(sender)
}
@discardableResult func prepareCompletion() -> Bool {
sourceForCompletion=nil; completion=nil
guard isEditable,!hasMarkedText(),selectedRange().length == 0,
let next=BASICLanguage.completion(string,at:selectedRange().location) else {
assistance?("Type the beginning of a BASIC keyword, then choose Complete."); return false
}
sourceForCompletion=string; completion=next; completionOffset=selectedRange().location
refreshInlineSuggestion()
assistance?("\(next.words.count) BASIC keyword suggestions. Return accepts; Escape cancels.")
return true
}
override var rangeForUserCompletion:NSRange { sourceForCompletion == string ? completion?.range ?? NSRange(location:NSNotFound,length:0) : NSRange(location:NSNotFound,length:0) }
override func completions(forPartialWordRange charRange:NSRange,indexOfSelectedItem index:UnsafeMutablePointer<Int>?) -> [String]? {
guard sourceForCompletion == string, completion?.range == charRange else { return [] }
// Highlight the first choice so Return accepts it immediately.
// insertCompletion still refuses provisional list navigation.
index?.pointee = 0; return completion?.words
}
override func insertCompletion(_ word:String,forPartialWordRange charRange:NSRange,movement:Int,isFinal flag:Bool) {
guard flag else { return }
defer { sourceForCompletion=nil; completion=nil; refreshInlineSuggestion() }
guard movement != NSTextMovement.cancel.rawValue,isEditable,!hasMarkedText(),sourceForCompletion == string,
selectedRange() == NSRange(location:completionOffset,length:0),completion?.range == charRange,
completion?.words.contains(word) == true else { return }
breakUndoCoalescing(); insertText(word,replacementRange:charRange); breakUndoCoalescing()
undoManager?.setActionName("Complete BASIC Keyword")
}
override func performKeyEquivalent(with event:NSEvent) -> Bool {
let modifiers=event.modifierFlags.intersection([.command,.control,.option,.shift])
if event.keyCode == 49,modifiers == [.control] { complete(nil); return true }
return super.performKeyEquivalent(with:event)
}
}
/// Visual gutter plus the native toolbar action provide mouse and keyboard
/// alternatives. Line numbers remain ordinary editable source text.
final class BASICBreakpointRuler: BreakpointRuler {
private weak var editor: BASICTextView?
init(textView: BASICTextView) {
editor = textView
super.init(scrollView: textView.enclosingScrollView!, orientation: .verticalRuler)
clientView = textView; ruleThickness = 30
setAccessibilityLabel("BASIC breakpoint gutter")
setAccessibilityHelp("Click beside a numbered statement to toggle its breakpoint. The toolbar offers the same action at the insertion point.")
}
required init(coder: NSCoder) { fatalError("init(coder:) has not been implemented") }
private func targets() -> [(Int, NSRect)] {
guard let editor, let layout = editor.layoutManager, let container = editor.textContainer else { return [] }
let origin = editor.textContainerOrigin
// Horizontal scrolling must not change which rows appear in the gutter.
let viewport = NSRect(x: 0, y: editor.visibleRect.minY - origin.y,
width: max(1, editor.bounds.width), height: editor.visibleRect.height)
let glyphs = layout.glyphRange(forBoundingRect: viewport, in: container)
let visible = layout.characterRange(forGlyphRange: glyphs, actualGlyphRange: nil)
return editor.numberedRows.compactMap { row in
guard NSLocationInRange(row.labelRange.location, visible) else { return nil }
let glyph = layout.glyphIndexForCharacter(at: row.labelRange.location)
let fragment = layout.lineFragmentRect(forGlyphAt: glyph, effectiveRange: nil)
let point = convert(NSPoint(x: 0, y: fragment.midY + editor.textContainerOrigin.y), from: editor)
return (row.number, NSRect(x: 8, y: point.y - 6, width: 12, height: 12))
}
}
override var wantsDefaultClipping: Bool { true }
override func draw(_ dirtyRect: NSRect) {
// NSRulerView's standard edge treatment can extend outside its frame.
// This gutter has no native ruler ticks or markers: draw its own edge.
NSGraphicsContext.saveGraphicsState()
NSBezierPath(rect: bounds).addClip()
drawHashMarksAndLabels(in: dirtyRect)
NSColor.separatorColor.setFill()
NSRect(x: bounds.maxX - 1, y: bounds.minY, width: 1, height: bounds.height).fill()
NSGraphicsContext.restoreGraphicsState()
}
override func drawHashMarksAndLabels(in rect: NSRect) {
NSColor.windowBackgroundColor.setFill(); bounds.fill()
guard let editor else { return }
for (line, target) in targets() where target.intersects(bounds) {
let path = NSBezierPath(ovalIn: target)
if editor.breakpointLines.contains(line) { NSColor.systemRed.setFill(); path.fill() }
else { NSColor.separatorColor.setStroke(); path.lineWidth = 1; path.stroke() }
}
}
override func visibleRows() -> [Row] {
targets().compactMap { line, marker in
let hit = marker.insetBy(dx: -8, dy: -3).intersection(bounds)
return hit.isEmpty ? nil : (line, hit)
}
}
}
private struct BASICInspectionView: View {
@ObservedObject var model: BASICDevelopmentModel
let valuesHeight: CGFloat
@State private var expanded = true
@State private var showingWatches = false
var body: some View {
Divider()
DisclosureGroup(isExpanded: $expanded) {
VStack(alignment: .leading, spacing: 6) {
HStack {
Picker("Inspect", selection: $showingWatches) {
Text("Variables").tag(false); Text("Watches").tag(true)
}.pickerStyle(.segmented).labelsHidden().frame(width: 210).accessibilityIdentifier("basic.inspector-tabs")
Text(model.inspectionStatus).font(.caption).foregroundStyle(.secondary).lineLimit(2)
.accessibilityIdentifier("basic.inspection-status")
Spacer(minLength: 0)
Button { model.refreshInspection() } label: { Image(systemName: "arrow.clockwise") }
.accessibilityLabel("Refresh BASIC variables").help("Refresh values at the current BASIC stop")
.disabled(!model.inspectionAvailable).accessibilityIdentifier("basic.refresh-variables")
}
if showingWatches {
HStack {
TextField("Variable or array element, e.g. NAME$ or A(2)", text: $model.watchEntry)
.textFieldStyle(.roundedBorder).onSubmit { model.addWatch() }
.accessibilityIdentifier("basic.watch-entry")
Button { model.addWatch() } label: { Label("Add", systemImage: "plus") }
.disabled(model.watchEntry.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty)
.accessibilityIdentifier("basic.add-watch")
}
if let error = model.watchError { Text(error).font(.caption).foregroundStyle(.orange) }
}
ScrollView {
LazyVStack(alignment: .leading, spacing: 5) {
if showingWatches {
if model.watches.isEmpty { Text("Watch a variable or a specific array element without changing the program.").foregroundStyle(.secondary) }
ForEach(model.watches, id: \.self) { name in
HStack(alignment: .top) {
Text(name).fontWeight(.medium).frame(width: 160, alignment: .leading)
Text(model.watchValue(name)).textSelection(.enabled).frame(maxWidth: .infinity, alignment: .leading)
.accessibilityIdentifier("basic.watch-value.\(name)")
Button { model.removeWatch(name) } label: { Image(systemName: "minus.circle") }
.buttonStyle(.borderless).help("Remove watch \(name)").accessibilityLabel("Remove watch \(name)")
}.font(.system(.callout, design: .monospaced))
}
} else if model.variables.isEmpty {
Text(model.inspectionAvailable ? "Variables appear here as statements assign them." : "Run to a breakpoint or use Step to see current values.")
.foregroundStyle(.secondary)
} else {
ForEach(model.variables) { variable in BASICVariableView(variable: variable) }
}
}.frame(maxWidth: .infinity, alignment: .leading).padding(.vertical, 4).padding(.horizontal, 8)
}.frame(height: max(36, valuesHeight - (showingWatches ? 60 : 0)))
.accessibilityIdentifier("basic.inspector-values")
}.padding(.top, 6)
} label: {
Label("Variables and Watches", systemImage: "list.bullet.rectangle").font(.callout.bold())
}.padding(.horizontal, 14).padding(.vertical, 8)
}
}
private struct BASICVariableView: View {
let variable: BASICVariable
@State private var expanded = false
@State private var page = 0
private let pageSize = 32
private var first: Int { min(page * pageSize, max(0, variable.elements.count - 1) / pageSize * pageSize) }
var body: some View {
if variable.dimensions.isEmpty {
row(variable.name, variable.value)
} else {
VStack(alignment: .leading, spacing: 4) {
Button { expanded.toggle() } label: {
HStack {
Image(systemName: expanded ? "chevron.down" : "chevron.right").frame(width: 12)
Text(variable.title).fontWeight(.medium).frame(width: 140, alignment: .leading)
Text(variable.value).frame(maxWidth: .infinity, alignment: .leading)
}.font(.system(.callout, design: .monospaced)).padding(.vertical, 3).contentShape(Rectangle())
}.buttonStyle(.plain).accessibilityIdentifier("basic.array.\(variable.name)")
.accessibilityLabel("Array \(variable.title)").accessibilityValue(expanded ? "Expanded" : "Collapsed")
.help("Show array elements. Bounds are inclusive; subscripts start at zero.")
if expanded {
VStack(alignment: .leading, spacing: 4) {
ForEach(first..<min(first + pageSize, variable.elements.count), id: \.self) { offset in
row(variable.elementName(offset), variable.elements[offset])
}
if variable.elements.count > pageSize {
HStack {
Button("Previous", systemImage: "chevron.left") { page = max(0, page - 1) }.disabled(first == 0)
Text("\(first + 1)–\(min(first + pageSize, variable.elements.count)) of \(variable.elements.count)").font(.caption)
Button("Next", systemImage: "chevron.right") { page = first / pageSize + 1 }.disabled(first + pageSize >= variable.elements.count)
}
}
}.padding(.leading, 20)
}
}
}
}
private func row(_ name: String, _ value: String) -> some View {
HStack(alignment: .top) {
Text(name).fontWeight(.medium).frame(width: 160, alignment: .leading)
Text(value).frame(maxWidth: .infinity, alignment: .leading)
.accessibilityIdentifier("basic.variable-value.\(name)")
}.font(.system(.callout, design: .monospaced)).textSelection(.enabled)
}
}