PDF_Office/PDF Office/PDF Master/Class/PDFWindowController/ViewController/KMMainViewController+UI.swift

//
//  KMMainViewController+UI.swift
//  PDF Reader Pro
//
//  Created by wanjun on 2022/12/15.
//

import Foundation

extension KMMainViewController {
    // MARK: - 退出全屏
    
    
    @IBAction func startSpeaking(_ sender: Any) {
        self.showTTSWindow()
        let ttsView = KMTTSWindowController.share
        ttsView.buttonItemClick_Play(ttsView.playButton)
    }
    
    @IBAction func stopSpeaking(_ sender: Any) {
        let ttsWindowC = KMTTSWindowController.share
        if ttsWindowC.pdfView?.document?.documentURL.path == self.listView.document?.documentURL.path {
            if let data = ttsWindowC.window?.isVisible, data {
                ttsWindowC.stopSpeaking()
                ttsWindowC.close()
            }
        }
    }
}

extension KMMainViewController {
    //通知
    func preferenceDidChangeNotification(notification:Notification) {
        let info : [AnyHashable : Any] = notification.userInfo ?? [:]
        
        if info.keys.contains(KMPreference.viewZoomScaleTypeKey) {
            self.selectZoom(KMPreferenceManager.shared.viewZoomScaleType)
        }
        
        if notification.name.rawValue == "pdfViewDocumentDidLoaded" || info.keys.contains(KMPreference.viewPageDisplayTypeKey) {
            self.selectDisplay(display: KMPreferenceManager.shared.viewPageDisplayType)
        }
        
        if info.keys.contains(KMPreference.displayBackgroundNormalColorKey) || notification.name.rawValue == "pdfViewDocumentDidLoaded" {
            self.listView.backgroundColor = KMPreferenceManager.shared.displayBackgroundNormalColor
            self.listView.layoutDocumentView()
        }
         
        if (info.keys.contains(KMPreference.generalAuthorNameKey)) { // 作者名称
            CPDFKitConfig.sharedInstance().setAnnotationAuthor((info[KMPreference.generalAuthorNameKey] as! String))
        }
        if (info.keys.contains(KMPreference.highlightLinksKey)) {
            let hlLink = info[KMPreference.highlightLinksKey] as? Bool
            CPDFKitConfig.sharedInstance().setEnableLinkFieldHighlight(hlLink == nil ? false : hlLink!)
            self.listView.setNeedsDisplayForVisiblePages()
        }
        if info.keys.contains(KMPreference.thumbPageSizeKey) {
            self.leftSideViewController.refreshUIOfThumbnailIfNeed(preference: true)
        }
        if info.keys.contains(KMPreference.thumbSnapshotSizeKey) {
            self.leftSideViewController.refreshUIOfSnapshotIfNeed(preference: true)
        }
        if info.keys.contains(KMPreference.outlineFontSizeKey) {
            self.leftSideViewController.updateTableFont()
        }
        if info.keys.contains(KMPreference.greekThresholdKey) {
            let value = KMPreference.shared.greekThreshold.cgFloat
            self.listView.setGreekingThreshold(value)
        }
        if info.keys.contains(KMPreference.antiAliasTextKey) {
            self.listView.setShouldAntiAlias(KMPreference.shared.antiAliasText)
            self.listView.applyDefaultInterpolationQuality()
        }
        if info.keys.contains(KMPreference.markupColorHighlightKey) {
            if let item = self.toolbarController.findItem(KMToolbarHighlightAnnotationItemIdentifier) {
                if item.isSelected {
                    let color = KMPreference.shared.markupHighlightColor
                    let imageV = KMNoteTypeImageView()
                    item.image = imageV.noteTypeImage(withType: SKNHighlightString, color: color)
                }
            }
            
            if let item = self.toolbarController.findItem(KMToolbarSquigglyAnnotationItemIdentifier) {
                if item.isSelected {
                    if let color = UserDefaults.standard.PDFListViewColor(forKey: CSquigglyNoteColorKey) {
                        let imageV = KMNoteTypeImageView()
                        item.image = imageV.noteTypeImage(withType: "Squiggly", color: color)
                    }
                }
            }
        }
        if info.keys.contains(KMPreference.markupColorUnderlineKey) {
            if let item = self.toolbarController.findItem(KMToolbarUnderlineAnnotationItemIdentifier) {
                if item.isSelected {
                    let color = KMPreference.shared.markupUnderlineColor
                    let imageV = KMNoteTypeImageView()
                    item.image = imageV.noteTypeImage(withType: SKNUnderlineString, color: color)
                }
            }
        }
        if info.keys.contains(KMPreference.markupColorStrikthroughKey) {
            if let item = self.toolbarController.findItem(KMToolbarStrikeOutAnnotationItemIdentifier) {
                if item.isSelected {
                    let color = KMPreference.shared.markupStrikthroughColor
                    let imageV = KMNoteTypeImageView()
                    item.image = imageV.noteTypeImage(withType: SKNStrikeOutString, color: color)
                }
            }
        }
        if info.keys.contains(KMPreference.markupColorPenKey) {
            if let item = self.toolbarController.findItem(KMToolbarInkAnnotationItemIdentifier) {
                if item.isSelected {
                    let color = KMPreference.shared.markupPenColor
                    let imageV = KMNoteTypeImageView()
                    item.image = imageV.noteTypeImage(withType: SKNInkString, color: color)
                }
            }
        }
        if info.keys.contains(KMPreference.editPDFPopWindowShowKey) {
            let show = KMPreference.shared.editPDFPopWindowIsShow
            let win = KMEditPDFPopToolBarWindow.shared
            if !show && win.isVisible {
                win.orderOut(nil)
                win.setIsVisible(false)
            }
        }
    }
     
    func showConvertNotesProgress() {
        guard let pdfDocument = self.document else {
            return
        }
        guard let _ = self.listView.document else {
            return
        }
        guard let _ = self.view.window else {
            return
        }
        
        let isNewCreated = (self.myDocument as? KMMainDocument)?.isNewCreated ?? false
        if isNewCreated {
            return
        }
        
        self.model.needConvertNotes = false
        Task { @MainActor in
            self.convertNotesUsingPDFDocument(pdfDocument)
        }
    }
    
    func convertNotesUsingPDFDocument(_ pdfDocument: CPDFDocument, callback: (()->Void)? = nil) {
        guard let doc = self.listView.document else {
            return
        }
        DispatchQueue.main.async {
            self.beginProgressSheet(withMessage: "", maxValue: 0)
            
            let count = pdfDocument.pageCount
            DispatchQueue.global().async {
                 self.model.addAnnotations.removeAll()
                self.model.removeAnnotations.removeAll()
                for i in 0..<count {
                    let page = pdfDocument.page(at: i)
                     
                    for annotation in page?.annotations ?? [] {
                        var newAnnotation: CPDFAnnotation?
                        if let inkAnnotation = annotation as? CPDFInkAnnotation, inkAnnotation.contents.hasPrefix("<?xml version=\"1.0\" encoding=\"utf-8\"?>") {
                            let table = KMTableAnnotation(KMNoteBounds: inkAnnotation.bounds, document: doc)
                            table.border = inkAnnotation.border
                            table.color = inkAnnotation.color
                            table.createForm(withList: inkAnnotation.contents, andPaths: inkAnnotation.bezierPaths())
                            table.updateAppearanceInk(withIsAdd: false)
                            table.contents = annotation.contents
                            newAnnotation = table
                        }
                        if let newAnnotation = newAnnotation {
                            self.model.addAnnotations.append(newAnnotation)
                            self.model.removeAnnotations.append(annotation)
                        }
                    }
                     
                }
                
                DispatchQueue.main.async {
                    for i in 0..<self.model.addAnnotations.count {
                        let newAnnotation = self.model.addAnnotations[i]
                        let annotation = self.model.removeAnnotations[i]
                        
                        let page = annotation.page
                        // this is only to make sure markup annotations generate the lineRects, for thread safety
                        self.listView.addAnnotation(with: newAnnotation, to: page)
                        self.listView.remove(annotation)
                        if newAnnotation.contents != nil {
                            if newAnnotation.contents.count == 0 {
                                newAnnotation.autoUpdateString()
                            }
                        }
                    }
                    
                    self.dismissProgressSheet()
                    
                    self.listView.undoManager?.removeAllActions()
                    self.undoManager?.removeAllActions()
                    
                    // 清空数据
                    self.model.addAnnotations.removeAll()
                    self.model.removeAnnotations.removeAll()
                    
                    callback?()
                }
            }
        }
    }
    
    // MARK: - KMInterfaceThemeChangedProtocol
    
    override func interfaceThemeDidChanged(_ appearance: NSAppearance.Name) {
        super.interfaceThemeDidChanged(appearance)
        
        self.toolbarController.interfaceThemeDidChanged(appearance)
        self.leftSideViewController.interfaceThemeDidChanged(appearance)
        self.rightSideViewController.interfaceThemeDidChanged(appearance)
        
        self.pdfEditController?.interfaceThemeDidChanged(appearance)
        
        self.mianSplitView.superview?.wantsLayer = true
         if KMAppearance.isDarkMode() {
            self.mianSplitView.superview?.layer?.backgroundColor = NSColor(red: 0.149, green: 0.157, blue: 0.169, alpha: 1).cgColor
         } else {
            self.mianSplitView.superview?.layer?.backgroundColor = NSColor(red: 0.988, green: 0.992, blue: 1, alpha: 1).cgColor
         }
    }
}

// MARK: - KMToolbarControllerDelegate

extension KMMainViewController: KMToolbarControllerDelegate {
    func toolbarController(_ viewController: KMToolbarController, heightOffsetChange heightOffset: Float, animated: Bool) {
        let heightConst = (animated ? self.heightOffset.animator() : self.heightOffset)
        if viewManager.isPDFReadMode {
            if self.toolbarController.toolbarType == .Annatiton {
                heightConst?.constant = CGFloat(heightOffset)
            } else {
                heightConst?.constant = CGFloat(0)
            }
        } else {
            heightConst?.constant = CGFloat(heightOffset)
        }
        self.refreshListViewToolMode()
        self.trackEvent(toolMode: self.listView.toolMode)
        if self.listView.annotationType == .editTextImage ||
            self.listView.annotationType == .addText ||
            self.listView.annotationType == .addImage {
            self.closeRightPane()
        }
        self.listView.annotationType = .unkown
    }
    
    func changeAnnotationModeAction(item: KMToolbarClickButton) {
        if self.listView.toolMode == .formToolMode {
            if !IAPProductsManager.default().isAvailableAllFunction(){
                let winC = KMPurchaseCompareWindowController.sharedInstance()
                if let type = CAnnotationType(rawValue: item.tag) {
                    if type == .textField {
                        winC?.kEventName = "Reading_TextField_BuyNow"
                    } else if type == .checkBox {
                        winC?.kEventName = "Reading_CheckBox_BuyNow"
                    } else if type == .radioButton {
                        winC?.kEventName = "Reading_RadioButton_BuyNow"
                    } else if type == .listMenu {
                        winC?.kEventName = "Reading_ListBox_BuyNow"
                    } else if type == .comboBox {
                        winC?.kEventName = "Reading_ComboBox_BuyNow"
                    } else if type == .actionButton {
                        winC?.kEventName = "Reading_Button_BuyNow"
                    }
                }
                winC?.showWindow(nil)
                return
            }
        } else {
            let type = CAnnotationType(rawValue: item.tag) ?? CAnnotationType.unkown
            if type == .signature {
                if !IAPProductsManager.default().isAvailableAllFunction(){
                    let winC = KMPurchaseCompareWindowController.sharedInstance()
                    winC?.kEventName = "Reading_ElectronicSign_BuyNow"
                    winC?.showWindow(nil)
                    return
                }
            }
        }
        
        if (self.model.rightMouseEventing) {
            self.model.rightMouseEventing = false
        }
        if (self.toolbarController.ignoreCurrentAnnotationTypeChange) {
            self.toolbarController.ignoreCurrentAnnotationTypeChange = false
        }
        
        var currentType = self.listView.annotationType
 
        let isSelected = (currentType == CAnnotationType(rawValue: item.tag) ?? CAnnotationType.unkown) && ((self.listView.toolMode == .noteToolMode) || (self.listView.toolMode == .selfSignMode) || (self.listView.toolMode == .formToolMode))
        var editSelectd = false
        if self.listView.annotationType == CAnnotationType(rawValue: item.tag) ?? CAnnotationType.unkown && self.listView.toolMode == .editPDFToolMode {
            editSelectd = true
        }
        
        if isSelected {
            if self.listView.toolMode == .formToolMode {
                
            } else {
                self.listView.toolMode = .textToolMode
            }
            let type = CAnnotationType(rawValue: item.tag) ?? CAnnotationType.unkown
            if type == .signature {
                self.toolbarController.findItem(KMToolbarToolSignBoxIdentifier)?.isSelected = false
                
                if self.listView.toolMode == .formToolMode {
                    self.listView.toolMode = .noteToolMode
                }
            }
            self.listView.annotationType = .unkown
            self.closeRightPane()
        } else {
            let type = CAnnotationType(rawValue: item.tag) ?? CAnnotationType.unkown
            self.trackEvent(annotationType: type)

            if type == .signature {
                if self.listView.toolMode != .formToolMode {
                    self.listView.toolMode = .formToolMode
                    
                    self.toolbarController.findItem(KMToolbarToolSignBoxIdentifier)?.isSelected = true
                }
            }
            self.listView.annotationType = type
            
            if self.listView.currentSelection != nil {
              let annotation = self.listView.addAnnotation(with: CAnnotationType(rawValue: item.tag) ?? CAnnotationType.unkown, selection: self.listView.currentSelection, page: self.listView.currentSelection.page, bounds: self.listView.currentSelection.bounds)
                if((annotation != nil) &&
                   !self.listView.activeAnnotations.contains(annotation ?? self.listView.activeAnnotation)) {
                    var newAnnonations : [CPDFAnnotation] = []
                    newAnnonations.append(annotation!)
                    self.listView.updateActiveAnnotations(newAnnonations)
                    self.listView.setNeedsDisplayAnnotationViewFor(annotation?.page)
                }

            }
            
            if self.listView.toolMode == .formToolMode {
                
            } else {
                self.refreshListViewToolMode()
            }
        }
        
        if self.listView.toolMode != .editPDFToolMode && self.listView.annotationType != .unkown {
            self.rightSideViewController.isHidden = false
            let toolMode = self.listView.toolMode ?? .none
            self.rightSideViewController.kEventTag = toolMode == .selfSignMode ? 1 : 0
            self.rightSideViewController.subViewType = .AnnotationProperts
            if !viewManager.isPDFReadMode {
                self.openRightPane()
            }
        } else if self.listView.toolMode == .editPDFToolMode {
            if editSelectd {
                self.rightSideViewController.isHidden = true
                self.listView.setShouAddEdit([])
                self.listView.change([.text, .image])
                self.listView.annotationType = .editTextImage
                self.closeRightPane()
            } else if self.listView.annotationType == .addText {
                self.rightSideViewController.isHidden = false
                if !viewManager.isPDFReadMode {
                    self.openRightPane()
                }
                self.rightSideViewController.subViewType = .EditPDFAddText
                FMTrackEventManager.defaultManager.trackEvent(event: "SubTbr_EditPDF", withProperties: ["SubTbr_Btn" : "Btn_SubTbr_EditPDF_AddText"])
                self.listView.setShouAddEdit(.text)
                self.listView.change(.text)
            } else if self.listView.annotationType == .addImage {
                self.rightSideViewController.isHidden = false
                if !viewManager.isPDFReadMode {
                    self.openRightPane()
                }
                FMTrackEventManager.defaultManager.trackEvent(event: "SubTbr_EditPDF", withProperties: ["SubTbr_Btn" : "Btn_SubTbr_EditPDF_AddImage"])
 
                self.rightSideViewController.subViewType = .EditPDFAddImage
                self.listView.setShouAddEdit(.image)
                self.listView.change(.image)
                self.rightSideViewController.eidtPDFImageProperty.reloadData()
            }
        } else {
            self.rightSideViewController.isHidden = true
            self.closeRightPane()
        }
    }
    
    func refreshListViewToolMode () {
        if self.toolbarController.toolbarType == .Annatiton {
           self.listView.toolMode = .noteToolMode
        } else if self.toolbarController.toolbarType == .Move {
            self.listView.toolMode = .moveToolMode
        } else if self.toolbarController.toolbarType == .Magnify {
            self.listView.toolMode = .magnifyToolMode
        } else if self.toolbarController.toolbarType == .Select {
            self.listView.toolMode = .selectToolMode
        } else if self.toolbarController.toolbarType == .SelectZoom {
            self.listView.toolMode = .selectZoomToolMode
        } else if self.toolbarController.toolbarType == .Page {
            
        } else if self.toolbarController.toolbarType == .Form {
            self.listView.toolMode = .formToolMode
            self.rightSideViewController.subViewType = .AnnotationProperts
        } else if self.toolbarController.toolbarType == .FillSign {
            self.listView.toolMode = .selfSignMode
            self.rightSideViewController.subViewType = .AnnotationProperts
        } else if self.toolbarController.toolbarType == .editPDF {
            self.listView.toolMode = .editPDFToolMode 
             self.listView.setShouAddEdit([])
        }else if self.toolbarController.toolbarType == .LeftPanel {
            self.toggleLeftPane()
            self.leftSideViewController.showPanelView(show: true)
        }else {
            self.listView.toolMode = .textToolMode
        }
    }
    
    func showPDFLayoutModeAction(show: Bool) {
        self.listView.annotationType = .unkown
        self.showOrHideNotes()
    }
}
 

// MARK: - KMLeftSideViewControllerDelegate

extension KMMainViewController: KMLeftSideViewControllerDelegate {
    func controlStateChange(_ obj: KMLeftSideViewController, show: Bool) {
        if show {
            self.openLeftPane()
        } else {
            self.closeLeftPane()
        }
    }
    
    func enterEditMode(_ obj: KMLeftSideViewController, _ pages: [Int]) {
        let item : KMToolbarItemView = (self.toolbarController.mainToolBarView?.toolbarItemFindItemIdentifiers(value: KMDocumentPageToolbarItemIdentifier))!
        self.toolbarController.mainToolBarView?.delegate?.toolbarViewController?(self.toolbarController.mainToolBarView!, clickMode: .Page, toolbar: item, pages)
    }
    
    func searchAction(searchString: String,isCase:Bool) {
        self.search(searchString: searchString,isCase: isCase)
    }
    
    func controller(_ controller: KMLeftSideViewController, dispayDidChange dispay: KMPDFDisplayType) {
        self.selectDisplay(display: dispay, viewSettingIsReload: false)
    }
    
    func controller(controller: KMLeftSideViewController, itemClick item: Any?, itemKey: KMItemKey, params: Any?) {
        if (itemKey == .print) { // 打印
            if params is NSImage {
                KMPrintWindowController.cpdf_printImage(image: params as! NSImage)
                return
            }
            var pageRange: KMPrintPageRange = KMPrintPageRange(type: .allPage, selectPages: [], reversePrintOrder: false)
            if (params != nil) {
                pageRange.type = .custom
                pageRange.selectPages = params as! [Int]
            }
            
            self.showPrintWindow(pageRange: pageRange)
        } else if (itemKey == .cut || itemKey == .paste || itemKey == .delete || itemKey == .leftRotate || itemKey == .rightRotate) {
            self.recordIsPDFDocumentEdited(type: itemKey.toSubscribeWaterMarkType())
        } else if itemKey == .pageEdit {
            self.toolbarController.clickItem(KMDocumentPageToolbarItemIdentifier)
        } else if itemKey == .demote { // 大纲降级
            guard let currentOutline: CPDFOutline = controller.tocOutlineView.km.clickedItem() else {
                return
            }
            self.listView.demote(outline: currentOutline)
        } else if itemKey == .promote { // 大纲升级
            guard let currentOutline: CPDFOutline = controller.tocOutlineView.km.clickedItem() else {
                return
            }
            self.listView.promote(outline: currentOutline)
        } else if itemKey == .tts {
            FMTrackEventManager.defaultManager.trackEvent(event: "SubTbr_PageDisplay", withProperties: ["SubTbr_Btn": "Btn_SubTbr_PageDisplay_TTS"])
            self.listView.annotationType = .unkown
            self.showTTSWindow()
        }
    }
    
    func controller(controller: KMLeftSideViewController, bookMarkDidChange bookMarks: [KMBookMarkItem]) {
        self.needSave = true
        self.recordIsPDFDocumentEdited()
    }
    
    func controller(controller: KMLeftSideViewController, rotateType: KMRotateType) {
        if rotateType == .clockwise {
            self.menuItemAction_rotateRight((Any).self)
        } else if rotateType == .anticlockwise {
            self.menuItemAction_rotateLeft((Any).self)
        }
    }
    
    func controller(controller: KMLeftSideViewController, listViewSelectionDidChange object: Any?, info: [String : Any]?) {
        if controller.thumbnailTableView.isEqual(to: object) {
            let row = controller.thumbnailTableView.selectedRow
            let curIndex = self.listView.currentPageIndex
            if (row != -1 && row != curIndex) {
                self.listView.go(toPageIndex: row, animated: true)
            }
        }
    }
}

//MARK: - ReadModel
extension KMMainViewController {
     
    
    @objc func addOutLineItemAction() {
        let labelString = "\(KMLocalizedString("Page")) \((self.listView.currentPageIndex ?? 0) + 1)"
        let label = self.listView.currentSelection?.string() ?? labelString
        let dest =  self.listView.currentDestination
        if let row = self.leftSideViewController.selectedRowIndexes().last {
            if let ol = self.leftSideViewController.tocOutlineView.item(atRow: row) as? CPDFOutline {
                _ = self.listView.addOutline(for: ol.parent, label: label, dest: dest, at: ol.index+1)
            } else {
                let idx = self.listView.document?.outlineRoot()?.numberOfChildren ?? 0
                _ = self.listView.addOutlineForRoot(label: label, dest:dest, at: idx)
            }
        } else {
            let idx = self.listView.document?.outlineRoot()?.numberOfChildren ?? 0
            _ = self.listView.addOutlineForRoot(label: label, dest:dest, at: idx)
        }
    }
    
    @objc func showTTSView() {
        FMTrackEventManager.defaultManager.trackEvent(event: "RightClickBar", withProperties: ["RightClickBar_Btn": "Btn_RightClickBar_TTS"])
        
        self.showTTSWindow()
    }
    
    @objc func showShareAction() {
       
    }
    
    @objc func lookUpAction() {
        let label = self.listView.currentSelection?.string() ?? ""
        self.toolbarController.showFindBar()
        self.toolbarController.findSearchView.searchString(label)
 
    }
    
    @objc func searchBaiduAction() {
        let label = self.listView.currentSelection?.string() ?? ""
        let query = label.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed) ?? ""
        if let url = URL(string: "https://www.baidu.com/s?wd=\(query)") {
            NSWorkspace.shared.open(url)
        }
    }
    
    @objc func showInfoInFinder() {
        
    }
    
    @objc func NextPageAction() {
        
    }
    
    @objc func PreviousPageAction() {
        
    }
    
    @objc func TranslateItemAction() {
        // 获取选中的文本
        if let selection = self.listView.currentSelection?.string() {
            // 进行翻译
            let escapedText = selection.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed)!
            let urlStr = "https://translate.google.com/?sl=auto&amp;tl=zh-CN&amp;text=\(escapedText)"
            if let url = URL(string: urlStr) {
                NSWorkspace.shared.open(url)
            }
        } else {
            print("No text selected.")
        }
    }
    @objc func AutoScrollItemAction() {
        //增加判断，如果是正在滚动，就停止，否则就开始滚动
        self.listView.autoFlow()
    }
    @objc func shareFromService(sender: NSMenuItem) {
        if ((NSApp.mainWindow?.windowController is KMBrowserWindowController) == false) {
            return
        }
        
        var string = ""
        if let freeTextAnnotation = listView.activeAnnotation as? CPDFFreeTextAnnotation {
            string = freeTextAnnotation.contents ?? ""
        } else if let markupAnnotation = listView.activeAnnotation as? CPDFMarkupAnnotation {
            if let page = markupAnnotation.page {
                if let selection = page.selection(for: markupAnnotation.bounds) {
                    string = selection.string() ?? ""
                }
            }
        } else {
            string = listView.currentSelection?.string() ?? ""
        }
        
        let windowControler = NSApp.mainWindow?.windowController as! KMBrowserWindowController
        let model = windowControler.browser?.tabStripModel
        if let cnt = model?.count(), cnt <= 0 {
            return
        }
        
        if let data = model?.activeTabContents().isHome, data {
            return
        }
        
        let document: KMMainDocument = model?.activeTabContents() as! KMMainDocument
        if string.count > 0 {
            let represent : NSSharingService = sender.representedObject as! NSSharingService
            represent.perform(withItems: [string])
            return
        }

        let represent = sender.representedObject as? NSSharingService
        represent?.perform(withItems: [string])
    }
    
    @objc func cutAction(sender: NSMenuItem) {
        
    }
    @objc func deleteAction(sender: NSMenuItem) {
        
    }
    @objc func ColorsItemAction(sender: NSMenuItem) {
        
    }
    @objc func LinesItemAction(sender: NSMenuItem) {
        
    }
    @objc func EditNoteItemAction(sender: NSMenuItem) {
        
    }
    @objc func AITranslateItemAction(sender: NSMenuItem) {
        self.showAITypeChooseView(aiConfigType: .translate)
    }
    @objc func AIProofreadItemAction(sender: NSMenuItem) {
        self.showAITypeChooseView(aiConfigType: .proofreading)
    }
    @objc func AIRewriteItemAction(sender: NSMenuItem) {
        self.showAITypeChooseView(aiConfigType: .reWriting)
    }
     
}

// MARK: - KMEditImagePropertyViewControllerDelegate

extension KMMainViewController: KMEditImagePropertyViewControllerDelegate {
    func editImagePropertyViewControllerDidChanged(controller: KMEditImagePropertyViewController, type: KMEditImagePropertyViewControllerChangeType) {
        self.model.isPDFTextImageEdited = true
    }
}

// MARK: - KMSnapshotWindowControllerDelegate

extension KMMainViewController: KMSnapshotWindowControllerDelegate {
    func snapshotControllerWillClose(_ controller: KMSnapshotWindowController) {
        self.leftSideViewController.snapshotControllerWillClose(controller)
    }
    
    func snapshotController(_ controller: KMSnapshotWindowController, miniaturizedRect isMiniaturize: Bool) -> NSRect {
        if isMiniaturize && self.interactionMode != .presentation {
            if self.interactionMode != .legacyFullScreen && self.model.leftPanelOpen == false {
                self.toggleLeftPane()
            } else if self.interactionMode == .legacyFullScreen {
             }

            var row = NSNotFound
            for (i,sp) in self.leftSideViewController.snapshots.enumerated() {
                if controller.isEqual(sp.windowC) {
                    row = i
                }
            }
            if (row != NSNotFound) {
                if self.leftSideViewController.type.methodType != .snapshot {
                    self.leftSideViewController.leftView.segmentedControl.selectedSegment = 5
                } else {
                    self.leftSideViewController.refreshUIOfSnapshotIfNeed()
                }
                self.leftSideViewController.snapshotTableView.scrollRowToVisible(row)
            }
        }
        
        return self.leftSideViewController.snapshotController(controller, miniaturizedRect: isMiniaturize)
    }
    
    func snapshotControllerDidFinishSetup(_ controller: KMSnapshotWindowController) {
        self.leftSideViewController.snapshotControllerDidFinishSetup(controller)
    }
}

// MARK: - CPDFDocumentDelegate

extension KMMainViewController: CPDFDocumentDelegate {
    func documentDidBeginDocumentFind(_ document: CPDFDocument!) {
        self.leftSideViewController.documentDidBeginFind()
     }
    
    func documentDidEndDocumentFind(_ document: CPDFDocument!) {
        self.leftSideViewController.documentDidEndFind()
     }
}

// MAKR: - CPDFViewDelegate,CPDFListViewDelegate