i7t5--edmund
wehub-resource-sync
290 行
11 KiB
Swift
290 行
11 KiB
Swift
import AppKit
|
|
import EdmundCore
|
|
import Sparkle
|
|
|
|
// Entry point for the app the user knows as "Edmund" (CFBundleName). The
|
|
// executable target — and so this binary at Edmund.app/Contents/MacOS/edmd — is
|
|
// named `edmd`, an expansion of "Editor for Markdown". The backronym is the
|
|
// app's original working name; it survives only here and in Package.swift, never
|
|
// in anything user-facing.
|
|
|
|
// --- App Delegate -----------------------------------------------------------
|
|
|
|
@MainActor
|
|
class AppDelegate: NSObject, NSApplicationDelegate, NSMenuItemValidation {
|
|
|
|
var aboutWindowController: AboutWindowController?
|
|
var settingsWindowController: SettingsWindowController?
|
|
// startingUpdater: true kicks off the scheduled background check immediately;
|
|
// the "Check for Updates…" menu item targets this controller directly.
|
|
let updaterController = SPUStandardUpdaterController(
|
|
startingUpdater: true, updaterDelegate: nil, userDriverDelegate: nil)
|
|
|
|
// MARK: - Typewriter Mode (persisted)
|
|
|
|
static let typewriterModeKey = "EditorTypewriterMode"
|
|
|
|
/// Whether typewriter scrolling is enabled. Defaults to on (the historical
|
|
/// behavior) when nothing has been saved yet.
|
|
static func typewriterModeEnabled(_ defaults: UserDefaults = .standard) -> Bool {
|
|
defaults.object(forKey: typewriterModeKey) as? Bool ?? true
|
|
}
|
|
|
|
func applicationDidFinishLaunching(_ notification: Notification) {
|
|
AppSettings.applyLogging()
|
|
Log.info("Edmund launched", category: .app)
|
|
AppSettings.applyAppearance()
|
|
setupMenuBar()
|
|
|
|
// Opt-in (default off): upload any crash reports macOS wrote for us since
|
|
// last launch. Fire-and-forget; never blocks startup.
|
|
if AppSettings.sendCrashLogs {
|
|
CrashReporter.uploadPendingReports(
|
|
alreadySent: AppSettings.sentCrashReports,
|
|
onSent: { AppSettings.sentCrashReports.insert($0) })
|
|
}
|
|
|
|
// Open file from command-line argument. When a file is given,
|
|
// `applicationShouldOpenUntitledFile` suppresses the otherwise-automatic
|
|
// blank document, so we don't end up with two windows.
|
|
let args = CommandLine.arguments
|
|
if args.count > 1 {
|
|
let url = URL(fileURLWithPath: args[1])
|
|
Log.info("Opening file from launch argument: \(url.path)", category: .document)
|
|
NSDocumentController.shared.openDocument(withContentsOf: url, display: true) { _, _, _ in }
|
|
}
|
|
|
|
#if DEBUG
|
|
ReproScript.runIfRequested()
|
|
#endif
|
|
}
|
|
|
|
// Auto-open a blank document on launch only when no file was passed on the
|
|
// command line (otherwise the file arg + the blank doc make two windows).
|
|
func applicationShouldOpenUntitledFile(_ sender: NSApplication) -> Bool {
|
|
CommandLine.arguments.count <= 1 && AppSettings.startupAction == .createNewDocument
|
|
}
|
|
|
|
func applicationSupportsSecureRestorableState(_ app: NSApplication) -> Bool {
|
|
AppSettings.reopenWindows
|
|
}
|
|
|
|
func applicationShouldTerminateAfterLastWindowClosed(_ sender: NSApplication) -> Bool {
|
|
true
|
|
}
|
|
|
|
// Reopen a new untitled document when the app is activated with no windows.
|
|
func applicationShouldHandleReopen(_ sender: NSApplication, hasVisibleWindows flag: Bool) -> Bool {
|
|
if !flag {
|
|
if AppSettings.startupAction == .createNewDocument {
|
|
NSDocumentController.shared.newDocument(nil)
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
// MARK: - Settings
|
|
|
|
@MainActor @objc func showAbout(_ sender: Any?) {
|
|
if aboutWindowController == nil {
|
|
aboutWindowController = AboutWindowController()
|
|
}
|
|
aboutWindowController?.showWindow(nil)
|
|
aboutWindowController?.window?.makeKeyAndOrderFront(nil)
|
|
}
|
|
|
|
@MainActor @objc func showSettings(_ sender: Any?) {
|
|
if settingsWindowController == nil {
|
|
settingsWindowController = SettingsWindowController()
|
|
}
|
|
settingsWindowController?.showWindow(nil)
|
|
settingsWindowController?.window?.makeKeyAndOrderFront(nil)
|
|
}
|
|
|
|
// MARK: - View
|
|
|
|
/// Toggles typewriter scrolling, persists the choice, and applies it to every
|
|
/// open document immediately.
|
|
@MainActor @objc func toggleTypewriterMode(_ sender: Any?) {
|
|
let newValue = !AppDelegate.typewriterModeEnabled()
|
|
UserDefaults.standard.set(newValue, forKey: AppDelegate.typewriterModeKey)
|
|
for case let doc as Document in NSDocumentController.shared.documents {
|
|
doc.editor?.typewriterModeEnabled = newValue
|
|
}
|
|
}
|
|
|
|
@MainActor func validateMenuItem(_ menuItem: NSMenuItem) -> Bool {
|
|
if menuItem.action == #selector(toggleTypewriterMode(_:)) {
|
|
menuItem.state = AppDelegate.typewriterModeEnabled() ? .on : .off
|
|
}
|
|
return true
|
|
}
|
|
|
|
// MARK: - Open Document
|
|
|
|
/// Manual Open panel — bypasses NSDocumentController's type validation
|
|
/// which is broken without Info.plist.
|
|
@MainActor @objc func openDocumentManually(_ sender: Any?) {
|
|
let panel = NSOpenPanel()
|
|
panel.allowsMultipleSelection = false
|
|
panel.canChooseDirectories = false
|
|
panel.canChooseFiles = true
|
|
|
|
let complete: (NSApplication.ModalResponse) -> Void = { response in
|
|
guard response == .OK, let url = panel.url else { return }
|
|
NSDocumentController.shared.openDocument(
|
|
withContentsOf: url, display: true
|
|
) { _, _, error in
|
|
if let error = error {
|
|
NSAlert(error: error).runModal()
|
|
}
|
|
}
|
|
}
|
|
|
|
// Attach the panel to the front window as a sheet so it's always visible
|
|
// — a free-floating panel can open off-screen or behind the window
|
|
// (the app's windows can launch off-screen), which looks like a hang.
|
|
NSApp.activate(ignoringOtherApps: true)
|
|
if let window = NSApp.keyWindow ?? NSApp.mainWindow {
|
|
panel.beginSheetModal(for: window, completionHandler: complete)
|
|
} else {
|
|
panel.begin(completionHandler: complete)
|
|
}
|
|
}
|
|
|
|
// MARK: - Menu Bar
|
|
|
|
@MainActor private func setupMenuBar() {
|
|
let mainMenu = NSMenu()
|
|
|
|
// App menu (required for Cmd+Q)
|
|
let appMenuItem = NSMenuItem()
|
|
let appMenu = NSMenu()
|
|
appMenu.addItem(withTitle: "About Edmund",
|
|
action: #selector(AppDelegate.showAbout(_:)),
|
|
keyEquivalent: "")
|
|
appMenu.addItem(NSMenuItem.separator())
|
|
appMenu.addItem(withTitle: "Settings\u{2026}",
|
|
action: #selector(AppDelegate.showSettings(_:)),
|
|
keyEquivalent: ",")
|
|
|
|
let updatesItem = appMenu.addItem(
|
|
withTitle: "Check for Updates\u{2026}",
|
|
action: #selector(SPUStandardUpdaterController.checkForUpdates(_:)),
|
|
keyEquivalent: "")
|
|
updatesItem.target = updaterController
|
|
|
|
appMenu.addItem(NSMenuItem.separator())
|
|
|
|
appMenu.addItem(withTitle: "Quit Edmund",
|
|
action: #selector(NSApplication.terminate(_:)),
|
|
keyEquivalent: "q")
|
|
appMenuItem.submenu = appMenu
|
|
mainMenu.addItem(appMenuItem)
|
|
|
|
// File menu — NSDocument provides the standard actions
|
|
let fileMenuItem = NSMenuItem()
|
|
let fileMenu = NSMenu(title: "File")
|
|
|
|
fileMenu.addItem(withTitle: "New",
|
|
action: #selector(NSDocumentController.newDocument(_:)),
|
|
keyEquivalent: "n")
|
|
|
|
fileMenu.addItem(withTitle: "Open\u{2026}",
|
|
action: #selector(AppDelegate.openDocumentManually(_:)),
|
|
keyEquivalent: "o")
|
|
|
|
// Recent documents submenu
|
|
let recentMenuItem = NSMenuItem(title: "Open Recent", action: nil, keyEquivalent: "")
|
|
let recentMenu = NSMenu(title: "Open Recent")
|
|
recentMenu.addItem(withTitle: "Clear Menu",
|
|
action: #selector(NSDocumentController.clearRecentDocuments(_:)),
|
|
keyEquivalent: "")
|
|
recentMenuItem.submenu = recentMenu
|
|
fileMenu.addItem(recentMenuItem)
|
|
|
|
fileMenu.addItem(NSMenuItem.separator())
|
|
|
|
fileMenu.addItem(withTitle: "Save",
|
|
action: #selector(NSDocument.save(_:)),
|
|
keyEquivalent: "s")
|
|
|
|
fileMenu.addItem(NSMenuItem.separator())
|
|
|
|
fileMenu.addItem(withTitle: "Rename\u{2026}",
|
|
action: #selector(Document.rename(_:)),
|
|
keyEquivalent: "")
|
|
|
|
fileMenu.addItem(withTitle: "Move To\u{2026}",
|
|
action: #selector(Document.move(_:)),
|
|
keyEquivalent: "")
|
|
|
|
fileMenu.addItem(NSMenuItem.separator())
|
|
|
|
fileMenu.addItem(withTitle: "Export as PDF\u{2026}",
|
|
action: #selector(Document.exportToPDF(_:)),
|
|
keyEquivalent: "")
|
|
|
|
fileMenu.addItem(withTitle: "Print\u{2026}",
|
|
action: #selector(Document.printDocument(_:)),
|
|
keyEquivalent: "p")
|
|
|
|
fileMenuItem.submenu = fileMenu
|
|
mainMenu.addItem(fileMenuItem)
|
|
|
|
// Edit menu (required for Cmd+C/V/X/A/Z)
|
|
let editMenuItem = NSMenuItem()
|
|
let editMenu = NSMenu(title: "Edit")
|
|
|
|
editMenu.addItem(withTitle: "Undo",
|
|
action: #selector(EditorTextView.undo(_:)),
|
|
keyEquivalent: "z")
|
|
|
|
let redoItem = editMenu.addItem(withTitle: "Redo",
|
|
action: #selector(EditorTextView.redo(_:)),
|
|
keyEquivalent: "z")
|
|
redoItem.keyEquivalentModifierMask = [.command, .shift]
|
|
|
|
editMenu.addItem(NSMenuItem.separator())
|
|
|
|
editMenu.addItem(withTitle: "Cut",
|
|
action: #selector(NSText.cut(_:)),
|
|
keyEquivalent: "x")
|
|
|
|
editMenu.addItem(withTitle: "Copy",
|
|
action: #selector(NSText.copy(_:)),
|
|
keyEquivalent: "c")
|
|
|
|
editMenu.addItem(withTitle: "Paste",
|
|
action: #selector(NSText.paste(_:)),
|
|
keyEquivalent: "v")
|
|
|
|
editMenu.addItem(withTitle: "Select All",
|
|
action: #selector(NSText.selectAll(_:)),
|
|
keyEquivalent: "a")
|
|
|
|
editMenuItem.submenu = editMenu
|
|
mainMenu.addItem(editMenuItem)
|
|
|
|
// Format menu — built from the declarative command registry.
|
|
mainMenu.addItem(FormatMenu.build())
|
|
|
|
// View menu — built in its own file (ViewMenu.swift).
|
|
mainMenu.addItem(ViewMenu.build())
|
|
|
|
NSApplication.shared.mainMenu = mainMenu
|
|
}
|
|
}
|
|
|
|
// --- Launch -----------------------------------------------------------------
|
|
let app = NSApplication.shared
|
|
|
|
// Must be created before NSDocumentController.shared is first accessed.
|
|
let _ = DocumentController()
|
|
|
|
let delegate = AppDelegate()
|
|
app.delegate = delegate
|
|
app.setActivationPolicy(.regular)
|
|
app.activate(ignoringOtherApps: true)
|
|
app.run()
|