//
// KMMainDocument.swift
// PDF Reader Pro
//
// Created by wanjun on 2022/12/6.
//
import Cocoa
import CoreFoundation
@objc enum KMArchiveMask: Int {
case diskImage = 1
case email = 2
}
@objc enum KMExportOption: Int {
case `default` = 0
case withoutNotes
case withEmbeddedNotes
}
typealias KMMainDocumentCloudUploadHanddler = (@escaping(Bool, String)->()) -> ()
@objcMembers class KMMainDocument: CTTabContents {
struct MDFlags {
var exportOption: UInt32 // assuming this is a 2-bit field, change to appropriate data type
var exportUsingPanel: UInt32 // assuming this is a 1-bit field, change to appropriate data type
var gettingFileType: UInt32 // assuming this is a 1-bit field, change to appropriate data type
var convertingNotes: UInt32 // assuming this is a 1-bit field, change to appropriate data type
var needsPasswordToConvert: UInt32 // assuming this is a 1-bit field, change to appropriate data type
}
static let kLastExportedTypeKey = "SKLastExportedType"
static let kLastExportedOptionKey = "SKLastExportedOption"
static let kBundleDataFilename = "data"
var mainViewController: KMMainViewController?
var homeWindowController: KMHomeWindowController?
var homeViewController: KMHomeViewController?
var bookmarkSheetController: KMBookmarkSheetController?
var bookmarkController: KMBookmarkController?
var isNewCreated: Bool = false
var closedByUserGestureFlag: Bool = false // 标记 closedByUserGesture 这个状态需要延后存储(如果需要)
var cloud: Bool = false
var cloudUploadHanddler: KMMainDocumentCloudUploadHanddler?
var isUnlockFromKeychain: Bool = false
private var _saveAsing = false
var fileUpdateChecker: SKFileUpdateChecker?
var mdFlags: MDFlags?
var currentDocumentSetup: [String: Any] {
get {
var tempSetup: [String: Any] = [:]
let tempMainSetup: [String: Any] = mainViewController?.currentSetup() ?? [:]
let filePath = fileURL?.path ?? ""
if filePath.count > 0{
tempSetup.updateValue(filePath, forKey: KMDocumentSetupFileNameKey)
}else {
return tempSetup
}
if let alias = SKAlias.init(url: fileURL){
if let data = alias.data{
tempSetup.updateValue(data as Any, forKey: KMDocumentSetupAliasKey)
}
}
if tempSetup.count > 0 {
tempSetup.merge(tempMainSetup) { (_, new) in new }
}
return tempSetup
}
set {
}
}
private var _saveToURL: URL?
var saveToURL: URL? {
get {
return self._saveToURL
}
}
var exportAccessoryC: SKExportAccessoryController?
var pdfData: Data?
weak var watermarkSaveDelegate: AnyObject?
private var _trackEvents = IndexSet()
override func save(to url: URL, ofType typeName: String, for saveOperation: NSDocument.SaveOperationType, delegate: Any?, didSave didSaveSelector: Selector?, contextInfo: UnsafeMutableRawPointer?) {
if (self.isNewCreated) {
// if let data = self.mainViewController, !data.isPDFDocumentEdited && !data.needSave && !self.isDocumentEdited {
self._km_save(to: url, ofType: typeName, for: saveOperation, delegate: delegate, didSave: didSaveSelector, contextInfo: contextInfo)
return
// }
}
if (!self.needSaveWatermark()) {
self._km_save(to: url, ofType: typeName, for: saveOperation, delegate: delegate, didSave: didSaveSelector, contextInfo: contextInfo)
return
}
var openAccessoryView = self.watermarkSaveDelegate != nil
if (openAccessoryView) {
if let _browser = self.watermarkSaveDelegate as? KMBrowser, _browser.isCloseAllTabViewItem {
openAccessoryView = false
}
}
self._km_saveForWatermark(openAccessoryView: openAccessoryView) { [unowned self] in
self.trackEvents()
} callback: { [unowned self] needSave, params in
if (needSave) {
self._km_save(to: url, ofType: typeName, for: saveOperation, delegate: delegate, didSave: didSaveSelector, contextInfo: contextInfo)
} else { // 水印保存
if (self.watermarkSaveDelegate == nil) {
if let data = params.first as? KMResult, data == .cancel {
if let shouldClose = params.last as? Bool, shouldClose {
DispatchQueue.main.async {
self.mainViewController?.browserWindowController?.browser.windowDidBeginToClose()
}
}
} else {
DispatchQueue.main.async {
self.mainViewController?.browserWindowController?.browser.windowDidBeginToClose()
}
}
return
}
if let data = params.first as? KMResult, data == .cancel {
if var shouldClose = params.last as? Bool {
if let _browser = self.watermarkSaveDelegate as? KMBrowser, _browser.isCloseAllTabViewItem {
shouldClose = true
}
(self.watermarkSaveDelegate as? KMBrowser)?.document(self, shouldClose: shouldClose, contextInfo: nil)
}
} else {
(self.watermarkSaveDelegate as? KMBrowser)?.document(self, shouldClose: true, contextInfo: nil)
}
self.watermarkSaveDelegate = nil
}
}
}
override func makeWindowControllers() {
// Returns the storyboard that contains your document window.
if ((self.fileURL?.path) != nil) {
if !self.fileURL!.path.isPDFValid() {
let alert = NSAlert()
alert.alertStyle = .critical
alert.messageText = NSLocalizedString("An error occurred while opening this document. The file is damaged and could not be repaired.", comment: "")
alert.runModal()
return
}
}
let mainWindow = NSApp.mainWindow
var currentWindowController: KMBrowserWindowController?
if mainWindow != nil {
let windowController = mainWindow!.windowController
if windowController is KMBrowserWindowController {
currentWindowController = (windowController as! KMBrowserWindowController)
} else {
for window in NSApp.windows {
let windowController = window.windowController
if windowController is KMBrowserWindowController {
currentWindowController = (windowController as! KMBrowserWindowController)
break
}
}
}
} else {
for window in NSApp.windows {
let windowController = window.windowController
if windowController is KMBrowserWindowController {
currentWindowController = (windowController as! KMBrowserWindowController)
break
}
}
}
// if (currentWindowController == nil) && (self.fileURL != nil) {
// let browser = KMBrowser.init() as KMBrowser
// browser.addHomeTabContents()
// browser.windowController = KMBrowserWindowController.init(browser: browser)
// currentWindowController = browser.windowController as? KMBrowserWindowController
// }
if currentWindowController?.browser == nil && (self.fileURL != nil) {
let browser: KMBrowser = KMBrowser.init()
browser.windowController = KMBrowserWindowController.init(browser: browser)
browser.addHomeTabContents()
currentWindowController = browser.windowController as? KMBrowserWindowController
browser.windowController.showWindow(self)
}
mainViewController = KMMainViewController.init()
mainViewController?.myDocument = self
self.mdFlags = MDFlags(exportOption: 0, exportUsingPanel: 0, gettingFileType: 0, convertingNotes: 0, needsPasswordToConvert: 0)
if ((self.fileURL?.path) != nil) {
let pdfDocument = CPDFDocument.init(url: URL(fileURLWithPath: self.fileURL!.path))
mainViewController?.document = pdfDocument
}
if mainViewController?.document == nil {
return
}
self.view = mainViewController?.view
if let url = self.fileURL {
AppSandboxFileAccess().persistPermissionURL(url as URL)
let bookmarkData = try?url.bookmarkData(options: NSURL.BookmarkCreationOptions.withSecurityScope, includingResourceValuesForKeys: nil, relativeTo: nil)
if bookmarkData != nil {
AppSandboxFileAccess().bookmarkPersistanceDelegate.setBookmarkData(bookmarkData! as Data, for: url as URL)
AppSandboxFileAccess().bookmarkPersistanceDelegate.setBookmarkData(bookmarkData! as Data, for: NSURL(fileURLWithPath: url.path) as URL)
}
}
if let currentBrowser = currentWindowController?.browser {
let activeBrowser = currentBrowser.activeTabContents()
let activeIndex = currentBrowser.activeTabIndex()
let ishome = activeBrowser?.isHome ?? false
let isfirstTab = (activeIndex == 0)
if ishome && !isfirstTab { // 替换 【标签需要被替换】
self.addWindowController(currentWindowController!)
self.mainViewController?.browserWindowController = currentWindowController
// 替换 document
currentWindowController?.browser.replaceTabContents(at: Int32(activeIndex), with: self)
// 刷新标签
currentWindowController?.browser.updateTabState(at: Int32(activeIndex))
// 刷新 home icon
if let tabStripController = currentWindowController?.tabStripController {
if let view = tabStripController.view(at: UInt(activeIndex)) as? CTTabView {
view.controller().isHome = self.isHome
view.controller().isNewTab = self.isNewTab
view.controller().updateUI()
}
}
} else {
if currentWindowController?.browser.tabCount() ?? 0 > 1 && (!KMMemberInfo.shared.isMemberAllFunction || KMPreference.shared.openDocumentType == .newWindow){
// 开启新窗口
let browser = KMBrowser.init() as KMBrowser
browser.windowController = KMBrowserWindowController.init(browser: browser)
browser.addHomeTabContents()
browser.windowController.showWindow(self)
browser.add(self, at: Int32()-1, inForeground: true)
self.addWindowController(browser.windowController)
self.mainViewController?.browserWindowController = browser.windowController as? KMBrowserWindowController
}else { // 正常拼接到后面
self.addWindowController(currentWindowController!)
self.mainViewController?.browserWindowController = currentWindowController
currentWindowController?.browser.add(self, at: Int32()-1, inForeground: true)
}
}
}
}
override func showWindows() {
super.showWindows()
self.setDataFromTmpData()
}
override func windowControllerDidLoadNib(_ aController: NSWindowController) {
super.windowControllerDidLoadNib(aController)
self.setDataFromTmpData()
fileUpdateChecker = SKFileUpdateChecker.init(for: self)
fileUpdateChecker?.isEnabled = true
}
override func save(to url: URL, ofType typeName: String, for saveOperation: NSDocument.SaveOperationType) async throws {
do {
try await super.save(to: url, ofType: typeName, for: saveOperation)
} catch let outError {
NSApp.presentError(outError)
}
if saveOperation == .saveToOperation {
if let data = self.mdFlags?.exportUsingPanel, data == 1 {
if FileManager.default.fileExists(atPath: url.path) {
let ws = NSWorkspace.shared
ws.activateFileViewerSelecting([url])
}
}
}
self.mdFlags?.exportUsingPanel = 0
self.mdFlags?.exportOption = UInt32(KMExportOption.default.rawValue)
}
override func write(to url: URL, ofType typeName: String, for saveOperation: NSDocument.SaveOperationType, originalContentsURL absoluteOriginalContentsURL: URL?) throws {
try self._km_write(to: url, ofType: typeName, for: saveOperation, originalContentsURL: absoluteOriginalContentsURL)
}
override func canClose(withDelegate delegate: Any, shouldClose shouldCloseSelector: Selector?, contextInfo: UnsafeMutableRawPointer?) {
let isPrompt = KMPreferenceManager.shared.closeFileIsPrompt()
if (isPrompt) {
super.canClose(withDelegate: delegate, shouldClose: shouldCloseSelector, contextInfo: contextInfo)
if KMAdvertisementManager.manager.appClosedCount == 0 {
KMAdvertisementManager.manager.appClosedCount = 1
}
return
}
if (self.isNewCreated) {
self.save(nil)
} else if (self.isDocumentEdited) {
self.save(nil)
} else if (mainViewController != nil) {
if self.mainViewController!.isPDFDocumentEdited || self.mainViewController!.needSave {
self.save(nil)
}
}
super.canClose(withDelegate: delegate, shouldClose: shouldCloseSelector, contextInfo: contextInfo)
}
override func saveAs(_ sender: Any?) {
if (!self.needSaveWatermark()) {
self._km_saveAs(sender)
return
}
self._km_saveForWatermark { [weak self] needSave, _ in
if (needSave) {
self?._km_saveAs(sender)
}
}
}
override func saveTo(_ sender: Any?) {
guard let pdfDoc = self.mainViewController?.listView.document else {
NSSound.beep()
return
}
if pdfDoc.allowsPrinting == false || pdfDoc.allowsCopying == false {
Task {
_ = await KMAlertTool.runModel(message: NSLocalizedString("This is a secured document. Editing is not permitted.", comment: ""))
}
return
}
let idx = (sender as? NSMenuItem)?.tag ?? 0
var typeName = KMPDFDocumentType
if idx == 0 {
typeName = KMPDFDocumentType
} else if idx == 1 {
typeName = KMPDFBundleDocumentType
} else if idx == 2 {
typeName = KMNotesDocumentType
} else if idx == 3 {
typeName = KMNotesTextDocumentType
} else if idx == 4 {
typeName = KMNotesRTFDocumentType
} else if idx == 5 {
typeName = KMNotesRTFDDocumentType
} else if idx == 6 {
typeName = KMNotesDocumentType
}
KMDataManager.ud_set(typeName, forKey: Self.kLastExportedTypeKey)
super.saveTo(sender)
}
override func prepareSavePanel(_ savePanel: NSSavePanel) -> Bool {
let success = super.prepareSavePanel(savePanel)
let exportUsingPanel = self.mdFlags?.exportUsingPanel ?? 0
if success && exportUsingPanel > 0 {
// *formatPopup = [[savePanel accessoryView] subviewOfClass:[NSPopUpButton class]];
var formatPopup: NSPopUpButton?
let svs = savePanel.accessoryView?.subviews.first?.subviews ?? []
for sv in svs {
if let data = sv as? NSPopUpButton {
formatPopup = data
break
}
}
self._removeSavePanelOfFormatPopupItems(savePanel)
if (formatPopup != nil) {
let lastExportedType = KMDataManager.ud_string(forKey: Self.kLastExportedTypeKey)
var lastExportedOption = KMDataManager.ud_integer(forKey: Self.kLastExportedOptionKey)
if lastExportedOption == 0 {
lastExportedOption = KMExportOption.withEmbeddedNotes.rawValue
}
// if (lastExportedType != nil) {
// let idx = formatPopup?.indexOfItem(withRepresentedObject: lastExportedType) ?? -1
// let selectedIdx = formatPopup?.indexOfSelectedItem ?? 0
// if idx != -1 && idx != selectedIdx {
// formatPopup?.selectItem(at: idx)
// formatPopup?.sendAction(formatPopup?.action, to: formatPopup?.target)
// [savePanel setAllowedFileTypes:[NSArray arrayWithObjects:[self fileNameExtensionForType:lastExportedType saveOperation:NSSaveToOperation], nil]];
// if let data = self.fileNameExtension(forType: lastExportedType!, saveOperation: .saveToOperation) {
// savePanel.allowedFileTypes = [data]
// }
// }
// }
self.mdFlags?.exportOption = UInt32(lastExportedOption)
//
// self.exportAccessoryC = SKExportAccessoryController()
// self.exportAccessoryC?.addFormatPopUpButton(formatPopup)
// self.exportAccessoryC?.matrix.target = self
// self.exportAccessoryC?.matrix.action = #selector(changeExportOption)
// savePanel.accessoryView = self.exportAccessoryC?.view
// self._updateExportAccessoryView()
}
} else if success {
self._removeSavePanelOfFormatPopupItems(savePanel)
}
return success
}
override func runModalSavePanel(for saveOperation: NSDocument.SaveOperationType, delegate: Any?, didSave didSaveSelector: Selector?, contextInfo: UnsafeMutableRawPointer?) {
self.mdFlags?.exportUsingPanel = saveOperation == .saveToOperation ? 1 : 0
self.mdFlags?.exportOption = UInt32(KMExportOption.default.rawValue)
if (self.isNewCreated) {
// if let data = self.mainViewController, !data.isPDFDocumentEdited && !data.needSave && !self.isDocumentEdited {
self._km_runModalSavePanel(for: saveOperation, delegate: delegate, didSave: didSaveSelector, contextInfo: contextInfo)
return
// }
}
if (!self.needSaveWatermark()) {
self._km_runModalSavePanel(for: saveOperation, delegate: delegate, didSave: didSaveSelector, contextInfo: contextInfo)
return
}
self._km_saveForWatermark { [weak self] needSave, _ in
if (needSave) {
self?._km_runModalSavePanel(for: saveOperation, delegate: delegate, didSave: didSaveSelector, contextInfo: contextInfo)
}
}
}
override func save(_ sender: Any?) {
if (!self.needSaveWatermark()) {
self._km_save(sender)
return
}
self._km_saveForWatermark { [weak self] in
self?.trackEvents()
} callback: { [weak self] needSave, _ in
if (needSave) {
self?._km_save(sender)
}
}
}
func systemInteractionMode() -> KMInteractionMode {
let mainWindow = NSApp.mainWindow
if mainWindow != nil {
let windowController = mainWindow!.windowController
if windowController?.window?.screen?.isEqual(NSScreen.screens[0]) ?? false{
return mainViewController?.interactionMode ?? .normal
}
}
return .normal
}
func saveForWatermark() {
if (!self.needSaveWatermark()) {
self._km_save(nil)
return
}
self._km_saveForWatermark { [weak self] in
self?.trackEvents()
} callback: { [unowned self] needSave, params in
if (needSave) {
self._km_save(nil)
} else { // 水印保存
if (self.watermarkSaveDelegate == nil) {
if let data = params.first as? KMResult, data == .cancel {
if let shouldClose = params.last as? Bool, shouldClose {
DispatchQueue.main.async {
self.mainViewController?.browserWindowController?.browser.windowDidBeginToClose()
}
}
} else {
DispatchQueue.main.async {
self.mainViewController?.browserWindowController?.browser.windowDidBeginToClose()
}
}
return
}
if let data = params.first as? KMResult, data == .cancel {
if var shouldClose = params.last as? Bool {
if let _browser = self.watermarkSaveDelegate as? KMBrowser, _browser.isCloseAllTabViewItem {
shouldClose = true
}
(self.watermarkSaveDelegate as? KMBrowser)?.document(self, shouldClose: shouldClose, contextInfo: nil)
}
} else {
(self.watermarkSaveDelegate as? KMBrowser)?.document(self, shouldClose: true, contextInfo: nil)
}
self.watermarkSaveDelegate = nil
}
}
}
override func read(from absoluteURL: URL, ofType typeName: String) throws {
do {
try super.read(from: absoluteURL, ofType: typeName)
updateChangeCount(.changeCleared)
} catch let outError {
Swift.print(outError)
}
}
override func read(from data: Data, ofType typeName: String) throws {
// Insert code here to read your document from the given data of the specified type, throwing an error in case of failure.
// Alternatively, you could remove this method and override read(from:ofType:) instead. If you do, you should also override isEntireFileLoaded to return false if the contents are lazily loaded.
// let pdfDocument = CPDFDocument.init(data: data)
self.pdfData = data
// if pdfDocument == nil {
// throw NSError(domain: NSOSStatusErrorDomain, code: unimpErr, userInfo: nil)
// }
}
// MARK: Autosaving
override func close() {
mainViewController?.cancelMeasureType()
if self.isActive {
if browser != nil {
var activeIndex = 0
let dex = browser.index(of: self)
if dex == browser.tabCount() - 1 {
activeIndex = Int(browser.tabCount()-2)
} else {
activeIndex = Int(dex + 1)
}
let activeContents = browser.tabContents(at: Int32(activeIndex))
activeContents?.addWindowController(browser.windowController)
}
}
super.close()
}
// MARK: init
override init() {
super.init()
// Add your subclass-specific initialization here.
NotificationCenter.default.addObserver(self, selector: #selector(pdfChangedNotification(_:)), name: NSNotification.Name.init(rawValue: "CPDFListViewAnnotationsAttributeHasChangeNotification"), object: nil)
// NotificationCenter.default.addObserver(self, selector: #selector(pdfChangedNotification(_:)), name: NSNotification.Name.init(rawValue: "CPDFViewDocumentChangedNotification"), object: nil)
// NotificationCenter.default.addObserver(self, selector: #selector(pdfChangedNotification(_:)), name: NSNotification.Name.init(rawValue: "CPDFViewPageChangedNotification"), object: nil)
NotificationCenter.default.addObserver(self, selector: #selector(pdfChangedNotification(_:)), name: NSNotification.Name.init(rawValue: "CPDFListViewDidAddAnnotationNotification"), object: nil)
NotificationCenter.default.addObserver(self, selector: #selector(pdfChangedNotification(_:)), name: NSNotification.Name.CPDFViewPageChanged, object: nil)
}
override init?(baseTabContents baseContents: CTTabContents?) {
super.init(baseTabContents: baseContents)
if isHome {
homeViewController = KMHomeViewController.init()
homeViewController?.myDocument = self
self.view = homeViewController?.view
}
}
// MARK: Handling User Actions
override var title: String? {
get {
if isHome {
if (self.isNewTab) {
return NSLocalizedString("New Tab", comment: "")
} else {
return NSLocalizedString("Home", comment: "")
}
} else {
return fileURL?.lastPathComponent
}
}
set {
super.title = newValue
}
}
func needSaveWatermark() -> Bool {
if let need = self.mainViewController?.saveWatermarkFlag {
return need
}
return false
}
func changeExportOption(_ sender: NSMatrix?) {
self.mdFlags?.exportOption = UInt32(sender?.selectedCell()?.tag ?? 0)
}
// MARK: Private Methods
func pdfChangedNotification(_ notification: Notification) -> Void {
if !isHome {
let mainViewController = mainViewController
var document: CPDFDocument!
let dic = notification.object as? NSDictionary
if dic?["object"] is CPDFAnnotation {
guard let annotation = dic?["object"] as? CPDFAnnotation else { return }
document = annotation.page.document
} else if dic?["object"] is CPDFListView {
let pdflistView = notification.object as? CPDFListView
document = pdflistView?.document
}
if mainViewController != nil {
if document == mainViewController!.document {
updateChangeCount(.changeDone)
}
}
}
}
override func updateChangeCount(_ change: NSDocument.ChangeType) {
let mainWindow = NSApp.mainWindow
var currentWindowController: KMBrowserWindowController?
if mainWindow != nil {
let windowController = mainWindow!.windowController
if windowController is KMBrowserWindowController {
currentWindowController = (windowController as! KMBrowserWindowController)
} else {
for window in NSApp.windows {
let windowController = window.windowController
if windowController is KMBrowserWindowController {
currentWindowController = (windowController as! KMBrowserWindowController)
break
}
}
}
} else {
for window in NSApp.windows {
let windowController = window.windowController
if windowController is KMBrowserWindowController {
currentWindowController = (windowController as! KMBrowserWindowController)
break
}
}
}
if let currentBroser = currentWindowController?.browser {
if self.isEqual(to: currentBroser.activeTabContents()) {
super.updateChangeCount(change)
return
}
}
super.updateChangeCount(.changeCleared)
}
func uploadToCloud(_ callback: (@escaping(Bool, String)->())) {
guard let handdler = self.cloudUploadHanddler else {
return
}
handdler(callback)
}
func isPDFDocument() -> Bool {
return true
}
func setDataFromTmpData() {
guard let _document = self.mainViewController?.document else {
return
}
// self.tryToUnlockDocument(document!)
if (_document.permissionsStatus != .owner) {
var password: NSString? = nil
let fileId = self.fileId(for: _document)
if (fileId.isEmpty) {
return
}
self.getPassword(&password, fileId: fileId)
if (password != nil) {
self.isUnlockFromKeychain = true
// document.unlock(withPassword: password! as String)
self.mainViewController?.model.password = password as String?
}
}
//如果已存在，开个存在页签
var selectDocument: KMMainDocument? = self
if selectDocument != nil {
if let browser_ = selectDocument?.browser {
let currentIndex = browser_.tabStripModel.index(of: selectDocument)
browser_.tabStripModel.selectTabContents(at: Int32(currentIndex), userGesture: true)
if browser_.window.isVisible {
DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 0.1) {
browser_.window.orderFront(nil)
}
} else if browser_.window.isMiniaturized {
DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 0.1) {
browser_.window.orderFront(nil)
}
}
}
}
}
func tryToUnlockDocument(_ document: CPDFDocument) {
if (document.permissionsStatus != .owner) {
var password: NSString? = nil
let fileId = self.fileId(for: document)
if (fileId.isEmpty) {
return
}
self.getPassword(&password, fileId: fileId)
if (password != nil) {
self.isUnlockFromKeychain = true
document.unlock(withPassword: password! as String)
}
}
}
func km_updateChangeCount(_ change: NSDocument.ChangeType) {
super.updateChangeCount(change)
}
func trackEvents() {
km_synchronized(self) {
for i in self._trackEvents {
if let type = KMSubscribeWaterMarkType(rawValue: i) {
KMTools.trackEvent(type: type)
}
}
}
self.clearTrackEvents()
}
func recordTrackEvent(type: KMSubscribeWaterMarkType) {
if (type == .none) {
return
}
km_synchronized(self) {
self._trackEvents.insert(type.rawValue)
}
}
func clearTrackEvents() {
km_synchronized(self) {
self._trackEvents.removeAll()
}
}
@IBAction func saveArchive(_ sender: Any?) {
guard let item = sender as? NSMenuItem else {
NSSound.beep()
return
}
guard let fileURL = self.fileURL else {
NSSound.beep()
return
}
let check = try?fileURL.checkResourceIsReachable()
if check == false || self.isDocumentEdited {
let msg = KMLocalizedString("You must save this file first", "Alert text when trying to create archive for unsaved document")
let inf = KMLocalizedString("The document has unsaved changes, or has not previously been saved to disk.", "Informative text in alert dialog")
Task {
_ = await KMAlertTool.runModel(message: msg, informative: inf)
}
return
}
// NSString *ext = ([sender tag] | SKArchiveDiskImageMask) ? @"dmg" : @"tgz";
let idx = item.tag
let ext = (idx == 1 || idx == 3) ? "dmg" : "tgz"
let isEmail = (idx == 2 || idx == 3)
if isEmail {
// if (([sender tag] | SKArchiveEmailMask)) {
let tmpDirURL = FileManager.default.uniqueChewableItemsDirectoryURL()
let tmpFileURL = tmpDirURL.appendingPathComponent(fileURL.lastPathComponentReplacingPathExtension(ext))
self.newSaveArchive(to: tmpFileURL, email: true)
} else {
let sp = NSSavePanel()
sp.allowedFileTypes = [ext]
sp.canCreateDirectories = true
sp.nameFieldStringValue = fileURL.lastPathComponentReplacingPathExtension(ext)
sp.beginSheetModal(for: self.windowForSheet!) { result in
if result == .OK {
self.newSaveArchive(to: sp.url!, email: false)
}
}
}
}
// func saveArchiveToURL(to fileURL: URL, email: Bool) {
// NSTask *task = [[[NSTask alloc] init] autorelease];
// let task = Task()
// if fileURL.pathExtension == "dmg" {
// [task setLaunchPath:@""];
// task.launchPath = "/usr/bin/hdiutil"
// [task setArguments:[NSArray arrayWithObjects:@"create", @"-srcfolder", [[self fileURL] path], @"-format", @"UDZO", @"-volname", [[fileURL lastPathComponent] stringByDeletingPathExtension], [fileURL path], nil]];
// } else {
// [task setLaunchPath:@"/usr/bin/tar"];
// [task setArguments:[NSArray arrayWithObjects:@"-czf", [fileURL path], [[self fileURL] lastPathComponent], nil]];
// }
// [task setCurrentDirectoryPath:[[[self fileURL] URLByDeletingLastPathComponent] path]];
// [task setStandardOutput:[NSFileHandle fileHandleWithNullDevice]];
// [task setStandardError:[NSFileHandle fileHandleWithNullDevice]];
//
// SKAttachmentEmailer *emailer = nil;
// if (email)
// emailer = [SKAttachmentEmailer attachmentEmailerWithFileURL:fileURL subject:[self displayName] waitingForTask:task];
//
// @try {
// [task launch];
// }
// @catch (id exception) {
// [emailer taskFailed];
// }
// }
@IBAction func readNotes(_ sender: Any?) {
KMPrint("readNotes")
}
@IBAction func convertNotes(_ sender: Any?) {
KMPrint("convertNotes")
}
@IBAction func batchRemovePassWord(_ sender: Any?) {
self.mainViewController?.clickChildTool(type: .secure, index: 2)
}
@IBAction func batchRemovPrivatySecurity(_ sender: Any?) {
self.mainViewController?.removeOwnerPassword()
}
@IBAction func printPDFDocument(_ sender: Any?) {
self.mainViewController?.saveDocument()
KMPrintWindowController.showNewPrintWindowControll(inputDocument: self.mainViewController?.document, inputPageRange: KMPrintPageRange())
}
@IBAction func performFindPanelAction(_ sender: Any?) {
self.mainViewController?.toolbarController.showFindBar()
}
@IBAction func addBookmark(_ sender: Any?) {
guard let item = sender as? NSMenuItem else {
return
}
// let bookmarkSheetController = SKBookmarkSheetController(windowNibName: "BookmarkSheet")
// NSWindow.currentWindow().beginSheet(bookmarkSheetController.window!) { resoponse in
//
// }
// bookmarkSheetController.textField.stringValue = self.displayName
// bookmarkSheetController.beginSheetModal(for: self.windowForSheet) { [unowned self] result in
// if (result == NSApplication.ModalResponse.OK.rawValue) {
// let label = bookmarkSheetController.textField.stringValue;
// let folder: SKBookmark = bookmarkSheetController.selectedFolder ?? SKBookmarkController.shared().bookmarkRoot
// var bookmark = SKBookmark()
// switch (item.tag) {
// case 0:
// let mainViewController = self.mainViewController
// let page = mainViewController?.listView.currentPage()
// bookmark = SKBookmark.bookmark(with: self.fileURL, pageIndex: (page?.pageIndex())!, label: label) as! SKBookmark
// case 1:
// let setup = self.currentDocumntSetup()
// bookmark = SKBookmark.bookmark(withSetup: setup, label: label) as! SKBookmark
//
// case 2:
// let setups = NSApp.orderedDocuments.map { $0.value(forKey: "currentDocumentSetup") }
// bookmark = SKBookmark.bookmarkSession(withSetups: setups as [Any], label: label) as! SKBookmark
//
// default:
// break;
// }
// folder.mutableArrayValue(forKey: "children").add(bookmark)
// }
// }
if item.tag == 3 {
KMPrint("Edit Bookmark")
bookmarkController = KMBookmarkController.showBookmarkController()
} else if item.tag == 2 {
KMPrint("session Bookmark")
bookmarkSheetController = KMBookmarkSheetController.showBookmarkSheetController(type: .session)
} else if item.tag == 0 {
KMPrint("add Bookmark")
bookmarkSheetController = KMBookmarkSheetController.showBookmarkSheetController(type: .bookmark)
}
bookmarkSheetController?.stringValue = self.displayName
bookmarkSheetController?.cancelAction = { [weak self] controller, type in
}
//
bookmarkSheetController?.doneAction = { [unowned self] controller, type, label in
let folder = controller.selectedFolder
var bookmark: KMBookmark?
switch type {
case .bookmark:
let mainViewController = mainViewController
if let page = mainViewController?.listView.currentPage() {
let index: UInt = page.pageIndex()
bookmark = KMBookmark.bookmark(url: self.fileURL!, pageIndex: index, label: label)
}
case .setup: break
let setup = currentDocumentSetup
bookmark = KMBookmark.bookmark(setup: setup, label: label)
case .session:
let setups = NSApp.orderedDocuments.compactMap { $0.value(forKey:"currentDocumentSetup") }
bookmark = KMSessionBookmark.bookmarkSession(setups: setups as NSArray, label: label)
default:
break
}
if let bookmark = bookmark {
folder?.children.append(bookmark)
}
KMBookmarkManager.manager.saveData()
}
}
func currentDocumntSetup() -> [String: Any] {
var setup: [String: Any] = [:]
let data = SKAlias.init(url: fileURL).data
if (data != nil) {
setup.updateValue(data as Any, forKey: "_BDAlias")
} else {
setup.updateValue(fileURL?.path as Any, forKey: "fileName")
}
return setup;
}
@IBAction func showWindow(_ sender: Any?) {
KMPrint("showWindow")
}
// MARK: - Private Methods
private func _PDFBundleFileWrapper(for name: String) -> FileWrapper {
var aName = name
if name.isCaseInsensitiveEqual(Self.kBundleDataFilename) {
aName = aName + "1"
}
// var data: Data?
let fileWrapper = FileWrapper(directoryWithFileWrappers: [:])
let info = KMInfoWindowController.shared.info(for: self)
// NSDictionary *options = [[self mainWindowController] presentationOptions];
// if (options) {
// info = [[info mutableCopy] autorelease];
// [(NSMutableDictionary *)info setObject:options forKey:SKPresentationOptionsKey];
// }
if let data = self.pdfData {
fileWrapper.addRegularFile(withContents: data, preferredFilename: aName + ".pdf")
}
if let data = self.mainViewController?.document?.string()?.data(using: .utf8) {
fileWrapper.addRegularFile(withContents: data, preferredFilename: Self.kBundleDataFilename + ".txt")
}
if let data = try?PropertyListSerialization.data(fromPropertyList: info, format: .xml, options: PropertyListSerialization.WriteOptions(0)) {
fileWrapper.addRegularFile(withContents: data, preferredFilename: Self.kBundleDataFilename + ".plist")
}
// if ((data = [NSPropertyListSerialization dataWithPropertyList:info format:NSPropertyListXMLFormat_v1_0 options:0 error:NULL]))
// [fileWrapper addRegularFileWithContents:data preferredFilename:[BUNDLE_DATA_FILENAME stringByAppendingPathExtension:@"plist"]];
// if ([[self notes] count] > 0) {
// if ((data = [self notesData]))
// [fileWrapper addRegularFileWithContents:data preferredFilename:[name stringByAppendingPathExtension:@"skim"]];
// if ((data = [[self notesString] dataUsingEncoding:NSUTF8StringEncoding]))
// [fileWrapper addRegularFileWithContents:data preferredFilename:[name stringByAppendingPathExtension:@"txt"]];
// if ((data = [self notesRTFData]))
// [fileWrapper addRegularFileWithContents:data preferredFilename:[name stringByAppendingPathExtension:@"rtf"]];
// if ((data = [self notesFDFDataForFile:[name stringByAppendingPathExtension:@"pdf"] fileIDStrings:[[self pdfDocument] fileIDStrings]]))
// [fileWrapper addRegularFileWithContents:data preferredFilename:[name stringByAppendingPathExtension:@"fdf"]];
// }
return fileWrapper
}
private func _km_write(to url: URL, ofType typeName: String, for saveOperation: NSDocument.SaveOperationType, originalContentsURL absoluteOriginalContentsURL: URL?) throws {
if typeName == KMPDFBundleDocumentType {
// NSFileWrapper *fileWrapper = [self PDFBundleFileWrapperForName:[[absoluteURL lastPathComponent] stringByDeletingPathExtension]];
// if (fileWrapper)
// didWrite = [fileWrapper writeToURL:absoluteURL options:0 originalContentsURL:nil error:&error];
// else
// error = [NSError writeFileErrorWithLocalizedDescription:NSLocalizedString(@"Unable to write file", @"Error description")];
let fileWrapper = self._PDFBundleFileWrapper(for: url.deletingPathExtension().lastPathComponent)
do {
try fileWrapper.write(to: url, options: FileWrapper.WritingOptions(rawValue: 0), originalContentsURL: nil)
} catch {
NSApp.presentError(error)
}
return
}
var success = true
if !self.isHome {
if mainViewController != nil {
mainViewController?.savePdfAlertView()
if mainViewController?.document != nil {
self.mainViewController?.commitEditingIfNeed()
// if mainViewController!.document!.isEncrypted {
// success = mainViewController!.document!.write(to: url)
// } else {
if (mainViewController!.needSave) {
if let options = self.mainViewController?.secureOptions, !options.isEmpty {
self.mainViewController!.document?.setDocumentAttributes(self.mainViewController?.documentAttribute)
success = self.mainViewController!.document!.write(to: url, withOptions: options)
} else if let flag = self.mainViewController?.removeSecureFlag, flag {
success = self.mainViewController!.document!.writeDecrypt(to: url)
} else {
if(mainViewController?.hasEnterRedact() == true) {
success = mainViewController?.redactController.redactPdfView.document?.write(to: url) ?? false
} else {
success = mainViewController!.document!.write(to: url)
}
}
} else {
if(mainViewController?.hasEnterRedact() == true) {
success = mainViewController?.redactController.redactPdfView.document?.write(to: url) ?? false
} else {
success = mainViewController!.document!.write(to: url)
}
}
// }
self.mainViewController?.needSave = false
self.mainViewController?.clearSecureOptions()
self.mainViewController?.clearRemoveSecureFlag()
}
}
} else {
success = false
}
if (success && self._saveAsing) {
if let tabView = self.browser?.windowController?.tabStripController?.activeTabView() as? CTTabView {
tabView.controller()?.title = url.lastPathComponent
}
self._saveAsing = false
}
if success && isNewCreated && NSDocument.SaveOperationType.saveAsOperation == saveOperation {
isNewCreated = false
}
if mainViewController != nil {
mainViewController?.savePdfFinishAlertView()
}
}
private func _km_saveForWatermark(openAccessoryView: Bool = true, subscribeDidClick: (()->Void)? = nil, callback:@escaping (_ needSave: Bool, _ param: Any...)->Void) {
Task { @MainActor in
if await (KMLightMemberManager.manager.canPayFunction() == false) {
let _ = KMSubscribeWaterMarkWindowController.show(window: NSApp.mainWindow!, isContinue:false, type: .save) {
if let _callback = subscribeDidClick {
_callback()
}
} completion: { isSubscribeSuccess, isWaterMarkExport, isClose in
if (isClose) {
callback(false, KMResult.cancel, false)
return
}
if (isSubscribeSuccess) {
callback(true)
return
}
if (isWaterMarkExport) {
guard let _document = self.mainViewController?.document else {
callback(false, KMResult.failure)
return
}
// 提交文本编辑的内容
self.mainViewController?.commitEditingIfNeed()
DispatchQueue.main.async {
NSPanel.savePanel(NSApp.mainWindow!, openAccessoryView, panel:{ panel in
if (!self.isNewCreated) {
panel.directoryURL = _document.documentURL.deletingLastPathComponent()
}
panel.nameFieldStringValue = _document.documentURL.lastPathComponent
}) { response, url, isOpen in
if (response == .cancel) {
callback(false, KMResult.cancel, true)
return
}
guard let _url = KMTools.saveWatermarkDocument(document: _document, to: url!, secureOptions: self.mainViewController?.secureOptions, documentAttribute: self.mainViewController?.documentAttribute,removePWD: self.mainViewController!.removeSecureFlag) else {
callback(false, KMResult.failure)
return
}
callback(false, KMResult.success)
if (isOpen) {
NSDocumentController.shared.km_safe_openDocument(withContentsOf: _url, display: true) { _, _, _ in
}
} else {
NSWorkspace.shared.activateFileViewerSelecting([_url])
}
}
}
return
}
callback(false, KMResult.cancel, false)
}
return
}
callback(true)
}
}
private func _km_save(_ sender: Any?) {
super.save(sender)
}
private func _km_save(to url: URL, ofType typeName: String, for saveOperation: NSDocument.SaveOperationType, delegate: Any?, didSave didSaveSelector: Selector?, contextInfo: UnsafeMutableRawPointer?) {
self._saveToURL = url
super.save(to: url, ofType: typeName, for: saveOperation, delegate: delegate, didSave: didSaveSelector, contextInfo: contextInfo)
// self.mdFlags?.exportUsingPanel = 0
// self.mdFlags?.exportOption = UInt32(KMExportOption.default.rawValue)
}
private func _km_saveAs(_ sender: Any?) {
super.saveAs(sender)
self._saveAsing = true
}
private func _km_runModalSavePanel(for saveOperation: NSDocument.SaveOperationType, delegate: Any?, didSave didSaveSelector: Selector?, contextInfo: UnsafeMutableRawPointer?) {
super.runModalSavePanel(for: saveOperation, delegate: delegate, didSave: didSaveSelector, contextInfo: contextInfo)
}
private func _updateExportAccessoryView() {
let typeName = self.fileTypeFromLastRunSavePanel ?? ""
let matrix = self.exportAccessoryC?.matrix
matrix?.selectCell(withTag: Int(self.mdFlags?.exportOption ?? 0))
if self._canAttachNotesForType(typeName) {
matrix?.isHidden = false
let ws = NSWorkspace.shared
let isLocked = self.mainViewController?.listView.document.isLocked ?? false
let allowsPrinting = self.mainViewController?.listView.document.allowsPrinting ?? false
if ws.type(typeName, conformsToType: KMPDFDocumentType) && isLocked == false && allowsPrinting {
(matrix?.cell(withTag: KMExportOption.withEmbeddedNotes.rawValue))?.isEnabled = true
} else {
(matrix?.cell(withTag: KMExportOption.withEmbeddedNotes.rawValue))?.isEnabled = false
if let data = self.mdFlags?.exportOption, data == KMExportOption.withEmbeddedNotes.rawValue {
self.mdFlags?.exportOption = UInt32(KMExportOption.default.rawValue)
matrix?.selectCell(withTag: KMExportOption.default.rawValue)
}
}
} else {
matrix?.isHidden = true
}
}
private func _canAttachNotesForType(_ typeName: String) -> Bool {
let ws = NSWorkspace.shared
return ws.type(typeName, conformsToType: KMPDFDocumentType) || ws.type(typeName, conformsToType: KMPostScriptDocumentType) || ws.type(typeName, conformsToType: KMDVIDocumentType) || ws.type(typeName, conformsToType: KMXDVDocumentType)
}
private func _removeSavePanelOfFormatPopupItems(_ savePanel: NSSavePanel) {
var formatPopup: NSPopUpButton?
let svs = savePanel.accessoryView?.subviews.first?.subviews ?? []
for sv in svs {
if let data = sv as? NSPopUpButton {
formatPopup = data
break
}
}
if let item = formatPopup?.item(withTitle: "Notes as Text") {
formatPopup?.removeItem(at: formatPopup!.index(of: item))
}
if let item = formatPopup?.item(withTitle: "Notes as FDF") {
formatPopup?.removeItem(at: formatPopup!.index(of: item))
}
if let item = formatPopup?.item(withTitle: "Notes as RTFD") {
formatPopup?.removeItem(at: formatPopup!.index(of: item))
}
if let item = formatPopup?.item(withTitle: NSLocalizedString("Text", comment: "")) {
formatPopup?.removeItem(at: formatPopup!.index(of: item))
}
if let item = formatPopup?.item(withTitle: NSLocalizedString("text", comment: "")) {
formatPopup?.removeItem(at: formatPopup!.index(of: item))
}
if let item = formatPopup?.item(withTitle: "PDF Reader Pro Edition Notes") {
formatPopup?.removeItem(at: formatPopup!.index(of: item))
}
if let item = formatPopup?.item(withTitle: "XDV") {
formatPopup?.removeItem(at: formatPopup!.index(of: item))
}
if let item = formatPopup?.item(withTitle: "DVI") {
formatPopup?.removeItem(at: formatPopup!.index(of: item))
}
if let item = formatPopup?.item(withTitle: "Images") {
formatPopup?.removeItem(at: formatPopup!.index(of: item))
}
if let item = formatPopup?.item(withTitle: "Encapsulated PostScript") {
formatPopup?.removeItem(at: formatPopup!.index(of: item))
}
}
// MARK: - Printing
override func printOperation(withSettings printSettings: [NSPrintInfo.AttributeKey : Any]) throws -> NSPrintOperation {
let printInfo = self.printInfo.copy() as! NSPrintInfo
printInfo.dictionary().addEntries(from: printSettings)
var printOperation: NSPrintOperation?
if self.isHome {
return NSPrintOperation()
}
let documentURL = self.mainViewController?.document?.documentURL
if documentURL == nil {
return NSPrintOperation()
}
guard let pdfDoc = PDFDocument(url: documentURL!) else {
return NSPrintOperation()
}
if pdfDoc.responds(to: #selector(PDFDocument.printOperation(for:scalingMode:autoRotate:))) {
printOperation = pdfDoc.printOperation(for: printInfo, scalingMode: .pageScaleNone, autoRotate: true)
} else if pdfDoc.responds(to: #selector(PDFDocument.getPrintOperation(for:autoRotate:))) {
printOperation = pdfDoc.getPrintOperation(for: printInfo, autoRotate: true)
}
// NSPrintProtected is a private key that disables the items in the PDF popup of the Print panel, and is set for encrypted documents
if pdfDoc.isEncrypted {
printOperation?.printInfo.dictionary().setValue(false, forKey: "NSPrintProtected")
}
let printPanel = printOperation?.printPanel
printPanel?.options = [.showsCopies, .showsPageRange, .showsPaperSize, .showsOrientation, .showsScaling, .showsPreview]
if printOperation == nil {
throw NSError.printDocumentError(withLocalizedDescription: "")
}
return printOperation!
}
override func runModalPrintOperation(_ printOperation: NSPrintOperation, delegate: Any?, didRun didRunSelector: Selector?, contextInfo: UnsafeMutableRawPointer?) {
printOperation.run()
}
}
extension PDFDocument {
@objc func getPrintOperation(for printInfo: NSPrintInfo, autoRotate: Bool) -> NSPrintOperation {
// 在此处实现方法的具体逻辑
return NSPrintOperation()
}
}
extension KMMainDocument {
override func validateMenuItem(_ menuItem: NSMenuItem) -> Bool {
if (menuItem.action == #selector(save(_ :))) {
if (self.isHome) {
return false
}
if (self.isDocumentEdited) {
return self.isDocumentEdited
}
guard let mainVC = self.mainViewController else {
return false
}
return mainVC.isPDFDocumentEdited || mainVC.needSave
} else if (menuItem.action == #selector(saveAs(_ :))) {
return !self.isHome
} else if menuItem.action == #selector(batchRemovPrivatySecurity) {
if self.isHome {
return false
}
guard let doc = self.mainViewController?.listView?.document else {
return false
}
let allowsPrinting = doc.allowsPrinting
let allowsCopying = doc.allowsCopying
if allowsCopying && allowsPrinting {
return false
}
return true
} else if menuItem.action == #selector(saveArchive) {
return !self.isHome
} else if (menuItem.action == #selector(saveTo(_ :))) {
return !self.isHome
} else if (menuItem.action == #selector(batchRemovePassWord)) {
return !self.isHome
} else if (menuItem.action == #selector(addBookmark)) {
if menuItem.tag == 3 {
return true
}else {
return !self.isHome
}
}
return super.validateMenuItem(menuItem)
}
}
extension NSDocument {
@objc class func isDamage(url: URL) -> Bool {
// 文件路径是否存在
if (FileManager.default.fileExists(atPath: url.path) == false) {
return true
}
/// PDF 格式文件
if (url.pathExtension.lowercased() == "pdf") {
let document = PDFDocument(url: url)
if (document == nil) {
return true
}
if (document!.isLocked) { // 加锁文件不在这里判断
return false
}
if (document!.pageCount <= 0) {
return true
}
return false
}
// 支持的图片格式
let imageExts = ["jpg","cur","bmp","jpeg","gif","png","tiff","tif","ico","icns","tga","psd","eps","hdr","jp2","jpc","pict","sgi","heic"]
let isImage = imageExts.contains(url.pathExtension.lowercased())
if (isImage == false) { // 其他格式目前返回没损坏，后续再补充(如果有需求)
return false
}
// 图片格式
let image = NSImage(contentsOf: url)
let data = image?.tiffRepresentation
if (data == nil) {
return true
}
let imageRep = NSBitmapImageRep(data: data!)
imageRep!.size = image!.size
var imageData: NSData?
if (url.pathExtension.lowercased() == "png") {
imageData = imageRep?.representation(using: .png, properties: [:]) as NSData?
} else {
imageData = imageRep?.representation(using: .jpeg, properties: [:]) as NSData?
}
if (imageData == nil) {
return true
}
let path = NSSearchPathForDirectoriesInDomains(.applicationSupportDirectory, .userDomainMask, true).last?.stringByAppendingPathComponent(Bundle.main.bundleIdentifier!)
if (FileManager.default.fileExists(atPath: path!) == false) {
try?FileManager.default.createDirectory(atPath: path!, withIntermediateDirectories: false)
}
var tagString: String = ""
let dateFormatter = DateFormatter()
dateFormatter.dateFormat = "yyMMddHHmmss"
tagString.append(dateFormatter.string(from: Date()))
tagString = tagString.appendingFormat("%04d", arc4random()%10000)
let filePath = path?.appending("/\(tagString).png")
if (imageData!.write(toFile: filePath!, atomically: true) == false) {
return true
}
// 删除临时图片
try?FileManager.default.removeItem(atPath: filePath!)
return false
}
@objc class func isDamage(url: URL, needAlertIfDamage need: Bool) -> Bool {
let result = self.isDamage(url: url)
if (result == false) {
return false
}
if (need == false) {
return true
}
let alert = NSAlert()
alert.messageText = NSLocalizedString("An error occurred while opening this document. The file is damaged and could not be repaired.", comment: "")
alert.runModal()
return true
}
}
// MARK: -
// MARK: 保存密码
extension NSDocument {
func savePasswordInKeychain(_ password: String, _ document: CPDFDocument) {
if (document.isLocked || password.isEmpty) {
return
}
let fileId = self.fileId(for: document)
if (fileId.isEmpty) {
return
}
// let status: SKPasswordStatus =
let label = "PDF Reader Pro: \(self.displayName!)"
SKKeychain.setPassword(password, item: nil, forService: self.passwordServiceName(), account: fileId, label: label, comment: self.fileURL?.path)
}
func getPassword(_ password: AutoreleasingUnsafeMutablePointer<NSString?>, fileId: String) {
let status = SKKeychain.getPassword(password, item: nil, forService: self.passwordServiceName(), account: fileId)
// if (status == .found) {
// }
}
fileprivate func fileId(for document: CPDFDocument) -> String {
return "\(document.documentURL.path.hash)"
}
private func passwordServiceName() -> String {
return "PDF Reader Pro password"
}
}
extension KMMainDocument: SKPDFSynchronizerDelegate {
func synchronizer(_ synchronizer: SKPDFSynchronizer!, foundLine line: Int, inFile file: String!) {
if FileManager.default.fileExists(atPath: file) {
let defaults = UserDefaults.standard
var editorPreset = defaults.string(forKey: SKTeXEditorPresetKey) ?? ""
var editorCmd: String?
var editorArgs: String?
var cmdString: String?
if !KMSyncPreferences.getTeXEditorCommand(command: &editorCmd, arguments: &editorArgs, forPreset: editorPreset) {
editorCmd = defaults.string(forKey: SKTeXEditorCommandKey)
editorArgs = defaults.string(forKey: SKTeXEditorArgumentsKey)
}
if var cmdString = editorArgs {
if !editorCmd!.hasPrefix("/") {
var searchPaths = ["/usr/bin", "/usr/local/bin"]
var toolPath: String?
let fm = FileManager.default
if !(editorPreset.isEmpty) {
if let path = NSWorkspace.shared.fullPath(forApplication: editorPreset) {
if let appBundle = Bundle(path: path) {
if let contentsPath = appBundle.path(forResource: "Contents", ofType: nil) {
searchPaths.insert(contentsPath, at: 0)
}
if editorPreset != "BBEdit", let execPath = appBundle.executablePath {
searchPaths.insert(execPath, at: 0)
}
if let resourcePath = appBundle.resourcePath {
searchPaths.insert(resourcePath, at: 0)
}
if let sharedSupportPath = appBundle.sharedSupportPath {
searchPaths.insert(sharedSupportPath, at: 0)
}
}
}
} else {
let appSupportDirs = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask)
let appSupportPaths = appSupportDirs.map { $0.path }
searchPaths.append(contentsOf: appSupportPaths)
}
for path in searchPaths {
toolPath = (path as NSString).appendingPathComponent(editorCmd!)
if fm.isExecutableFile(atPath: toolPath!) {
editorCmd = toolPath
break
}
toolPath = ((path as NSString).appendingPathComponent("bin") as NSString).appendingPathComponent(editorCmd!)
if fm.isExecutableFile(atPath: toolPath!) {
editorCmd = toolPath
break
}
}
}
cmdString = cmdString.replacingOccurrences(of: "%line", with: "\(line + 1)")
cmdString = cmdString.replacingOccurrences(of: "%file", with: file)
cmdString = cmdString.replacingOccurrences(of: "%output", with: fileURL?.path ?? "")
cmdString.insert(contentsOf: "\" ", at: cmdString.startIndex)
cmdString.insert(contentsOf: editorCmd!, at: cmdString.startIndex)
cmdString.insert("\"", at: cmdString.startIndex)
let ws = NSWorkspace.shared
if let theUTI = try? ws.type(ofFile: editorCmd!) {
if ws.type(theUTI, conformsToType: "com.apple.applescript.script") || ws.type(theUTI, conformsToType: "com.apple.applescript.text") {
cmdString.insert(contentsOf: "/usr/bin/osascript ", at: cmdString.startIndex)
}
}
let task = Process()
task.launchPath = "/bin/sh"
task.currentDirectoryPath = (file as NSString).deletingLastPathComponent
task.arguments = ["-c", cmdString]
task.standardOutput = FileHandle.nullDevice
task.standardError = FileHandle.nullDevice
do {
try task.run()
} catch let error {
Swift.print("command failed: \(cmdString ?? ""): \(error)")
}
}
}
}
func synchronizer(_ synchronizer: SKPDFSynchronizer!, foundLocation point: NSPoint, atPageIndex pageIndex: UInt, options: Int) {
guard let pdfDoc = self.mainViewController?.document else { return }
if pageIndex < pdfDoc.pageCount {
if let page = pdfDoc.page(at: pageIndex) {
var adjustedPoint = point
if options & SKPDFSynchronizerFlippedMask != 0 {
let mediaBox = page.bounds(for: .mediaBox)
adjustedPoint.y = NSMaxY(mediaBox) - adjustedPoint.y
}
self.mainViewController?.listView.displayLine(at: adjustedPoint, inPageAtIndex: Int(pageIndex), showReadingBar: options & SKPDFSynchronizerShowReadingBarMask != 0)
}
}
}
}
extension KMMainDocument {
}