397 lines
15 KiB
Swift
397 lines
15 KiB
Swift
import AppKit
|
||
import OpenAPIRuntime
|
||
import SwiftUI
|
||
import UniformTypeIdentifiers
|
||
|
||
let maxImageBytes = 5 << 20
|
||
|
||
struct PendingImage: Identifiable {
|
||
let id = UUID()
|
||
let data: Data
|
||
let image: NSImage
|
||
}
|
||
|
||
func imageType(_ data: Data) -> String? {
|
||
let b = [UInt8](data.prefix(12))
|
||
if b.starts(with: [0x89, 0x50, 0x4E, 0x47]) {
|
||
return "png"
|
||
}
|
||
if b.starts(with: [0xFF, 0xD8, 0xFF]) {
|
||
return "jpeg"
|
||
}
|
||
if b.starts(with: Array("GIF8".utf8)) {
|
||
return "gif"
|
||
}
|
||
if b.count == 12, b.starts(with: Array("RIFF".utf8)), Array(b[8..<12]) == Array("WEBP".utf8) {
|
||
return "webp"
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func pngFromTIFF(_ data: Data) -> Data? {
|
||
NSBitmapImageRep(data: data)?.representation(using: .png, properties: [:])
|
||
}
|
||
|
||
@MainActor
|
||
@Observable
|
||
final class Attachments {
|
||
var images: [PendingImage] = []
|
||
let spike: SpikeLog
|
||
let api: API
|
||
let name: String
|
||
|
||
init(spike: SpikeLog, api: API, name: String) {
|
||
self.spike = spike
|
||
self.api = api
|
||
self.name = name
|
||
}
|
||
|
||
func add(_ data: Data, from source: String) {
|
||
guard let kind = imageType(data), let image = NSImage(data: data) else {
|
||
spike.log("\(name): \(source) gave \(data.count) bytes that aren't PNG, JPEG, GIF or WebP")
|
||
return
|
||
}
|
||
if data.count > maxImageBytes {
|
||
spike.log("\(name): \(source) image is over \(maxImageBytes >> 20) MiB")
|
||
return
|
||
}
|
||
spike.log("\(name): \(source) attached a \(kind), \(data.count) bytes")
|
||
images.append(PendingImage(data: data, image: image))
|
||
}
|
||
|
||
func add(pasteboard pb: NSPasteboard, from source: String) -> Bool {
|
||
if let urls = pb.readObjects(forClasses: [NSURL.self], options: [.urlReadingFileURLsOnly: true]) as? [URL], !urls.isEmpty {
|
||
var any = false
|
||
for url in urls {
|
||
if let data = try? Data(contentsOf: url), imageType(data) != nil || pngFromTIFF(data) != nil && NSImage(data: data) != nil {
|
||
add(imageType(data) != nil ? data : pngFromTIFF(data)!, from: "\(source) file \(url.lastPathComponent)")
|
||
any = true
|
||
}
|
||
}
|
||
return any
|
||
}
|
||
for t in [NSPasteboard.PasteboardType.png, NSPasteboard.PasteboardType(UTType.jpeg.identifier), NSPasteboard.PasteboardType(UTType.gif.identifier), NSPasteboard.PasteboardType(UTType.webP.identifier)] {
|
||
if let data = pb.data(forType: t) {
|
||
add(data, from: "\(source) \(t.rawValue)")
|
||
return true
|
||
}
|
||
}
|
||
if let tiff = pb.data(forType: .tiff), let png = pngFromTIFF(tiff) {
|
||
add(png, from: "\(source) public.tiff converted to PNG")
|
||
return true
|
||
}
|
||
return false
|
||
}
|
||
|
||
func add(providers: [NSItemProvider], from source: String) {
|
||
spike.log("\(name): \(source) with types \(providers.map { $0.registeredTypeIdentifiers })")
|
||
for p in providers {
|
||
let types = [UTType.png, .jpeg, .gif, .webP, .tiff, .fileURL].filter { p.hasItemConformingToTypeIdentifier($0.identifier) }
|
||
guard let t = types.first else {
|
||
continue
|
||
}
|
||
_ = p.loadDataRepresentation(for: t) { data, error in
|
||
Task { @MainActor in
|
||
guard let data else {
|
||
self.spike.log("\(self.name): \(source) load failed: \(String(describing: error))")
|
||
return
|
||
}
|
||
if t == .fileURL, let url = URL(dataRepresentation: data, relativeTo: nil), let file = try? Data(contentsOf: url) {
|
||
self.add(imageType(file) != nil ? file : (pngFromTIFF(file) ?? file), from: "\(source) file \(url.lastPathComponent)")
|
||
} else if t == .tiff, let png = pngFromTIFF(data) {
|
||
self.add(png, from: "\(source) tiff converted to PNG")
|
||
} else {
|
||
self.add(data, from: "\(source) \(t.identifier)")
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
func send(_ text: String) {
|
||
let images = self.images
|
||
self.images = []
|
||
spike.log("\(name): send \(text.debugDescription) with \(images.count) images")
|
||
Task {
|
||
for img in images {
|
||
do {
|
||
spike.log("\(name): uploaded blob \(try await upload(img.data))")
|
||
} catch {
|
||
spike.log("\(name): upload failed: \(errorText(error))")
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
private func upload(_ data: Data) async throws -> String {
|
||
let body = HTTPBody(data)
|
||
let typed: Operations.UploadBlob.Input.Body = switch imageType(data) {
|
||
case "png": .png(body)
|
||
case "jpeg": .jpeg(body)
|
||
case "gif": .imageGif(body)
|
||
default: .imageWebp(body)
|
||
}
|
||
return try await api.client.uploadBlob(body: typed).created.body.json.id
|
||
}
|
||
}
|
||
|
||
struct Thumbnails: View {
|
||
@Bindable var attachments: Attachments
|
||
|
||
var body: some View {
|
||
HStack {
|
||
ForEach(attachments.images) { img in
|
||
ZStack(alignment: .topTrailing) {
|
||
Image(nsImage: img.image)
|
||
.resizable()
|
||
.scaledToFit()
|
||
.frame(width: 64, height: 64)
|
||
Button("×") {
|
||
attachments.images.removeAll { $0.id == img.id }
|
||
}
|
||
}
|
||
}
|
||
}
|
||
.frame(height: attachments.images.isEmpty ? 0 : 64)
|
||
}
|
||
}
|
||
|
||
struct ComposerSpike: View {
|
||
@Environment(Store.self) private var store
|
||
@Environment(SpikeLog.self) private var spike
|
||
|
||
var body: some View {
|
||
HStack(alignment: .top, spacing: 16) {
|
||
SwiftUIComposer(attachments: Attachments(spike: spike, api: store.api, name: "TextEditor"))
|
||
AppKitComposerPanel(attachments: Attachments(spike: spike, api: store.api, name: "NSTextView"))
|
||
RoutedComposer(attachments: Attachments(spike: spike, api: store.api, name: "Routed"))
|
||
}
|
||
.padding(8)
|
||
}
|
||
}
|
||
|
||
struct ComposerFocusKey: FocusedValueKey {
|
||
typealias Value = Attachments
|
||
}
|
||
|
||
extension FocusedValues {
|
||
var composer: Attachments? {
|
||
get {
|
||
self[ComposerFocusKey.self]
|
||
}
|
||
set {
|
||
self[ComposerFocusKey.self] = newValue
|
||
}
|
||
}
|
||
}
|
||
|
||
struct PasteboardCommands: Commands {
|
||
@FocusedValue(\.composer) private var composer
|
||
|
||
var body: some Commands {
|
||
CommandGroup(replacing: .pasteboard) {
|
||
Button("Cut") {
|
||
NSApp.sendAction(#selector(NSText.cut(_:)), to: nil, from: nil)
|
||
}
|
||
.keyboardShortcut("x")
|
||
Button("Copy") {
|
||
NSApp.sendAction(#selector(NSText.copy(_:)), to: nil, from: nil)
|
||
}
|
||
.keyboardShortcut("c")
|
||
Button("Paste") {
|
||
if let composer, composer.add(pasteboard: .general, from: "Edit ▸ Paste") {
|
||
return
|
||
}
|
||
NSApp.sendAction(#selector(NSText.paste(_:)), to: nil, from: nil)
|
||
}
|
||
.keyboardShortcut("v")
|
||
Button("Select All") {
|
||
NSApp.sendAction(#selector(NSText.selectAll(_:)), to: nil, from: nil)
|
||
}
|
||
.keyboardShortcut("a")
|
||
}
|
||
}
|
||
}
|
||
|
||
struct RoutedComposer: View {
|
||
@ViewState var attachments: Attachments
|
||
@ViewState private var text = ""
|
||
@ViewState private var overlayHits = false
|
||
@ViewState private var targeted = false
|
||
|
||
var body: some View {
|
||
VStack(alignment: .leading) {
|
||
Text("SwiftUI TextEditor, paste through Edit ▸ Paste, drop overlay")
|
||
Toggle("Drop overlay takes hits (off: clicks pass through to the editor)", isOn: $overlayHits)
|
||
Thumbnails(attachments: attachments)
|
||
TextEditor(text: $text)
|
||
.frame(minHeight: 160)
|
||
.border(targeted ? Color.accentColor : Color.secondary.opacity(0.4))
|
||
.focusedValue(\.composer, attachments)
|
||
.onKeyPress(.return, phases: .down) { press in
|
||
let marked = (NSApp.keyWindow?.firstResponder as? NSTextView)?.hasMarkedText() ?? false
|
||
attachments.spike.log("Routed: onKeyPress return, modifiers \(press.modifiers.rawValue), hasMarkedText \(marked)")
|
||
if press.modifiers.contains(.shift) || marked {
|
||
return .ignored
|
||
}
|
||
attachments.send(text)
|
||
text = ""
|
||
return .handled
|
||
}
|
||
.overlay {
|
||
Color.clear
|
||
.contentShape(Rectangle())
|
||
.allowsHitTesting(overlayHits)
|
||
.onDrop(of: [.image, .fileURL], isTargeted: $targeted) { providers in
|
||
attachments.add(providers: providers, from: "overlay onDrop")
|
||
return true
|
||
}
|
||
}
|
||
.onChange(of: targeted) {
|
||
attachments.spike.log("Routed: overlay drop targeted \(targeted)")
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
struct SwiftUIComposer: View {
|
||
@ViewState var attachments: Attachments
|
||
@ViewState private var text = ""
|
||
@ViewState private var checkMarked = false
|
||
|
||
var body: some View {
|
||
VStack(alignment: .leading) {
|
||
Text("SwiftUI TextEditor + onKeyPress, onPasteCommand, onDrop")
|
||
Toggle("In onKeyPress, also ignore Return while the first responder hasMarkedText()", isOn: $checkMarked)
|
||
Thumbnails(attachments: attachments)
|
||
TextEditor(text: $text)
|
||
.frame(minHeight: 160)
|
||
.border(Color.secondary.opacity(0.4))
|
||
.onKeyPress(.return, phases: .down) { press in
|
||
let marked = (NSApp.keyWindow?.firstResponder as? NSTextView)?.hasMarkedText() ?? false
|
||
attachments.spike.log("TextEditor: onKeyPress return, modifiers \(press.modifiers.rawValue), hasMarkedText \(marked)")
|
||
if press.modifiers.contains(.shift) {
|
||
return .ignored
|
||
}
|
||
if checkMarked && marked {
|
||
return .ignored
|
||
}
|
||
attachments.send(text)
|
||
text = ""
|
||
return .handled
|
||
}
|
||
.onPasteCommand(of: [.png, .jpeg, .gif, .webP, .tiff, .fileURL]) { providers in
|
||
attachments.add(providers: providers, from: "onPasteCommand")
|
||
}
|
||
.onDrop(of: [.image, .fileURL], isTargeted: nil) { providers in
|
||
attachments.add(providers: providers, from: "onDrop")
|
||
return true
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
struct AppKitComposerPanel: View {
|
||
@ViewState var attachments: Attachments
|
||
|
||
var body: some View {
|
||
VStack(alignment: .leading) {
|
||
Text("NSTextView in NSViewRepresentable")
|
||
Text("doCommand(insertNewline:), paste(_:), performDragOperation")
|
||
Thumbnails(attachments: attachments)
|
||
AppKitComposer(attachments: attachments)
|
||
.frame(minHeight: 160)
|
||
.border(Color.secondary.opacity(0.4))
|
||
}
|
||
}
|
||
}
|
||
|
||
final class ComposerTextView: NSTextView {
|
||
var attachments: Attachments!
|
||
|
||
override func keyDown(with event: NSEvent) {
|
||
if event.keyCode == 36 || event.keyCode == 76 {
|
||
attachments.spike.log("NSTextView: keyDown return, modifiers \(event.modifierFlags.intersection(.deviceIndependentFlagsMask).rawValue), hasMarkedText \(hasMarkedText())")
|
||
}
|
||
super.keyDown(with: event)
|
||
}
|
||
|
||
override func doCommand(by selector: Selector) {
|
||
let shift = NSApp.currentEvent?.modifierFlags.contains(.shift) ?? false
|
||
if selector == #selector(insertNewline(_:)) && !shift {
|
||
attachments.send(string)
|
||
string = ""
|
||
return
|
||
}
|
||
if selector == #selector(insertNewline(_:)) {
|
||
insertNewlineIgnoringFieldEditor(nil)
|
||
return
|
||
}
|
||
super.doCommand(by: selector)
|
||
}
|
||
|
||
override func paste(_ sender: Any?) {
|
||
if attachments.add(pasteboard: .general, from: "paste(_:)") {
|
||
return
|
||
}
|
||
super.paste(sender)
|
||
}
|
||
|
||
override var readablePasteboardTypes: [NSPasteboard.PasteboardType] {
|
||
super.readablePasteboardTypes + [.png, .tiff, .fileURL]
|
||
}
|
||
|
||
override func draggingEntered(_ sender: any NSDraggingInfo) -> NSDragOperation {
|
||
if hasImage(sender.draggingPasteboard) {
|
||
return .copy
|
||
}
|
||
return super.draggingEntered(sender)
|
||
}
|
||
|
||
override func draggingUpdated(_ sender: any NSDraggingInfo) -> NSDragOperation {
|
||
if hasImage(sender.draggingPasteboard) {
|
||
return .copy
|
||
}
|
||
return super.draggingUpdated(sender)
|
||
}
|
||
|
||
override func performDragOperation(_ sender: any NSDraggingInfo) -> Bool {
|
||
if hasImage(sender.draggingPasteboard) {
|
||
return attachments.add(pasteboard: sender.draggingPasteboard, from: "drop")
|
||
}
|
||
return super.performDragOperation(sender)
|
||
}
|
||
|
||
private func hasImage(_ pb: NSPasteboard) -> Bool {
|
||
if let urls = pb.readObjects(forClasses: [NSURL.self], options: [.urlReadingFileURLsOnly: true]) as? [URL], !urls.isEmpty {
|
||
return urls.contains { (try? Data(contentsOf: $0)).map { imageType($0) != nil || NSImage(data: $0) != nil } ?? false }
|
||
}
|
||
return pb.availableType(from: [.png, .tiff, NSPasteboard.PasteboardType(UTType.jpeg.identifier), NSPasteboard.PasteboardType(UTType.gif.identifier), NSPasteboard.PasteboardType(UTType.webP.identifier)]) != nil
|
||
}
|
||
}
|
||
|
||
struct AppKitComposer: NSViewRepresentable {
|
||
let attachments: Attachments
|
||
|
||
func makeNSView(context: Context) -> NSScrollView {
|
||
let scroll = NSScrollView()
|
||
scroll.hasVerticalScroller = true
|
||
let tv = ComposerTextView(frame: .zero)
|
||
tv.attachments = attachments
|
||
tv.isRichText = false
|
||
tv.allowsUndo = true
|
||
tv.font = Fonts.ct(13) as NSFont
|
||
tv.minSize = .zero
|
||
tv.maxSize = NSSize(width: CGFloat.greatestFiniteMagnitude, height: CGFloat.greatestFiniteMagnitude)
|
||
tv.isVerticallyResizable = true
|
||
tv.isHorizontallyResizable = false
|
||
tv.autoresizingMask = [.width]
|
||
tv.textContainer?.widthTracksTextView = true
|
||
tv.registerForDraggedTypes([.png, .tiff, .fileURL])
|
||
scroll.documentView = tv
|
||
return scroll
|
||
}
|
||
|
||
func updateNSView(_ nsView: NSScrollView, context: Context) {}
|
||
}
|