+/*
+ Copyright (C) 2024 Rubén Beltrán del Río
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see https://captura.tranquil.systems.
+ */
import SwiftUI
-import SwiftData
import Cocoa
import Combine
import AVFoundation
+import Sparkle
@main
struct CapturaApp: App {
-
+
@NSApplicationDelegateAdaptor(CapturaAppDelegate.self) var appDelegate
var body: some Scene {
}
}
-class CapturaAppDelegate: NSObject, NSApplicationDelegate, NSMenuDelegate {
+@objc(CapturaAppDelegate) class CapturaAppDelegate: NSObject, NSApplicationDelegate, NSMenuDelegate {
@Environment(\.openURL) var openURL
var statusItem: NSStatusItem!
var images: [CGImage] = []
var outputFile: CapturaFile? = nil
var gifCallbackTimer = ContinuousClock.now
- var fps = CapturaSettings.frameRate
var pixelDensity: CGFloat = 1.0
var stopTimer: DispatchWorkItem?
var remoteFiles: [CapturaRemoteFile] = []
+ var captureSessionConfiguration: CaptureSessionConfiguration = CaptureSessionConfiguration()
+
+ // Sparkle Configuration
+ @IBOutlet var checkForUpdatesMenuItem: NSMenuItem!
+ let updaterController: SPUStandardUpdaterController = SPUStandardUpdaterController(startingUpdater: true, updaterDelegate: nil, userDriverDelegate: nil)
+
+ @objc dynamic var scriptedPreferences: ScriptedPreferences = ScriptedPreferences()
func applicationDidFinishLaunching(_ notification: Notification) {
setupStatusBar()
statusItem = NSStatusBar.system.statusItem(withLength: NSStatusItem.variableLength)
if let button = statusItem.button {
- button.image = NSImage(systemSymbolName: "rectangle.dashed.badge.record", accessibilityDescription: "Captura")
+ button.image = NSImage(named: "Idle")
}
statusItem.isVisible = true
statusItem.menu?.addItem(NSMenuItem.separator())
statusItem.menu?.addItem(NSMenuItem(title: "Open Local Folder", action: #selector(CapturaAppDelegate.onOpenFolder), keyEquivalent: ""))
statusItem.menu?.addItem(NSMenuItem.separator())
+
+ checkForUpdatesMenuItem = NSMenuItem(title: "Check for Updates", action: #selector(SPUStandardUpdaterController.checkForUpdates(_:)), keyEquivalent: "")
+ checkForUpdatesMenuItem.target = updaterController
+ statusItem.menu?.addItem(checkForUpdatesMenuItem)
+
statusItem.menu?.addItem(NSMenuItem(title: "Preferences", action: #selector(CapturaAppDelegate.onOpenPreferences), keyEquivalent: ""))
statusItem.menu?.addItem(NSMenuItem(title: "Quit", action: #selector(CapturaAppDelegate.onQuit), keyEquivalent: ""))
}
window.close()
}
}
+
+ // MARK: - URL Event Handler
+
+ func application(_ application: NSApplication, open urls: [URL]) {
+ if (CapturaSettings.shouldAllowURLAutomation) {
+ for url in urls {
+ if let action = CapturaURLDecoder.decodeParams(url: url) {
+ switch action {
+ case let .configure(config):
+ NotificationCenter.default.post(name: .setConfiguration, object: nil, userInfo: [
+ "config": config
+ ])
+ case let .record(config):
+ NotificationCenter.default.post(name: .setCaptureSessionConfiguration, object: nil, userInfo: [
+ "config": config
+ ])
+ NotificationCenter.default.post(name: .startAreaSelection, object: nil, userInfo: nil)
+ }
+ }
+ }
+ } else {
+ let alert = NSAlert()
+ alert.messageText = "URL Automation Prevented"
+ alert.informativeText = "A website or application attempted to record your screen using URL Automation. If you want to allow this, enable it in Preferences."
+ alert.alertStyle = .warning
+ alert.addButton(withTitle: "OK")
+ alert.runModal()
+ }
+ }
// MARK: - UI Event Handlers
func menuWillOpen(_ menu: NSMenu) {
if captureState != .idle {
- menu.cancelTracking()
+ menu.cancelTrackingWithoutAnimation()
+ if captureState == .selectingArea {
+ NotificationCenter.default.post(name: .startRecording, object: nil, userInfo: nil)
+ return
+ }
if captureState == .recording {
NotificationCenter.default.post(name: .stopRecording, object: nil, userInfo: nil)
+ return
}
}
}
if let frame = notification.userInfo?["frame"] {
receivedFrame(frame as! CVImageBuffer)
}
+ case .setConfiguration:
+ DispatchQueue.main.async {
+ if let userInfo = notification.userInfo {
+ if let config = userInfo["config"] as? ConfigureAction {
+ self.setConfiguration(config)
+ }
+ }
+ }
+ case .reloadConfiguration:
+ reloadConfiguration()
+ case .setCaptureSessionConfiguration:
+ if let userInfo = notification.userInfo {
+ if let config = userInfo["config"] as? RecordAction {
+ setCaptureSessionConfiguration(config)
+ }
+ }
case .NSManagedObjectContextObjectsDidChange:
DispatchQueue.main.async {
self.fetchRemoteItems()
helpShown = false
if captureState != .selectingArea {
captureState = .selectingArea
+ updateImage()
if let button = statusItem.button {
let rectInWindow = button.convert(button.bounds, to: nil)
let rectInScreen = button.window?.convertToScreen(rectInWindow)
NSApp.activate(ignoringOtherApps: true)
- recordingWindow = RecordingWindow(rectInScreen)
+ recordingWindow = RecordingWindow(captureSessionConfiguration, rectInScreen)
recordingWindow?.makeKeyAndOrderFront(nil)
recordingWindow?.orderFrontRegardless()
boxListener = recordingWindow?.recordingContentView.$box
func startRecording() {
captureState = .recording
updateImage()
- fps = CapturaSettings.frameRate
outputFile = nil
images = [];
pixelDensity = recordingWindow?.pixelDensity ?? 1.0
stopTimer = DispatchWorkItem {
self.stopRecording()
}
- DispatchQueue.main.asyncAfter(deadline: .now() + 300, execute: stopTimer!)
+ DispatchQueue.main.asyncAfter(deadline: .now() + Double(captureSessionConfiguration.maxLength), execute: stopTimer!)
outputFile = CapturaFile()
- if CapturaSettings.shouldSaveMp4 {
+ if captureSessionConfiguration.shouldSaveMp4 {
captureSession.startRecording(to: outputFile!.mp4URL)
} else {
captureSession.startRunning()
stop()
Task.detached {
- if CapturaSettings.shouldSaveGif {
+ if self.captureSessionConfiguration.shouldSaveGif {
if let outputFile = self.outputFile {
- await GifRenderer.render(self.images, at: self.fps, to: outputFile.gifURL)
+ await GifRenderer.render(self.images, at: self.captureSessionConfiguration.frameRate, to: outputFile.gifURL)
}
}
let wasSuccessful = await self.uploadOrCopy()
func reset() {
captureState = .idle
updateImage()
+ captureSessionConfiguration = CaptureSessionConfiguration()
stop()
}
func receivedFrame(_ frame: CVImageBuffer) {
let now = ContinuousClock.now
- if now - gifCallbackTimer > .nanoseconds(1_000_000_000 / UInt64(fps)) {
+ if now - gifCallbackTimer > .nanoseconds(1_000_000_000 / UInt64(captureSessionConfiguration.frameRate)) {
gifCallbackTimer = now
DispatchQueue.main.async {
- if let cgImage = frame.cgImage?.resize(by: self.pixelDensity) {
+ if var cgImage = frame.cgImage {
+ if self.pixelDensity > 1 {
+ cgImage = cgImage.resize(by: self.pixelDensity) ?? cgImage
+ }
self.images.append(cgImage)
}
}
}
}
+ func setConfiguration(_ config: ConfigureAction) {
+ CapturaSettings.apply(config)
+ }
+
+ func reloadConfiguration() {
+ self.captureSessionConfiguration = CaptureSessionConfiguration()
+ }
+
+ func setCaptureSessionConfiguration(_ config: RecordAction) {
+ self.captureSessionConfiguration = CaptureSessionConfiguration(from: config)
+ }
+
// MARK: - CoreData
private func fetchRemoteItems() {
if let button = statusItem.button {
let image: String = switch captureState {
case .idle:
- "rectangle.dashed.badge.record"
+ "Idle"
case .selectingArea:
- "circle.rectangle.dashed"
+ if recordingWindow?.recordingContentView.box != nil {
+ "Ready to Record"
+ } else {
+ "Selecting"
+ }
case .recording:
- "checkmark.rectangle"
+ "Stop Frame 1"
case .uploading:
- "dock.arrow.up.rectangle"
+ "Upload Frame 1"
case .uploaded:
- "checkmark.rectangle.fill"
+ "OK"
case .error:
- "xmark.rectangle.fill"
+ "ERR"
}
- button.image = NSImage(systemSymbolName: image, accessibilityDescription: "Captura")
+ button.image = NSImage(named: image)
}
}
}
private func uploadOrCopy() async -> Bool {
- if CapturaSettings.shouldUseBackend {
+ if captureSessionConfiguration.shouldUseBackend {
let result = await uploadToBackend()
- if result && !CapturaSettings.shouldKeepLocalFiles {
+ if result && !captureSessionConfiguration.shouldKeepLocalFiles {
deleteLocalFiles()
}
return result
}
private func copyLocalToClipboard() {
- let fileType: NSPasteboard.PasteboardType = .init(rawValue: CapturaSettings.shouldSaveGif ? "com.compuserve.gif" : "public.mpeg-4")
- if let url = CapturaSettings.shouldSaveGif ? outputFile?.gifURL : outputFile?.mp4URL {
+ let fileType: NSPasteboard.PasteboardType = .init(rawValue: captureSessionConfiguration.shouldSaveGif ? "com.compuserve.gif" : "public.mpeg-4")
+ if let url = captureSessionConfiguration.shouldSaveGif ? outputFile?.gifURL : outputFile?.mp4URL {
if let data = try? Data(contentsOf: url) {
let pasteboard = NSPasteboard.general
pasteboard.declareTypes([fileType], owner: nil)
}
private func uploadToBackend() async -> Bool {
- let contentType = CapturaSettings.shouldUploadGif ? "image/gif" : "video/mp4"
- if let url = CapturaSettings.shouldUploadGif ? outputFile?.gifURL : outputFile?.mp4URL {
+ let contentType = captureSessionConfiguration.shouldUploadGif ? "image/gif" : "video/mp4"
+ if let url = captureSessionConfiguration.shouldUploadGif ? outputFile?.gifURL : outputFile?.mp4URL {
if let data = try? Data(contentsOf: url) {
- if let remoteUrl = CapturaSettings.backend {
+ if let remoteUrl = captureSessionConfiguration.backend {
var request = URLRequest(url: remoteUrl)
request.httpMethod = "POST"
request.httpBody = data
}
private func deleteLocalFiles() {
- if CapturaSettings.shouldSaveGif {
+ if captureSessionConfiguration.shouldSaveGif {
if let url = outputFile?.gifURL {
try? FileManager.default.removeItem(at: url)
}
}
- if CapturaSettings.shouldSaveMp4 {
+ if captureSessionConfiguration.shouldSaveMp4 {
if let url = outputFile?.mp4URL {
try? FileManager.default.removeItem(at: url)
}
git.r.bdr.sh / rbdr / captura / blobdiff