Publish VCC Plus OSS source distribution for 3.6.2 build 60
This commit is contained in:
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)
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user