[SwiftUI][Image] イメージ処理アプリを作る（７）

struct MainView: View {
    @EnvironmentObject var editModel: EditModel
    @State private var isTargeted = false

    var body: some View {
        HStack {
            ZStack(alignment: .center) {
                Image(nsImage: editModel.image).resizable().scaledToFit().frame(width: editModel.canvasSize.width, height: editModel.canvasSize.height)
                    .accessibility(identifier: "mainImage")
                    .onDrop(of: [UTType.fileURL], isTargeted: $isTargeted) { (providers) -> Bool in
                        guard let provider = providers.first else { return false } // handle first item only
                        provider.loadItem(forTypeIdentifier: kUTTypeURL as String, options: nil) { (url, error) in
                            DispatchQueue.main.async {
                                if let url = url as? Data {
                                    let imageURL = NSURL(absoluteURLWithDataRepresentation: url, relativeTo: nil) as URL
                                    if let localImage = NSImage(contentsOf: imageURL) {
                                        editModel.image = localImage
                                    }
                                } else if let error = error {
                                    print(error)
                                }
                            }
                        }
                        return true
                    }
                GlassImage()
            }
            .padding()
            VStack {
                Button(action: {
                    let exportImage = editModel.composedImage()
                    exportNSImage(image: exportImage)
                }, label: {
                    Text("Save")
                })
            }
            .padding()
        }
    }
    ... snip ...
}

struct MainViewWithSave:View {
    @EnvironmentObject var editModel: EditModel
    @State private var isTargeted = false

    var body: some View {
        HStack {
            MainView()
                .padding()
                .onDrop(of: [UTType.fileURL], isTargeted: $isTargeted) { (providers) -> Bool in
                    guard let provider = providers.first else { return false } // handle first item only
                    provider.loadItem(forTypeIdentifier: kUTTypeURL as String, options: nil) { (url, error) in
                        DispatchQueue.main.async {
                            if let url = url as? Data {
                                let imageURL = NSURL(absoluteURLWithDataRepresentation: url, relativeTo: nil) as URL
                                if let localImage = NSImage(contentsOf: imageURL) {
                                    editModel.image = localImage
                                }
                            } else if let error = error {
                                print(error)
                            }
                        }
                    }
                    return true
                }

            VStack {
                Button(action: {
                    let exportImage = editModel.composedImage()
                    exportNSImage(image: exportImage)
                }, label: {
                    Text("Save")
                })
            }
            .padding()
        }
    }
    func exportNSImage(image: NSImage) {
        // png file
        guard let imageData = image.tiffRepresentation else { return }
        guard let bitmapRep = NSBitmapImageRep(data: imageData) else { return }
        guard let jpgData = bitmapRep.representation(using: .jpeg, properties: [NSBitmapImageRep.PropertyKey.compressionFactor:1.0]) else { return }
        
        let savePanel = NSSavePanel()
        savePanel.canCreateDirectories = true
        savePanel.showsTagField = false
        savePanel.isExtensionHidden = false
        savePanel.nameFieldStringValue = "ExportedImage.jpg"
        //savePanel.nameFieldStringValue = "ExportedImage.png"
        savePanel.begin { (result) in
            if result == .OK {
                guard let saveFileURL = savePanel.url else { return }
                do {
                    try jpgData.write(to: saveFileURL)
                } catch {
                    print("\(error)")
                }

            }
        }
    }
}

struct MainView: View {
    @EnvironmentObject var editModel: EditModel

    var body: some View {
        ZStack(alignment: .center) {
            Image(nsImage: editModel.image).resizable().scaledToFit().frame(width: editModel.canvasSize.width, height: editModel.canvasSize.height)
                .accessibility(identifier: "mainImage")
            GlassImage()
        }
        .padding()
    }
}

    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view.
        editModel = EditModel()
        let glassMainView = MainView().environmentObject(editModel)

        let glassHostView = NSHostingView(rootView: glassMainView)
        glassHostView.frame = CGRect(origin: CGPoint(x: 10, y: 10), size: CGSize(width: 500, height: 500))
        self.view.addSubview(glassHostView)
        
    }

    func startContentEditing(with contentEditingInput: PHContentEditingInput, placeholderImage: NSImage) {
        // Present content for editing, and keep the contentEditingInput for use when closing the edit session.
        // If you returned true from canHandleAdjustmentData:, contentEditingInput has the original image and adjustment data.
        // If you returned false, the contentEditingInput has past edits "baked in".
        input = contentEditingInput
        if let url = contentEditingInput.fullSizeImageURL {
            let inputImage = NSImage(contentsOf: url)!
            editModel.image = inputImage
        }
    }

    func finishContentEditing(completionHandler: @escaping ((PHContentEditingOutput?) -> Void)) {
        // Update UI to reflect that editing has finished and output is being rendered.
        
        // Render and provide output on a background queue.
        DispatchQueue.global().async {
            // Create editing output from the editing input.
            let output = PHContentEditingOutput(contentEditingInput: self.input!)
            
            // Provide new adjustments and render output to given location.
            let dummyAdjustmentData = "dummy".data(using: .utf8)!
            output.adjustmentData = PHAdjustmentData(formatIdentifier: Self.myFormatID, formatVersion: Self.myFormatVersion, data: dummyAdjustmentData)

            let editedImage = self.editModel.composedImage()
            guard let imageData = editedImage.tiffRepresentation else { return }
            guard let bitmapRep = NSBitmapImageRep(data: imageData) else { return }
            guard let jpgData = bitmapRep.representation(using: .jpeg, properties: [NSBitmapImageRep.PropertyKey.compressionFactor:1.0]) else { return }
            do {
                try jpgData.write(to: output.renderedContentURL, options: .atomic)
            } catch {
                print(error)
            }
            
            // Call completion handler to commit edit to Photos.
            completionHandler(output)
            
            // Clean up temporary files, etc.
        }
    }