325 lines
22 KiB
Swift
325 lines
22 KiB
Swift
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
import AppKit
|
|
import SwiftUI
|
|
import UniformTypeIdentifiers
|
|
|
|
private let diskEditorMoveType = NSPasteboard.PasteboardType("com.brianholman.vccplus.disk-editor-files")
|
|
|
|
/// Bounded diagnostics live only in the isolated UI-test app's own fixture folder.
|
|
enum DiskEditorPromiseDiagnostics {
|
|
#if VCC_UI_TESTING
|
|
private static let lock = NSLock()
|
|
#endif
|
|
static func record(_ phase: String) {
|
|
#if VCC_UI_TESTING
|
|
lock.lock(); defer { lock.unlock() }
|
|
guard let path = ProcessInfo.processInfo.environment["VCC_DISK_EDITOR_PROMISE_TRACE"] else { return }
|
|
let url = URL(fileURLWithPath: path)
|
|
let line = Data((phase + "\n").utf8)
|
|
if !FileManager.default.fileExists(atPath: path) { _ = FileManager.default.createFile(atPath: path, contents: nil) }
|
|
guard let handle = try? FileHandle(forWritingTo: url) else { return }
|
|
defer { try? handle.close() }
|
|
guard let end = try? handle.seekToEnd(), end < 16_384 else { return }
|
|
try? handle.write(contentsOf: line)
|
|
#endif
|
|
}
|
|
}
|
|
|
|
#if VCC_UI_TESTING
|
|
/// Observe actual mouse delivery without changing native drag eligibility.
|
|
private final class DiskEditorNativeTableView: NSTableView {
|
|
var dragTrace: ((String) -> Void)?
|
|
override func mouseDown(with event: NSEvent) {
|
|
dragTrace?("mouse-down row=\(row(at: convert(event.locationInWindow, from: nil))) key=\(window?.isKeyWindow ?? false)")
|
|
super.mouseDown(with: event)
|
|
}
|
|
override func canDragRows(with rowIndexes: IndexSet, at mouseDownPoint: NSPoint) -> Bool {
|
|
let allowed = super.canDragRows(with: rowIndexes, at: mouseDownPoint)
|
|
dragTrace?("can-drag native=\(allowed) rows=\(rowIndexes)")
|
|
return allowed
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/// Native table supplies Finder multi-file promises and accepts ordinary host
|
|
/// file URLs. Directory navigation stays inside the validated image namespace.
|
|
struct DiskEditorFileTable: NSViewRepresentable {
|
|
@ObservedObject var model: DiskImageEditorModel
|
|
func makeCoordinator() -> Coordinator { Coordinator(model) }
|
|
func makeNSView(context: Context) -> NSScrollView {
|
|
#if VCC_UI_TESTING
|
|
let table = DiskEditorNativeTableView()
|
|
#else
|
|
let table = NSTableView()
|
|
#endif
|
|
table.identifier = NSUserInterfaceItemIdentifier("disk-editor-files")
|
|
table.setAccessibilityIdentifier("disk-editor-files"); table.allowsMultipleSelection = true
|
|
table.usesAlternatingRowBackgroundColors = true; table.rowHeight = 25
|
|
table.delegate = context.coordinator; table.dataSource = context.coordinator
|
|
table.target = context.coordinator; table.doubleAction = #selector(Coordinator.activate)
|
|
let coordinator = context.coordinator
|
|
#if VCC_UI_TESTING
|
|
table.dragTrace = { [weak coordinator] in coordinator?.trace($0) }
|
|
#endif
|
|
table.registerForDraggedTypes([diskEditorMoveType, .fileURL]); table.setDraggingSourceOperationMask(.copy, forLocal: false)
|
|
table.setDraggingSourceOperationMask(model.os9 ? .move : .copy, forLocal: true)
|
|
let menu = NSMenu(); menu.delegate = context.coordinator; menu.autoenablesItems = false; table.menu = menu
|
|
context.coordinator.table = table; context.coordinator.configureColumns()
|
|
let scroll = NSScrollView(); scroll.hasVerticalScroller = true; scroll.hasHorizontalScroller = true; scroll.documentView = table
|
|
return scroll
|
|
}
|
|
func updateNSView(_ scroll: NSScrollView, context: Context) {
|
|
context.coordinator.model = model; context.coordinator.update()
|
|
}
|
|
@MainActor final class Coordinator: NSObject, NSTableViewDataSource, NSTableViewDelegate, NSMenuDelegate {
|
|
var model: DiskImageEditorModel
|
|
weak var table: NSTableView?
|
|
var rows: [DiskEditorEntry] = []
|
|
var last: [DiskEditorEntry] = []
|
|
var os9: Bool?
|
|
private var restoringSelection = false
|
|
private var dragRequest: DiskEditorMoveRequest?
|
|
#if VCC_UI_TESTING
|
|
private var dragTraceCount = 0
|
|
private var dragTraceLines: [String] = []
|
|
#endif
|
|
fileprivate func trace(_ message: @autoclosure () -> String) {
|
|
#if VCC_UI_TESTING
|
|
guard dragTraceCount < 250 else { return }; dragTraceCount += 1
|
|
let line = message()
|
|
dragTraceLines.append(line)
|
|
if dragTraceLines.count > 40 { dragTraceLines.removeFirst() }
|
|
let text = "DiskEditorDrag VCC_UI_TESTING\n" + dragTraceLines.joined(separator: "\n")
|
|
table?.setAccessibilityHelp(text)
|
|
table?.setAccessibilityValue(text)
|
|
NSLog("DiskEditorDrag %@", line)
|
|
#endif
|
|
}
|
|
init(_ model: DiskImageEditorModel) { self.model = model }
|
|
func configureColumns() {
|
|
guard let table else { return }
|
|
for column in table.tableColumns { table.removeTableColumn(column) }
|
|
let definitions: [(String, CGFloat)] = model.os9
|
|
? [("Name", 250), ("Size", 95), ("Type", 120), ("Attributes", 110), ("Owner", 80), ("Modified", 150)]
|
|
: [("Name", 290), ("Size", 110), ("File Type", 200), ("Encoding", 120)]
|
|
for (title, width) in definitions {
|
|
let column = NSTableColumn(identifier: NSUserInterfaceItemIdentifier(title)); column.title = title; column.width = width; column.minWidth = title == "Name" ? 160 : 70
|
|
column.sortDescriptorPrototype = NSSortDescriptor(key: title, ascending: true); table.addTableColumn(column)
|
|
}
|
|
table.sortDescriptors = [NSSortDescriptor(key: "Name", ascending: true)]; os9 = model.os9
|
|
trace("configure os9=\(model.os9) local-mask=\(model.os9 ? "move" : "copy")")
|
|
}
|
|
func update() {
|
|
table?.setDraggingSourceOperationMask(model.os9 ? .move : .copy, forLocal: true)
|
|
if os9 != model.os9 { configureColumns() }
|
|
guard last != model.contents.entries else { return }
|
|
last = model.contents.entries; reload()
|
|
}
|
|
func reload() {
|
|
guard let table else { return }
|
|
restoringSelection = true
|
|
defer { restoringSelection = false }
|
|
let descriptor = table.sortDescriptors.first, key = descriptor?.key ?? "Name", ascending = descriptor?.ascending ?? true
|
|
rows = model.contents.entries.sorted {
|
|
let result: ComparisonResult
|
|
if key == "Size" { result = $0.size == $1.size ? .orderedSame : $0.size < $1.size ? .orderedAscending : .orderedDescending }
|
|
else if key == "Modified" { result = $0.modified == $1.modified ? .orderedSame : $0.modified < $1.modified ? .orderedAscending : .orderedDescending }
|
|
else { result = value($0, key).localizedStandardCompare(value($1, key)) }
|
|
return ascending ? result == .orderedAscending : result == .orderedDescending
|
|
}
|
|
// Reloading emits a selection notification. Preserve the selection
|
|
// before that callback can clear the model's authoritative IDs.
|
|
let selectedIDs = model.selection
|
|
table.reloadData()
|
|
let selection = IndexSet(rows.indices.filter { selectedIDs.contains(rows[$0].id) })
|
|
table.selectRowIndexes(selection, byExtendingSelection: false)
|
|
}
|
|
func numberOfRows(in tableView: NSTableView) -> Int { rows.count }
|
|
func value(_ entry: DiskEditorEntry, _ key: String) -> String {
|
|
switch key {
|
|
case "Name": return entry.name
|
|
case "Size": return entry.directory ? "—" : ByteCountFormatter.string(fromByteCount: entry.size, countStyle: .file)
|
|
case "Type", "File Type": return entry.type
|
|
case "Encoding": return entry.encoding
|
|
case "Attributes": return entry.attributes
|
|
case "Owner": return "\(entry.group).\(entry.owner)"
|
|
case "Modified": return entry.modified > 0 ? Date(timeIntervalSince1970: entry.modified).formatted(date: .abbreviated, time: .shortened) : "—"
|
|
default: return ""
|
|
}
|
|
}
|
|
func tableView(_ tableView: NSTableView, viewFor tableColumn: NSTableColumn?, row: Int) -> NSView? {
|
|
guard rows.indices.contains(row), let column = tableColumn else { return nil }
|
|
let entry = rows[row], text = value(entry, column.identifier.rawValue)
|
|
let cell = NSTableCellView(); let label = NSTextField(labelWithString: text)
|
|
label.lineBreakMode = .byTruncatingMiddle; label.translatesAutoresizingMaskIntoConstraints = false
|
|
label.font = column.identifier.rawValue == "Size" ? .monospacedDigitSystemFont(ofSize: 13, weight: .regular) : .systemFont(ofSize: 13)
|
|
if column.identifier.rawValue == "Size" { label.alignment = .right }
|
|
cell.textField = label; cell.addSubview(label)
|
|
if column.identifier.rawValue == "Name" {
|
|
let icon = NSImageView(image: NSImage(systemSymbolName: entry.directory ? "folder" : "doc", accessibilityDescription: nil) ?? NSImage())
|
|
icon.translatesAutoresizingMaskIntoConstraints = false; cell.addSubview(icon)
|
|
NSLayoutConstraint.activate([icon.leadingAnchor.constraint(equalTo: cell.leadingAnchor, constant: 5), icon.widthAnchor.constraint(equalToConstant: 17), icon.centerYAnchor.constraint(equalTo: cell.centerYAnchor), label.leadingAnchor.constraint(equalTo: icon.trailingAnchor, constant: 6)])
|
|
} else { label.leadingAnchor.constraint(equalTo: cell.leadingAnchor, constant: 5).isActive = true }
|
|
NSLayoutConstraint.activate([label.trailingAnchor.constraint(equalTo: cell.trailingAnchor, constant: -7), label.centerYAnchor.constraint(equalTo: cell.centerYAnchor)])
|
|
return cell
|
|
}
|
|
func tableViewSelectionDidChange(_ notification: Notification) {
|
|
guard !restoringSelection, let table else { return }
|
|
let selected = Set(table.selectedRowIndexes.compactMap { rows.indices.contains($0) ? rows[$0].id : nil })
|
|
if model.selection != selected { model.selection = selected }
|
|
}
|
|
func tableView(_ tableView: NSTableView, sortDescriptorsDidChange oldDescriptors: [NSSortDescriptor]) { reload() }
|
|
@objc func activate() {
|
|
guard !model.busy, let table, rows.indices.contains(table.clickedRow) else { return }
|
|
model.activate([rows[table.clickedRow].id])
|
|
}
|
|
func menuNeedsUpdate(_ menu: NSMenu) {
|
|
if let table, rows.indices.contains(table.clickedRow), !table.selectedRowIndexes.contains(table.clickedRow) {
|
|
table.selectRowIndexes(IndexSet(integer: table.clickedRow), byExtendingSelection: false)
|
|
}
|
|
menu.removeAllItems()
|
|
let move = NSMenuItem(title: "Move To…", action: #selector(moveSelected), keyEquivalent: "")
|
|
move.target = self; move.isEnabled = model.canMove; menu.addItem(move)
|
|
}
|
|
@objc private func moveSelected() { model.moveTo() }
|
|
func tableView(_ tableView: NSTableView, pasteboardWriterForRow row: Int) -> NSPasteboardWriting? {
|
|
trace("writer row=\(row) busy=\(model.busy) os9=\(model.os9) selected=\(tableView.selectedRowIndexes)")
|
|
guard !model.busy, rows.indices.contains(row), !rows[row].directory else { return nil }
|
|
if !(dragRequest.map { model.moveSourceIsCurrent($0) } ?? false) {
|
|
let indexes = tableView.selectedRowIndexes.contains(row) ? tableView.selectedRowIndexes : IndexSet(integer: row)
|
|
dragRequest = model.moveRequest(for: indexes.compactMap { rows.indices.contains($0) ? rows[$0] : nil })
|
|
}
|
|
let payload = dragRequest.flatMap { try? JSONEncoder().encode(DiskEditorDragPayload($0)) }
|
|
trace("writer request=\(dragRequest?.id.uuidString ?? "none") files=\(dragRequest?.files.count ?? 0) payload=\(payload?.count ?? 0)")
|
|
return DiskEditorFilePromise.make(bytes: model.contents.bytes, entry: rows[row], machine: model.machine, sourceURL: model.sourceURL, movePayload: payload, volumeID: model.contents.volumeID)
|
|
}
|
|
func tableView(_ tableView: NSTableView, draggingSession session: NSDraggingSession, willBeginAt screenPoint: NSPoint, forRowIndexes rowIndexes: IndexSet) {
|
|
let paths = rowIndexes.compactMap { rows.indices.contains($0) ? rows[$0].path : nil }
|
|
// The advertised payload was frozen when AppKit asked for writers,
|
|
// before it negotiates destination types. Do not add a type here.
|
|
if dragRequest?.files.map(\.path) != paths { dragRequest = nil }
|
|
trace("begin rows=\(rowIndexes) request=\(dragRequest?.id.uuidString ?? "none") types=\(session.draggingPasteboard.types?.map(\.rawValue) ?? [])")
|
|
}
|
|
func tableView(_ tableView: NSTableView, draggingSession session: NSDraggingSession, endedAt screenPoint: NSPoint, operation: NSDragOperation) {
|
|
trace("ended operation=\(operation.rawValue)")
|
|
dragRequest = nil
|
|
}
|
|
private func ownedMove(_ info: NSDraggingInfo) -> DiskEditorMoveRequest? {
|
|
guard let source = info.draggingSource as? NSTableView else { trace("refuse source-not-table class=\(info.draggingSource.map { String(describing: type(of: $0)) } ?? "nil")"); return nil }
|
|
guard source === table else { trace("refuse different-table"); return nil }
|
|
guard let request = dragRequest else { trace("refuse no-request"); return nil }
|
|
guard model.moveSourceIsCurrent(request) else { trace("refuse stale-source"); return nil }
|
|
guard let data = info.draggingPasteboard.data(forType: diskEditorMoveType), data.count <= DiskEditorIO.limit else { trace("refuse missing-or-oversized-payload"); return nil }
|
|
guard let payload = try? JSONDecoder().decode(DiskEditorDragPayload.self, from: data), payload == DiskEditorDragPayload(request) else { trace("refuse mismatched-payload"); return nil }
|
|
return request
|
|
}
|
|
private func destination(in table: NSTableView, for info: NSDraggingInfo) -> (path: String, row: Int)? {
|
|
// proposedRow describes an insertion boundary, which can be the row
|
|
// after the folder under the pointer. Folder moves target the row
|
|
// actually under the pointer, then explicitly use an on-row drop.
|
|
let row = table.row(at: table.convert(info.draggingLocation, from: nil))
|
|
if rows.indices.contains(row) { return rows[row].directory ? (rows[row].path, row) : nil }
|
|
return (model.path, -1)
|
|
}
|
|
func tableView(_ tableView: NSTableView, validateDrop info: NSDraggingInfo, proposedRow row: Int, proposedDropOperation operation: NSTableView.DropOperation) -> NSDragOperation {
|
|
trace("validate proposed=\(row) operation=\(operation.rawValue) hovered=\(tableView.row(at: tableView.convert(info.draggingLocation, from: nil))) source=\(info.draggingSource.map { String(describing: type(of: $0)) } ?? "nil") types=\(info.draggingPasteboard.types?.map(\.rawValue) ?? [])")
|
|
guard !model.busy else { return [] }
|
|
if info.draggingSource is NSTableView || info.draggingPasteboard.availableType(from: [diskEditorMoveType]) != nil {
|
|
guard let request = ownedMove(info) else { return [] }
|
|
guard let target = destination(in: tableView, for: info) else { trace("refuse target-not-folder"); return [] }
|
|
guard target.path.caseInsensitiveCompare(request.sourcePath) != .orderedSame else { trace("refuse same-folder"); return [] }
|
|
trace("validate move target-row=\(target.row)")
|
|
tableView.setDropRow(target.row, dropOperation: .on)
|
|
return .move
|
|
}
|
|
tableView.setDropRow(-1, dropOperation: .on); return .copy
|
|
}
|
|
func tableView(_ tableView: NSTableView, acceptDrop info: NSDraggingInfo, row: Int, dropOperation operation: NSTableView.DropOperation) -> Bool {
|
|
trace("accept proposed=\(row) operation=\(operation.rawValue)")
|
|
guard !model.busy else { return false }
|
|
if info.draggingSource is NSTableView || info.draggingPasteboard.availableType(from: [diskEditorMoveType]) != nil {
|
|
guard let request = ownedMove(info), let target = destination(in: tableView, for: info), target.path.caseInsensitiveCompare(request.sourcePath) != .orderedSame else { trace("accept refused"); return false }
|
|
trace("accept move files=\(request.files.count) target-row=\(target.row)")
|
|
model.move(request, to: target.path); return true
|
|
}
|
|
guard let urls = info.draggingPasteboard.readObjects(forClasses: [NSURL.self], options: [.urlReadingFileURLsOnly: true]) as? [URL], !urls.isEmpty else { return false }
|
|
model.proposeImport(urls); return true
|
|
}
|
|
}
|
|
}
|
|
|
|
enum DiskEditorFilePromise {
|
|
@MainActor static func make(bytes: Data, entry: DiskEditorEntry, machine: any DiskEditorHost, sourceURL: URL?, movePayload: Data? = nil, volumeID: String? = nil) -> NSFilePromiseProvider {
|
|
let delegate = DiskEditorPromiseDelegate(bytes: bytes, entry: entry, machine: machine, sourceURL: sourceURL, volumeID: volumeID)
|
|
// Keep ordinary exports on the plain provider. The owned subtype uses
|
|
// only the designated initializer. Both providers have weak delegates;
|
|
// documented strong userInfo keeps the immutable snapshot alive.
|
|
let provider: NSFilePromiseProvider
|
|
if let movePayload {
|
|
let owned = DiskEditorOwnedFilePromise(payload: movePayload)
|
|
owned.fileType = UTType.data.identifier; owned.delegate = delegate; provider = owned
|
|
} else { provider = NSFilePromiseProvider(fileType: UTType.data.identifier, delegate: delegate) }
|
|
provider.userInfo = delegate
|
|
return provider
|
|
}
|
|
}
|
|
/// Advertise the owned move identity before AppKit starts type negotiation.
|
|
/// Use NSFilePromiseProvider's designated init(), never its convenience init
|
|
/// which would dispatch back to an unimplemented Swift subclass initializer.
|
|
private final class DiskEditorOwnedFilePromise: NSFilePromiseProvider {
|
|
private let payload: Data
|
|
init(payload: Data) { self.payload = payload; super.init() }
|
|
override func writableTypes(for pasteboard: NSPasteboard) -> [NSPasteboard.PasteboardType] {
|
|
super.writableTypes(for: pasteboard) + [diskEditorMoveType]
|
|
}
|
|
override func pasteboardPropertyList(forType type: NSPasteboard.PasteboardType) -> Any? {
|
|
type == diskEditorMoveType ? payload : super.pasteboardPropertyList(forType: type)
|
|
}
|
|
override func writingOptions(forType type: NSPasteboard.PasteboardType, pasteboard: NSPasteboard) -> NSPasteboard.WritingOptions {
|
|
type == diskEditorMoveType ? [] : super.writingOptions(forType: type, pasteboard: pasteboard)
|
|
}
|
|
}
|
|
/// Finder can request every selected row concurrently. Chain the complete
|
|
/// async jobs, rather than only their delegate callbacks, so the shared machine
|
|
/// guard and snapshot reader are used by one promise at a time.
|
|
private actor DiskEditorPromiseExports {
|
|
static let shared = DiskEditorPromiseExports()
|
|
private var tail: Task<Void, Never>?
|
|
func write(snapshot: Data, entryPath: String, machine: any DiskEditorHost, source: URL?, destination: URL, volumeID: String?) async throws {
|
|
let previous = tail
|
|
let job = Task {
|
|
await previous?.value
|
|
DiskEditorPromiseDiagnostics.record("promise snapshot read begin")
|
|
let reader = try DiskImageEditorStore(data: snapshot, selectedVolumeID: volumeID)
|
|
let data = try await reader.read(entryPath)
|
|
DiskEditorPromiseDiagnostics.record("promise snapshot read complete; await machine export")
|
|
try await machine.savePromisedDiskEditorExport(data, to: destination, protecting: source)
|
|
}
|
|
tail = Task { _ = try? await job.value }
|
|
try await job.value
|
|
}
|
|
}
|
|
private final class DiskEditorPromiseDelegate: NSObject, NSFilePromiseProviderDelegate {
|
|
let bytes: Data, entry: DiskEditorEntry
|
|
let volumeID: String?
|
|
let machine: any DiskEditorHost, sourceURL: URL?
|
|
private let queue: OperationQueue = { let q = OperationQueue(); q.maxConcurrentOperationCount = 1; return q }()
|
|
init(bytes: Data, entry: DiskEditorEntry, machine: any DiskEditorHost, sourceURL: URL?, volumeID: String?) { self.bytes = bytes; self.entry = entry; self.machine = machine; self.sourceURL = sourceURL; self.volumeID = volumeID }
|
|
func filePromiseProvider(_ filePromiseProvider: NSFilePromiseProvider, fileNameForType fileType: String) -> String { DiskEditorPromiseDiagnostics.record("promise filename"); return entry.name }
|
|
func operationQueue(for filePromiseProvider: NSFilePromiseProvider) -> OperationQueue { queue }
|
|
func filePromiseProvider(_ filePromiseProvider: NSFilePromiseProvider, writePromiseTo url: URL, completionHandler: @escaping (Error?) -> Void) {
|
|
// A Finder promise may be fulfilled after another edit or after closing
|
|
// this window. Its immutable snapshot is the version the user dragged.
|
|
DiskEditorPromiseDiagnostics.record("promise write entered")
|
|
let snapshot = bytes, entryPath = entry.path, machine = machine, source = sourceURL, selectedVolume = volumeID
|
|
Task.detached {
|
|
do {
|
|
try await DiskEditorPromiseExports.shared.write(snapshot: snapshot, entryPath: entryPath,
|
|
machine: machine, source: source, destination: url, volumeID: selectedVolume)
|
|
DiskEditorPromiseDiagnostics.record("promise export complete")
|
|
completionHandler(nil)
|
|
} catch { DiskEditorPromiseDiagnostics.record("promise export error"); completionHandler(error) }
|
|
}
|
|
}
|
|
}
|