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

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

import Foundation

extension KMMainViewController {
    func search(searchString: String, isCase: Bool) {
        let document = self.listView.document
        if ((document?.isFinding) != nil) {
            document?.cancelFindString()
        }
        if searchString == "" {
            self.searchResults = []
            //            self.leftSideViewController.searchViewController.searchResults = self.searchResults
            self.leftSideViewController.searchResults = self.searchResults
            //            self.leftSideViewController.searchViewController.reloadData()
        } else {
            mwcFlags.wholeWordSearch = isCase == true ? 1 : 0
            var findArray : [[CPDFSelection]]
            if isCase {
                if self.leftSideViewController.mwcFlags.wholeWordSearch == 1 {
                    findArray = self.listView.document.findString(searchString, with: .matchWholeWord) ?? []
                } else {
                    findArray = self.listView.document.findString(searchString) ?? []
                }
            } else {
                if self.leftSideViewController.mwcFlags.wholeWordSearch == 1 {
                    findArray = self.listView.document.findString(searchString, with: [.caseSensitive, .matchWholeWord]) ?? []
                } else {
                    findArray = self.listView.document.findString(searchString, with: .caseSensitive) ?? []
                }
                
            }
            self.searchResults.removeAll()
            for selections in findArray {
                for selection in selections {
                    let mode : KMSearchMode = KMSearchMode()
                    mode.selection = selection
                    mode.attributedString = KMOCToolClass.getAttributedString(selection: selection, keyword: searchString)
                    mode.selectionPageIndex = self.listView.document.index(for: selection.page)
                    self.searchResults.insert(mode, at: self.searchResults.count)
                }
            }
            //            self.leftSideViewController.searchViewController.searchResults = self.searchResults
            //            self.leftSideViewController.searchViewController.reloadData()
            self.leftSideViewController.searchResults = self.searchResults
        }
        
        if self.leftSideViewController.findPaneState == .singular {
            self.leftSideViewController.displayFindViewAnimating(true)
        } else {
            self.leftSideViewController.displayGroupedFindViewAnimating(true)
        }
    }
    
    func removeSignatures(signatures:[CPDFSignature]) {
        for signature in signatures {
            self.listView.document.removeSignature(signature)
        }
        for i in 0..<self.listView.document.pageCount {
            let page : CPDFPage = self.listView.document.page(at: i)
            let annotations : [CPDFAnnotation] = page.annotations
            for j in 0..<annotations.count {
                let annotation = annotations[j]
                if annotation is CPDFSignatureWidgetAnnotation {
                    (annotation as! CPDFSignatureWidgetAnnotation).updateAppearanceStream()
                }
            }
        }
        self.listView.setNeedsDisplayForVisiblePages()
        let tSignatures : [CPDFSignature] = self.listView.document.signatures()
        var mSignatures : [CPDFSignature] = []
        for sign in tSignatures {
            if sign.signers.count > 0 {
                mSignatures.append(sign)
            }
        }
        //        self.leftSideViewController.signatureViewController.signatures = signatures
        //        self.leftSideViewController.signatureViewController.reloadData()
    }
    
    //MARK: menu菜单
    
    func fontColorMenuItem()->NSMenuItem {
        let fontColorItem = NSMenuItem(title: NSLocalizedString("Text Color", comment: ""), action: #selector(menuItemEditingClick_FontColor), keyEquivalent: "")
        
        return fontColorItem;
    }
    
    func fontSizeMenuItem()->NSMenuItem {
        let currentFontSize = self.listView.editingTextFontSize()
        let fontSizes = self.fontSizes()
        let submenu = NSMenu(title: "")
        for i in 0 ... fontSizes.count - 1 {
            let fontSize : String = fontSizes.object(at: i) as! String
            let item = NSMenuItem(title:fontSize , action: #selector(menuItemEditingClick_FontSize), keyEquivalent: "")
            item.target = self
            item.tag = i
            submenu.addItem(item)
            if (Int(currentFontSize) == Int(fontSize)) {
                item.state = .on
            }
        }
        
        let fontSizeItem = NSMenuItem(title: NSLocalizedString("Font Size", comment: ""), action:nil, keyEquivalent: "")
        
        fontSizeItem.submenu = submenu
        return fontSizeItem;
    }
    
    func corpImageMenuItem()->NSMenuItem {
        let corpImageItem = NSMenuItem(title: NSLocalizedString("Confirm Crop", comment: ""), action: #selector(menuItemEditingClick_CropImage), target: self)
        return corpImageItem
    }
    
    func cancelCorpImageMenuItem()->NSMenuItem {
        let cancelCorpImageItem = NSMenuItem(title: NSLocalizedString("Cancel Crop", comment: ""), action: #selector(menuItemEditingClick_CancelCrop), target: self)
        return cancelCorpImageItem
    }
    
    func restoreCorpImageMenuItem()->NSMenuItem {
        let cancelCorpImageItem = NSMenuItem(title: NSLocalizedString("Restore Crop", comment: ""), action: #selector(menuItemEditingClick_RestoreCrop), target: self)
        return cancelCorpImageItem
    }
    
    func cutImageArea()->NSMenuItem {
        let deleteItem = NSMenuItem(title: NSLocalizedString("Crop", comment: ""), action: #selector(menuItemEditingClick_CutImage), target: self)
        return deleteItem
    }
    
    func editAddBlanMenu(menu:NSMenu){
        _ = menu.insertItem(withTitle: NSLocalizedString("Add Text", comment: ""), action: #selector(addImageText), target: self, at: 0)
        _ = menu.insertItem(withTitle: NSLocalizedString("Add Image", comment: ""), action: #selector(addImageText), target: self, at: 1)
    }
    
    func addText() -> NSMenuItem {
        let addTextItem = NSMenuItem(title: NSLocalizedString("Add Text", comment: ""), action: #selector(addImageText), target: self, tag: 0)
        return addTextItem
    }
    
    func addImage() -> NSMenuItem {
        let addImageItem = NSMenuItem(title: NSLocalizedString("Add Image", comment: ""), action: #selector(addImageText), target: self, tag: 1)
        return addImageItem
    }
    
    func replaceImageArea()->NSMenuItem {
        let replaceItem = NSMenuItem(title: NSLocalizedString("Replace", comment: ""), action: #selector(menuItemEditingClick_ReplaceImage), target: self)
        return replaceItem
    }
    
    func exportImageArea()->NSMenuItem {
        let exportItem = NSMenuItem(title: NSLocalizedString("Export", comment: ""), action: #selector(menuItemEditingClick_ExportImage), target: self)
        return exportItem
    }
    
    func exportImageStampItem()->NSMenuItem {
        let exportItem = NSMenuItem(title: NSLocalizedString("Export", comment: ""), action: #selector(menuItemEditingClick_ExportImage), target: self)
        let menu = NSMenu()
        let item1 = menu.insertItem(withTitle: NSLocalizedString("PNG", comment: ""), action:#selector(exportStampImage), target: self, tag:0, at: 0)
        let item2 = menu.insertItem(withTitle: NSLocalizedString("PDF", comment: ""), action:#selector(exportStampImage), target: self, tag:2, at: 1)
        exportItem.submenu = menu
        return exportItem
    }
    
    func exportMenu() -> NSMenu {
        let menu = NSMenu()
        _ = menu.insertItem(withTitle: NSLocalizedString("PNG", comment: ""), action:#selector(exportCorpImage), target: self, tag:0, at: 0)
        _ = menu.insertItem(withTitle: NSLocalizedString("JPG", comment: ""), action:#selector(exportCorpImage), target: self, tag:1, at: 1)
        _ = menu.insertItem(withTitle: NSLocalizedString("PDF", comment: ""), action:#selector(exportCorpImage), target: self, tag:2, at: 2)
        
        return menu
    }
    
    func cropMenu() -> NSMenu {
        let menu = NSMenu()
        _ = menu.insertItem(withTitle: NSLocalizedString("Crop Current Page", comment: ""), action:#selector(cropCurrentPage), target: self, at: 0)
        _ = menu.insertItem(withTitle: NSLocalizedString("Crop All Pages", comment: ""), action:#selector(cropAllPage), target: self, at: 1)
        _ = menu.insertItem(withTitle: NSLocalizedString("Auto Crop – Separate", comment: ""), action:#selector(autoCropAll), target: self, at: 2)
        _ = menu.insertItem(withTitle: NSLocalizedString("Auto Crop – Combined", comment: ""), action:#selector(autoCropAll), target: self, at: 2)
        return menu
    }
    
    func zoomSelectionMenuItem() -> NSMenuItem {
        let item = NSMenuItem(title: NSLocalizedString("Zoom To Selection", comment: ""), action: #selector(doZoomToAutoSelection), target: self)
        return item
    }
    
    func setDefaultAnnotationPorpert(type:CAnnotationType) -> NSMenuItem {
        let item = NSMenuItem(title: NSLocalizedString("Set as Default", comment: ""), action: #selector(defaultAnnotationPorpert), target: self, tag: type.rawValue)
        return item
    }
    
    func enterAnnotationStype() -> NSMenuItem {
        let stypItem = NSMenuItem(title: NSLocalizedString("Annotation", comment: ""), action: nil, target: self)
        let stypeMenu = NSMenu()
        if listView.currentSelection != nil && listView.currentSelection.selectionType() == .text {
            _ = stypeMenu.addItem(withTitle: NSLocalizedString("Highlight", comment: ""), action: #selector(menuItemAnnotationClick_add), target: self, tag: 0)
            _ = stypeMenu.addItem(withTitle: NSLocalizedString("Underline", comment: ""), action: #selector(menuItemAnnotationClick_add), target: self, tag: 1)
            _ = stypeMenu.addItem(withTitle: NSLocalizedString("Strikethrough", comment: ""), action: #selector(menuItemAnnotationClick_add), target: self, tag: 2)
            stypeMenu.addItem(NSMenuItem.separator())
        }
        //        stypeMenu.addItem(withTitle: NSLocalizedString("Freehand", comment: ""), action: #selector(menuItemAnnotationClick_addStype), target: self, tag: 0)
        _ = stypeMenu.addItem(withTitle: NSLocalizedString("Text Box", comment: ""), action: #selector(menuItemAnnotationClick_addStype), target: self, tag: 1)
        _ = stypeMenu.addItem(withTitle: NSLocalizedString("Anchored Note", comment: ""), action: #selector(menuItemAnnotationClick_addStype), target: self, tag: 2)
        //        stypeMenu.insertItem(NSMenuItem.separator(), at: 10000)
        stypeMenu.addItem(NSMenuItem.separator())
        _ = stypeMenu.addItem(withTitle: NSLocalizedString("Rectangle", comment: ""), action: #selector(menuItemAnnotationClick_addStype), target: self, tag: 3)
        _ = stypeMenu.addItem(withTitle: NSLocalizedString("Circle", comment: ""), action: #selector(menuItemAnnotationClick_addStype), target: self, tag: 4)
        _ = stypeMenu.addItem(withTitle: NSLocalizedString("Arrow", comment: ""), action: #selector(menuItemAnnotationClick_addStype), target: self, tag: 5)
        _ = stypeMenu.addItem(withTitle: NSLocalizedString("Line", comment: ""), action: #selector(menuItemAnnotationClick_addStype), target: self, tag: 6)
        //        stypeMenu.insertItem(NSMenuItem.separator(), at: 10000)
        if self.isReadMode {
            
        } else {
            stypeMenu.addItem(NSMenuItem.separator())
            //            _ = stypeMenu.addItem(withTitle: NSLocalizedString("Link", comment: ""), action: #selector(menuItemAnnotationClick_addStype), target: self, tag: 7)
            _ = stypeMenu.addItem(withTitle: NSLocalizedString("Stamp", comment: ""), action: #selector(menuItemAnnotationClick_addStype), target: self, tag: 8)
            _ = stypeMenu.addItem(withTitle: NSLocalizedString("Image", comment: ""), action: #selector(menuItemAnnotationClick_addStype), target: self, tag: 10)
            _ = stypeMenu.addItem(withTitle: NSLocalizedString("Signature", comment: ""), action: #selector(menuItemAnnotationClick_addStype), target: self, tag: 9)
        }
        stypItem.submenu = stypeMenu
        if self.listView.annotationType == .ink {
            stypeMenu.item(at: 0)?.state = .on
        } else if self.listView.annotationType == .freeText {
            stypeMenu.item(at: 1)?.state = .on
        } else if self.listView.annotationType == .anchored {
            stypeMenu.item(at: 2)?.state = .on
        } else if self.listView.annotationType == .square {
            stypeMenu.item(at: 3)?.state = .on
        } else if self.listView.annotationType == .circle {
            stypeMenu.item(at: 4)?.state = .on
        } else if self.listView.annotationType == .arrow {
            stypeMenu.item(at: 5)?.state = .on
        } else if self.listView.annotationType == .line {
            stypeMenu.item(at: 6)?.state = .on
        } else if self.listView.annotationType == .link {
            stypeMenu.item(at: 7)?.state = .on
        } else if self.listView.annotationType == .stamp {
            stypeMenu.item(at: 8)?.state = .on
        } else if self.listView.annotationType == .signSignature {
            stypeMenu.item(at: 9)?.state = .on
        }
        return stypItem
    }
    
    func setAnnotationToolStype() -> NSMenuItem {
        let stypItem = NSMenuItem(title: NSLocalizedString("Tool Mode", comment: ""), action: nil, target: self)
        let stypeMenu = NSMenu()
        
        let item1 = stypeMenu.addItem(withTitle: NSLocalizedString("Text", comment: ""), action: #selector(menuItemAnnotationClick_toolModel), target: self, tag: CToolMode.noteToolMode.rawValue)
        let item2 = stypeMenu.addItem(withTitle: NSLocalizedString("Scroll", comment: ""), action: #selector(menuItemAnnotationClick_toolModel), target: self, tag: CToolMode.moveToolMode.rawValue)
        let item3 = stypeMenu.addItem(withTitle: NSLocalizedString("Magnify", comment: ""), action: #selector(menuItemAnnotationClick_toolModel), target: self, tag: CToolMode.magnifyToolMode.rawValue)
        let item4 = stypeMenu.addItem(withTitle: NSLocalizedString("Select", comment: ""), action: #selector(menuItemAnnotationClick_toolModel), target: self, tag: CToolMode.selectToolMode.rawValue)
        //        stypeMenu.addItem(withTitle: NSLocalizedString("Zoom to Selected Area", comment: ""), action: #selector(menuItemAnnotationClick_toolModel), target: self, tag: 4)
        stypeMenu.insertItem(NSMenuItem.separator(), at: 4)
        let item5 = stypeMenu.addItem(withTitle: NSLocalizedString("Highlight", comment: ""), action: #selector(changeAnnotationMode_itemAction), target: self, tag:  CAnnotationType.highlight.rawValue)
        let item6 = stypeMenu.addItem(withTitle: NSLocalizedString("Underline", comment: ""), action: #selector(changeAnnotationMode_itemAction), target: self, tag: CAnnotationType.underline.rawValue)
        let item7 = stypeMenu.addItem(withTitle: NSLocalizedString("Strikethrough", comment: ""), action: #selector(changeAnnotationMode_itemAction), target: self, tag: CAnnotationType.strikeOut.rawValue)
        let item8 = stypeMenu.addItem(withTitle: NSLocalizedString("Freehand", comment: ""), action: #selector(changeAnnotationMode_itemAction), target: self, tag: CAnnotationType.ink.rawValue)
        let item9 = stypeMenu.addItem(withTitle: NSLocalizedString("Text Note", comment: ""), action: #selector(changeAnnotationMode_itemAction), target: self, tag: CAnnotationType.freeText.rawValue)
        let item10 = stypeMenu.addItem(withTitle: NSLocalizedString("Anchored Note", comment: ""), action: #selector(changeAnnotationMode_itemAction), target: self, tag: CAnnotationType.anchored.rawValue)
        let item11 = stypeMenu.addItem(withTitle: NSLocalizedString("Rectangle", comment: ""), action: #selector(changeAnnotationMode_itemAction), target: self, tag: CAnnotationType.square.rawValue)
        let item12 = stypeMenu.addItem(withTitle: NSLocalizedString("Circle", comment: ""), action: #selector(changeAnnotationMode_itemAction), target: self, tag: CAnnotationType.circle.rawValue)
        let item13 = stypeMenu.addItem(withTitle: NSLocalizedString("Arrow", comment: ""), action: #selector(changeAnnotationMode_itemAction), target: self, tag: CAnnotationType.arrow.rawValue)
        let item14 = stypeMenu.addItem(withTitle: NSLocalizedString("Line", comment: ""), action: #selector(changeAnnotationMode_itemAction), target: self, tag: CAnnotationType.line.rawValue)
        let item15 = stypeMenu.addItem(withTitle: NSLocalizedString("Link", comment: ""), action: #selector(changeAnnotationMode_itemAction), target: self, tag: CAnnotationType.link.rawValue)
        
        stypItem.submenu = stypeMenu
        if self.toolbarController.toolbarType == .Annatiton {
            stypeMenu.item(at: 0)?.state = .on
        } else if self.toolbarController.toolbarType == .Move {
            stypeMenu.item(at: 1)?.state = .on
        } else if self.toolbarController.toolbarType == .Magnify {
            stypeMenu.item(at: 2)?.state = .on
        } else if self.toolbarController.toolbarType == .Select {
            stypeMenu.item(at: 3)?.state = .on
        } else if self.toolbarController.toolbarType == .SelectZoom {
            stypeMenu.item(at: 4)?.state = .on
        }
        return stypItem
    }
    
    func addReadModelStype() -> NSMenuItem {
        var stypItem = NSMenuItem(title: NSLocalizedString("Read Mode On", comment: ""), action: #selector(openReadModel), target: self)
        if self.isReadMode {
            stypItem = NSMenuItem(title: NSLocalizedString("Read Mode Off", comment: ""), action: #selector(closeReadModel), target: self)
        }
        return stypItem
    }
    func addOutlineStype() -> NSMenuItem {
        let stypItem = NSMenuItem(title: NSLocalizedString("Add Outline Item", comment: ""), action: #selector(addOutLineItemAction), target: self)
        
        return stypItem
    }
    
    func setTTSStype() -> NSMenuItem {
        let stypItem = NSMenuItem(title: NSLocalizedString("TTS", comment: ""), action: #selector(showTTSView), target: self)
        
        return stypItem
    }
    func setShareStype() -> NSMenuItem {
        let stypItem = NSMenuItem(title: NSLocalizedString("Share", comment: ""), action: #selector(showShareAction), target: self)
        var string = ""
        if listView.activeAnnotation != nil {
            string = listView.activeAnnotation.contents
        }
        
        stypItem.submenu = NSSharingServicePicker.menu(forSharingItems: [string], subjectContext: "", withTarget: self, selector: #selector(shareFromService), serviceDelegate: nil)
        return stypItem
    }
    func setLookUpStype() -> NSMenuItem {
        let str = String(format: "Look Up %@", listView?.currentSelection?.string() ?? "")
        let stypItem = NSMenuItem(title: NSLocalizedString(str, comment: ""), action: #selector(lookUpAction), target: self)
        
        return stypItem
    }
    func setSearchBaiduStype() -> NSMenuItem {
        let stypItem = NSMenuItem(title: NSLocalizedString("Search with Baidu", comment: ""), action: #selector(searchBaiduAction), target: self)
        
        return stypItem
    }
    func setCutStype() -> NSMenuItem {
        let stypItem = NSMenuItem(title: NSLocalizedString("Cut", comment: ""), action: #selector(cutAction), target: self)
        
        return stypItem
    }
    func setDeleteStype() -> NSMenuItem {
        let stypItem = NSMenuItem(title: NSLocalizedString("Delete", comment: ""), action: #selector(deleteAction), target: self)
        
        return stypItem
    }
    func setColorsStype() -> NSMenuItem {
        let stypItem = NSMenuItem(title: NSLocalizedString("Colors...", comment: ""), action: #selector(ColorsItemAction), target: self)
        
        return stypItem
    }
    func setLinesStype() -> NSMenuItem {
        let stypItem = NSMenuItem(title: NSLocalizedString("Lines...", comment: ""), action: #selector(LinesItemAction), target: self)
        
        return stypItem
    }
    func setEditNoteStype() -> NSMenuItem {
        let stypItem = NSMenuItem(title: NSLocalizedString("Edit Note", comment: ""), action: #selector(EditNoteItemAction), target: self)
        
        return stypItem
    }
    func setRotateStype() -> NSMenuItem {
        let stypItem = NSMenuItem(title: NSLocalizedString("Rotate", comment: ""), action: nil, target: self)
        let stypeMenu = NSMenu()
        let item1 = stypeMenu.addItem(withTitle: NSLocalizedString("Rotate Left", comment: ""), action: #selector(rotateLeftAction), target: self, tag: 0)
        let item2 = stypeMenu.addItem(withTitle: NSLocalizedString("Rotate Right", comment: ""), action: #selector(rotateRightAction), target: self, tag: 1)
        stypItem.submenu = stypeMenu
        if self.toolbarController.toolbarType == .Annatiton {
            stypeMenu.item(at: 0)?.state = .on
        } else if self.toolbarController.toolbarType == .Move {
            stypeMenu.item(at: 1)?.state = .on
        }
        return stypItem
    }
    func setNextPageStype() -> NSMenuItem {
        let stypItem = NSMenuItem(title: NSLocalizedString("Next Page", comment: ""), action: #selector(NextPageAction), target: self)
        stypItem.isEnabled = false
        if listView.canGoToNextPage() {
            stypItem.isEnabled = true
        }
        return stypItem
    }
    
    func setPreviousPageStype() -> NSMenuItem {
        let stypItem = NSMenuItem(title: NSLocalizedString("Previous Page", comment: ""), action: #selector(PreviousPageAction), target: self)
        stypItem.isEnabled = false
        if listView.canGoToPreviousPage() {
            stypItem.isEnabled = true
        }
        return stypItem
    }
    
    func setTranslateStype() -> NSMenuItem {
        let str = String(format: "Translate %@", listView?.currentSelection?.string() ?? "")
        let stypItem = NSMenuItem(title: NSLocalizedString(str, comment: ""), action: #selector(TranslateItemAction), target: self)
        
        return stypItem
    }
    
    func setAutoScrollStype() -> NSMenuItem {
        let stypItem = NSMenuItem(title: NSLocalizedString("Auto Scroll", comment: ""), action: #selector(AutoScrollItemAction), target: self)
        stypItem.state = self.listView.isAutoFlow() ? .on : .off
        return stypItem
    }
    
    func setSnapshotStype() -> NSMenuItem {
        let stypItem = NSMenuItem(title: NSLocalizedString("Snapshot", comment: ""), action: nil, target: self)
        let stypeMenu = NSMenu()
        let item1 = stypeMenu.addItem(withTitle: NSLocalizedString("Auto", comment: ""), action: #selector(takeSnapshot), target: self, tag: 0)
        let item2 = stypeMenu.addItem(withTitle: NSLocalizedString("Select Area", comment: ""), action: #selector(takeSnapshotSelectContent), target: self, tag: 1)
        stypItem.submenu = stypeMenu
        //        if self.toolbarController.toolbarType == .Annatiton {
        //            stypeMenu.item(at: 0)?.state = .on
        //        } else if self.toolbarController.toolbarType == .Move {
        //            stypeMenu.item(at: 1)?.state = .on
        //        }
        return stypItem
    }
    
    func setServicesStype() -> NSMenuItem {
        let stypItem = NSMenuItem(title: NSLocalizedString("Services", comment: ""), action: nil, target: self)
        let stypeMenu = NSMenu()
        let item1 = stypeMenu.addItem(withTitle: NSLocalizedString("Add to Music as a Spoken Track", comment: ""), action: #selector(AddtoMusicasASpokenTrack), target: self, tag: 0)
        let item2 = stypeMenu.addItem(withTitle: NSLocalizedString("Convert Text to Simplified Chinese", comment: ""), action: #selector(ConvertTextToSimplifiedChinese), target: self, tag: 1)
        let item3 = stypeMenu.addItem(withTitle: NSLocalizedString("Convert Text to Traditional Chinese", comment: ""), action: #selector(ConvertTextToTraditionalChinese), target: self, tag: 2)
        let item4 = stypeMenu.addItem(withTitle: NSLocalizedString("Open", comment: ""), action: #selector(OpenItemAction), target: self, tag: 3)
        let item5 = stypeMenu.addItem(withTitle: NSLocalizedString("Search With Baidu", comment: ""), action: #selector(searchBaiduAction), target: self, tag: 4)
        let item6 = stypeMenu.addItem(withTitle: NSLocalizedString("Show in Finder", comment: ""), action: #selector(showInFinder), target: self, tag: 4)
        let item7 = stypeMenu.addItem(withTitle: NSLocalizedString("Show Info in Finder", comment: ""), action: #selector(showInfoInFinder), target: self, tag: 5)
        stypItem.submenu = stypeMenu
        //        if self.toolbarController.toolbarType == .Annatiton {
        //            stypeMenu.item(at: 0)?.state = .on
        //        } else if self.toolbarController.toolbarType == .Move {
        //            stypeMenu.item(at: 1)?.state = .on
        //        }
        return stypItem
    }
    func setCropStype() -> NSMenuItem {
        let stypItem = NSMenuItem(title: NSLocalizedString("Crop", comment: ""), action: nil, target: self)
        let stypeMenu = NSMenu()
        _ = stypeMenu.addItem(withTitle: NSLocalizedString("Crop All Pages", comment: ""), action: #selector(cropAllPageItem), target: self, tag: 0)
        _ = stypeMenu.addItem(withTitle: NSLocalizedString("Crop Current Page", comment: ""), action: #selector(cropCurrentPageItem), target: self, tag: 1)
        _ = stypeMenu.addItem(withTitle: NSLocalizedString("Auto Crop – Separate", comment: ""), action: #selector(autoCropAllItem), target: self, tag: 2)
        _ = stypeMenu.addItem(withTitle: NSLocalizedString("Auto Crop – Combined", comment: ""), action: #selector(smartAutoCropAllItem), target: self, tag: 3)
        //        if(NSIsEmptyRect(selectionRect)) {
        _ = stypeMenu.addItem(withTitle: NSLocalizedString("Select Area", comment: ""), action: #selector(selectToolModel), target: self, tag: 4)
        _ = stypeMenu.addItem(withTitle: NSLocalizedString("Crop Options...", comment: ""), action: #selector(customCropModel), target: self, tag: 5)
        //
        //        }
        
        stypItem.submenu = stypeMenu
        //        if self.toolbarController.toolbarType == .Annatiton {
        //            stypeMenu.item(at: 0)?.state = .on
        //        } else if self.toolbarController.toolbarType == .Move {
        //            stypeMenu.item(at: 1)?.state = .on
        //        } else if self.toolbarController.toolbarType == .Magnify {
        //            stypeMenu.item(at: 2)?.state = .on
        //        } else if self.toolbarController.toolbarType == .Select {
        //            stypeMenu.item(at: 3)?.state = .on
        //        } else if self.toolbarController.toolbarType == .SelectZoom {
        //            stypeMenu.item(at: 4)?.state = .on
        //        }
        return stypItem
    }
    
    func addHighlightLinksStype() -> NSMenuItem {
        let highlightLink = KMPreferenceManager.shared.highlightLinks
        var highlightLinkTitle = NSLocalizedString("Highlight Links", comment: "")
        if highlightLink {
            highlightLinkTitle = NSLocalizedString("Disable Highlight Links", comment: "")
        }
        let highlightLinksItem = NSMenuItem(title: highlightLinkTitle, action: #selector(highlightLinks), target: self)
        return highlightLinksItem
    }
    
    func addAnnotationForStyleMenu(_ item: NSMenuItem?) {
        if item == nil {
            return
        }
        
        let menu = NSMenu()
        item?.submenu = menu
 
        let height = NSMenuItem(title: NSLocalizedString("Highlight", comment: ""), action: #selector(menuItemAnnotationClick_add), target: self, tag: 0)
        let underline = NSMenuItem(title: NSLocalizedString("Underline", comment: ""), action: #selector(menuItemAnnotationClick_add), target: self, tag: 1)
        let strickout = NSMenuItem(title: NSLocalizedString("Strikethrough", comment: ""), action: #selector(menuItemAnnotationClick_add), target: self, tag: 2)
        let text = NSMenuItem(title: NSLocalizedString("Text", comment: ""), action: #selector(menuItemAnnotationClick_add), target: self, tag: 3)
        let note = NSMenuItem(title: NSLocalizedString("Note", comment: ""), action: #selector(menuItemAnnotationClick_add), target: self, tag: 4)
        let rectangle = NSMenuItem(title: NSLocalizedString("Rectangle", comment: ""), action: #selector(menuItemAnnotationClick_add), target: self, tag: 5)
        let oval = NSMenuItem(title: NSLocalizedString("Oval", comment: ""), action: #selector(menuItemAnnotationClick_add), target: self, tag: 6)
        let line = NSMenuItem(title: NSLocalizedString("Line", comment: ""), action: #selector(menuItemAnnotationClick_add), target: self, tag: 7)
        let link = NSMenuItem(title: NSLocalizedString("Add Link", comment: ""), action: #selector(menuItemAnnotationClick_add), target: self, tag: 8)
        let outline = NSMenuItem(title: NSLocalizedString("Add Outline", comment: ""), action: #selector(menuItemAnnotationClick_add), target: self, tag: 9)
        let aiTranslation = NSMenuItem(title: NSLocalizedString("AI Translation", comment: ""), action: #selector(aiTranslationAction), target: self)
        //        let tts = NSMenuItem(title: NSLocalizedString("TTS", comment: ""), action: #selector(menuItemAnnotationClick_add), target: self, tag: 10)!
        menu.insertItem(NSMenuItem.separator(), at: menu.items.count)
        if listView.currentSelection.selectionType() != .image {
            menu.insertItem(height, at: menu.items.count)
            menu.insertItem(underline, at: menu.items.count)
            menu.insertItem(strickout, at: menu.items.count)
            menu.insertItem(NSMenuItem.separator(), at: menu.items.count)
        }
        
        if self.isReadMode {
            
        } else {
            if listView.currentSelection.selectionType() != .image &&
                listView.currentSelection.selectionType() != .text {
                menu.insertItem(text, at: menu.items.count)
                menu.insertItem(note, at: menu.items.count)
            }
        }
        
        if self.isReadMode {
            
        } else {
            if listView.currentSelection.selectionType() != .image {
                menu.insertItem(NSMenuItem.separator(), at: menu.items.count)
                menu.insertItem(rectangle, at: menu.items.count)
                menu.insertItem(oval, at: menu.items.count)
            }
        }
        
        if self.isReadMode {
            
        } else {
            if listView.currentSelection.selectionType() != .image &&
                listView.currentSelection.selectionType() != .text {
                menu.insertItem(line, at: menu.items.count)
            }
        }
        menu.insertItem(NSMenuItem.separator(), at: menu.items.count)
        if self.isReadMode {
            
        } else {
            menu.insertItem(link, at: menu.items.count)
        }
        
        if self.isReadMode {
            
        } else {
            if listView.currentSelection.selectionType() != .image {
                menu.insertItem(outline, at: menu.items.count)
            }
        }
        menu.insertItem(NSMenuItem.separator(), at: menu.items.count)
        
        if self.isReadMode {
            
        } else {
            if (listView.currentSelection.selectionType() != .image) {
                menu.insertItem(aiTranslation, at: menu.items.count)
            }
        }
        menu.insertItem(NSMenuItem.separator(), at: menu.items.count)
    }
    
    func addBookmarkMenu() -> NSMenuItem {
        if self.listView.document.bookmark(forPageIndex: UInt(self.listView.currentPageIndex)) == nil {
            let bookMarkItem = NSMenuItem(title: NSLocalizedString("Add Bookmark", comment: ""), action: #selector(menuItemBookMarkClick_add), target: self)
            return bookMarkItem
        } else {
            let bookMarkItem = NSMenuItem(title: NSLocalizedString("Remove Bookmark", comment: ""), action: #selector(menuItemBookMarkClick_add), target: self)
            return bookMarkItem
        }
    }
    
    func findStringMenu() -> NSMenuItem {
        let menuItem = NSMenuItem(title: NSLocalizedString("Find", comment: ""), action: #selector(menuItemAnnotationClick_FindString), target: self)
        menuItem.keyEquivalent = "f"
        return menuItem
    }
    
    func printingMenu() -> NSMenuItem {
        let menuItem = NSMenuItem(title: NSLocalizedString("Print", comment: ""), action: #selector(menuItemAnnotationClick_Print), keyEquivalent: "p")
        return menuItem
    }
    
    func fontSizes()->NSArray {
        return ["6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "24", "36", "48", "72", "96", "144", "288"]
    }
    
    func handleRightMouseDown(theEvent: NSEvent) -> Bool {
        if interactionMode == .SKPresentationMode {
            listView.goToPreviousPage(nil)
            return true
        }
        return false
    }
    
    func canExitPresentation() -> Bool {
        var isExit = false
        if mwcFlags.isSwitchingFullScreen == 0 && self.interactionMode == .SKPresentationMode {
            isExit = true
        }
        return isExit
    }
    
    func canEnterFullscreen() -> Bool {
        if (mwcFlags.isSwitchingFullScreen != 0) {
            return false
        }
        if useNativeFullScreen() {
            return interactionMode == .SKNormalMode || interactionMode == .SKPresentationMode
        } else {
            return !self.listView.document.isLocked && (interactionMode == .SKNormalMode || interactionMode == .SKPresentationMode) && self.view.window?.tabbedWindows?.count ?? 0 < 2
        }
    }
    
    func canEnterPresentation() -> Bool {
        if (mwcFlags.isSwitchingFullScreen == 0 && !self.listView.document.isLocked && (interactionMode == .SKNormalMode || interactionMode == .SKFullScreenMode || interactionMode == .SKLegacyFullScreenMode) && self.view.window?.tabbedWindows?.count ?? 0 < 2){
            return true
        }
        return false
    }
    
    func useNativeFullScreen() -> Bool {
        var isFull = false
//        NSWindow.instancesRespond(toSelector: #selector(toggleFullScreen:))
        let sel = NSSelectorFromString("toggleFullscreen:")
        if NSWindow.instancesRespond(to: sel) && UserDefaults.standard.bool(forKey: "SKUseLegacyFullScreenKey"){
            isFull = true
        }
        return isFull
    }
    
    func enterPresentation() {
        let wasInteractionMode = self.interactionMode
        if self.canEnterPresentation() == false { return }
        if wasInteractionMode == .SKFullScreenMode {
            mwcFlags.wantsPresentation = 1
            self.view.window?.toggleFullScreen(nil)
            return
        }
        
        let backgroundColor = NSColor.black
        let level = UserDefaults.standard.bool(forKey: "SKUseNormalLevelForPresentationKey") ? NSWindow.Level.normal : NSWindow.Level.popUpMenu
        let page = self.listView.currentPage()
        
        if wasInteractionMode == .SKNormalMode {
            savedNormalSetup.setDictionary(self.currentPDFSettings() as! [AnyHashable : Any])
        }
        
        mwcFlags.isSwitchingFullScreen = 1
        
//        if findController.view().window() != nil {
//            findController.toggleAboveView(nil, animate: false)
//        }
        
        interactionMode = .SKPresentationMode
        
        if wasInteractionMode == .SKLegacyFullScreenMode {
            self.enterPresentationMode()
            
//            updatePresentationOptions(for: self.view.window!)
            
            pdfSplitView.frame = CGRect(x: 0, y: 0, width: CGRectGetWidth(centerContentView.bounds), height: CGRectGetHeight(centerContentView.bounds)-1)
            centerContentView.addSubview(pdfSplitView)
            listView.frame = (self.view.window?.contentView?.bounds)!
            self.view.window?.contentView?.addSubview(listView)
            
            self.view.window?.backgroundColor = backgroundColor
            self.view.window?.level = level
            listView.layoutDocumentView()
            listView.requiresDisplay()
            
            self.forceSubwindowsOnTop(false)
            
            self.hideLeftSideWindow()
            self.hideRightSideWindow()
            self.removeBlankingWindows()
        } else {
            self.fadeInFullScreenWindow(with: backgroundColor, level: level.rawValue)
            
            self.enterPresentationMode()
            
//            self.fadeInFullScreenView(listView, inset: 0.0)
        }
        
//        if _isShowToolbar {
//            self.toolbarViewController.hiddenToolbar(true)
//        }
//        
//        if self.pdfView().currentPage()?.isEqual(page) == false {
//            self.pdfView().go(to: page)
//        }
//        
//        mwcFlags.isSwitchingFullScreen = 0
//        
//        pdfView().setInteractionMode(SKPresentationMode)
    }
    
    func mainWindow() -> NSWindow? {
        return self.view.window
    }
    
    func fadeInFullScreenWindow(with backgroundColor: NSColor, level: Int) {
        let view: NSView = self.view.window!.firstResponder as! NSView
        if view.isDescendant(of: pdfSplitView){
            self.view.window?.makeFirstResponder(nil)
        }
//        let fullScreenWindow = SKFullScreenWindow(screen: mainWindow().screen, backgroundColor: backgroundColor, level: NSPopUpMenuWindowLevel, isMain: true)
        
        let fullScreenWindow = KMFullScreenWindow(screen: (mainWindow()?.screen ?? NSScreen.main)!, bgColor: backgroundColor, level: NSWindow.Level.popUpMenu.rawValue, isMain: true)
        
        mainWindow()?.delegate = nil
        fullScreenWindow.fadeInBlocking()
        let window = NSWindow.currentWindow()
        window.windowController?.window = fullScreenWindow
        fullScreenWindow.makeKey()
        
//        NSApp.updatePresentationOptions(for: fullScreenWindow)
        
        let sel = NSSelectorFromString("setAnimationBehavior:")
        if mainWindow()?.responds(to: sel) ?? false{
            mainWindow()?.animationBehavior = .none
        }
        mainWindow()?.orderOut(nil)
        if mainWindow()?.responds(to: sel) ?? false{
            mainWindow()?.animationBehavior = .default
        }
        fullScreenWindow.level = NSWindow.Level(rawValue: level)
        fullScreenWindow.orderFront(nil)
//        NSApp.addWindowsItem(fullScreenWindow, title: windowTitleForDocumentDisplayName(self.document?.displayName) ?? "", filename: false)
    }
    
    func removeBlankingWindows() {
//        blankingWindows.makeObjectsPerform(#selector(fadeOut))
//        blankingWindows = nil
    }
    
    func hideLeftSideWindow() {
//        if leftSideViewController.view.window == leftSideWindow {
//            self.leftView.remove()
//            if leftSideWindow.firstResponder()?.isDescendant(of: leftSideController.view()) {
//                leftSideWindow.makeFirstResponder(nil)
//            }
//            leftSideController.view().setFrame(SKShrinkRect(NSInsetRect(leftSideContentView.bounds, -1.0, -1.0), 1.0, .maxYEdge))
//            leftSideContentView.addSubview(leftSideController.view())
//            
//            if self.interactionMode() == SKPresentationMode {
//                self.setLeftSidePaneState(mwcFlags.savedLeftSidePaneState)
//            }
//            
//            leftSideWindow = nil
//        }
    }
    
    func hideRightSideWindow() {
//        if rightSideController.view().window() == rightSideWindow {
//            rightSideWindow.remove()
//            if rightSideWindow.firstResponder()?.isDescendant(of: rightSideController.view()) {
//                rightSideWindow.makeFirstResponder(nil)
//            }
//            rightSideController.view().setFrame(SKShrinkRect(NSInsetRect(rightSideContentView.bounds, -1.0, -1.0), 1.0, .maxYEdge))
//            rightSideContentView.addSubview(rightSideController.view())
//            
//            rightSideWindow = nil
//        }
    }
    
    func forceSubwindowsOnTop(_ flag: Bool) {
//        let winC: NSWindowController = self.kmCurrentWindowC!
//        for wc in winC.document!.windowControllers {
//            let sel = NSSelectorFromString("setForceOnTop:")
//            if wc.responds(to: sel){
//                wc.
//            }
//        }
    }
    
    func enterPresentationMode() {
        let scrollView = listView.documentView().enclosingScrollView
        savedNormalSetup.setValue(scrollView?.hasHorizontalScroller, forKey: HASHORIZONTALSCROLLER_KEY)
        savedNormalSetup.setValue(scrollView?.hasVerticalScroller, forKey: HASVERTICALSCROLLER_KEY)
        savedNormalSetup.setValue(scrollView?.autohidesScrollers, forKey: AUTOHIDESSCROLLERS_KEY)
        // Set up presentation mode
//        if RUNNING(version: 10_12) {
//            pdfView.setBackgroundColor(NSColor.black)
//        } else {
            listView.backgroundColor = NSColor.clear
//        }
        listView.autoScales = true
//        listView.setDisplayMode(kPDFDisplaySinglePage)
        listView.setDisplay(.singlePage)
//        listView.setDisplayBox(kPDFDisplayBoxCropBox)
        listView.displayBox = .cropBox
//        listView.setDisplaysPageBreaks(false)
        listView.displaysPageBreaks = false
//        scrollView.setAutohidesScrollers(true)
        scrollView?.autohidesScrollers = true
//        scrollView.setHasHorizontalScroller(false)
        scrollView?.hasHorizontalScroller = false
//        scrollView.setHasVerticalScroller(false)
        scrollView?.hasVerticalScroller = false
        
        listView.setCurrentSelection(nil, animate: true)
//        if listView.hasReadingBar() {
//            listView.toggleReadingBar()
//        }
        
//        myDocument!.currentPage(presentationNotesDocument.pdfDocument().page(at: listView.currentPage().pageIndex()))
        
        // Prevent sleep
//        if activityAssertionID == kIOPMNullAssertionID && kIOReturnSuccess != IOPMAssertionCreateWithName(kIOPMAssertionTypeNoDisplaySleep, kIOPMAssertionLevelOn, "Skim" as CFString, &activityAssertionID) {
//            activityAssertionID = kIOPMNullAssertionID
//        }
    }
    
    func currentPDFSettings() -> NSDictionary {
        var setup = NSMutableDictionary()
        setup[DISPLAYSPAGEBREAKS_KEY] = NSNumber(value: listView.displaysPageBreaks)
        setup[DISPLAYSASBOOK_KEY] = NSNumber(value: listView.displaysAsBook)
        setup[DISPLAYBOX_KEY] = NSNumber(value: listView.displayBox.rawValue)
        setup[SCALEFACTOR_KEY] = NSNumber(value: listView.scaleFactor)
        setup[AUTOSCALES_KEY] = NSNumber(value: listView.autoScales)
        setup[DISPLAYMODE_KEY] = NSNumber(value: listView.displayMode.rawValue)
        
        return setup
    }
    
    //MARK: menuItem Action
    
    @objc func menuItemEditingClick_FontColor(sender: NSMenuItem) {
        let color = listView.editingSelectionFontColor()
        let panel = NSColorPanel.shared
        panel.setTarget(self)
        panel.setAction(#selector(fontColorChangeAction))
        panel.orderFront(nil)
        panel.showsAlpha = false
        panel.color = color ?? NSColor.black
    }
    
    @objc func fontColorChangeAction(sender: NSColorPanel) {
        self.listView.setEditingSelectionFontColor(sender.color)
    }
    
    @objc func menuItemEditingClick_FontSize(sender: NSMenuItem) {
        let fontSize = self.fontSizes().object(at: sender.tag)
        self.listView.setEditingSelectionFontSize(CGFloat(Int(fontSize as! String)!))
    }
    
    @objc func addImageText(sender: NSMenuItem) {
        let event = NSApp.currentEvent
        let clickLocation = event?.locationInWindow
        var point = self.listView.convert(clickLocation!, from: NSApp.mainWindow?.contentView)
        var point2 = self.listView.convert(point, to: self.listView.currentPage())
        point2 = CGPoint(x: self.listView.bounds.width - point2.x, y: self.listView.bounds.height - point2.y)
        point = point2
        if sender.tag == 0 {
            KMPrint("添加文字")
            let isSelect = self.toolbarController.findItem(KMToolbarAddTextEditPDFItemIdentifier)?.isSelected ?? false
            if !isSelect {
                self.toolbarController.selectItem(KMToolbarAddTextEditPDFItemIdentifier)
            }
            
//            self.pdfViewEditingAddTextArea(self.listView, add: CGRectMake(point.x, point.y, 0, 0))
        } else if sender.tag == 1 {
            KMPrint("添加图片")
            let isSelect = self.toolbarController.findItem(KMToolbarAddImageEditPDFItemIdentifier)?.isSelected ?? false
            if !isSelect {
                self.toolbarController.selectItem(KMToolbarAddImageEditPDFItemIdentifier)
            }
//            self.pdfViewEditingAddImageArea(self.listView, add: CGRectMake(point.x, point.y, 0, 0))
        } else if sender.tag == 2 {
            KMPrint("粘贴")
        }
    }
    
    @objc func menuItemEditingClick_CropImage(sender: NSMenuItem) {
        if self.rightSideViewController.eidtPDFImageProperty != nil {
            self.rightSideViewController.eidtPDFImageProperty.confirmVCImageAction((Any).self)
        } else {
            if self.listView.cropAreas != nil && self.listView.selectImageAreas != nil{
                self.listView.cropEditImageArea(self.listView.selectImageAreas, withBounds: self.listView.cropAreas.cropRect)
            }
        }
    }
    
    @objc func menuItemEditingClick_CancelCrop(sender: NSMenuItem) {
        if self.rightSideViewController.eidtPDFImageProperty != nil {
            self.rightSideViewController.eidtPDFImageProperty?.cancelCutImageAction("")
        } else {
            self.listView.exitCrop(with: self.listView.selectImageAreas)
            self.listView.cropAreas = nil
            self.listView.isEditImage = false
        }
    }
    
    @objc func menuItemEditingClick_RestoreCrop(sender: NSMenuItem) {
        if self.rightSideViewController.eidtPDFImageProperty != nil {
            self.rightSideViewController.eidtPDFImageProperty?.restoreCutImageAction("")
        } else {
            self.listView.resetCrop(with: self.listView.selectImageAreas)
        }
    }
    
    @objc func menuItemEditingClick_CutImage(sender: NSMenuItem) {
        if self.listView.selectImageAreas != nil {
            self.listView.isEditImage = true
            self.listView.enterCrop(with: self.listView.selectImageAreas)
            self.rightSideViewController.eidtPDFImageProperty.updateButtonState(hidden: false)
        }
    }
    
    @objc func menuItemEditingClick_ReplaceImage(sender: NSMenuItem) {
        if self.listView.selectImageAreas == nil {
            return
        }
        let panel = NSOpenPanel()
        panel.allowsMultipleSelection = false
        panel.allowedFileTypes = ["png","jpg"]
        panel.beginSheetModal(for: NSApp.mainWindow!) { response in
            if response == .OK {
                let openPath = panel.url?.path
                let s = self.listView.replace(self.listView.selectImageAreas, imagePath: openPath!)
                if s {
                    
                }
            }
        }
    }
    
    @objc func menuItemEditingClick_ExportImage(sender: NSMenuItem) {
        if self.listView.selectImageAreas == nil {
            return
        }
        let panel = NSSavePanel()
//        panel.nameFieldStringValue = "[新文件].png"
        panel.nameFieldStringValue = "\(NSLocalizedString("Untitled", comment: "")).jpg"
//        let button = NSButton.init(checkboxWithTitle: "保存后打开文档", target: nil, action: nil)
//        button.state = .on
//        panel.accessoryView = button
        panel.isExtensionHidden = true
        let response = panel.runModal()
        if response == .OK {
            let url = panel.url
            if FileManager.default.fileExists(atPath: url!.path) {
                try?FileManager.default.removeItem(atPath: url!.path)
            }
            let result = self.listView.extractImage(with: self.listView.selectImageAreas, toImagePath: url!.path)
            if result {
                NSWorkspace.shared.activateFileViewerSelecting([url!])
//                if button.state == .on { /// 开启文档
//                    NSWorkspace.shared.openFile(url!.path)
//                } else {
//
//                }
            }
        }
    }
    
    @objc func AddtoMusicasASpokenTrack(sender: NSMenuItem) {
        
    }
    @objc func ConvertTextToSimplifiedChinese(sender: NSMenuItem) {
        
    }
    @objc func ConvertTextToTraditionalChinese(sender: NSMenuItem) {
        
    }
    @objc func OpenItemAction(sender: NSMenuItem) {
        
    }
    
    @objc func cropAllPageItem(sender: NSMenuItem) {
        self.cropAll(nil)
    }
    @objc func cropCurrentPageItem(sender: NSMenuItem) {
        self.crop(nil)
    }
    @objc func autoCropAllItem(sender: NSMenuItem) {
        self.autoCropAll(nil)
    }
    @objc func smartAutoCropAllItem(sender: NSMenuItem) {
        self.smartAutoCropAll(nil)
    }
    @objc func customCropModel(sender: NSMenuItem) {
        let pdfDoc: CPDFDocument = self.listView.document
        if !pdfDoc.allowsCopying || !pdfDoc.allowsPrinting {
            let alert = NSAlert()
            alert.alertStyle = .critical
            alert.messageText = NSLocalizedString("This is a secured document. Editing is not permitted.", comment: "")
            alert.runModal()
            return
        }
        let window = NSWindow.currentWindow()
        let currentPage = pdfDoc.index(for: self.listView.currentPage())
        let cropVC = KMPDFCropWindowController(document: pdfDoc, pwd: "", currentPage: Int(currentPage), cropSize: CGRectMake(100, 100, 50, 80), selectPageString: "\(currentPage)")
        window.km_beginSheet(windowC: cropVC)
        cropVC.cropWindowCloseBlock = { [weak self] doc in
            window.km_quick_endSheet()
            let isSuccessful = doc.write(to: self?.listView.document.documentURL)
            if isSuccessful {
                if let documen = CPDFDocument(url: self?.document?.documentURL) {
                    if documen.isLocked {
                        documen.unlock(withPassword: pdfDoc.password)
                    }
                    self?.document = documen
                    self?.listView.document = self?.document
                    self?.listView.layoutDocumentView()
                }
            }
        }
    }
    @objc func rotateRightAction(sender: NSMenuItem) {
        
    }
    @objc func rotateLeftAction(sender: NSMenuItem) {
        
    }
    @objc func menuItemAnnotationClick_toolModel(sender: NSMenuItem) {
        self.listView.toolMode = .noteToolMode
        var identifier = KMDocumentAnnotationToolbarItemIdentifier
        var model : KMToolbarViewType = .None
        switch sender.tag {
        case 0:
            identifier = KMDocumentAnnotationToolbarItemIdentifier
            model = .Annatiton
        case 1:
            identifier = KMToolbarMoveToolModeItemIdentifier
            model = .Move
        case 2:
            identifier = KMToolbarMagnifyToolModeItemIdentifier
            model = .Magnify
        case 3:
            identifier = KMToolbarSelectToolModeItemIdentifier
            model = .Select
        case 4:
            identifier = KMToolbarZoomToSelectionItemIdentifier
            model = .SelectZoom
        default:
            break
        }
        let item : KMToolbarItemView = (self.toolbarController.mainToolBarView?.toolbarItemFindItemIdentifiers(value: identifier))!
        self.toolbarController.mainToolBarView?.delegate?.toolbarViewController?(self.toolbarController.mainToolBarView!, clickMode:model, toolbar: item, [])
    }
    
    @objc func changeAnnotationMode_itemAction(sender : NSMenuItem) {
        var itemId: String?
        if sender.tag == CAnnotationType.highlight.rawValue {
            itemId = KMToolbarHighlightAnnotationItemIdentifier
        } else if sender.tag == CAnnotationType.underline.rawValue {
            itemId = KMToolbarUnderlineAnnotationItemIdentifier
        } else if sender.tag == CAnnotationType.strikeOut.rawValue {
            itemId = KMToolbarStrikeOutAnnotationItemIdentifier
        } else if sender.tag == CAnnotationType.ink.rawValue {
            itemId = KMToolbarInkAnnotationItemIdentifier
        } else if sender.tag == CAnnotationType.freeText.rawValue {
            itemId = KMToolbarFreeTextAnnotationItemIdentifier
        } else if sender.tag == CAnnotationType.anchored.rawValue {
            itemId = KMToolbarAnchoredAnnotationItemIdentifier
        } else if sender.tag == CAnnotationType.square.rawValue {
            itemId = KMToolbarSquareAnnotationItemIdentifier
        } else if sender.tag == CAnnotationType.circle.rawValue {
            itemId = KMToolbarCircleAnnotationItemIdentifier
        } else if sender.tag == CAnnotationType.arrow.rawValue {
            itemId = KMToolbarArrowAnnotationItemIdentifier
        } else if sender.tag == CAnnotationType.line.rawValue {
            itemId = KMToolbarLineAnnotationItemIdentifier
        } else if sender.tag == CAnnotationType.link.rawValue {
            itemId = KMToolbarLinkAnnotationItemIdentifier
        }
        if let data = itemId {
            self.toolbarController.clickItem(data)
        }
    }
    
    @objc func menuItemAnnotationClick_add(sender : NSMenuItem) {
        var annotationType : CAnnotationType = .unkown
        switch sender.tag {
        case 0:
            annotationType = .highlight
        case 1:
            annotationType = .underline
        case 2:
            annotationType = .strikeOut
        case 3:
            annotationType = .freeText
        case 4:
            annotationType = .anchored
        case 5:
            annotationType = .square
        case 6:
            annotationType = .circle
        case 7:
            annotationType = .line
        case 8:
            annotationType = .link
        case 9:
//            var newOutline : CPDFOutline = CPDFOutline()
//            newOutline.label = "11111111"
//            let des = self.listView.currentDestination
//            if "\(des?.point.x ?? 0)" != "nan" {
//                newOutline.destination = self.listView.currentDestination
//            } else {
//                let destination : CPDFDestination = CPDFDestination(document: self.listView.document, pageIndex: self.listView.currentPageIndex, at: CGPoint(x: 0, y: 0), zoom: self.listView.scaleFactor)
//                newOutline.destination = destination
//            }
//            let current = self.listView.document.outlineRoot().insertChild(at: 0) ?? CPDFOutline()
//            let parent = current.parent ?? CPDFOutline()
//            let index = current.index + 1
//            parent.insertChild(newOutline, at: index)
            if self.leftPanelOpen == false || self.leftSideViewController.type.methodType != .Outline {
                self.leftSideViewController.refreshMethodType(methodType: .Outline)
            }
//            self.leftSideViewController.outlineViewController.addItemAction()
            return
        case 10:
            annotationType = .unkown
        default:
            break
        }
        
        if (annotationType != .link) {
            self.listView.addAnnotation(with: annotationType, selection: self.listView.currentSelection, page: self.listView.currentSelection.page, bounds: self.listView.currentSelection.bounds)
            self.listView.currentSelection = nil;
            return
        }

        // link
        let selection = self.listView.currentSelection
        self.toolbarController.selectItem(KMToolbarLinkAnnotationItemIdentifier)
        DispatchQueue.main.async {
            Task { @MainActor in
                #if VERSION_DMG
                if await (KMLightMemberManager.manager.canUseAdvanced() == false) {
                    return
                }
                #endif
                let annotation = self.listView.addAnnotation(with: annotationType, selection: selection, page: selection?.page, bounds: selection!.bounds)
                self.listView.currentSelection = nil;
                if (annotation != nil) {
                    self.listView.updateActiveAnnotations([annotation!])
                }
            }
        }
    }
    
    @objc func aiTranslationAction(sender: NSMenuItem) {
        let content = self.listView.currentSelection.string() ?? ""
        let origin = self.listView.currentSelection.bounds.origin
        
        self.aiTranslationWindow = KMAITranslationWindowController.init(windowNibName: "KMAITranslationWindowController")
        self.aiTranslationWindow?.content = content
        
        self.view.window!.addChildWindow(self.aiTranslationWindow!.window!, ordered: NSWindow.OrderingMode.above)
        self.aiTranslationWindow!.window?.center()

    }
    
    @objc func menuItemAnnotationClick_addStype(sender: NSMenuItem) {
        Task { @MainActor in
            #if VERSION_DMG
            if (sender.tag == 7 || sender.tag == 8 || sender.tag == 9) {
                if await (KMLightMemberManager.manager.canUseAdvanced() == false) {
                    let _ = KMComparativeTableViewController.show(window: self.view.window!)
                    return
                }
            }
            #endif

            var point = mouseRightMenuEvent?.locationInWindow
            if (point == nil) {
                point = NSZeroPoint
            }
            
            let currentPoint: NSPoint = self.listView.convert(point!, from: self.listView.superview)
            let currentPage = self.listView.page(for: currentPoint, nearest: true)
            var pagePoint = self.listView.convert(currentPoint, to: currentPage)
            
            var annotation: CPDFAnnotation?
            
            if self.isReadMode {
                if (sender.tag == 0 || sender.tag == 7 || sender.tag == 8 || sender.tag == 9) { // Ink & Link & stamp & sign
                    self.listView.toolMode = .noteToolMode
                }
                switch sender.tag {
                case 0:
                    self.listView.annotationType = CAnnotationType.ink
                case 1:
//                    self.listView.annotationType = CAnnotationType.freeText
                    let defaultSize = self.listView.defaultSize(with: .freeText, in: currentPage)
                    let bounds = CPDFListViewRectFromCenterAndSize(CPDFListViewIntegralPoint(pagePoint), defaultSize)
                    annotation = self.listView.addAnnotation(with: .freeText, selection: nil, page: currentPage, bounds: bounds)
                    if ((annotation) != nil) {
                        self.listView.updateActiveAnnotations([annotation!])
                        self.listView.edit(annotation)
                    }
                case 2:
//                    self.listView.annotationType = CAnnotationType.anchored
                    let defaultSize = self.listView.defaultSize(with: .anchored, in: currentPage)
                    let bounds = CPDFListViewRectFromCenterAndSize(CPDFListViewIntegralPoint(pagePoint), defaultSize)
                    annotation = self.listView.addAnnotation(with: .anchored, selection: nil, page: currentPage, bounds: bounds)
                    self.listView.edit(annotation)
                case 3:
//                    self.listView.annotationType = CAnnotationType.square
                    let defaultSize = self.listView.defaultSize(with: .square, in: currentPage)
                    let bounds = CPDFListViewRectFromCenterAndSize(CPDFListViewIntegralPoint(pagePoint), defaultSize)
                    annotation = self.listView.addAnnotation(with: .square, selection: nil, page: currentPage, bounds: bounds)
                case 4:
//                    self.listView.annotationType = CAnnotationType.circle
                    let defaultSize = self.listView.defaultSize(with: .circle, in: currentPage)
                    let bounds = CPDFListViewRectFromCenterAndSize(CPDFListViewIntegralPoint(pagePoint), defaultSize)
                    annotation = self.listView.addAnnotation(with: .circle, selection: nil, page: currentPage, bounds: bounds)
                case 5:
//                    self.listView.annotationType = CAnnotationType.arrow
                    let defaultSize = self.listView.defaultSize(with: .arrow, in: currentPage)
                    let bounds = CPDFListViewRectFromCenterAndSize(CPDFListViewIntegralPoint(pagePoint), defaultSize)
                    annotation = self.listView.addAnnotation(with: .arrow, selection: nil, page: currentPage, bounds: bounds)
                case 6:
//                    self.listView.annotationType = CAnnotationType.line
                    let defaultSize = self.listView.defaultSize(with: .line, in: currentPage)
                    let bounds = CPDFListViewRectFromCenterAndSize(CPDFListViewIntegralPoint(pagePoint), defaultSize)
                    annotation = self.listView.addAnnotation(with: .line, selection: nil, page: currentPage, bounds: bounds)
                case 7:
                    self.listView.annotationType = CAnnotationType.link
                    self.openRightPane()
                case 8:
                    self.listView.annotationType = CAnnotationType.stamp
                    self.openRightPane()
                case 9:
                    self.listView.annotationType = CAnnotationType.signSignature
                    self.openRightPane()
                default:
                    break
                }
                
                self.rightSideViewController.isHidden = true
                self.rightSideViewController.subViewType = .AnnotationProperts
            } else {
                if (sender.tag == 7 || sender.tag == 8 || sender.tag == 9) { // Ink & Link & stamp & sign
                    if(self.toolbarController.toolbarType == .None) {
                        self.toolbarController.toolbarType = .Annatiton
                    }
                    self.listView.toolMode = .noteToolMode
                }
                switch sender.tag {
                case 0:
                    self.toolbarController.ignoreCurrentAnnotationTypeChange = true
                    self.rightMouseEventing = true
                    if(self.toolbarController.toolbarType == .None) {
                        self.toolbarController.toolbarType = .Annatiton
                    }
                    self.listView.toolMode = .noteToolMode

                    self.listView.annotationType = CAnnotationType.ink
                case 1:
//                    self.listView.annotationType = CAnnotationType.freeText
                    let defaultSize = self.listView.defaultSize(with: .freeText, in: currentPage)
                    if (pagePoint.x - defaultSize.width > 0){
                        pagePoint.x -= defaultSize.width;
                    }else{
                        pagePoint.x = 0;
                    }
                    let bounds = CPDFListViewRectFromCenterAndSize(CPDFListViewIntegralPoint(pagePoint), defaultSize)
                    annotation = self.listView.addAnnotation(with: .freeText, selection: nil, page: currentPage, bounds: bounds)
//                    self.view.window?.makeFirstResponder()
                    if ((annotation) != nil) {
//                        self.listView.updateActiveAnnotations([annotation!])
                        self.listView.edit(annotation)
                    }
                case 2:
//                    self.listView.annotationType = CAnnotationType.anchored
                    let defaultSize = self.listView.defaultSize(with: .anchored, in: currentPage)
                    let bounds = CPDFListViewRectFromCenterAndSize(CPDFListViewIntegralPoint(pagePoint), defaultSize)
                    annotation = self.listView.addAnnotation(with: .anchored, selection: nil, page: currentPage, bounds: bounds)
                    self.listView.edit(annotation)
                case 3:
//                    self.listView.annotationType = CAnnotationType.square
                    let defaultSize = self.listView.defaultSize(with: .square, in: currentPage)
                    if (pagePoint.x - defaultSize.width > 0){
                        pagePoint.x -= defaultSize.width;
                    }else{
                        pagePoint.x = 0;
                    }
                    let bounds = CPDFListViewRectFromCenterAndSize(CPDFListViewIntegralPoint(pagePoint), defaultSize)
                    annotation = self.listView.addAnnotation(with: .square, selection: nil, page: currentPage, bounds: bounds)
                case 4:
//                    self.listView.annotationType = CAnnotationType.circle
                    let defaultSize = self.listView.defaultSize(with: .circle, in: currentPage)
                    let bounds = CPDFListViewRectFromCenterAndSize(CPDFListViewIntegralPoint(pagePoint), defaultSize)
                    annotation = self.listView.addAnnotation(with: .circle, selection: nil, page: currentPage, bounds: bounds)
                case 5:
//                    self.listView.annotationType = CAnnotationType.arrow
                    let defaultSize = self.listView.defaultSize(with: .arrow, in: currentPage)
                    let bounds = CPDFListViewRectFromCenterAndSize(CPDFListViewIntegralPoint(pagePoint), defaultSize)
                    annotation = self.listView.addAnnotation(with: .arrow, selection: nil, page: currentPage, bounds: bounds)
                case 6:
//                    self.listView.annotationType = CAnnotationType.line
                    let defaultSize = self.listView.defaultSize(with: .line, in: currentPage)
                    let bounds = CPDFListViewRectFromCenterAndSize(CPDFListViewIntegralPoint(pagePoint), defaultSize)
                    annotation = self.listView.addAnnotation(with: .line, selection: nil, page: currentPage, bounds: bounds)
                case 7:
                    self.listView.annotationType = CAnnotationType.link
                    self.openRightPane()
                case 8:
                    self.listView.annotationType = CAnnotationType.stamp
                    self.openRightPane()
                case 9:
                    self.listView.annotationType = CAnnotationType.signSignature
                    self.openRightPane()
                case 10:
                    self.addImgAnnotationToView(center: pagePoint)
                default:
                    break
                }
                
                //        self.rightSideViewController.view.isHidden = false
                self.rightSideViewController.isHidden = false
                //        self.openRightPane()
                self.rightSideViewController.subViewType = .AnnotationProperts
            }
            
            if (annotation != nil) {
                self.listView.updateIsRightActiveAnnotations([annotation!])
            }
        }
    }
    
    func addImgAnnotationToView(center: NSPoint) {
        let accessoryCtr = KMImageAccessoryController()
        let openPanel = NSOpenPanel()
        openPanel.allowedFileTypes = KMImageAccessoryController.supportedImageTypes()
        openPanel.allowsMultipleSelection = false
        openPanel.accessoryView = accessoryCtr.view
        openPanel.isAccessoryViewDisclosed = true
        openPanel.beginSheetModal(for: self.view.window!) { result in
            if result == .OK {
                let fileURL = openPanel.urls.first
                let filePath = fileURL!.path
                if filePath.pathExtension == "pdf" {
                    let pdf = CPDFDocument(url: fileURL)
                    if pdf!.isEncrypted {
                        NSSound.beep()
                        return
                    }
                }

                let img = NSImage(contentsOfFile: filePath)
                let isRemoveBGColor = accessoryCtr.selectedButton.state == .on
                self.listView.addImageAnnotation(img, center: center, isRemoveBGColor: isRemoveBGColor)
            }
        }
    }
    
    @objc func menuItemBookMarkClick_add(sender:NSMenuItem) {
        if self.listView.document.bookmark(forPageIndex: UInt(self.listView.currentPageIndex)) == nil {
            let index = self.listView.currentPageIndex
            self.listView.document.addBookmark("\(NSLocalizedString("Page", comment: "")) \(index+1)", forPageIndex: UInt(index))
            self.listView.setNeedsDisplayForVisiblePages()
        } else {
            self.listView.document.removeBookmark(forPageIndex: UInt(self.listView.currentPageIndex))
            self.listView.setNeedsDisplayForVisiblePages()
        }
        
        if self.isReadMode {
            
        } else {
            if self.leftPanelOpen == false || self.leftSideViewController.type.methodType != .BookMark {
                self.leftSideViewController.refreshMethodType(methodType: .BookMark)
            }
            let bookMark = self.listView.document.bookmark(forPageIndex: UInt(self.listView.currentPageIndex))
            if bookMark != nil {
                let item = KMBookMarkItem()
                item.bookMark = bookMark!
                item.label = (bookMark?.label)!
                item.index = UInt(bookMark!.pageIndex)
//                self.leftSideViewController.bookViewController.reloadData()
//                self.leftSideViewController.bookViewController.addBookMarkAndEdit(newBookMark: item)
            } else {
//                self.leftSideViewController.bookViewController.reloadData()
            }
        }
    }
    
    @objc func menuItemAnnotationClick_FindString(sender:NSMenuItem) {
        self.leftSideViewController.refreshMethodType(methodType: .Search)
    }
    
    @objc func menuItemAnnotationClick_Print(sender:NSMenuItem) {
        let rect = listView.currentSelectionRect()
        let page = listView.currentPage()
        let copyPage : CPDFPage = page!.copy() as! CPDFPage
        copyPage.setBounds(rect, for: .cropBox)
        let image : NSImage = copyPage.thumbnail(of:(copyPage.bounds(for: .cropBox)).size)
//        let pdfDocument : PDFDocument = PDFDocument()
//        let newpage : PDFPage = PDFPage(image: image)!
//        pdfDocument.insert(newpage, at: 0)
        
        // 执行右键操作后，需要取消框选区域
        if self.listView.toolMode == .selectToolMode {
            objc_sync_enter(self)
            self.listView.selectionRect = NSZeroRect
            self.listView.selectionPageIndex = UInt(NSNotFound)
            objc_sync_exit(self)
        }
        
        if (self.listView.document != nil && !self.listView.document.allowsPrinting) { // 有打印限制
            KMPasswordInputWindow.openWindow(window: self.view.window!, type: .owner,  url: self.listView.document.documentURL) { [weak self] result ,password in
                if (result == .cancel) {
                    return
                }
                // 解除权限
                self?.isSaveKeyChain = false
                self?.listView.document.unlock(withPassword: password)
                // 隐藏提示
                self?.hiddenSecureLimitTip()
                // 去打印
                KMPrintWindowController.printImage(image: image)
            }
            return
        }
        
        KMPrintWindowController.printImage(image: image)
    }
    
    func splitView(withTag tag: Int) {
        if tag == 0 {
            self.listView.viewSplitMode = KMPDFViewSplitMode.horizontal
            self.singlePageScreen(isSinglePage: false, doublePagesScreen: false)
        } else if tag == 1 {
            self.listView.viewSplitMode = KMPDFViewSplitMode.vertical
            self.singlePageScreen(isSinglePage: false, doublePagesScreen: true)
        } else if tag == 2 {
            self.listView.viewSplitMode = KMPDFViewSplitMode.disable
            self.singlePageScreen(isSinglePage: true, doublePagesScreen: false)
        }
        self.listView.needsDisplay = true
    }
    
    // MARK: Redact 【密文标记】
    @objc func redact_menuItemClick_delete(sender: NSMenuItem?) {
        self.listView.remove(self.listView.activeAnnotation)
    }
    
    @objc func redact_menuItemClick_setProperty(sender: NSMenuItem?) {
        let windowController = KMRedactPropertyWindowController(windowNibName: "KMRedactBaseWindowController")
        windowController.annotation = (self.listView.activeAnnotation as! CPDFRedactAnnotation)
        self.view.window?.beginSheet(windowController.window!)
        self.currentWindowController = windowController
        windowController.itemClick = { [weak self] index, value in
            if (index == 1) { /// 取消
                self?.view.window?.endSheet((self?.currentWindowController.window)!)
                self?.currentWindowController = nil
                return
            }
            
            let windowController_redact = self?.currentWindowController as! KMRedactPropertyWindowController
            let annotaton: CPDFRedactAnnotation = self?.listView.activeAnnotation as! CPDFRedactAnnotation
            annotaton.setBorderColor(windowController_redact.outsideColor)
            annotaton.setInteriorColor(windowController_redact.fillColor)
            if (windowController_redact.isOver) {
                annotaton.setFontColor(windowController_redact.fontColor)
                annotaton.setAlignment(windowController_redact.aligement)
                annotaton.setFont(windowController_redact.font)
                annotaton.setOverlayText(windowController_redact.overText)
            }
            
            self?.view.window?.endSheet((self?.currentWindowController.window)!)
            self?.currentWindowController = nil
        }
    }
    
    @objc func redact_menuItemClick_setCurrentPropertyToDefaultValue(sender: NSMenuItem?) {
        if (self.listView.activeAnnotation == nil || (self.listView.activeAnnotation.isKind(of: CPDFRedactAnnotation.self)) == false) {
            return
        }
        
        let annotation: CPDFRedactAnnotation = self.listView.activeAnnotation as! CPDFRedactAnnotation
        let model = CPDFAnnotationModel(annotationType: .redact)
        model?.setColor(annotation.borderColor())
        model?.setInteriorColor(annotation.interiorColor())
        let overlayText: String = annotation.overlayText()
        if (overlayText.isEmpty) {
            model?.setIsOverlayText(false)
        } else {
            model?.setIsOverlayText(true)
            model?.setOverlayText(overlayText)
            model?.setFontColor(annotation.fontColor())
            model?.setAlignment(annotation.alignment())
            model?.setFontName(annotation.font().fontName)
            model?.setFontSize(annotation.font().pointSize)
        }
    }
    
    @objc func redact_menuItemClick_MultiPageFlag(sender: NSMenuItem?) {
        let anno = self.listView.activeAnnotation
        if (anno == nil || (anno?.isKind(of: CPDFRedactAnnotation.self)) == false) {
            return
        }
        
        let windowController = KMRedactMutilPageFlagWindowController(windowNibName: "KMRedactBaseWindowController")
        windowController.pageCount = Int(self.listView.document.pageCount)
        self.currentWindowController = windowController
        self.view.window?.beginSheet(windowController.window!)
        windowController.itemClick = { [weak self] index, value in
            if (index == 1) {
                self!.view.window?.endSheet(self!.currentWindowController.window!)
                self!.currentWindowController = nil
                return
            }
            
            let windowController_mutilPageFlag = self?.currentWindowController as! KMRedactMutilPageFlagWindowController
            let pageType = windowController_mutilPageFlag.pageType
            let pageString = windowController_mutilPageFlag.pageString
            if (pageType == 4) { /// 自定义页面
                let array = KMPageRangeTools.findSelectPage(pageRangeString: pageString, pageCount: Int((self?.listView.document.pageCount)!))
                if (array.count == 0) {
                    let alert = NSAlert()
                    alert.messageText = NSLocalizedString("Invalid page range or the page number is out of range. Please try again.", comment: "")
                    alert.runModal()
                    return
                }
            }
            
            self!.view.window?.endSheet(self!.currentWindowController.window!)
            self!.currentWindowController = nil
            
            let indexs = KMRedactTools.getPageIndexs(pageType, string: pageString, Int((self?.listView.document.pageCount)!))
            if (indexs.count == 0) {
                return
            }
            
            for i in indexs {
                let page: CPDFPage = (self?.listView.document.page(at: UInt(i)))!
                let redactAnno = KMRedactTools.createRedactAnnotation((self?.listView.document)!, anno as! CPDFRedactAnnotation)
                self?.listView.add(redactAnno, to: page)
            }
        }
    }
    
    @objc func redact_menuItemClick_apply(sender: NSMenuItem?) {
        self.exeRedactConfirm(.redactOne) {}
    }
    
    @objc func redact_menuItemClick_clear(sender: NSMenuItem?) {
        self.exeRedactConfirm(.eraserOne) {}
    }
    
    @objc func redact_menuItemClick_paste(sender: NSMenuItem?) {
        
    }
    
    
    @objc func exportStampImage(sender:NSMenuItem) {
        if listView.activeAnnotation != nil && ((listView.activeAnnotation is CPDFStampAnnotation) || (listView.activeAnnotation is CPDFSignatureAnnotation)) {
            var image : NSImage = NSImage()
            if (listView.activeAnnotation is CPDFStampAnnotation) {
                image = (listView.activeAnnotation as! CPDFStampAnnotation).stampImage()
            } else if (listView.activeAnnotation is CPDFSignatureAnnotation) {
                image = (listView.activeAnnotation as! CPDFSignatureAnnotation).signImage
            }
            let data = image.tiffRepresentation
            if sender.tag == 0 {
                let imageRep : NSBitmapImageRep = NSBitmapImageRep(data: data!) ?? NSBitmapImageRep()
                imageRep.size = image.size
                let imageData : Data = imageRep.representation(using: NSBitmapImageRep.FileType.png, properties: [:])!
                let savePanel = NSSavePanel()
                savePanel.allowedFileTypes = ["png"]
                savePanel.beginSheetModal(for: self.view.window!) { response in
                    if (response != .OK) {
                        return
                    }
                    if NSData(data: imageData).write(to: savePanel.url!, atomically: true) {
                        NSWorkspace.shared.selectFile(savePanel.url?.path, inFileViewerRootedAtPath: "");
                    }
                }
            } else {
                let pdfdocument = CPDFDocument()
                let signatureImagePath = NSSearchPathForDirectoriesInDomains(.applicationSupportDirectory, .userDomainMask, true).first?.stringByAppendingPathComponent("signatureImage.png")
                if NSData(data: data!).write(to: URL(fileURLWithPath: signatureImagePath!), atomically: true) {
                    pdfdocument?.insertPage(image.size, withImage: signatureImagePath, at: 0)
                    let savePanel = NSSavePanel()
                    savePanel.allowedFileTypes = ["pdf"]
                    savePanel.beginSheetModal(for: self.view.window!) { response in
                        if (response != .OK) {
                            return
                        }
                        if pdfdocument!.write(to: savePanel.url!) {
                            NSWorkspace.shared.selectFile(savePanel.url?.path, inFileViewerRootedAtPath: "");
                        }
                    }
                }
            }
        }
    }
        
    @objc func exportCorpImage(sender:NSMenuItem) {
        let rect = NSIntegralRect(listView.currentSelectionRect())
        let orgPage : CPDFPage = listView.currentSelectionPage() ?? listView.currentPage()
        let page : CPDFPage = orgPage.copy() as! CPDFPage
        page.setBounds(rect, for: .cropBox)
        let image = page.thumbnail(of: rect.size) ?? NSImage()
        let data = image.tiffRepresentation
        let imageRep : NSBitmapImageRep = NSBitmapImageRep(data: data!) ?? NSBitmapImageRep()
        imageRep.size = rect.size
        
        let savePanel = NSSavePanel()
        switch sender.tag {
        case 0:
            savePanel.allowedFileTypes = ["png"]
            
            let imageData : Data = imageRep.representation(using: NSBitmapImageRep.FileType.png, properties: [:])!
            savePanel.beginSheetModal(for: self.view.window!) { response in
                if (response != .OK) {
                    return
                }
                if NSData(data: imageData).write(to: savePanel.url!, atomically: true) {
                    NSWorkspace.shared.selectFile(savePanel.url?.path, inFileViewerRootedAtPath: "");
                }
            }
        case 1:
            savePanel.allowedFileTypes = ["jpg"]
            
            let imageData : Data = imageRep.representation(using: NSBitmapImageRep.FileType.jpeg, properties: [:])!
            savePanel.beginSheetModal(for: self.view.window!) { response in
                if (response != .OK) {
                    return
                }
                if NSData(data: imageData).write(to: savePanel.url!, atomically: true) {
                    NSWorkspace.shared.selectFile(savePanel.url?.path, inFileViewerRootedAtPath: "");
                }
            }
        case 2:
            savePanel.allowedFileTypes = ["pdf"]

            let pdfdocument = CPDFDocument()
            let signatureImagePath = NSSearchPathForDirectoriesInDomains(.applicationSupportDirectory, .userDomainMask, true).first?.stringByAppendingPathComponent("signatureImage.png")
            let imageData : Data = imageRep.representation(using: NSBitmapImageRep.FileType.jpeg, properties: [:])!
            if NSData(data: imageData).write(to: URL(fileURLWithPath: signatureImagePath!), atomically: true) {
                pdfdocument?.insertPage(image.size, withImage: signatureImagePath, at: 0)
                savePanel.beginSheetModal(for: self.view.window!) { response in
                    if (response != .OK) {
                        return
                    }
                    if pdfdocument!.write(to: savePanel.url!) {
                        NSWorkspace.shared.selectFile(savePanel.url?.path, inFileViewerRootedAtPath: "");
                    }
                }
            }

        default:
            break
        }
        // 执行右键操作后，需要取消框选区域
        if self.listView.toolMode == .selectToolMode {
            objc_sync_enter(self)
            self.listView.selectionRect = NSZeroRect
            self.listView.selectionPageIndex = UInt(NSNotFound)
            objc_sync_exit(self)
        }
    }
    
    @IBAction func doZoomToAutoSelection(sender:NSMenuItem) {
        let rect = listView.currentSelectionRect()
        let page = listView.currentPage()
        if NSIsEmptyRect(rect) == false && page != nil {
            let isLegacy = NSScroller.responds(to: NSSelectorFromString("preferredScrollerStyle")) == false || NSScroller.preferredScrollerStyle == .legacy
            var bounds = listView.bounds
            var scale = 1.0
            if isLegacy {
                bounds.size.width -= NSScroller.scrollerWidth(for: .regular, scrollerStyle: listView.documentView().scrollerStyle)
                bounds.size.height -= NSScroller.scrollerWidth(for: .regular, scrollerStyle: listView.documentView().scrollerStyle)
            }
            if NSWidth(bounds) * NSHeight(rect) > NSWidth(rect) * NSHeight(bounds) {
                scale = NSHeight(bounds) / NSHeight(rect)
            } else {
                scale = NSWidth(bounds) /  NSWidth(rect)
            }
            listView.setScaleFactor(scale, animated: false)
            let scrollView = listView.scroll()
            if isLegacy && scrollView?.hasHorizontalScroller == false || scrollView?.hasVerticalScroller == false {
                if ((scrollView?.hasVerticalScroller) != nil) {
                    bounds.size.width -= NSScroller.scrollerWidth(for: .regular, scrollerStyle: listView.documentView().scrollerStyle)
                }
                if ((scrollView?.hasHorizontalScroller) != nil) {
                    bounds.size.height -= NSScroller.scrollerWidth(for: .regular, scrollerStyle: listView.documentView().scrollerStyle)
                }
                if NSWidth(bounds) * NSHeight(rect) > NSWidth(rect) * NSHeight(bounds) {
                    scale = NSHeight(bounds) / NSHeight(rect)
                } else {
                    scale = NSWidth(bounds) /  NSWidth(rect)
                }
                listView.setScaleFactor(scale, animated: false)
            }
            DispatchQueue.main.asyncAfter(deadline: .now() + 0.03) { [self] in
                let pagePoint = CGPoint(x: rect.origin.x, y: (rect.origin.y + rect.size.height))
                listView.go(toTargetPoint: pagePoint, on: page, at: .top)
            };
        }
        
        // 执行右键操作后，需要取消框选区域
        if self.listView.toolMode == .selectToolMode {
            objc_sync_enter(self)
            self.listView.selectionRect = NSZeroRect
            self.listView.selectionPageIndex = UInt(NSNotFound)
            objc_sync_exit(self)
        }
    }
    
//    @IBAction func autoCropAll(sender:NSMenuItem) {
//   
//    }
    
    private func cropPagesToRects(rects:NSPointerArray) {
        
    }
    
    @IBAction func defaultAnnotationPorpert(sender:NSMenuItem) {
        let model : CPDFAnnotationModel = CPDFAnnotationModel(annotationType: CAnnotationType(rawValue: sender.tag)!)!
        switch sender.tag {
        case CAnnotationType.highlight.rawValue,CAnnotationType.underline.rawValue,CAnnotationType.strikeOut.rawValue:
            model.setColor((listView.activeAnnotation as! CPDFMarkupAnnotation).color)
            model.setOpacity((listView.activeAnnotation as! CPDFMarkupAnnotation).opacity)
            
            var red: CGFloat = 0.0
            var green: CGFloat = 0.0
            var blue: CGFloat = 0.0
            var alpha: CGFloat = 0.0
            (listView.activeAnnotation as! CPDFMarkupAnnotation).color.usingColorSpaceName(.calibratedRGB)?.getRed(&red, green: &green, blue: &blue, alpha: &alpha)
            if sender.tag == CAnnotationType.highlight.rawValue {
                KMPreferenceManager.shared.setData(data: [red, green, blue, (listView.activeAnnotation as! CPDFMarkupAnnotation).opacity], forKey: KMPreference.markupColorHighlightKey)
            } else if sender.tag == CAnnotationType.underline.rawValue {
                KMPreferenceManager.shared.setData(data: [red, green, blue, (listView.activeAnnotation as! CPDFMarkupAnnotation).opacity], forKey: KMPreference.markupColorUnderlineKey)
            } else if sender.tag == CAnnotationType.strikeOut.rawValue {
                KMPreferenceManager.shared.setData(data: [red, green, blue, (listView.activeAnnotation as! CPDFMarkupAnnotation).opacity], forKey: KMPreference.markupColorStrikthroughKey)
            }
        case CAnnotationType.ink.rawValue:
            model.setColor((listView.activeAnnotation as! CPDFInkAnnotation).color)
            model.setOpacity((listView.activeAnnotation as! CPDFInkAnnotation).opacity)
            model.setLineWidth((listView.activeAnnotation as! CPDFInkAnnotation).lineWidth())
            model.setStyle((listView.activeAnnotation as! CPDFInkAnnotation).borderStyle())
            
            var red: CGFloat = 0.0
            var green: CGFloat = 0.0
            var blue: CGFloat = 0.0
            var alpha: CGFloat = 0.0
            (listView.activeAnnotation as! CPDFInkAnnotation).color.usingColorSpaceName(.calibratedRGB)?.getRed(&red, green: &green, blue: &blue, alpha: &alpha)
            KMPreferenceManager.shared.setData(data: [red, green, blue, (listView.activeAnnotation as! CPDFInkAnnotation).opacity], forKey: KMPreference.markupColorPenKey)
        case CAnnotationType.freeText.rawValue:
            model.setColor((listView.activeAnnotation as! CPDFFreeTextAnnotation).color)
            model.setOpacity((listView.activeAnnotation as! CPDFFreeTextAnnotation).opacity)
            model.setFontColor((listView.activeAnnotation as! CPDFFreeTextAnnotation).fontColor)
            model.setFontName((listView.activeAnnotation as! CPDFFreeTextAnnotation).font.fontName)
            model.setFontSize((listView.activeAnnotation as! CPDFFreeTextAnnotation).font.pointSize)
            model.setAlignment((listView.activeAnnotation as! CPDFFreeTextAnnotation).alignment)
            
            var red: CGFloat = 0.0
            var green: CGFloat = 0.0
            var blue: CGFloat = 0.0
            var alpha: CGFloat = 0.0
            (listView.activeAnnotation as! CPDFFreeTextAnnotation).fontColor.usingColorSpaceName(.calibratedRGB)?.getRed(&red, green: &green, blue: &blue, alpha: &alpha)
            KMPreferenceManager.shared.setData(data: [red, green, blue, (listView.activeAnnotation as! CPDFFreeTextAnnotation).opacity], forKey: KMPreference.markupColorTextKey)
            
            if (KMPreferenceManager.supportFonts.contains((listView.activeAnnotation as! CPDFFreeTextAnnotation).font.fontName)) {
                UserDefaults.standard.set((listView.activeAnnotation as! CPDFFreeTextAnnotation).font.fontName, forKey: KMPreference.markupFontTextStringKey)
                UserDefaults.standard.synchronize()
            }
            let alignment = (listView.activeAnnotation as! CPDFFreeTextAnnotation).alignment
            if (alignment == .left || alignment == .center || alignment == .right) {
                UserDefaults.standard.set(alignment.rawValue, forKey: KMPreference.markupFontTextAligmentKey)
                UserDefaults.standard.synchronize()
            }
        case CAnnotationType.anchored.rawValue:
            model.setColor((listView.activeAnnotation as! CPDFTextAnnotation).color)
            model.setAnchoredIconType((listView.activeAnnotation as! CPDFTextAnnotation).iconType())
            
            var red: CGFloat = 0.0
            var green: CGFloat = 0.0
            var blue: CGFloat = 0.0
            var alpha: CGFloat = 0.0
            (listView.activeAnnotation as! CPDFTextAnnotation).color.usingColorSpaceName(.calibratedRGB)?.getRed(&red, green: &green, blue: &blue, alpha: &alpha)
            KMPreferenceManager.shared.setData(data: [red, green, blue, alpha], forKey: KMPreference.markupColorNoteKey)
        case CAnnotationType.square.rawValue:
            model.setInteriorColor((listView.activeAnnotation as! CPDFSquareAnnotation).interiorColor)
            model.setColor((listView.activeAnnotation as! CPDFSquareAnnotation).color)
            model.setOpacity((listView.activeAnnotation as! CPDFSquareAnnotation).opacity)
            model.setLineWidth((listView.activeAnnotation as! CPDFSquareAnnotation).lineWidth())
            
            var red: CGFloat = 0.0
            var green: CGFloat = 0.0
            var blue: CGFloat = 0.0
            var alpha: CGFloat = 0.0
            (listView.activeAnnotation as! CPDFSquareAnnotation).interiorColor.usingColorSpaceName(.calibratedRGB)?.getRed(&red, green: &green, blue: &blue, alpha: &alpha)
            KMPreferenceManager.shared.setData(data: [red, green, blue, (listView.activeAnnotation as! CPDFSquareAnnotation).interiorOpacity], forKey: KMPreference.markupColorRectangleFillKey)
            (listView.activeAnnotation as! CPDFSquareAnnotation).color.usingColorSpaceName(.calibratedRGB)?.getRed(&red, green: &green, blue: &blue, alpha: &alpha)
            KMPreferenceManager.shared.setData(data: [red, green, blue, (listView.activeAnnotation as! CPDFSquareAnnotation).opacity], forKey: KMPreference.markupColorRectangleBorderKey)
        case CAnnotationType.circle.rawValue:
            model.setInteriorColor((listView.activeAnnotation as! CPDFCircleAnnotation).interiorColor)
            model.setColor((listView.activeAnnotation as! CPDFCircleAnnotation).color)
            model.setOpacity((listView.activeAnnotation as! CPDFCircleAnnotation).opacity)
            model.setLineWidth((listView.activeAnnotation as! CPDFCircleAnnotation).lineWidth())
            
            var red: CGFloat = 0.0
            var green: CGFloat = 0.0
            var blue: CGFloat = 0.0
            var alpha: CGFloat = 0.0
            (listView.activeAnnotation as! CPDFCircleAnnotation).interiorColor.usingColorSpaceName(.calibratedRGB)?.getRed(&red, green: &green, blue: &blue, alpha: &alpha)
            KMPreferenceManager.shared.setData(data: [red, green, blue, (listView.activeAnnotation as! CPDFCircleAnnotation).interiorOpacity], forKey: KMPreference.markupColorCircleFillKey)
            (listView.activeAnnotation as! CPDFCircleAnnotation).color.usingColorSpaceName(.calibratedRGB)?.getRed(&red, green: &green, blue: &blue, alpha: &alpha)
            KMPreferenceManager.shared.setData(data: [red, green, blue, (listView.activeAnnotation as! CPDFCircleAnnotation).opacity], forKey: KMPreference.markupColorCircleBorderKey)
        default:
            break
        }
    }
    
    @objc internal func menuItemClick_HidenorShowNote(sender: NSMenuItem?) {
        self.showOrHideNotes()
    }
    
    //MARK: action
    
    @objc func cropCurrentPage() {
        var rect = NSIntegralRect(self.listView.currentSelectionRect())
        var page: CPDFPage?
        if ((self.listView.currentSelectionPage()) != nil) {
            page = self.listView.currentSelectionPage()
        } else {
            page = self.listView.currentPage()
        }

        if (NSIsEmptyRect(rect)) {
            rect = KMCropTools.getPageForegroundBox(page!)
        }
        
        let index: UInt = (page?.pageIndex())!
        
        cropPage(at: index, in: rect)
        
        // 执行右键操作后，需要取消框选区域
        if self.listView.toolMode == .selectToolMode {
            objc_sync_enter(self)
            self.listView.selectionRect = NSZeroRect
            self.listView.selectionPageIndex = UInt(NSNotFound)
            objc_sync_exit(self)
        }
        
        self.handlePageBoundsDidChange(page: page, action: CPDFPage.Action.crop)
    }
    
    func cropPage(at index: UInt, in rect: NSRect) {
        let oldRect = self.listView.document.page(at: index)?.bounds(for: .cropBox)
        
        let undoManager = self.listView.undoManager
        (undoManager?.prepare(withInvocationTarget: self) as? AnyObject)!.cropPage(at: index, in: oldRect!)
        
        let page = self.listView.document.page(at: index)
        let newRect = NSIntersectionRect(rect, (page?.bounds(for: .mediaBox))!)
        page?.setBounds(newRect, for: .cropBox)
        
        /// 刷新预览视图
        self.listView.layoutDocumentView()
        
        self.listView.displayBox = .cropBox
    }
    
    func beginProgressSheet(with message: String, maxValue: UInt) { 
        let progress = SKProgressController()
        progress.window?.backgroundColor = NSColor.km_init(hex: "#ffffff")
        progress.window?.contentView?.wantsLayer = true
        progress.window?.contentView?.layer?.backgroundColor = NSColor.km_init(hex: "#ffffff").cgColor
        progress.progressField.textColor = NSColor.black
        progress.message = NSLocalizedString("Converting...", comment: "")
        progressController = progress
        progressController?.message = message
        if maxValue > 0 {
            progressController?.indeterminate = false
            progressController?.maxValue = Double(maxValue)
        } else {
            progressController?.indeterminate = true
        }
        if maxValue > 0 {
            progressController?.indeterminate = false
            progressController?.maxValue = Double(maxValue)
        } else {
            progressController?.indeterminate = true
        }
        self.km_beginSheet(windowC: progressController!)
    }
    
    
   @objc func cropAllPage() {
        var size = NSZeroSize
        for i in 0 ..< self.listView.document.pageCount {
            let page = self.listView.document.page(at: i)
            let rect = KMCropTools.getPageForegroundBox(page!)
            size.width = fmax(size.width, NSWidth(rect))
            size.height = fmax(size.height, NSHeight(rect))
        }
       beginProgressSheet(with: KMLocalizedString("Cropping Pages", "Message for progress sheet"), maxValue: min(18, self.listView.document.pageCount))
       var rectArray: Array<NSRect> = []
        for i in 0 ..< self.listView.document.pageCount {
            progressController?.increment(by: Double(i))
            progressController?.doubleValue = Double(i)
            let page = self.listView.document.page(at: i)
            var rect = KMCropTools.getPageForegroundBox(page!)
            let bounds: NSRect = (page?.bounds(for: .mediaBox))!
            if (rect.minX - bounds.minX > bounds.maxX-rect.maxX) {
                rect.origin.x = rect.maxX-size.width
            }
            
            rect.origin.y = rect.maxY-size.height
            rect.size = size
            
            if (NSWidth(rect) > NSWidth(bounds)) {
                rect.size.width = NSWidth(bounds)
            }
            if (NSHeight(rect) > NSHeight(bounds)) {
                rect.size.height = NSHeight(bounds)
            }
            
            if (NSMinX(rect) < NSMinX(bounds)) {
                rect.origin.x = NSMinX(bounds)
            } else if (NSMaxX(rect) > NSMaxX(bounds)) {
                rect.origin.x = NSMaxX(bounds) - NSWidth(rect)
            }
            
            if (NSMinY(rect) < NSMinY(bounds)) {
                rect.origin.y = NSMinY(bounds)
            } else if (NSMaxY(rect) > NSMaxY(bounds)) {
                rect.origin.y = NSMaxY(bounds) - NSHeight(rect)
            }
            
            rectArray.append(rect)
        }
        
        cropPages(to: rectArray)
       self.handlePageBoundsDidChange(page: nil, action: CPDFPage.Action.crop)
    }
    
    func cropPages(to rects: Array<NSRect>) {
        let currentPage = self.listView.currentPage()
        let visibleRect: NSRect = self.listView.convert(self.listView.convert(self.listView.documentView().visibleRect, from: self.listView.documentView()), to: self.listView.currentPage())
        
        var oldRectArray: Array<NSRect> = []
        for i in 0 ..< self.listView.document.pageCount {
            let page = self.listView.document.page(at: i)
            let rect = NSIntersectionRect(rects[Int(i)], (page?.bounds(for: .mediaBox))!)
            let oldRect = page?.bounds(for: .cropBox)
            oldRectArray.append(oldRect!)
            
            page?.setBounds(rect, for: .cropBox)
        }
        
        let undoManager = self.listView.undoManager
        (undoManager?.prepare(withInvocationTarget: self) as AnyObject).cropPages(to: oldRectArray)
        
        /// 刷新预览视图
        self.listView.layoutDocumentView()
        
        self.listView.displayBox = .cropBox
        
        self.listView.go(to: currentPage)
        self.listView.go(to: visibleRect, on: currentPage)
        DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 0.25) { [self] in
            self.dismissProgressSheet()
        }
    }
    
    private func cropCustomArea() {
        self.listView.toolMode = .selectToolMode
        
        self.listView.autoScales = true
        self.listView.autoScales = false
        var pageHeight: CGFloat = NSHeight(self.listView.currentPage().bounds(for: self.listView.displayBox))
        if (self.listView.displaysPageBreaks) {
            pageHeight += 8
        }
        
        var scaleFactor: CGFloat = fmax(self.listView.minimumScaleFactor, NSHeight(self.listView.frame)/pageHeight)
//        if (scaleFactor < self.preView.scaleFactor) {
            self.listView.scaleFactor = scaleFactor
//        }
        
        let tipView = KMCropTipView()
        tipView.setString(string: "请框选裁剪区域")
        tipView.frame = self.topTipBox.contentView!.frame
        tipView.autoresizingMask = NSView.AutoresizingMask(rawValue: 18)
        self.addTopTip(tipView)
        
        tipView.enterAction = {
            () in
            var rect = NSIntegralRect(self.listView.currentSelectionRect())
            if (NSIsEmptyRect(rect)) {
                return
            }
            
            let window = KMCropSettingWindowController(windowNibName: "KMCropSettingWindowController")
            self.view.window?.beginSheet(window.window!)
            self.cropSettingWindowController = window
            
            window.itemClick = { [self]
                (index: Int) in
                if (index == 1) { /// 取消
                    self.view.window?.endSheet((self.cropSettingWindowController?.window)!)
                    self.cropSettingWindowController = nil
                    return
                }
                let pageRangeType = self.cropSettingWindowController.pageRangeIndex
                let pageCount: Int = Int(self.listView.document.pageCount)
                var pages: Array<Int> = []
                if (pageRangeType == 0) { /// 当前页面
                    pages.append(self.listView.currentPageIndex)
                } else if (pageRangeType == 1) { /// 全部页面
                    for i in 0 ..< pageCount {
                        pages.append(i)
                    }
                } else if (pageRangeType == 2) { /// 奇数页面
                    var string: String = ""
                    for i in 0 ..< pageCount {
                        if (i % 2 == 1) {
                            continue
                        }
                        
                        pages.append(i)
                    }
                } else if (pageRangeType == 3) { /// 偶数页面
                    var string: String = ""
                    for i in 0 ..< pageCount {
                        if (i % 2 == 0) {
                            continue
                        }
                        
                        pages.append(i)
                    }
                } else { /// 自定义
                    for i in self.cropSettingWindowController.pageRangePages {
                        pages.append(i)
                    }
                }
                
                if (pages.count < 0) {
                    let alert = NSAlert()
                    alert.messageText = "请选择页面"
                    alert.runModal()
                    return
                }
                
                var pageSize: NSSize = NSZeroSize
                if (self.cropSettingWindowController.pageSize == "None") {
                    
                } else {
                    pageSize = KMCropTools.getPageSizeValue(self.cropSettingWindowController.pageSize)
                }
                
                for i in pages {
                    var page: CPDFPage = self.listView.document.page(at: UInt(i))
                    var rect = NSIntegralRect(self.listView.selectionRect)

                    if (NSIsEmptyRect(rect)) {
                        rect = KMCropTools.getPageForegroundBox(page)
                    }
                    
                    var newRect = NSIntersectionRect(rect, (page.bounds(for: .mediaBox)))
                    page.setBounds(newRect, for: .cropBox)
                    
                    if (pageSize.width == 0 && pageSize.height == 0) {
                        
                    } else {
//                        let tiffData = page.pdfListViewTIFFData(for: rect)
                        let index: UInt = (page.pageIndex())
//                        let newPage: CPDFPage = nil
//                        self.listView.document.removePage(at: index)
//                        newPage.setBounds(NSMakeRect(0, 0, pageSize.width, pageSize.height), for: .cropBox)
                        //        let result = self.preView.document.insertPageObject(newPage, at: index)
                        let result = self.listView.document.insertPage(pageSize, at: index)
                    }
                }
                
                /// 保存到临时路径
                let toPath: String = self.listView.document.documentURL.path
                let documentPath = NSTemporaryDirectory()
                let tempPath: String = "\(documentPath)/\(toPath.lastPathComponent)"
                if (FileManager.default.fileExists(atPath: tempPath)) {
                    try?FileManager.default.removeItem(atPath: tempPath)
                }

                let result = self.listView.document.write(to: URL(fileURLWithPath: tempPath))
                if (result) {
                    if (FileManager.default.fileExists(atPath: toPath)) {
                        try?FileManager.default.removeItem(atPath: toPath)
                    }
                    
                    try?FileManager.default.moveItem(atPath: tempPath, toPath: toPath)
                } else {
                    try?FileManager.default.removeItem(atPath: tempPath)
                }
                DispatchQueue.main.async {
                    self.listView.toolMode = .textToolMode

                    /// 刷新预览视图
                    self.listView.layoutDocumentView()
                    
                    self.listView.displayBox = .cropBox
                }
                
                self.view.window?.endSheet((self.cropSettingWindowController?.window)!)
                self.cropSettingWindowController = nil
                self.addTopTip(nil)
            }
        }
    }
    
    @objc private func shareDocument(sender:KMToolbarViewController, limit: Bool = false) {
        if (limit) {
            var doucumentURL : URL = self.listView.document.documentURL
            if doucumentURL != nil {
                let docDir = NSTemporaryDirectory()
                let documentName : String = doucumentURL.path.lastPathComponent
                let path = docDir.stringByAppendingPathComponent(documentName)
//                let writeSuccess = self.listView.document.write(to: URL(fileURLWithPath: path))
                let data = KMTools.saveWatermarkDocument(document: self.listView.document, to: URL(fileURLWithPath: path), secureOptions: self.secureOptions, removePWD: self.removeSecureFlag)
                let writeSuccess = data != nil
                if writeSuccess == false {
                    __NSBeep()
                    return;
                }
               doucumentURL = URL(fileURLWithPath: path)
            }
            let array = [doucumentURL]
            let picker = NSSharingServicePicker.init(items: array)
            if sender.shareButton.window != nil {
                picker.show(relativeTo: sender.shareButton.bounds, of: sender.shareButton, preferredEdge: NSRectEdge.minY)
            } else {
                picker.show(relativeTo: NSRect(x: (self.view.window?.contentView?.frame.size.width)!, y: (self.view.window?.contentView?.frame.size.height ?? 0)-8, width: 0, height: 0), of: self.view.window?.contentView ?? NSView(), preferredEdge: NSRectEdge.minY)
            }
            
            return
        }
        
        var doucumentURL : URL = self.listView.document.documentURL
        if doucumentURL != nil {
            let docDir = NSTemporaryDirectory()
            let documentName : String = doucumentURL.path.lastPathComponent
            let path = docDir.stringByAppendingPathComponent(documentName)
            let writeSuccess = self.listView.document.write(to: URL(fileURLWithPath: path))
            if writeSuccess == false {
                __NSBeep()
                return;
            }
           doucumentURL = URL(fileURLWithPath: path)
        }
        let array = [doucumentURL]
        let picker = NSSharingServicePicker.init(items: array)
        if sender.shareButton.window != nil {
            picker.show(relativeTo: sender.shareButton.bounds, of: sender.shareButton, preferredEdge: NSRectEdge.minY)
        } else {
            picker.show(relativeTo: NSRect(x: (self.view.window?.contentView?.frame.size.width)!, y: (self.view.window?.contentView?.frame.size.height ?? 0)-8, width: 0, height: 0), of: self.view.window?.contentView ?? NSView(), preferredEdge: NSRectEdge.minY)
        }
    }
    
    @objc private func shareFlatten(sender:KMToolbarViewController, limit: Bool = false) {
        if (limit) {
            let document = self.listView.document ?? CPDFDocument()
            var path = document!.documentURL.path
            if path != nil {
                let docDir = NSTemporaryDirectory()
                let documentName : String = path.lastPathComponent
                path = docDir.stringByAppendingPathComponent(documentName)
            }
            let pathFolder = path.fileURL.deletingLastPathComponent().path
            var tfileName = path.deletingPathExtension.lastPathComponent
            let tStdFileSuffix = "_flatten"
            tfileName = tfileName + tStdFileSuffix + ".pdf"
            path = pathFolder + "/" + tfileName

            let data = KMTools.saveWatermarkDocumentForFlatten(document: document!, to: URL(fileURLWithPath: path))
            let success = data != nil
            if success {
                let url = URL(fileURLWithPath: path)
                let picker = NSSharingServicePicker.init(items: [url])
                if sender.shareButton.window != nil {
                    picker.show(relativeTo: sender.shareButton.bounds, of: sender.shareButton, preferredEdge: NSRectEdge.minY)
                } else {
                    picker.show(relativeTo: NSRect(x: (self.view.window?.contentView?.frame.size.width)!, y: (self.view.window?.contentView?.frame.size.height ?? 0)-8, width: 0, height: 0), of: self.view.window?.contentView ?? NSView(), preferredEdge: NSRectEdge.minY)
                }
            }
            return
        }
        
        let document = self.listView.document ?? CPDFDocument()
        var path = document!.documentURL.path
        if path != nil {
            let docDir = NSTemporaryDirectory()
            let documentName : String = path.lastPathComponent
            path = docDir.stringByAppendingPathComponent(documentName)
        }
        let pathFolder = path.fileURL.deletingLastPathComponent().path
        var tfileName = path.deletingPathExtension.lastPathComponent
        let tStdFileSuffix = "_flatten"
        tfileName = tfileName + tStdFileSuffix + ".pdf"
        path = pathFolder + "/" + tfileName
        let success : Bool = document!.writeFlatten(to: URL(fileURLWithPath: path))
        if success {
            let url = URL(fileURLWithPath: path)
            let picker = NSSharingServicePicker.init(items: [url])
            if sender.shareButton.window != nil {
                picker.show(relativeTo: sender.shareButton.bounds, of: sender.shareButton, preferredEdge: NSRectEdge.minY)
            } else {
                picker.show(relativeTo: NSRect(x: (self.view.window?.contentView?.frame.size.width)!, y: (self.view.window?.contentView?.frame.size.height ?? 0)-8, width: 0, height: 0), of: self.view.window?.contentView ?? NSView(), preferredEdge: NSRectEdge.minY)
            }
        }
    }
    @objc private func shareOriginalPDF(sender:KMToolbarViewController, limit: Bool = false) {
        if (limit) {
            let document = self.listView.document ?? CPDFDocument()
            var path = document!.documentURL.path
            if path != nil {
                let docDir = NSTemporaryDirectory()
                let documentName : String = path.lastPathComponent
                path = docDir.stringByAppendingPathComponent(documentName)
            }
//            var writeSuccess = document!.write(to: URL(fileURLWithPath: path))
            let data = KMTools.saveWatermarkDocument(document: document!, to: URL(fileURLWithPath: path), secureOptions: self.secureOptions, removePWD: self.removeSecureFlag)
            var writeSuccess = data != nil
            if writeSuccess == false {
                __NSBeep()
                return;
            }
            let newDocument = CPDFDocument(url: URL(fileURLWithPath: path))!
            
            for i in 0 ... newDocument.pageCount-1 {
                let page = newDocument.page(at: i)
                var annotations : [CPDFAnnotation] = []
                for annotation in page!.annotations {
                    annotations.append(annotation)
                }
                for annotation in annotations {
                    annotation.page.removeAnnotation(annotation)
                }
            }
            writeSuccess = newDocument.write(to:URL(fileURLWithPath: path))
            if writeSuccess {
                let url = URL(fileURLWithPath: path)
                let picker = NSSharingServicePicker.init(items: [url])
                if sender.shareButton.window != nil {
                    picker.show(relativeTo: sender.shareButton.bounds, of: sender.shareButton, preferredEdge: NSRectEdge.minY)
                } else {
                    picker.show(relativeTo: NSRect(x: (self.view.window?.contentView?.frame.size.width)!, y: (self.view.window?.contentView?.frame.size.height ?? 0)-8, width: 0, height: 0), of: self.view.window?.contentView ?? NSView(), preferredEdge: NSRectEdge.minY)
                }
            }
            return
        }
        
        let document = self.listView.document ?? CPDFDocument()
        var path = document!.documentURL.path
        if path != nil {
            let docDir = NSTemporaryDirectory()
            let documentName : String = path.lastPathComponent
            path = docDir.stringByAppendingPathComponent(documentName)
        }
        var writeSuccess = document!.write(to: URL(fileURLWithPath: path))
        if writeSuccess == false {
            __NSBeep()
            return;
        }
        let newDocument = CPDFDocument(url: URL(fileURLWithPath: path))!
        
        for i in 0 ... newDocument.pageCount-1 {
            let page = newDocument.page(at: i)
            var annotations : [CPDFAnnotation] = []
            for annotation in page!.annotations {
                annotations.append(annotation)
            }
            for annotation in annotations {
                annotation.page.removeAnnotation(annotation)
            }
        }
        writeSuccess = newDocument.write(to:URL(fileURLWithPath: path))
        if writeSuccess {
            let url = URL(fileURLWithPath: path)
            let picker = NSSharingServicePicker.init(items: [url])
            if sender.shareButton.window != nil {
                picker.show(relativeTo: sender.shareButton.bounds, of: sender.shareButton, preferredEdge: NSRectEdge.minY)
            } else {
                picker.show(relativeTo: NSRect(x: (self.view.window?.contentView?.frame.size.width)!, y: (self.view.window?.contentView?.frame.size.height ?? 0)-8, width: 0, height: 0), of: self.view.window?.contentView ?? NSView(), preferredEdge: NSRectEdge.minY)
            }
        }
    }
    
    // 开启/关闭左边栏
    @objc func toggleLeftPane() -> Void {
//        if lastLeftPanWidth >= functionWidth {
            leftPanelOpen = true
            applyLeftSideWidth(panelWidth+functionWidth, rightSideWidth: lastRightPanWidth)
//        } else {
//            leftPanelOpen = false
//            applyLeftSideWidth(functionWidth, rightSideWidth: lastRightPanWidth)
//        }
    }
    
    // 开启左边栏
    @objc func openLeftPane() -> Void {
        leftPanelOpen = true
        applyLeftSideWidth(panelWidth+functionWidth, rightSideWidth: lastRightPanWidth)
    }
    
    // 关闭左边栏
    @objc func closeLeftPane() -> Void {
        leftPanelOpen = false
        applyLeftSideWidth(functionWidth, rightSideWidth: lastRightPanWidth)
    }
    
    // 开启/关闭右边栏
    @objc func toggleRightPane() -> Void {
        if lastRightPanWidth > 5 {
            self.rightPanelIsOpen = false
            applyLeftSideWidth(lastLeftPanWidth, rightSideWidth: 0)
        } else {
            self.rightPanelIsOpen = true
            applyLeftSideWidth(lastLeftPanWidth, rightSideWidth: defaultRightWidth)
        }
    }
    
    @objc func openRightPane() -> Void {
        if (KMPreferenceManager.shared.autoExpandPropertyPanel) {
            if self.rightPanelIsOpen {
                return
            }
            self.rightPanelIsOpen = true
            self.toolbarController.selectItem(KMRightControlToolbarItemIdentifier)
            applyLeftSideWidth(lastLeftPanWidth, rightSideWidth: defaultRightWidth)
        }
    }
    
    @objc func closeRightPane() -> Void {
        if (KMPreferenceManager.shared.autoExpandPropertyPanel) {
            self.rightPanelIsOpen = false
            self.toolbarController.cancelSelected(KMRightControlToolbarItemIdentifier)
            applyLeftSideWidth(lastLeftPanWidth, rightSideWidth: 0)
        }
    }
    
    func rename(_ sender: NSNotification) -> Void {
        if (self.view.window == nil || self.view.window!.isVisible == false) {
            return
        }
        let tabController = sender.object as? CTTabController
        if tabController?.title == self.document?.documentURL.lastPathComponent {
            let outputSavePanel = NSSavePanel()
            outputSavePanel.title = NSLocalizedString("Rename", comment: "")
            outputSavePanel.allowedFileTypes = ["pdf"]
            outputSavePanel.nameFieldStringValue = (self.document?.documentURL.lastPathComponent)!
            outputSavePanel.directoryURL = self.document?.documentURL.deletingLastPathComponent()
            
            let result = outputSavePanel.runModal()
            if result == .OK {
                let pdfDocument = CPDFDocument(url: self.document?.documentURL)
                let fileURL = pdfDocument?.documentURL
                
                let fileManager = FileManager.default
                let newFileURL = fileURL!.deletingLastPathComponent().appendingPathComponent(outputSavePanel.url!.lastPathComponent)
                var result = true
                do {
                    try fileManager.moveItem(at: fileURL!, to: newFileURL)
                } catch {
                    result = false
                    KMPrint("Error renaming file! Threw: \(error.localizedDescription)")
                }
                if (result) {
                    tabController?.title = outputSavePanel.url!.lastPathComponent
                    
                    if let newPdfDocument = CPDFDocument(url: newFileURL) {
                        self.isSaveKeyChain = false
                        newPdfDocument.unlock(withPassword: self.document?.password)
                        if (newPdfDocument.pageCount > 0) {
                            self.setDocument = newPdfDocument
                        }
                    }
                }
            } else {
                outputSavePanel.close()
            }
        }
    }

    func showInFinder(_ sender: Any) -> Void {
        if sender is NSNotification {
            let tabController = (sender as! NSNotification).object as? CTTabController
            if tabController?.title == self.document?.documentURL.lastPathComponent {
                let file: URL = (self.myDocument?.fileURL)!
                if FileManager.default.fileExists(atPath: file.path) {
                    NSWorkspace.shared.activateFileViewerSelecting([file])
                }
            }
        } else {
            let file: URL = (self.myDocument?.fileURL)!
            if FileManager.default.fileExists(atPath: file.path) {
                NSWorkspace.shared.activateFileViewerSelecting([file])
            }
        }
    }
    
    func showOrHideNotes() {
        self.listView.hideNotes = !self.listView.hideNotes
        
        self.toolbarController.isShowAllAnnotations = !self.listView.hideNotes
        
        //BOTA 注释列表显示隐藏
//        self.leftSideViewController.annotationViewController.annotationShowState = self.listView.hideNotes ? .hidden : .none
//        self.leftSideViewController.thumbnailViewController.annotationShowState = self.listView.hideNotes ? .hidden : .none
    }
    
    func closeTab(_ sender: NSNotification) -> Void {
        let tabController = sender.object as? CTTabController
        if tabController?.title == self.document?.documentURL.lastPathComponent {
            print("closeTab")
            self.leftSideViewController.clearAnnotationFilterData()
            self.leftSideViewController.clearNotification()
        }
    }
    
    @IBAction func toggleSplitPDF(_ sender: Any) {
        if let menuItem = sender as? NSMenuItem {
            splitView(withTag: menuItem.tag)
        }
    }
    
    @IBAction func readMode(_ sender: Any) {
        isReadMode = !isReadMode
        UserDefaults.standard.set(isReadMode, forKey: "kKMPDFViewIsReadMode")
        UserDefaults.standard.synchronize()

        if isReadMode {
            CustomAlertView.alertView(message: NSLocalizedString("Read Mode On", comment: ""), fromView: (view.window?.contentView)!, withStyle: .black)
        } else {
            CustomAlertView.alertView(message: NSLocalizedString("Read Mode Off", comment: ""), fromView: (view.window?.contentView)!, withStyle: .black)
        }
    }
    
    func handlePageBoundsDidChange(page: CPDFPage?, action: String) {
//        NSDictionary *info = [notification userInfo];
//        PDFPage *page = [info objectForKey:SKPDFPagePageKey];
//        NSString *action = [info objectForKey:SKPDFPageActionKey];
//        BOOL displayChanged = [action isEqualToString:SKPDFPageActionCrop] == NO || [pdfView displayBox] == kPDFDisplayBoxCropBox;
        let displayChanged = action == CPDFPage.Action.crop || self.listView.displayBox == .cropBox
//        if self.listView.displayBox == .cropBox {
//            KMPrint("cropBox")
//        } else if self.listView.displayBox == .artBox {
//            KMPrint("artBox")
//        } else if self.listView.displayBox == .trimBox {
//            KMPrint("trimBox")
//        } else if self.listView.displayBox == .bleedBox {
//            KMPrint("bleedBox")
//        } else if self.listView.displayBox == .mediaBox {
//            KMPrint("mediaBox")
//        } else {
//            KMPrint("other \(self.listView.displayBox.rawValue)")
//        }
            
        if (displayChanged) {
            self.listView.layoutDocumentView()
        }
        if (page != nil) {
            let idx = page!.pageIndex()
            if (displayChanged) {
                self.leftSideViewController.updateThumbnail(at: Int(idx))
            }
        } else {
            if (displayChanged) {
                self.leftSideViewController.allThumbnailsNeedUpdate()
            }
        }
        self.leftSideViewController.updateSnapshotsIfNeed(for: page)

//        [secondaryPdfView requiresDisplay];
        self.secondaryPdfView?.setNeedsDisplayForVisiblePages()
//
        if UserDefaults.standard.bool(forKey: SKDisplayPageBoundsKey) {
            //            [self updateRightStatus];
        }
    }
    
    func changeLineAttribute(_ sender: Any?) {
        var inspector = sender as? KMLineInspector
        if inspector == nil {
            inspector = KMLineInspector.shared
        }
        let action = inspector?.currentLineChangeAction ?? .no
        
        for annotation in self.listView.activeAnnotations {
            guard let anno = annotation as? CPDFAnnotation else {
                continue
            }
            
            if anno.hasBorder() {
//            if (mwcFlags.updatingLine == 0 && [annotation hasBorder]) {
//                mwcFlags.updatingLine = 1;
                switch (action) {
                case .lineWidth:
                    anno.setLineWidth(inspector?.lineWidth ?? 0)
                        break
                case .style:
                    anno.setBorderStyle(CPDFBorderStyle(rawValue: inspector?.style ?? 0) ?? .solid)
                        break
                case .dashPattern:
                    anno.setDashPattern(inspector?.dashPattern ?? [])
                        break
                case .startLineStyle:
                    if anno.isLine() {
                        (anno as? CPDFLineAnnotation)?.startLineStyle = CPDFLineStyle(rawValue: inspector?.startLineStyle ?? 0) ?? .none
                    }
                        break
                case .endLineStyle:
                    if anno.isLine() {
                        (anno as? CPDFLineAnnotation)?.endLineStyle = CPDFLineStyle(rawValue: inspector?.endLineStyle ?? 0) ?? .none
                    }
                        break
                case .no:
                    break
                }
//                mwcFlags.updatingLine = 0;
                // in case one property changes another, e.g. when adding a dashPattern the borderStyle can change
            }
        }
        
//        [self updateLineInspector];
    }
    
    // MARK: -
    // MARK: 显示窗口
    
    internal func showCompressWindow(url: URL? = nil) {
        if let wc = self.currentWindowController as? KMCompressWindowController, let _ = wc.window?.isSheet {
            KMPrint("压缩窗口已显示")
            return
        }
        let windowController = KMCompressWIndowControllerNew(windowNibName: "KMCompressWIndowControllerNew")
        self.view.window?.beginSheet(windowController.window!)
        self.currentWindowController = windowController
        windowController.password = self.listView?.document?.password ?? ""
//        if let _url = url {
//            windowController.oriDocumentUrl = self.listView.document.documentURL
//            windowController.documentURL = _url
//        } else {
            windowController.documentURL = self.listView.document.documentURL
//        }

        windowController.itemClick = { [weak self] in
            self?.view.window?.endSheet((self?.currentWindowController.window)!)
            self?.currentWindowController = nil

            self?.toolbarController.cancelSelected(KMToolbarToolCompressItemIdentifier)
        }

        windowController.batchAction = { [weak self] view, filePaths in
            self?.view.window?.endSheet((self?.currentWindowController.window)!)
            self?.currentWindowController = nil

            self?.toolbarController.cancelSelected(KMToolbarToolCompressItemIdentifier)

            let batchWindowController = KMBatchOperateWindowController.sharedWindowController
                    batchWindowController.window?.makeKeyAndOrderFront("")
            let batchOperateFile = KMBatchOperateFile(filePath: filePaths.first!.path)
            batchWindowController.switchToOperateType(KMBatchOperationType.Compress, files: [batchOperateFile])
            batchWindowController.window?.makeKeyAndOrderFront("")
        }

        windowController.resultCallback = { [weak self] result, openDocument, fileURL, error in
            if (result) {
                self?.view.window?.endSheet((self?.currentWindowController.window)!)
                self?.currentWindowController = nil

                self?.toolbarController.cancelSelected(KMToolbarToolCompressItemIdentifier)

                if (openDocument) {
                    NSDocumentController.shared.openDocument(withContentsOf: fileURL, display: true) { document, result, error in }
                } else {
                    NSWorkspace.shared.activateFileViewerSelecting([fileURL])
                }
            } else {
                let alert = NSAlert()
                alert.messageText = NSLocalizedString("Compress Faild", comment: "")
                alert.runModal()
            }
        }
    }
    
    internal func showConvertWindow(type: KMToolbarType, documentUrl: URL? = nil, identifier: String?) {
        if let wc = self.currentWindowController as? KMConvertBaseWindowController, let _ = wc.window?.isSheet {
            KMPrint("转档窗口已显示")
            return
        }
        var convertT: KMConvertType = .Word
        var windowController: KMConvertBaseWindowController?
        if (type == .word) { /// Word
            convertT = .Word
        } else if (type == .excel) {
            convertT = .Excel
        } else if (type == .ppt || type == .rtf || type == .html || type == .conversion_text) {
            if (type == .ppt) {
                convertT = .PPT
            } else if (type == .rtf) {
                convertT = .RTF
            } else if (type == .html) {
                convertT = .HTML
            } else if (type == .conversion_text) {
                convertT = .Text
            }
        } else if (type == .csv) {
            convertT = .CSV
        } else if (type == .conversion_image) {
            windowController = KMConvertImageWindowController()
        }
        windowController?.subscribeWaterMarkType = type.toSubscribeWaterMarkType()
        
        var url: URL?
        if (documentUrl != nil) {
            url = documentUrl
            windowController?.oriDocumentUrl = self.listView.document.documentURL
        } else {
            url = self.listView.document.documentURL
        }
        self.showAllConvertWindow(convertT: convertT)
        
//        let model = KMDocumentModel(url: url!)
//        if (self.listView.document.password != nil) {
//            let _ = model.unlock(self.listView.document.password)
//        }
//        model.currentIndex = self.listView.currentPageIndex
//        windowController?.documentModel = model
//        
//        windowController?.itemClick = { [weak self] index in
//            if (identifier != nil) {
//                self?.toolbarController.cancelSelected(identifier!)
//            }
//            
//            if (self?.currentWindowController == nil) {
//                return
//            }
//            self?.view.window?.endSheet(self!.currentWindowController.window!)
//            self?.currentWindowController = nil
//        }
//        
//        self.view.window?.beginSheet((windowController?.window)!)
//        self.currentWindowController = windowController
    }
    //MARK: 转档 -
    func showAllConvertWindow(convertT: KMConvertType) {
        let convertWC = KMConvertWindowController(documemtV: self.document!, currentPage: self.listView.currentPage(), convertT: convertT) {
            DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 0.25) { [self] in
                var type: KMConvertWithPDFType = .WordAdvance
                switch convertT {
                case .Word:
                    break
                case .Excel:
                    type = .Excel
                case .PPT:
                    type = .PowerPoint
                case .RTF:
                    type = .RTF
                case .CSV:
                    type = .CSV
                case .HTML:
                    type = .HTML
                case .Text:
                    type = .Text
                case .JPEG:
                    type = .JPEG
                case .PNG:
                    type = .PNG
                case .GIF:
                    type = .GIF
                case .JPG:
                    type = .JPG
                case .TIFF:
                    type = .TIFF
                case .TGA:
                    type = .TGA
                case .BMP:
                    type = .BMP
                case .JP2:
                    type = .JPEG2000
                case .AdvancedWord:
                    break
                default:
                    break
                }
//                let document = self.document
                let batchWindowController = KMBatchOperateWindowController.sharedWindowController
                
                var needShowHint = false
                if KMConvertOperationQueue.sharedQueue.operations.count > 0 {
                    needShowHint = true
                } else {
                    var needContinue = false
                    if KMBatchOperateManager.defaultManager.files?.count ?? 0 > 0 {
                        let arr: [String] = converFilesToPath(files: KMBatchOperateManager.defaultManager.files!)
                        let ss = self.document?.documentURL.path
                        if arr.contains(ss!) {
                            needContinue = false
                        }else {
                            needContinue = true
                        }
                    }else {
                        needContinue = true
                    }
                    
                    if needContinue {
                        let ss = self.document?.documentURL.path
                        let file = KMBatchOperateFile(filePath: ss!, type: .Convert)
                        file.password = document?.password ?? ""
                        KMBatchOperateManager.defaultManager.files?.append(file)
                    }
                    batchWindowController.switchToOperateType(.Convert, files: KMBatchOperateManager.defaultManager.files!)
                    batchWindowController.switchToConvertType(convertType: type)
                }

                batchWindowController.window?.makeKeyAndOrderFront(nil)
                if needShowHint {
                    batchWindowController.showIsConvertingHint()
                } else {
                    
                }
            }
        }
        self.km_beginSheet(windowC: convertWC)
    }
    //MARK: 转档 - OCR
    func showOCRWindow() {
        let com = KMOCRPDFWindowController(cpdfDocument: self.listView.document!, pwd: self.listView.document.password)
        self.km_beginSheet(windowC: com)
    }
    
    //MARK: 数字签名
    
    func hasShowDigitalSign() -> Bool {
        return self.digitalSignController?.view.superview != nil
    }
    
    func exitDigitalSign() {
        self.digitalSignController?.view.removeFromSuperview()
        self.digitalSignController = nil
    }
    
    func showDigitalSignWindow(withFilePathURL fileURL: URL) {
        if hasShowDigitalSign() {
            self.exitDigitalSign()
        }
        
        var currentPageIndex = listView.document?.index(for: listView.currentPage()) ?? 0
        var password: String = ""
        
        self.toolbarController.toolbarType = .None
        if digitalSignController == nil {
            password = listView.document?.password ?? ""
            
            digitalSignController = KMPDFDigitalSignViewController()
        }
        
        digitalSignController?.currentPageIndex = Int(currentPageIndex)
        digitalSignController?.url = listView.document.documentURL
        digitalSignController?.password = password
        digitalSignController?.scaleFactor = listView.scaleFactor
        
        digitalSignController?.titleChangeBlock = { [weak self] title, index in
            currentPageIndex = UInt(index)
        }
        
        digitalSignController?.buttonActionBlock = { [unowned self] type, isChanged in
            if type == .cancel {
//                self.toolbarController?.digitalSignModeButtonAction(nil)
                if let page = self.listView.document?.page(at: currentPageIndex) {
                    self.listView.go(to: page)
                }
                
                self.digitalSignController?.view.removeFromSuperview()
                self.digitalSignController = nil
            }
        }
        
        if let digitalSignView = digitalSignController?.view, let splitViewSuperview = mianSplitView.superview {
            digitalSignView.frame = splitViewSuperview.bounds
            digitalSignView.autoresizingMask = [.width, .height]
            splitViewSuperview.addSubview(digitalSignView)
        }
    }
    
    //MARK: 导出图片
    func extractImageAction(num: Int) {
        if !(self.listView.document.allowsPrinting || self.listView.document.allowsCopying) {
            let alert = NSAlert()
            alert.alertStyle = .critical
            alert.messageText = NSLocalizedString("This is a secured document. Editing is not permitted.", comment: "")
            alert.runModal()
            return
        }
        //        if sender is KMToolbarItem {
        //            (sender as! KMToolbarItem).isSelected = false
        //        }
        
        //        if !IAPProductsManager.defaultManager.isAvailableAllFunction {
        //            KMPurchaseCompareWindowController.sharedInstance().showWindow(nil)
        //            return
        //        }
        
        let document = self.listView.document
        var fileURL = document?.documentURL
        
        if num == 1 {
            let pageCount = self.document?.pageCount ?? 0
            var indeSet = NSMutableIndexSet()

            indeSet.add(in: NSRange(location: 0, length: Int(pageCount)))
            if indeSet.count == 0 {
                return
            }
            let lastPathName = fileURL?.deletingPathExtension().lastPathComponent ?? ""
            let tFileName = (String(format: "%@_Extract Images", lastPathName))
            let outputSavePanel = NSSavePanel()
            outputSavePanel.title = NSLocalizedString("Save as PDF", comment: "")
            outputSavePanel.allowsOtherFileTypes = true
            outputSavePanel.isExtensionHidden = true
            outputSavePanel.canCreateDirectories = true
            outputSavePanel.nameFieldStringValue = tFileName
            outputSavePanel.beginSheetModal(for: self.view.window!, completionHandler: { (result) in
                if result == NSApplication.ModalResponse.OK {
                    DispatchQueue.main.async {
                        self.beginProgressSheet(withMessage: NSLocalizedString("Extracting all pictures...", comment: "") + "...", maxValue: 0)
                        let tDestFile = outputSavePanel.url!.path
                        let uniquePath = KMExtractImageWindowController.createDestFolder(path: tDestFile, isUnique: false)
                        let pdfconverter = PDFConvertObject()
                        pdfconverter.extractResourcesFromPDF(at: fileURL?.path ?? "", pdfPassword: document?.password, selectIndexSet: indeSet as IndexSet, destDocPath: uniquePath, moreOptions: nil)
                        self.dismissProgressSheet()
                        let fileManager = FileManager.default
                        if fileManager.fileExists(atPath: tDestFile) {
                            let workspace = NSWorkspace.shared
                            let url = URL(fileURLWithPath: tDestFile)
                            workspace.activateFileViewerSelecting([url])
                        }
                    }
                }
            })
            return
        }
        
        if fileURL != nil {
            self.myDocument?.save(nil)
        } else {
            let myDocument = self.myDocument
            let str = String(format: "%@.pdf", myDocument?.displayName ?? "")
            let writeSuccess = self.document!.write(to: URL(fileURLWithPath: (kTempSavePath?.stringByAppendingPathComponent(str))!))
            if writeSuccess {
                var documentTemp = CPDFDocument(url: URL(fileURLWithPath: (kTempSavePath?.stringByAppendingPathComponent(str))!))
                fileURL = self.document?.documentURL
            } else {
                NSSound.beep()
                return
            }
        }
        let extract = KMExtractImageWindowController(windowNibName: "KMExtractImageWindowController")
        extract.docPath = fileURL?.path ?? ""
        extract.password = document?.password ?? ""
        extract.currentPage = self.listView.currentPageIndex
//        extract.beginSheetModal(for: NSApp.mainWindow!, completionHandler: nil)
        self.km_beginSheet(windowC: extract)
        extract.selectCurrentPageBtn()
//        self.showCreateStamp()
//        self.showAddSignature()
    }
    //MARK: 创建文字图章示例实际上不会在这里使用
    func showCreateStamp() {
        let stampCreaterWindowController = KMStampCreaterWindowController()
        stampCreaterWindowController.window?.backgroundColor = .clear
        self.km_beginSheet(windowC: stampCreaterWindowController)
        stampCreaterWindowController.closeCallBack = { result in
            if result == 1 {
                
            }
        }
    }
    //MARK: 添加签名示例实际上不会在这里使用
    func showAddSignature() {
        let signatureWindowController = KMSignatureWindowController(windowNibName: "KMSignatureWindowController")//[[KMSignatureWindowController alloc] initWithWindowNibName:@"KMSignatureWindowController"];
//        signatureWindowController.window?.backgroundColor = .clear
        signatureWindowController.beginSheetModal(for: self.view.window) { signature in
            
        }
    }
    
    func beginProgressSheet(withMessage message: String, maxValue: UInt) {
//        if progressController == nil {
//            progressController = SKProgressController(windowNibName: "ProgressSheet")
//        }
        let progress = SKProgressController()
        progress.window?.backgroundColor = NSColor.km_init(hex: "#36383B")
        progress.window?.contentView?.wantsLayer = true
        progress.window?.contentView?.layer?.backgroundColor = NSColor.km_init(hex: "#36383B").cgColor
        progress.progressField.textColor = NSColor.white
        progress.message = NSLocalizedString("Converting...", comment: "")
        progressController = progress
        progressController?.message = message
        if maxValue > 0 {
            progressController?.indeterminate = false
            progressController?.maxValue = Double(maxValue)
        } else {
            progressController?.indeterminate = true
        }
        self.km_beginSheet(windowC: progressController!)
    }
    
    func dismissProgressSheet() {
        progressController?.stopAnimation()
        self.km_endSheet()
        progressController = nil
    }
    
    func converFilesToPath(files: Array<KMBatchOperateFile>) -> [String] {
        let newArr = NSMutableArray()
        for item in files {
            newArr.add(item.filePath)
        }
        return newArr as! [String]
    }
    
    internal func showPrintWindow(pageRange: KMPrintPageRange = KMPrintPageRange(type: .allPage, selectPages: [])) {
        if (self.listView.document != nil && !self.listView.document.allowsPrinting) { // 有打印限制
            KMPasswordInputWindow.openWindow(window: self.view.window!, type: .owner,  url: self.listView.document.documentURL) { [weak self] result ,password in
                if (result == .cancel) {
                    return
                }
                // 解除权限
                self?.listView.document.unlock(withPassword: password)
                // 隐藏提示
                self?.hiddenSecureLimitTip()
                // 去打印
                if let data = self?.saveWatermarkFlag, !data {
                    KMPrintWindowController.openDocument(inputDocument: self!.listView?.document, inputPageRange: pageRange)
                    return
                }
                if let _url = KMTools.saveWatermarkDocumentToTemp(document: self!.listView.document, secureOptions: self!.secureOptions, removePWD: self!.removeSecureFlag) {
                    _ = CPDFDocument(url: _url)
                    KMPrintWindowController.showPrintWindowControll(inputData: _url, inputDocument: self?.listView.document, inputPageRange: pageRange)
                } else {
                    KMPrintWindowController.openDocument(inputDocument: self?.listView?.document, inputPageRange: pageRange)
                }
            }
            return
        }
        if (!self.saveWatermarkFlag) {
            KMPrintWindowController.openDocument(inputDocument: self.listView?.document, inputPageRange: pageRange)
            return
        }
        if let _url = KMTools.saveWatermarkDocumentToTemp(document: self.listView.document, secureOptions: self.secureOptions, removePWD: self.removeSecureFlag) {
            let _document = CPDFDocument(url: _url)
            KMPrintWindowController.showPrintWindowControll(inputData: _url, inputDocument: self.listView.document, inputPageRange: pageRange)
        } else {
            KMPrintWindowController.openDocument(inputDocument: self.listView?.document, inputPageRange: pageRange)
        }
    }
    
    // MARK: - Split View
    
    @IBAction func secondaryViewOpenFile(_ sender: NSButton) -> Void {
        
    }
    
    @objc func removeSecondaryPdfContentView(_ sender: Notification?) {
        if let _ = sender {
            NotificationCenter.default.removeObserver(self, name: KMSplitView.animationDidEndNotification, object: self.newPDFSplitView)
        }
        self.secondaryPdfContentView?.removeFromSuperview()
        self.newPDFSplitView.adjustSubviews()
    }
    
    func singlePageScreen(isSinglePage: Bool, doublePagesScreen isHorizontal: Bool) -> Void {
        if !isSinglePage && isHorizontal {
            self.openSecondaryPdfView?.changeBenefit(ofContrastLabelWidth: 208)
        }
        if (!isSinglePage && !isHorizontal) {
            self.openSecondaryPdfView?.changeBenefit(ofContrastLabelWidth: 300)
        }
        self.displaySinglePageScreen(isSinglePage: isSinglePage, doublePageScreen: isHorizontal)
    }
    
    func displaySinglePageScreen(isSinglePage: Bool, doublePageScreen isHorizontal: Bool) -> Void {
        if isSinglePage {
            if self.newPDFSplitView.animating {
                return
            }
            if self.secondaryPdfContentView?.window != nil {
                self.lastSplitPDFHeight = self.lastSplitPDFHeightFloat(self.secondaryPdfContentView?.frame ?? .zero)
                self.newPDFSplitView.setPosition(self.newPDFSplitView.maxPossiblePositionOfDivider(at: 0), ofDividerAt: 0, animate: true)
                if self.newPDFSplitView.animating {
                    NotificationCenter.default.addObserver(self, selector: #selector(removeSecondaryPdfContentView), name: KMSplitView.animationDidEndNotification, object: self.newPDFSplitView)
                } else {
                    self.removeSecondaryPdfContentView(nil)
                }
            }
            self.view.window?.recalculateKeyViewLoop()
            if self.interactionMode == .SKLegacyFullScreenMode {
                self.view.window?.makeFirstResponder(self.listView)
            }
        } else {
            if self.newPDFSplitView.animating {
                return
            }
            self.newPDFSplitView.dividerStyle = .paneSplitter
            self.newPDFSplitView.isVertical = isHorizontal
            if self.secondaryPdfView?.window == nil {
                let frame = self.newPDFSplitView.bounds

                if (self.lastSplitPDFHeight <= 0.0) {
                    var DEFAULT_SPLIT_PDF_FACTOR: Float = 0.3
                    self.lastSplitPDFHeight = floorf(DEFAULT_SPLIT_PDF_FACTOR * self.lastSplitPDFHeightFloat(frame))
                }
                
                var position = self.lastSplitPDFHeightFloat(frame)-self.lastSplitPDFHeight-Float(self.newPDFSplitView.dividerThickness)
                var point: NSPoint = .zero
                var page: CPDFPage?
                self.newPDFSplitView.setPosition(position.cgFloat, ofDividerAt: 0, animate: true)

                if (self.secondaryPdfContentView == nil) {
//                    secondaryPdfContentView = [[SKGradientView alloc] initWithFrame:NSMakeRect(0.0, 0.0, 200.0, 20.0)];
                    self.secondaryPdfContentView = NSView(frame: NSMakeRect(0, 0, 200, 20))
                    self.secondaryPdfView = KMSecondaryPDFView(frame: self.secondaryPdfContentView?.bounds ?? .zero)
                    self.secondaryPdfView?.autoresizingMask = [.width, .height]
//                    self.secondaryPdfContentView?.isHidden = true
                    self.secondaryPdfContentView?.addSubview(self.secondaryPdfView!)
                    self.newPDFSplitView.addSubview(self.secondaryPdfContentView!)
//                    self.newPDFSplitView.addArrangedSubview(self.secondaryPdfContentView!)
//                    // Because of a PDFView bug, display properties can not be changed before it is placed in a window
                    self.secondaryPdfView?.synchronizedPDFView = self.listView
                    self.secondaryPdfView?.backgroundColor = self.listView.backgroundColor
//                    [secondaryPdfView applyDefaultPageBackgroundColor];
                    self.secondaryPdfView?.displaysPageBreaks = false
                    self.secondaryPdfView?.setShouldAntiAlias(KMPreference.shared.antiAliasText)
                    self.secondaryPdfView?.applyDefaultInterpolationQuality()
                    self.secondaryPdfView?.setGreekingThreshold(KMPreference.shared.greekThreshold.cgFloat)
                    self.secondaryPdfView?.setSynchronizeZoom(true)
//        //            [secondaryPdfView setDocument:[pdfView document]];
                    point = NSMakePoint(NSMinX(frame), NSMaxY(frame) - position.cgFloat - self.newPDFSplitView.dividerThickness)
                    page = self.listView.page(for: point, nearest: true)
//
                    let controlView = self.secondaryPdfView?.controlView
                    var color = NSColor(calibratedWhite: 0.97, alpha: 1.0)
                    if KMAppearance.isDarkMode() {
                        color = KMAppearance.Layout.l0Color()
                    }
//                    [(SKGradientView *)secondaryPdfContentView setGradient:[[[NSGradient alloc] initWithStartingColor:color endingColor:color] autorelease]];
//                    [(SKGradientView *)secondaryPdfContentView setAlternateGradient:nil];
                    var pdfRect: NSRect = .zero
                    var controlRect: NSRect = .zero
                    NSDivideRect(self.secondaryPdfContentView?.bounds ?? .zero, &controlRect, &pdfRect, NSHeight(controlView?.frame ?? .zero), .minY)
                    controlRect.size.width = NSWidth(controlView?.frame ?? .zero)
                    controlView?.frame = controlRect
                    controlView?.autoresizingMask = [.maxXMargin, .maxYMargin, .width]
//                    [(SKGradientView *)secondaryPdfContentView setMinSize:controlRect.size];
                    self.secondaryPdfView?.frame = pdfRect
                    self.secondaryPdfContentView?.addSubview(controlView!)

                    self.openSecondaryPdfView = KMSecondaryViewController()
                    self.openSecondaryPdfView?.view.frame = self.secondaryPdfContentView?.frame ?? .zero
                    self.secondaryPdfContentView?.addSubview(self.openSecondaryPdfView!.view)
                    self.openSecondaryPdfView?.secondaryView.receivedFileUrlBlock = { [weak self] fileUrl in
                        if let docUrl = fileUrl {
                            _ = self?.displaySecondaryPDFView(withUrl: docUrl)
                            self?.openSecondaryPdfView?.view.removeFromSuperview()
                            self?.openSecondaryPdfView = nil
                        }
                    }
                    self.openSecondaryPdfView?.delegate = self
                    if (!isHorizontal) {
                        self.openSecondaryPdfView?.changeBenefit(ofContrastLabelWidth: 300)
                    }
                } else {
                    self.secondaryPdfContentView?.isHidden = true
                    self.newPDFSplitView.addSubview(self.secondaryPdfContentView!)
                }
                
//                self.newPDFSplitView.setPosition(self.secondaryPdfContentView?.bounds.size.width ?? 120, ofDividerAt: 1, animate: true)

                if (page != nil) {
                    self.secondaryPdfView?.go(toPageIndex: Int(page!.pageIndex()), animated: false)
//                    point = [secondaryPdfView convertPoint:[secondaryPdfView convertPoint:[pdfView convertPoint:point toPage:page] fromPage:page] toView:[secondaryPdfView documentView]];
                    let tmpP = self.listView.convert(point, to: page)
                    let conP = self.secondaryPdfView?.convert(tmpP, from: page) ?? .zero
                    point = self.secondaryPdfView?.convert(conP, to: self.secondaryPdfView?.documentView()) ?? .zero
                    if let docView = self.secondaryPdfView?.documentView(), docView.contentView.isFlipped == false {
                        point.y -= docView.isFlipped ? -NSHeight(docView.visibleRect) : NSHeight(docView.visibleRect)
                    }
                    self.secondaryPdfView?.documentView()?.scroll(point)
                    self.secondaryPdfView?.layoutDocumentView()
                }
            }
            self.view.window?.recalculateKeyViewLoop()
            if self.interactionMode == .SKLegacyFullScreenMode {
                self.view.window?.makeFirstResponder(self.listView)
            }

            if self.secondaryPdfView?.document == nil {
                self.openSecondaryPdfView?.viewHighlyAdaptive()
            }
        }
    }
    
    func lastSplitPDFHeightFloat(_ rect: NSRect) -> Float {
        if (self.newPDFSplitView.isVertical) {
            return Float(NSWidth(rect))
        } else {
            return Float(NSHeight(rect))
        }
    }
    
    func displaySecondaryPDFView(withUrl url: URL) -> Bool {
        let document = CPDFDocument.init(url: url)
        if document != nil {
            self.secondaryPdfView?.document = nil
            self.secondaryPdfView?.document = document
            return true
        } else {
            return false
        }
    }
    
    func updateNextAndPreViousButtonState() {
        let item = self.toolbarController.mainToolBarView?.toolbarItemFindItemIdentifiers(value: KMDocumentNextPageToolbarItemIdentifier)
        let toItem = self.toolbarController.mainToolBarView?.toolbarItemFindItemIdentifiers(value: KMDocumentPreviousPageToolbarItemIdentifier)
        if self.listView.canGoToNextPage() {
            item?.unEnabled = false
        } else {
            item?.unEnabled = true
        }
        if self.listView.canGoToPreviousPage() {
            toItem?.unEnabled = false
        } else {
            toItem?.unEnabled = true
        }
    }
    
    func updateBackAndForwardButtonState() {
        let item = self.toolbarController.mainToolBarView?.toolbarItemFindItemIdentifiers(value: KMDocumentNextPageToolbarItemIdentifier)
        let toItem = self.toolbarController.mainToolBarView?.toolbarItemFindItemIdentifiers(value: KMDocumentPreviousPageToolbarItemIdentifier)
        if self.listView.km_canGoBack() {
            item?.unEnabled = false
        } else {
            item?.unEnabled = true
        }
        if self.listView.km_canGoForward() {
            toItem?.unEnabled = false
        } else {
            toItem?.unEnabled = true
        }
    }
    
    func updateZoomInOutButtonState() {
        let item : KMToolbarItemView = (self.toolbarController.mainToolBarView?.toolbarItemFindItemIdentifiers(value: KMDocumentZoomOutToolbarItemIdentifier)) ?? KMToolbarItemView()
        let toItem : KMToolbarItemView = (self.toolbarController.mainToolBarView?.toolbarItemFindItemIdentifiers(value: KMDocumentZoomToolbarItemIdentifier)) ?? KMToolbarItemView()
        if self.listView.canZoomIn {
            item.unEnabled = false
        } else {
            item.unEnabled = true
        }
        if self.listView.canZoomOut {
            toItem.unEnabled = false
        } else {
            toItem.unEnabled = true
        }
    }
}

// MARK: -
// MARK: - KMSecondaryViewControllerDelegate

extension KMMainViewController: KMSecondaryViewControllerDelegate {
    func receivedFileUrl(_ url: URL!) {
        let state = self.displaySecondaryPDFView(withUrl: url)
        if !state {
            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
        } else {
            self.openSecondaryPdfView?.view.removeFromSuperview()
            self.openSecondaryPdfView = nil
        }
    }
}

// MARK: -
// MARK: - KMMainToolbarControllerDelegate

extension KMMainViewController : KMMainToolbarControllerDelegate {
    func changeModelAction(mode: CToolMode) {
        self.listView.toolMode = mode
        if mode == .editPDFToolMode {
            self.childToolbarController.updateType(newType: .editPDF)
        }
    }
    
   func toolbarViewController(_ viewController:KMToolbarViewController, zoomModel selectedTag:Int) {
        switch selectedTag {
        case 2:
            if self.listView.scaleFactor != 1.0 {
                self.listView.scaleFactor = 1.0
                self.listView.autoScales = false
            }
            break
        case 1:
            let pageHeight = self.listView.currentPage()!.size.height
            let pdfviewHeight = self.listView.bounds.size.height
            self.listView.scaleFactor = pdfviewHeight/pageHeight
            self.listView.autoScales = false
            break
        case 0:
            //            self.listView.autoScales = !self.listView.autoScales
            self.listView.autoScales = true
            break
        case 3:
            self.listView.scaleFactor = 0.1
            break
        case 4:
            self.listView.scaleFactor = 0.25
            break
        case 5:
            self.listView.scaleFactor = 0.5
            break
        case 6:
            self.listView.scaleFactor = 0.75
            break
        case 7:
            self.listView.scaleFactor = 1.0
            break
        case 8:
            self.listView.scaleFactor = 1.5
            break
        case 9:
            self.listView.scaleFactor = 2.0
            break
        case 10:
            self.listView.scaleFactor = 4.0
            break
        case 11:
            self.listView.scaleFactor = 8.0
            break
        case 12:
            self.listView.scaleFactor = 10.0
            break
        default:
            break
        }
       viewController.zoomTextField.stringValue =  "\(Int(self.listView.scaleFactor*100))%"
    }
    
    func toolbarViewController(_ viewController: KMToolbarViewController, zoomSting: String) {
        var scale = CGFloat((NSString(string: zoomSting)).floatValue / 100.0)
        if scale > 100 {
            scale = 100
        }
        if (scale <= 0.101) {
            self.listView.scaleFactor = self.listView.minScaleFactor()
        } else {
            self.listView.scaleFactor = scale
        }
        
        viewController.zoomTextField.stringValue =  "\(Int(self.listView.scaleFactor*100))%"
        DispatchQueue.main.async {
            self.updateZoomInOutButtonState()
        }
    }
    
    func changePDFViewZoomInAction() {
        let zoomSting = self.toolbarController.mainToolBarView?.zoomTextField.stringValue ?? "10"
        var scale = CGFloat((NSString(string: zoomSting)).floatValue / 100.0)
        switch scale {
        case 0...0.25:
            scale += 0.25
        case 0.25...3:
            scale += 0.25
        case 3.1...10:
            scale += 0.4
        case 10.1...100:
            scale += 1
        default:
            scale += 1
        }
        self.listView.scaleFactor = scale
        self.toolbarController.mainToolBarView?.zoomTextField.stringValue =  "\(nearbyint(self.listView.scaleFactor*100))%"
        //        self.listView.zoomIn(nil)
    }
    
    func changePDFViewZoomOutAction() {
        let zoomSting = self.toolbarController.mainToolBarView?.zoomTextField.stringValue ?? "10"
        var scale = CGFloat((NSString(string: zoomSting)).floatValue / 100.0)
        switch scale {
        case 0...0.25:
            scale = 0
        case 0.25...3:
            scale -= 0.25
        case 3.1...10:
            scale -= 0.4
        case 10.1...100:
            scale -= 1
        default:
            scale -= 1
        }
        self.listView.scaleFactor = scale
        self.toolbarController.mainToolBarView?.zoomTextField.stringValue =  "\(nearbyint(self.listView.scaleFactor*100))%"
//        self.listView.zoomOut(nil)
//        self.updateZoomInOutButtonState()
    }
    
    func changePDFViewGotoNextPageAction() {
        self.listView.km_goBack(nil)
        if (self.listView.canGoToNextPage()) {
            self.listView.goToNextPage(nil)
        }
        self.updateNextAndPreViousButtonState()
    }
    
    func changePDFViewGoToPreviousPageAction() {
        if (self.listView.canGoToPreviousPage()) {
            self.listView.goToPreviousPage(nil)
        }
        self.updateNextAndPreViousButtonState()
    }
    
    func changePDFViewGotoBackAction() {
        self.listView.km_goBack(nil)
        self.updateBackAndForwardButtonState()
    }
    
    func changePDFViewGoToForwardAction() {
        self.listView.km_goForward(nil)
        self.updateBackAndForwardButtonState()
    }
    
    func aiTranslationPDFFileAction() {
        #if VERSION_DMG
        #else
        if !KMLightMemberManager.manager.isLogin() && NSApp.mainWindow != nil {
            KMLoginWindowController.show(window: NSApp.mainWindow!)

            return
        }
        #endif
        self.trackEvent_aiTranslate()
        self._aiTranslationPDFFileAction()
//        Task { @MainActor in
//            if await (KMLightMemberManager.manager.canPayFunction() == false) {
//                let _ = KMSubscribeWaterMarkWindowController.show(window: self.view.window!, type: .aiTranslate) { isSub, _, isClose in
//                    if (isClose) {
//                        return
//                    }
//                    if (isSub) {
//                        self._aiTranslationPDFFileAction()
//                        return
//                    }
//                }
//                return
//            }
//
//            self._aiTranslationPDFFileAction()
//        }
    }
    
    private func _aiTranslationPDFFileAction() {
        let isExceedsLimit = self.isPDFPageCountExceedsLimit(filePath: (self.document?.documentURL.path)!)
        if self.isFileGreaterThan10MB(atPath: (self.document?.documentURL.path)!) {
            let alert = NSAlert()
            alert.alertStyle = .critical
            alert.messageText = NSLocalizedString("The uploaded file size cannot exceed 10MB", comment: "")
            alert.runModal()

            return
        } else if isExceedsLimit  {
            let alert = NSAlert()
            alert.alertStyle = .critical
            alert.messageText = NSLocalizedString("Documents cannot exceed 30 pages", comment: "")
            alert.runModal()

            return
        }
        
        let alert = NSAlert()
        alert.messageText = NSLocalizedString("Processing times may be longer for larger documents. Thank you for your patience.", comment: "")
        alert.addButton(withTitle: NSLocalizedString("Continue", comment: ""))
        alert.addButton(withTitle: NSLocalizedString("Cancel", comment: ""))
        alert.beginSheetModal(for: view.window!) { [unowned self] result in
            if (result == .alertFirstButtonReturn) {
                self.aiTranslationConfirWC = KMAITranslationConfirmWindowController.init(windowNibName: NSNib.Name("KMAITranslationConfirmWindowController"))
                self.aiTranslationConfirWC!.filePath = (self.document?.documentURL.path)!
                self.view.window?.beginSheet(self.aiTranslationConfirWC!.window!)
            } else if result == .alertSecondButtonReturn {
                return
            }
        }
    }
    
    func toolbarViewController(_ viewController: KMToolbarViewController, shareAction toolbarItem: KMToolbarItemView) {
        self.trackEvent_share()
    }
    
    func toolbarViewController(_ viewController: KMToolbarViewController, shareDocument item: NSMenuItem) {
        if (!self.saveWatermarkFlag) {
            self.shareDocument(sender: viewController)
            return
        }
        Task { @MainActor in
            if await (KMLightMemberManager.manager.canPayFunction() == false) {
                KMSubscribeWaterMarkWindowController.show(window: self.view.window!, isContinue: true) { isSubscribeSuccess, isWaterMarkExport, isClose in
                    if (isClose) {
                        return
                    }
                    if (isSubscribeSuccess) {
                        self.shareDocument(sender: viewController)
                        return
                    }
                    if (isWaterMarkExport) {
                        self.shareDocument(sender: viewController, limit: true)
                        return
                    }
                }
                return
            }
            self.shareDocument(sender: viewController)
        }
    }
    
    func toolbarViewController(_ viewController: KMToolbarViewController, shareFlatten item: NSMenuItem) {
//        if (!self.saveWatermarkFlag) {
//            self.shareFlatten(sender: viewController)
//            return
//        }
        Task { @MainActor in
#if VERSION_DMG
            if await (KMLightMemberManager.manager.canUseAdvanced() == false) {
                let _ = KMComparativeTableViewController.show(window: self.view.window!, .shareFlatten)
                return
            }
#endif
            if await (KMLightMemberManager.manager.canPayFunction() == false) {
                KMSubscribeWaterMarkWindowController.show(window: self.view.window!, isContinue: true) { isSubscribeSuccess, isWaterMarkExport, isClose in
                    if (isClose) {
                        return
                    }
                    if (isSubscribeSuccess) {
                        self.shareFlatten(sender: viewController)
                        return
                    }
                    if (isWaterMarkExport) {
                        self.shareFlatten(sender: viewController, limit: true)
                        return
                    }
                }
                return
            }
            self.shareFlatten(sender: viewController)
        }
    }
    
    func toolbarViewController(_ viewController: KMToolbarViewController, shareOriginalPDF item: NSMenuItem) {
        if (!self.saveWatermarkFlag) {
            self.shareOriginalPDF(sender: viewController)
            return
        }
        Task { @MainActor in
            if await (KMLightMemberManager.manager.canPayFunction() == false) {
                let _ = KMSubscribeWaterMarkWindowController.show(window: self.view.window!, isContinue: true) { isSubscribeSuccess, isWaterMarkExport, isClose in
                    if (isClose) {
                        return
                    }
                    if (isSubscribeSuccess) {
                        self.shareOriginalPDF(sender: viewController)
                        return
                    }
                    if (isWaterMarkExport) {
                        self.shareOriginalPDF(sender: viewController, limit: true)
                        return
                    }
                }
                return
            }
            self.shareOriginalPDF(sender: viewController)
        }
    }
    
    func toolbarViewController(_ viewController: KMToolbarViewController, scanOCRModel selectedTag: Int) {
        if(0 == selectedTag) {
//            self.documentAIViewController?.enteredIncreaseAllPage()
//            self.documentAIViewController?.updateToolState(false)
        } else {
//            self.documentAIViewController?.recognitionPageString("1", with: .english)
//            self.documentAIViewController?.recognitionPartModel(with: .english)
//            self.documentAIViewController?.updateToolState(true)
        }
        // 0 : Scan  1:OCR Text
    }
    
    func mainToolDidClicked(_ toolController: KMToolbarController, _ beforeType: KMToolbarViewType, _ type: KMToolbarViewType, _ item: KMToolbarItemView , _ pages: [Int]) {
        if beforeType == .editPDF {
//            self.asyncSaveDocument { params in
//
//            }
        }
        
        // 埋点
        self.trackEvent(toolType: type)
        
        if(type != .Page) {
            if (hasEnterPageEdit()) {
                self.exitPageEdit()
            }
        }
        if type != .redact {
            if self.hasEnterRedact() {
                self.exitRedact()
            }
        }
        if item.itemIdentifier != KMDocumentDigitalSignToolbarItemIdentifier {
            if self.hasShowDigitalSign() {
                self.exitDigitalSign()
            }
        }
        
        if(type != .ScanOCR) {
//            if ((self.documentAIViewController?.view.superview) != nil) {
//                self.listView.isHidden = false
//                self.documentAIViewController?.creatRecognitionDocument()
//                self.documentAIViewController?.view .removeFromSuperview()
//                self.documentAIViewController = nil;
//                self.listView.layoutDocumentView()
//            }
        }
        
        if (type == .Page) {
            if (hasEnterPageEdit()) {
                self.exitPageEdit()
            } else {
                self.enterPageEdit(pages)
            }
        } else if(type == .ScanOCR) {
//            if((self.documentAIViewController?.view.superview) != nil) {
//                let alert = NSAlert()
//                alert.messageText = NSLocalizedString("If you need to edit again after exit, you need to re-execute OCR recognition, sure you want to exit?", comment: "")
//                alert.addButton(withTitle: "YES")
//                alert.addButton(withTitle: "NO")
//                let result = alert.runModal()
//                if (result == .alertFirstButtonReturn) { /// 取消
//                    self.listView.isHidden = false
//                    self.documentAIViewController?.creatRecognitionDocument()
//                    self.documentAIViewController?.view .removeFromSuperview()
//                    self.documentAIViewController = nil;
//                    self.listView.layoutDocumentView()
//                } else {
//                    self.toolbarController.toolbarType = .ScanOCR
//                }
//            } else {
//                self.documentAIViewController = KMDocumentAIViewController(pdfView: self.listView)
//                self.PDFContendView.addSubview(self.documentAIViewController?.view ??  KMDocumentAIViewController().view);
//                self.documentAIViewController?.view.frame = self.PDFContendView.bounds
//                self.documentAIViewController?.view.autoresizingMask = NSView.AutoresizingMask([.width,.height])
//                self.listView.isHidden = true //不影藏的话会出现鼠标事件的崩溃
//            }
        } else if type == .editPDF {
            self.listView.annotationType = .editTextImage
        } else if type == .Annatiton {
            self.rightSideViewController.subViewType = .AnnotationProperts
        } else if type == .redact {
            self.enterRedact()
        } else if type == .Tool {
            self.loadOpenFileFunctionGuide(.pdfCompareGuide)
        } else if type == . Conversion {
            self.loadOpenFileFunctionGuide(.convertGuide)
        }
    }
    
    func clickChildTool(type: KMToolbarType, index: Int) {
        if (type == .secure) {
            if (index == 1) {
                self.trackEvent_setPassword()
            } else if (index == 2) {
                self.trackEvent_removePassword()
            }
        } else {
            self.trackEvent(toolBarType: type)
        }
        
        Task { @MainActor in
            if (type == .compress) { /// 压缩
                if await (KMLightMemberManager.manager.canPayFunction() == false) {
//                    self.view.window?.contentView?.superview?.beginLoading()
                    let document = self.listView.document
                    let secureOptions = self.secureOptions
                    let removeSecureFlag = self.removeSecureFlag
                    
//                    DispatchQueue.global().async { [unowned self] in
                        guard let _url = KMTools.saveWatermarkDocumentToTemp(document: document!, secureOptions: secureOptions, removePWD: removeSecureFlag) else {
//                            DispatchQueue.main.async {
//                                self.view.window?.contentView?.superview?.endLoading()
//                            }
                            return
                        }
//                        DispatchQueue.main.async {
//                            self.view.window?.contentView?.superview?.endLoading()
                            self.showCompressWindow(url: _url)
//                        }
//                    }
                    return
                }
                
                if (self.needSaveDocument()) {
                    self.saveDocumentWithProgressAlert { [unowned self] params in
                        self.showCompressWindow()
                    }
                    return
                }
                
                self.showCompressWindow()
                return
            }
            
            if ((KMToolbarType.word.rawValue ... KMToolbarType.conversion_image.rawValue).contains(type.rawValue)) { /// 转档
                var identifier: String?
                if (type == .word) { /// Word
                    identifier = KMToolbarConversionWordItemIdentifier
                } else if (type == .excel) {
                    identifier = KMToolbarConversionExcelItemIdentifier
                } else if (type == .ppt) {
                    identifier = KMToolbarConversionPPTItemIdentifier
                } else if (type == .rtf) {
                    identifier = KMToolbarConversionRTFItemIdentifier
                } else if (type == .html) {
                    identifier = KMToolbarConversionHTMLItemIdentifier
                } else if (type == .conversion_text) {
                    identifier = KMToolbarConversionTextItemIdentifier
                } else if (type == .csv) {
                    identifier = KMToolbarConversionCSVItemIdentifier
                } else if (type == .conversion_image) {
                    identifier = KMToolbarConversionImageItemIdentifier
                }
                
                #if VERSION_DMG
//                if await (KMLightMemberManager.manager.canUseAdvanced() == false) {
//                    if (identifier != nil) {
//                        self.toolbarController.cancelSelected(identifier!)
//                    }
                    
//                    let _ = KMComparativeTableViewController.show(window: self.view.window!, .convert)
//                    return
//                }
                #endif

                
//                if await (KMLightMemberManager.manager.canPayFunction() == false) {
//                    guard let _url =  KMTools.saveWatermarkDocumentToTemp(document: self.listView.document, secureOptions: self.secureOptions, removePWD: self.removeSecureFlag) else {
//                        return
//                    }
//                    self.showConvertWindow(type: type, documentUrl: _url, identifier: identifier)
//                    return
//                }
                
                if (self.needSaveDocument()) {
                    self.saveDocumentWithProgressAlert {  [unowned self] params in
                        self.showConvertWindow(type: type, identifier: identifier)
                    }
                    return
                }
                self.showConvertWindow(type: type, identifier: identifier)
                return
            }
            
            if (type == .merge) { /// 合并
                if (self.listView.document.allowsCopying == false || self.listView.document.allowsPrinting == false) {
                    if await (KMLightMemberManager.manager.canPayFunction() == false) {
                            KMPasswordInputWindow.openWindow(window: self.view.window!, type: .owner, url: self.listView.document.documentURL) { [unowned self] result , password in
                                if (result == .cancel) {
                                    return
                                }
                                 
                                guard let _url =  KMTools.saveWatermarkDocumentToTemp(document: self.listView.document, secureOptions: self.secureOptions, removePWD: self.removeSecureFlag) else {
                                    return
                                }
                                self.showMergeWindow(url: _url, password)
                            }
                        return
                    }
                    
                    KMPasswordInputWindow.openWindow(window: self.view.window!, type: .owner, url: self.listView.document.documentURL) { [unowned self] result , password in
                        if (result == .cancel) {
                            return
                        }
  
                            
                        if (self.needSaveDocument()) {
                            self.saveDocumentWithProgressAlert { [unowned self] params in
                                self.showMergeWindow(password)
                            }
                            return
                        }
                        
                        self.showMergeWindow(password)
                    }
                    return
                }
                
                if await (KMLightMemberManager.manager.canPayFunction() == false) {
                    guard let _url =  KMTools.saveWatermarkDocumentToTemp(document: self.listView.document, secureOptions: self.secureOptions, removePWD: self.removeSecureFlag) else {
                        return
                    }
                    self.showMergeWindow(url: _url, password)
                    return
                }
                
                if (self.needSaveDocument()) {
                    self.saveDocumentWithProgressAlert { [unowned self] params in
                        self.showMergeWindow(self.listView.document.password)
                    }
                    return
                }
                self.showMergeWindow(self.listView.document.password)
                return
            }
            
            if (type == .crop) {
        if !IAPProductsManager.default().isAvailableAllFunction(){
            KMPurchaseCompareWindowController.sharedInstance().showWindow(nil)
            return
        }

                self.recordSaveWatermarkFlag(type: .crop)
                
                if (index == 1) {
                    self.cropCurrentPage()
                    return
                }
                if (index == 2) {
                    self.cropAllPage()
                    return
                }
                
                //// 自定义裁剪区域
                //            self.cropCustomArea()
            } else if (type == .bates || type == .headerAndFooter) {
                if (index == 1) {
        if !IAPProductsManager.default().isAvailableAllFunction(){
            KMPurchaseCompareWindowController.sharedInstance().showWindow(nil)
            return
        }
                    
                    var windowController: KMBaseWindowController = KMBaseWindowController()
                    
                    if (type == .bates) {
                        windowController = KMHeaderFooterWindowController(windowNibName: "KMHeaderFooterWindowController")
                        (windowController as! KMHeaderFooterWindowController).operateCallBack = { [unowned self] controller, headerFooter in
                            let file = KMFileAttribute()
                            file.filePath = (self.document?.documentURL.path)!
                            self.showBatchWindow(type: .AddBates, files: [file])
                        }
                        
                        windowController.isBates = true
                    } else if (type == .headerAndFooter) {
                        windowController = KMHeaderFooterWindowController(windowNibName: "KMHeaderFooterWindowController")
                        (windowController as! KMHeaderFooterWindowController).operateCallBack = { [unowned self] controller, headerFooter in
                            let file = KMFileAttribute()
                            file.filePath = (self.document?.documentURL.path)!
                            self.showBatchWindow(type: .AddHeaderFooter, files: [file])
                        }
                    } else if (type == .background) {
//                        controller = KMBackgroundController()
                    } else if (type == .watermark) {
//                        controller = KMWatermarkViewController()
                    }
                    windowController.pdfDocument = self.listView.document
                    
                    windowController.cancelAction = { [unowned self] controller in
                        self.view.window?.endSheet((self.currentWindowController.window)!)
                        self.currentWindowController = nil
                    }
                    
                    self.currentWindowController = windowController
                    await self.view.window?.beginSheet(windowController.window!)
                    
                    return
                }
                if (index == 1) { /// 取消
                    self.toolbarController.exitWatermarkAdjective()
                    //                self.rightSideViewController.view.isHidden = true
                    self.rightSideViewController.isHidden = true
                    self.rightSideViewController.subViewType = .None
                    self.closeRightPane()
                    return
                } else if index == 3 {
                    let file = KMFileAttribute()
                    file.filePath = (self.document?.documentURL.path)!
                    if type == .bates {
                        self.showBatchWindow(type: .AddBates, files: [file])
                    } else {
                        self.showBatchWindow(type: .AddHeaderFooter, files: [file])
                    }
                } else if index == 4 {
                    let file = KMFileAttribute()
                    file.filePath = (self.document?.documentURL.path)!
                    if type == .bates {
                        self.showBatchWindow(type: .RemoveBates, files: [file])
                    } else {
                        self.showBatchWindow(type: .RemoveHeaderFooter, files: [file])
                    }
                } else if (index == 2) { //// 移除
        if !IAPProductsManager.default().isAvailableAllFunction(){
            KMPurchaseCompareWindowController.sharedInstance().showWindow(nil)
            return
        }
                    
                    if type == .headerAndFooter {
                        let savePanelAccessoryViewController = KMSavePanelAccessoryController()
                        let savePanel = NSSavePanel()
                        savePanel.nameFieldStringValue = self.document?.documentURL.deletingPathExtension().lastPathComponent ?? ""
                        savePanel.allowedFileTypes = ["pdf"]
                        savePanel.accessoryView = savePanelAccessoryViewController.view
                        savePanel.beginSheetModal(for: NSWindow.currentWindow()) { [unowned self] result in
                            if result.rawValue == NSApplication.ModalResponse.OK.rawValue {
                                KMHeaderFooterView.saveAsPDFRemoveAllHeaderFooter(document!, password: document?.password, toPath: savePanel.url!.path) { success in
                                    if savePanelAccessoryViewController.openAutomaticButton.state == .on {
                                        NSDocumentController.shared.openDocument(withContentsOf: URL(fileURLWithPath: savePanel.url!.path), display: true) { _, _, _ in
                                        }
                                    } else {
                                        NSWorkspace.shared.selectFile(savePanel.url?.path, inFileViewerRootedAtPath: "")
                                    }
                                }
                            }
                        }
                    } else if type == .bates {
                        let savePanelAccessoryViewController = KMSavePanelAccessoryController()
                        let savePanel = NSSavePanel()
                        savePanel.nameFieldStringValue = self.document?.documentURL.deletingPathExtension().lastPathComponent ?? ""
                        savePanel.allowedFileTypes = ["pdf"]
                        savePanel.accessoryView = savePanelAccessoryViewController.view
                        savePanel.beginSheetModal(for: NSWindow.currentWindow()) { [unowned self] result in
                            if result.rawValue == NSApplication.ModalResponse.OK.rawValue {
                                KMHeaderFooterView.saveAsPDFRemoveAllHeaderFooterBates(document!, password: document?.password, toPath: savePanel.url!.path) { success in
                                    if savePanelAccessoryViewController.openAutomaticButton.state == .on {
                                        NSDocumentController.shared.openDocument(withContentsOf: URL(fileURLWithPath: savePanel.url!.path), display: true) { _, _, _ in
                                        }
                                    } else {
                                        NSWorkspace.shared.selectFile(savePanel.url?.path, inFileViewerRootedAtPath: "")
                                    }
                                }
                            }
                        }
                    }
                
                    return
                } else if (index == 2) { /// 应用
                    let model = self.rightSideViewController.model
                    if (type == .bates || type == .headerAndFooter) {
                        if (model == nil || (model?.isKind(of: KMBatesModel.self) == false)) {
                            let alert = NSAlert()
                            alert.alertStyle = .critical
                            alert.messageText = "没有找到模型"
                            alert.runModal()
                            return
                        }
                        
                        if ((model as! KMBatesModel).hasVaild == false) {
                            let alert = NSAlert()
                            alert.alertStyle = .critical
                            alert.messageText = "没有找到内容"
                            alert.runModal()
                            return
                        }
                    }
                    
                    KMWatermarkAdjectiveTools.apply(model!, self.listView, self.listView.document.documentURL.path) {
                        result in
                        DispatchQueue.main.async {
                            self.listView.layoutDocumentView()
                            self.listView.setNeedsDisplayForVisiblePages()
                        }
                        if (result) {
                            let alert = NSAlert()
                            alert.alertStyle = .warning
                            alert.messageText = "成功"
                            alert.runModal()
                        } else {
                            let alert = NSAlert()
                            alert.alertStyle = .critical
                            alert.messageText = "失败"
                            alert.runModal()
                        }
                    }
                    return
                } else if index == 5 {
                    self.rightSideViewController.isHidden = false
                    self.rightSideViewController.subViewType = KMWatermarkAdjectiveTools.KMToolBarTypeToRightSubViewType(type)
                    self.openRightPane()
                }
            } else if (type == .redact) { /// 标记密文
                if !IAPProductsManager.default().isAvailableAllFunction(){
                    KMPurchaseCompareWindowController.sharedInstance().showWindow(nil)
                    return
                }
                
                if (index == 1) { /// 取消
                    if (self.hasAddRedact) {
                        let alert = NSAlert()
                        alert.messageText = NSLocalizedString("You can save a document with unapplied cipher text and edit it again. If you do not save, all changes will be lost.", comment: "")
                        alert.addButton(withTitle: NSLocalizedString("Don’t Save", comment: ""))
                        alert.addButton(withTitle: NSLocalizedString("Cancel", comment: ""))
                        let result = alert.runModal()
                        if (result == .alertFirstButtonReturn) {
                            self.listView.toolMode = .moveToolMode
                            self.toolbarController.exitRedact()
                        }
                        return
                    }
                    self.listView.toolMode = .moveToolMode
                    self.toolbarController.exitRedact()
                    return
                }
                if (index == 2) { /// 擦除
                    self.exeRedactConfirm(.eraserAll) {}
                    return
                }
                if (index == 3) { /// 应用
                    self.exeRedactConfirm(.redactAll) {}
                    return
                }
                if (index == 4) { /// 文本&图像
                    self.listView.toolMode = .redactToolMode
                    return
                }
                if (index == 5) { /// 页面
                    let windowController = KMRedactPageRangeWindowController(windowNibName: "KMRedactBaseWindowController")
                    await self.view.window?.beginSheet(windowController.window!)
                    self.currentWindowController = windowController
                    
                    windowController.itemClick = { [weak self] index, value in
                        if (index == 1) {
                            let topBarView = self?.toolbarController.fetchTopBarView()
                            if (topBarView == nil || topBarView?.isKind(of: KMRedactTopToolBar.self) == false) {
                                return
                            }
                            (topBarView as! KMRedactTopToolBar).selectItem(0)
                            self?.view.window?.endSheet((self?.currentWindowController.window)!)
                            self?.currentWindowController = nil
                            return
                        }
                        
                        let windowController_pageRange = self?.currentWindowController as! KMRedactPageRangeWindowController
                        let pageType = windowController_pageRange.pageType
                        let pageString = windowController_pageRange.pageString
                        if (pageType == 5) { /// 自定义页面
                            let array = KMPageRangeTools.findSelectPage(pageRangeString: pageString, pageCount: Int((self?.listView.document.pageCount)!))
                            if (array.count == 0) {
                                let alert = NSAlert()
                                alert.messageText = NSLocalizedString("Invalid page range or the page number is out of range. Please try again.", comment: "")
                                alert.runModal()
                                return
                            }
                        }
                        
                        self!.view.window?.endSheet(self!.currentWindowController.window!)
                        self!.currentWindowController = nil
                        var indexs: IndexSet = []
                        if (pageType == 1) { /// 当前页面
                            indexs.insert((self?.listView.currentPageIndex)!)
                        } else {
                            indexs = KMRedactTools.getPageIndexs(pageType-1, string: pageString, Int((self?.listView.document.pageCount)!))
                        }
                        
                        if (indexs.count == 0) {
                            return
                        }
                        
                        for i in indexs {
                            let page: CPDFPage = (self?.listView.document.page(at: UInt(i)))!
                            let redactAnno = CPDFRedactAnnotation(PDFListViewNoteWith: (self?.listView.document)!)
                            redactAnno.bounds = page.bounds
                            self?.listView.add(redactAnno, to: page)
                        }
                    }
                    
                    return
                }
            } else if (type == .secure) { /// 安全
        if !IAPProductsManager.default().isAvailableAllFunction(){
            KMPurchaseCompareWindowController.sharedInstance().showWindow(nil)
            return
        }
                
                if (index == 1) { /// 设置密码
                    if (!self.listView.document!.allowsCopying || !self.listView.document!.allowsPrinting) {
                        KMPasswordInputWindow.openWindow(window: self.view.window!, type: .owner, url: self.listView.document.documentURL) { [weak self]  result, password in
                            if (result == .cancel) {
                                return
                            }
                            
                            self?.isSaveKeyChain = false
                            self?.listView.document.unlock(withPassword: password)
                            self?.hiddenSecureLimitTip()
                            
                            self?.showSecureWindow((self?.listView.document.documentURL)!)
                        }
                        return
                    }
                    self.showSecureWindow(self.listView.document.documentURL)
                    return
                } else if index == 2 {
                    if !self.document!.allowsCopying || !self.document!.allowsPrinting {
                        let alert = NSAlert()
                        alert.alertStyle = .warning
                        alert.messageText = NSLocalizedString("Warning", comment: "")
                        alert.informativeText = NSLocalizedString("This is a secured document. Editing is not permitted.", comment: "")
                        alert.addButton(withTitle: NSLocalizedString("OK", comment: ""))
                        alert.addButton(withTitle: NSLocalizedString("Remove Security", comment: ""))
                        alert.beginSheetModal(for: NSWindow.currentWindow()) { returnCode in
                            if returnCode == .alertSecondButtonReturn {
                                DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 0.25) { [unowned self] in
                                    KMBaseWindowController.checkPassword(url: self.document!.documentURL!) { [unowned self] success, resultPassword in
                                        if success {
                                            self.document?.unlock(withPassword: resultPassword)
                                            self.clickChildTool(type: .secure, index: 2)
                                        }
                                    }
                                }
                            }
                        }
                    } else {
                        let controller = KMRemovePasswordWindowController(windowNibName: "KMRemovePasswordWindowController")
                        controller.pdfDocument = self.document
                        self.currentWindowController = controller
                        
                        controller.batchAction = { [unowned self] controller, files in
                            self.view.window?.endSheet((self.currentWindowController.window)!)
                            self.currentWindowController = nil
                            
                            self.toolbarController.cancelSelected(KMToolbarToolCompressItemIdentifier)
                            
                            let batchWindowController = KMBatchOperateWindowController.sharedWindowController
                                    batchWindowController.window?.makeKeyAndOrderFront("")
                            let batchOperateFile = KMBatchOperateFile(filePath: files.first?.filePath ?? "")
                            batchWindowController.switchToOperateType(.RemovePassword, files: [batchOperateFile])
                            batchWindowController.window?.makeKeyAndOrderFront("")
                        }
                        
                        controller.cancelAction = { [unowned self] controller in
                            self.view.window?.endSheet((self.currentWindowController.window)!)
                            self.currentWindowController = nil
                        }
                        
                        controller.doneAction = {  [unowned self] controller in
                            self.view.window?.endSheet((self.currentWindowController.window)!)
                            self.currentWindowController = nil
                            
                            KMBaseWindowController.checkPassword(url: self.document!.documentURL!) { [unowned self] success, resultPassword in
                                if success {
                                    /// 删除安全性设置
                                    if (!self.listView.document!.allowsCopying || !self.listView.document!.allowsPrinting) {
                                        self.isSaveKeyChain = false
                                        self.listView.document.unlock(withPassword: password)
                                        self.hiddenSecureLimitTip()
                                        self.recordRemoveSecureFlag()
                                        self.recordSaveWatermarkFlag(type: .removePassword)
                                        
                                        let tip = KMRemovePasswordResultTipView()
                                        tip.result = .success
                                        tip.showInView(superView: (self.listView.superview)!)
                                    } else {
                                        self.recordRemoveSecureFlag()
                                        self.recordSaveWatermarkFlag(type: .removePassword)
                                        let tip = KMRemovePasswordResultTipView()
                                        tip.result = .success
                                        self.hiddenSecureLimitTip()
                                        
                                        tip.showInView(superView: self.listView.superview!)
                                    }
                                }
                            }
                        }
                        await NSWindow.currentWindow().beginSheet(controller.window!)
                    }
                    return
                }
            } else if type == .comparison {
        if !IAPProductsManager.default().isAvailableAllFunction(){
            KMPurchaseCompareWindowController.sharedInstance().showWindow(nil)
            return
        }
                
                let controller = KMCompareWindowController(windowNibName: "KMCompareWindowController")
                self.currentWindowController = controller
                controller.password = self.document?.password ?? ""
                controller.filePath = (self.document?.documentURL.path)!
                
                controller.cancelAction = { [unowned self] controller in
                    self.view.window?.endSheet((self.currentWindowController.window)!)
                    self.currentWindowController = nil
                }
                
                controller.contentComplete = { [unowned self] controller, pdfCompareContent, result, oldDocument, document in
                    DispatchQueue.main.async {
                        self.view.window?.endSheet((controller.window)!)
                        self.currentWindowController = nil
                        
                        self.openContentCompareVC(with: pdfCompareContent, results: result, oldDocument: oldDocument, document: document)
                    }
                }
                
                controller.coveringComplete = { [unowned self] controller, document in
                    self.view.window?.endSheet((controller.window)!)
                    self.currentWindowController = nil
                    
                    self.openCoveringCompareVC(with: document)
                }
            
                if index == 1 {
                    controller.fileType = .content
                } else {
                    controller.fileType = .coverting
                }
            
                await NSWindow.currentWindow().beginSheet(controller.window!)
            } else if type == .watermark {
                if index == 1 {
        if !IAPProductsManager.default().isAvailableAllFunction(){
            KMPurchaseCompareWindowController.sharedInstance().showWindow(nil)
            return
        }
                    
                    let controller = KMWatermarkWindowController(windowNibName: "KMWatermarkWindowController")
                    self.currentWindowController = controller
                    controller.pdfDocument = self.document
                    
                    controller.cancelAction = { [unowned self] controller in
                        self.view.window?.endSheet((self.currentWindowController.window)!)
                        self.currentWindowController = nil
                    }
                    
                    controller.operateCallBack = { [unowned self] controller, watermark, countType in
                        let file = KMFileAttribute()
                        file.filePath = (self.document?.documentURL.path)!
                        self.showBatchWindow(type: .AddWatermark, files: [file])
                    }
//                    NSWindow.currentWindow().beginSheet(controller.window!)
                    NSWindow.currentWindow().beginSheet(controller.window!, completionHandler: nil)
                } else if index == 2 {
        if !IAPProductsManager.default().isAvailableAllFunction(){
            KMPurchaseCompareWindowController.sharedInstance().showWindow(nil)
            return
        }
                    
                    let watermarks = self.listView.document.watermarks()
                    if (watermarks == nil || watermarks!.count <= 0) {
                        let alert = NSAlert()
                        alert.alertStyle = .warning
                        alert.messageText = NSLocalizedString("无法在本文件中找到可删除的水印。如果您看到水印，其不是使用PDF Reader Pro添加的，因此无法被检测到。", comment: "")
                        alert.addButton(withTitle: NSLocalizedString("确认", comment: ""))
                        alert.addButton(withTitle: NSLocalizedString("取消", comment: ""))
                        alert.runModal()
                        return
                    }
                    
                    let alert = NSAlert()
                    alert.alertStyle = .warning
                    alert.messageText = NSLocalizedString("确定要删除文件水印吗？", comment: "")
                    alert.addButton(withTitle: NSLocalizedString("删除", comment: ""))
                    alert.addButton(withTitle: NSLocalizedString("取消", comment: ""))
                    let result = alert.runModal()
                    if (result != .alertFirstButtonReturn) {
                        return
                    }
                    
                    let oType: KMWatermarkAdjectiveType = KMWatermarkAdjectiveTools.KMWatermarkAdjectiveType(from: type)
                    KMWatermarkAdjectiveTools.delete(oType, self.listView, self.listView.document.documentURL.path) {
                        result in
                        DispatchQueue.main.async {
                            self.listView.layoutDocumentView()
                            self.listView.setNeedsDisplayForVisiblePages()
                        }
                        if (result) {
                            let alert = NSAlert()
                            alert.alertStyle = .warning
                            alert.messageText = "成功"
                            alert.runModal()
                        } else {
                            let alert = NSAlert()
                            alert.alertStyle = .critical
                            alert.messageText = "失败"
                            alert.runModal()
                        }
                    }
                } else if index == 3 {
                    let file = KMFileAttribute()
                    file.filePath = (self.document?.documentURL.path)!
                    self.showBatchWindow(type: .AddWatermark, files: [file])
                } else if index == 4 {
                    let file = KMFileAttribute()
                    file.filePath = (self.document?.documentURL.path)!
                    self.showBatchWindow(type: .RemoveWatermark, files: [file])
                } else if index == 5 {
                    self.rightSideViewController.isHidden = false
                    self.rightSideViewController.subViewType = KMWatermarkAdjectiveTools.KMToolBarTypeToRightSubViewType(type)
                    self.openRightPane()
                    return
                }
            } else if type == .background {
                if index == 1 {
        if !IAPProductsManager.default().isAvailableAllFunction(){
            KMPurchaseCompareWindowController.sharedInstance().showWindow(nil)
            return
        }
                    
                    let controller = KMBackgroundWindowController(windowNibName: "KMBackgroundWindowController")
                    self.currentWindowController = controller
                    controller.pdfDocument = self.document
                    
                    controller.cancelAction = { [unowned self] controller in
                        self.view.window?.endSheet((self.currentWindowController.window)!)
                        self.currentWindowController = nil
                    }
                    
                    controller.operateCallBack = { [unowned self] controller, background, countType in
                        let file = KMFileAttribute()
                        file.filePath = (self.document?.documentURL.path)!
                        self.showBatchWindow(type: .AddBackground, files: [file])
                    }
                    
                    await NSWindow.currentWindow().beginSheet(controller.window!)
                } else if index == 2 {
        if !IAPProductsManager.default().isAvailableAllFunction(){
            KMPurchaseCompareWindowController.sharedInstance().showWindow(nil)
            return
        }
                    
                    guard let document = self.document else { return }
                    
                    if !document.allowsPrinting || !document.allowsCopying {
                        let alert = NSAlert()
                        alert.alertStyle = .critical
                        alert.messageText = NSLocalizedString("This is a secured document. Editing is not permitted.", comment: "")
                        alert.runModal()
                        return
                    }

                    guard let documentURL = document.documentURL else { return }

                    let savePanelAccessoryViewController = KMSavePanelAccessoryController()
                    let savePanel = NSSavePanel()
                    savePanel.nameFieldStringValue = documentURL.deletingPathExtension().lastPathComponent
                    savePanel.allowedFileTypes = ["pdf"]
                    savePanel.accessoryView = savePanelAccessoryViewController.view

                    savePanel.beginSheetModal(for: NSApp.mainWindow!) { result in
                        guard result == .OK else { return }

                        KMAddBackgroundView.saveAsPDFRemoveAllBackground(PDFDocument: document, password: document.password, toPath: savePanel.url!.path, completionHandler: { [unowned self] success in
                            if success == 1 {
                                if savePanelAccessoryViewController.openAutomaticButton.state == .on {
                                    NSDocumentController.shared.openDocument(withContentsOf: savePanel.url!, display: true) { _, _, _ in }
                                } else {
                                    NSWorkspace.shared.selectFile(savePanel.url!.path, inFileViewerRootedAtPath: "")
                                }
                            }
                        })
                    }
                } else if index == 3 {
                    let file = KMFileAttribute()
                    file.filePath = (self.document?.documentURL.path)!
                    self.showBatchWindow(type: .AddBackground, files: [file])
                } else if index == 4 {
                    let file = KMFileAttribute()
                    file.filePath = (self.document?.documentURL.path)!
                    self.showBatchWindow(type: .RemoveBackground, files: [file])
                } else if index == 5 {
                    self.rightSideViewController.isHidden = false
                    self.rightSideViewController.subViewType = KMWatermarkAdjectiveTools.KMToolBarTypeToRightSubViewType(type)
                    self.openRightPane()
                    return
                }
            }
        }
    }

    func showBatchWindow(type: KMBatchOperationType, files: [KMFileAttribute]?) {
        let batchWindowController = KMBatchOperateWindowController.sharedWindowController
                batchWindowController.window?.makeKeyAndOrderFront("")
        
        var array: [KMBatchOperateFile] = []
        for file in files! {
            let batchOperateFile = KMBatchOperateFile(filePath: file.filePath)
            array.append(batchOperateFile)
        }
        batchWindowController.switchToOperateType(type, files: array)
        batchWindowController.window?.makeKeyAndOrderFront("")
    }
    
    func toolbarViewController(_ viewController: KMToolbarViewController, itemDidClick toolbarItem: KMToolbarItemView) {
        if(toolbarItem.itemIdentifier != KMDocumentPageToolbarItemIdentifier) {
            if (hasEnterPageEdit()) {
                self.exitPageEdit()
            }
        }
        if toolbarItem.itemIdentifier != KMDocumentRedactToolbarItemIdentifier {
            if self.hasEnterRedact() {
                self.exitRedact()
            }
        }
        if toolbarItem.itemIdentifier != KMDocumentDigitalSignToolbarItemIdentifier {
            if self.hasShowDigitalSign() {
                self.exitDigitalSign()
            }
        }
        
        if let itemID = toolbarItem.itemIdentifier {
            if isMainToolItem(itemID) {
                if toolbarItem.itemIdentifier == KMDocumentHomeToolbarItemIdentifier {
                    self.browserWindowController?.browser.selectTabContents(at: 0, userGesture: true)
                    self.toolbarController.findItem(KMDocumentHomeToolbarItemIdentifier)?.isSelected = false
                } else if toolbarItem.itemIdentifier == KMDocumentPreviousPageToolbarItemIdentifier {
                    self.changePDFViewGoToPreviousPageAction()
                } else if toolbarItem.itemIdentifier == KMDocumentNextPageToolbarItemIdentifier {
                    self.changePDFViewGotoNextPageAction()
                } else if toolbarItem.itemIdentifier == KMDocumentViewDisplayToolbarItemIdentifier {
                    let isSelected = toolbarItem.isSelected
                    self.toolbarController.toolbarType = isSelected ? .None : .viewSetting
                    toolbarItem.isSelected = !isSelected
                    self.toolbarController.clickItem(KMToolbarViewSettingIdentifier)
                } else if toolbarItem.itemIdentifier == KMLeftControlToolbarItemIdentifier {
                    toolbarItem.isSelected = !toolbarItem.isSelected
                    self.leftSideViewController.showPanelView(show: toolbarItem.isSelected)
                } else if toolbarItem.itemIdentifier == KMRightControlToolbarItemIdentifier {
                    toolbarItem.isSelected = !toolbarItem.isSelected
                    self.toggleRightPane()
                } else if itemID == KMDocumentRedactToolbarItemIdentifier {
                    self.listView.toolMode = .redactToolMode
                    self.enterRedact()
                } else if itemID == KMDocumentScanOCRToolbarItemIdentifier {
                    showOCRWindow()
                } else if itemID == KMDocumentDigitalSignToolbarItemIdentifier {
                    self.listView.toolMode = .textToolMode
                    toolbarItem.isSelected = !toolbarItem.isSelected
                    if self.hasShowDigitalSign() {
                        self.exitDigitalSign()
                    } else {
                        self.showDigitalSignWindow(withFilePathURL: self.listView.document.documentURL)
                    }
                }
            } else {
                if toolbarItem.itemIdentifier == KMToolbarAnnotationSettingItemIdentifier {
                    let windowC = KMToolbarCustomWindowController()
                    windowC.toolbar = self.toolbarController.childToolBarView?.toolbar
                    self.km_beginSheet(windowC: windowC)
                } else if toolbarItem.itemIdentifier == KMToolbarComparisonItemIdentifier {
                    Swift.debugPrint("KMToolbarComparisonItemIdentifier ...")
                } else if toolbarItem.itemIdentifier == KMDocumentPrintToolbarItemIdentifier {
                    self.trackEvent_print()
                    self.showPrintWindow()
                } else if toolbarItem.itemIdentifier == KMToolbarToolProfileIdentifier {
                    Swift.debugPrint("KMToolbarToolProfileIdentifier ...")
                    let windowC = KMProfileInfoWindowController(windowNibName: "KMProfileInfoWindowController")
                    windowC.callBack = { [weak self] string in
//                        if (string.length > 0) {
//                            [blockSelf.pdfView addTextFieldWithSubType:KMSelfSignAnnotationFreeTextSubType_Profile string:string];
//                        }
                        self?.km_endSheet()
                    }
                    self.km_beginSheet(windowC: windowC)
                } else if toolbarItem.itemIdentifier == KMToolbarViewSettingIdentifier {
                    toolbarItem.isSelected = !toolbarItem.isSelected
                    rightSideViewController.mainController = self
                    self.rightSideViewController.isHidden = false
                    self.rightSideViewController.subViewType = .ViewSettings
                    self.toggleRightPane()
                } else if toolbarItem.itemIdentifier == KMToolbarSnapshotIdentifier {
                    self.listView.takeSnapshot(nil)
                } else if toolbarItem.itemIdentifier == KMToolbarTTSIdentifier {
                    self.showTTSWindow()
                } else if toolbarItem.itemIdentifier == KMToolbarConversionOCRIdentifier {
                    self.showOCRWindow()
                } else if toolbarItem.itemIdentifier == KMAnnotationImageToolbarItemIdentifier {
                    Swift.debugPrint("KMAnnotationImageToolbarItemIdentifier ...")
                } else if toolbarItem.itemIdentifier == KMAnnotationTableToolbarItemIdentifier {
                    Swift.debugPrint("KMAnnotationTableToolbarItemIdentifier ...")
                }
            }
        }
    }
    
    func showTTSWindow() {
        var lastPDFView: CPDFView?
        let ttsView = KMTTSWindowController.share
        if (ttsView.window?.isVisible ?? false) {
            lastPDFView = ttsView.pdfView
            if lastPDFView?.document?.documentURL?.path == self.listView.document?.documentURL?.path {
                lastPDFView = nil
                ttsView.window?.orderOut(nil)
            } else {
                ttsView.pdfView = self.listView
                ttsView.showWindow(nil)
            }
        } else {
            ttsView.pdfView = self.listView
            ttsView.showWindow(nil)
        }
//        weak var blockSelf = self
        ttsView.closeWindowCallback = { (isCloseWindow: Bool) in
            if isCloseWindow {
//                for item in blockSelf?.toolbar.items ?? [] {
//                    if item.itemIdentifier == KMToolbarTTSViewItemIdentifier {
//                        item.isSelected = false
//                    }
//                }
            }
        }

        if let currentSelection = self.listView.currentSelection {
            if let data = currentSelection.selectionsByLine, data.isEmpty == false {
                ttsView.startSpeakingPDFSelection(currentSelection)
            }
        }
        if let lastPDFView = lastPDFView {
            lastPDFView.setHighlightedSelections([])
            ttsView.stopSpeaking()
        }
    }
    
    func toolbarViewController(_ viewController: KMToolbarViewController, menuItemDidClick toolbarItem: KMToolbarItemView, index: Int, info: Any?) {
        if (toolbarItem.itemIdentifier == KMToolbarToolWatermarkItemIdentifier) {
            self.clickChildTool(type: .watermark, index: index)
        } else if (toolbarItem.itemIdentifier == KMToolbarToolBackgroundItemIdentifier) {
            self.clickChildTool(type: .background, index: index)
        } else if (toolbarItem.itemIdentifier == KMToolbarToolHeaderFooterItemIdentifier) {
            self.clickChildTool(type: .headerAndFooter, index: index)
        } else if (toolbarItem.itemIdentifier == KMToolbarToolBatesItemIdentifier) {
            self.clickChildTool(type: .bates, index: index)
        } else if (toolbarItem.itemIdentifier == KMToolbarComparisonItemIdentifier) {
            self.clickChildTool(type: .comparison, index: index)
        } else if (toolbarItem.itemIdentifier == KMToolbarToolFormAlignIdentifier) {
        } else if (toolbarItem.itemIdentifier == KMToolbarConversionImageItemIdentifier) {
            convertToImg(index: index)
        } else if (toolbarItem.itemIdentifier == KMToolbarConversionExportImageItemIdentifier) {
            extractImageAction(num: index)
        } else if (toolbarItem.itemIdentifier == KMToolbarConversionCreatePDFItemIdentifier) {
            self.createPdf(index: index)
        } else if (toolbarItem.itemIdentifier == KMToolbarCropIdentifier) {
            if index == 2 { // 裁剪当前页面
                self.cropCurrentPage()
            } else if index == 3 { // Auto Crop – Separate
                self.cropAllPage()
            } else if index == 4 { // Auto Crop – Combined
                self.cropAllPage()
            } else if index == 5 { // Select Area
                self.toolbarController.clickItem(KMToolbarSelectToolModeItemIdentifier)
            }
        } else if (toolbarItem.itemIdentifier == KMToolbarToolSecureItemIdentifier) {
            self.clickChildTool(type: .secure, index: index)
        } else if toolbarItem.itemIdentifier == KMDocumentSearchToolbarItemIdentifier {
            KMPrint("KMDocumentSearchToolbarItemIdentifier ...")
        } else if toolbarItem.itemIdentifier == KMRightControlToolbarItemIdentifier {
            toolbarItem.isSelected = !toolbarItem.isSelected
            self.toggleRightPane()
        } else if toolbarItem.itemIdentifier == KMDocumentViewDisplayToolbarItemIdentifier {
            self.toolbarController.toolbarType = .viewSetting
        } else if toolbarItem.itemIdentifier == KMToolbarConversionOCRIdentifier {
            self.showOCRWindow()
        }
    }
    
    func convertToImg(index: Int) {
        var convertT: KMConvertType = .JPEG
        switch index {
        case 7:
            convertT = .JPEG
        case 8:
            convertT = .JPG
        case 9:
            convertT = .PNG
        case 10:
            convertT = .GIF
        case 11:
            convertT = .TIFF
        case 12:
            convertT = .TGA
        case 13:
            convertT = .BMP
        default:
            convertT = .JPEG
        }
        showAllConvertWindow(convertT: convertT)
    }
    
    func toolbarViewController(_ viewController: KMToolbarViewController, searchAction searchString: String, forward: Bool) {
        if self.searchResults.count == 0 {
            self.search(searchString: searchString, isCase: true)
        }
        
        var row = max(searchIndex - 1, 0)
        if forward {
            row = searchIndex + 1
        }
        if row >= 0 && row < self.searchResults.count && self.searchResults.count != 0 {
            let model = self.searchResults[row]
            if model.selection != nil {
                self.listView.go(to: model.selection, animated: true)
                self.listView.setHighlightedSelection(model.selection, animated: true)
                self.listView.setNeedsDisplayAnnotationViewForVisiblePages()
                
                searchIndex = row
            }
        }
    }
    
    func toolbarViewController(_ viewController: KMToolbarViewController, searchAllAction searchString: String, forward: Bool) {
//        if self.searchResults.count == 0 {
            self.leftSideViewController.showSearchMode(searchString)
//        }
        
//        var row = max(searchIndex - 1, 0)
//        if forward {
//            row = searchIndex + 1
//        }
//        if row >= 0 && row < self.searchResults.count && self.searchResults.count != 0 {
//            let model = self.searchResults[row]
//            if model.selection != nil {
//                self.listView.go(to: model.selection, animated: true)
//                self.listView.setHighlightedSelection(model.selection, animated: true)
//                self.listView.setNeedsDisplayAnnotationViewForVisiblePages()
//                
//                searchIndex = row
//            }
//        }
    }
}

// MARK: -
// MARK: - Mouse
extension KMMainViewController {
    override func mouseDown(with event: NSEvent) {
        super.mouseDown(with: event)
        KMPrint("KMMainViewController mouseDown")
        self.leftSideViewCancelSelect()
        self.pageNumberDisplayView.isEdit = false
    }
}

//MARK: LeftSideViewController
extension KMMainViewController {
    func leftSideViewCancelSelect() {
//        switch self.leftSideViewController.type.methodType {
//        case .Thumbnail:
////            self.leftSideViewController.thumbnailViewController.cancelSelect()
//            break
//        case .Outline:
////            self.leftSideViewController.outlineViewController.cancelSelect()
//            break
//        case .BookMark:
////            self.leftSideViewController.bookViewController.cancelSelect()
//            break
//        case .Search:
////            self.leftSideViewController.searchViewController.cancelSelect()
//            break
//        case .Annotation:
////            self.leftSideViewController.annotationViewController.cancelSelect()
//            break
//        default:
            if self.listView.isEditing() {
                if self.listView.editingAreas() != nil &&
                    self.listView.editingAreas().count != 0 {
                    let areas = self.listView.editingAreas().first
                    if areas is CPDFEditTextArea  {
                        self.listView.clearEditingSelectCharItem()
                        self.listView.updateEditing([])
                        KMPrint("取消选中")
                    }
                }
            }
            KMPrint("其他")
//        }
    }
}


extension KMMainViewController: KMReadModelViewDelegate {
    func firstPageButtonDidChange(view: KMReadModelView, sender: Any) {
        self.listView.goToFirstPage(nil)
    }
    
    func beforePageButtonDidChange(view: KMReadModelView, sender: Any) {
        self.listView.goToPreviousPage(nil)
    }
    
    func afterPageButtonDidChange(view: KMReadModelView, sender: Any) {
        self.listView.goToNextPage(nil)
    }
    
    func lastPageButtonDidChange(view: KMReadModelView, sender: Any) {
        self.listView.goToLastPage(nil)
    }
    
    func currentPageButtonDidChange(view: KMReadModelView, sender: Any, pageIndex: Int) {
        self.listView.go(toPageIndex: max(pageIndex - 1, 0), animated: true)
    }
    
    func scaleDidChange(view: KMReadModelView, sender: Any, type: KMReadModelViewScaleType) {
        var scale: Double = 1.0
        switch type {
        case .fitWidth:
            self.listView.autoScales = !self.listView.autoScales
            scale = self.listView.scaleFactor
            break
        case .actualSize:
            if self.listView.scaleFactor != 1.0 {
                self.listView.scaleFactor = 1.0
                self.listView.autoScales = false
            }
            scale = self.listView.scaleFactor
            break
        case .autoSize:
            self.listView.autoScales = true
            self.listView.autoScales = false
            scale = self.listView.scaleFactor
            break
        case ._10:
            scale = 0.1
            break
        case ._25:
            scale = 0.25
            break
        case ._50:
            scale = 0.5
            break
        case ._100:
            scale = 1.0
            break
        case ._150:
            scale = 1.5
            break
        case ._200:
            scale = 2.0
            break
        case ._400:
            scale = 4.0
            break
        case ._800:
            scale = 8.0
            break
        default:
            break
        }
        self.listView.scaleFactor = scale
        
        self.toolbarController.mainViewController?.childToolbarController.zoomTextField.stringValue =  "\(Int(self.listView.scaleFactor*100))%"
    }
    
    func cancelReadModel(view: KMReadModelView, sender: Any) {
        if self.isReadMode {
            self.closeReadModel()
        }
    }
    
    func readModelViewWidthChange(view: KMReadModelView, width: CGFloat) {
//        if self.readModelViewWidthConstraint.constant != width {
            self.readModelViewWidthConstraint.constant = width
//        }
    }
}

extension KMMainViewController: KMPageNumberDisplayViewDelegate {
    func gotoPageIndex(view: KMPageNumberDisplayView, pageIndex: Int) {
        self.listView.go(toPageIndex: pageIndex, animated: true)
    }
    
    func updateWidth(view: KMPageNumberDisplayView, width: CGFloat) {
        if self.tipCurrentPageBoxWidthConstraint.constant != width {
            self.tipCurrentPageBoxWidthConstraint.constant = width
        }
    }
    
    func commitEditingIfNeed() {
        let isEdited = self.listView?.isEdited() ?? false
        if isEdited || self.isPDFTextImageEdited {
            self.listView.commitEditing()
        }
    }
}

// MARK: - Analytics (埋点)

extension KMMainViewController {
    func trackEvent(toolType type: KMToolbarViewType) -> Void {
        if (type == .Annatiton) {
            KMAnalytics.trackEvent(eventName: "Btn_Tbr_Annotation", parameters: [
                KMAnalytics.Parameter.categoryKey : KMAnalytics.Category.tbr,
                KMAnalytics.Parameter.labelKey : KMAnalytics.Label.tbr_Btn], platform: .AppCenter, appTarget: .all)
        } else if (type == .editPDF) {
            KMAnalytics.trackEvent(eventName: "Btn_Tbr_EditPDF", parameters: [
                KMAnalytics.Parameter.categoryKey : KMAnalytics.Category.tbr,
                KMAnalytics.Parameter.labelKey : KMAnalytics.Label.tbr_Btn], platform: .AppCenter, appTarget: .all)
        } else if (type == .Page) {
            KMAnalytics.trackEvent(eventName: "Btn_Tbr_PageEdit", parameters: [
                KMAnalytics.Parameter.categoryKey : KMAnalytics.Category.tbr,
                KMAnalytics.Parameter.labelKey : KMAnalytics.Label.tbr_Btn], platform: .AppCenter, appTarget: .all)
        } else if (type == .Conversion) {
            KMAnalytics.trackEvent(eventName: "Btn_Tbr_Converter", parameters: [
                KMAnalytics.Parameter.categoryKey : KMAnalytics.Category.tbr,
                KMAnalytics.Parameter.labelKey : KMAnalytics.Label.tbr_Btn], platform: .AppCenter, appTarget: .all)
        } else if (type == .Tool) {
            KMAnalytics.trackEvent(eventName: "Btn_Tbr_Tools", parameters: [
                KMAnalytics.Parameter.categoryKey : KMAnalytics.Category.tbr,
                KMAnalytics.Parameter.labelKey : KMAnalytics.Label.tbr_Btn], platform: .AppCenter, appTarget: .all)
        }
    }
    
    func trackEvent_aiTranslate() -> Void {
        KMAnalytics.trackEvent(eventName: "Btn_Tbr_AITranslate", parameters: [
            KMAnalytics.Parameter.categoryKey : KMAnalytics.Category.tbr,
            KMAnalytics.Parameter.labelKey : KMAnalytics.Label.tbr_Btn], platform: .AppCenter, appTarget: .all)
    }
    
    func trackEvent_print() -> Void {
        KMAnalytics.trackEvent(eventName: "Btn_Tbr_Print", parameters: [
            KMAnalytics.Parameter.categoryKey : KMAnalytics.Category.tbr,
            KMAnalytics.Parameter.labelKey : KMAnalytics.Label.tbr_Btn], platform: .AppCenter, appTarget: .all)
    }
    
    func trackEvent_share() -> Void {
        KMAnalytics.trackEvent(eventName: "Btn_Tbr_Share", parameters: [
            KMAnalytics.Parameter.categoryKey : KMAnalytics.Category.tbr,
            KMAnalytics.Parameter.labelKey : KMAnalytics.Label.tbr_Btn], platform: .AppCenter, appTarget: .all)
    }
    
    func trackEvent_upgrade() -> Void {
        KMAnalytics.trackEvent(eventName: "Btn_Tbr_Upgrade", parameters: [
            KMAnalytics.Parameter.categoryKey : KMAnalytics.Category.tbr,
            KMAnalytics.Parameter.labelKey : KMAnalytics.Label.tbr_Btn], platform: .AppCenter, appTarget: .all)
    }
    
    func trackEvent(annotationType type: CAnnotationType) -> Void {
        if (type == .highlight) {
            KMAnalytics.trackEvent(eventName: "Btn_SubTbr_Highlight", parameters: [
                KMAnalytics.Parameter.categoryKey : KMAnalytics.Category.subTbr_annotation,
                KMAnalytics.Parameter.labelKey : KMAnalytics.Label.subTbr_Btn], platform: .AppCenter, appTarget: .all)
        } else if (type == .underline) {
            KMAnalytics.trackEvent(eventName: "Btn_SubTbr_Underline", parameters: [
                KMAnalytics.Parameter.categoryKey : KMAnalytics.Category.subTbr_annotation,
                KMAnalytics.Parameter.labelKey : KMAnalytics.Label.subTbr_Btn], platform: .AppCenter, appTarget: .all)
        } else if (type == .strikeOut) {
            KMAnalytics.trackEvent(eventName: "Btn_SubTbr_Strikethrough", parameters: [
                KMAnalytics.Parameter.categoryKey : KMAnalytics.Category.subTbr_annotation,
                KMAnalytics.Parameter.labelKey : KMAnalytics.Label.subTbr_Btn], platform: .AppCenter, appTarget: .all)
        } else if (type == .ink) {
            KMAnalytics.trackEvent(eventName: "Btn_SubTbr_Draw", parameters: [
                KMAnalytics.Parameter.categoryKey : KMAnalytics.Category.subTbr_annotation,
                KMAnalytics.Parameter.labelKey : KMAnalytics.Label.subTbr_Btn], platform: .AppCenter, appTarget: .all)
        } else if (type == .freeText) {
            KMAnalytics.trackEvent(eventName: "Btn_SubTbr_Text", parameters: [
                KMAnalytics.Parameter.categoryKey : KMAnalytics.Category.subTbr_annotation,
                KMAnalytics.Parameter.labelKey : KMAnalytics.Label.subTbr_Btn], platform: .AppCenter, appTarget: .all)
        } else if (type == .anchored) {
            KMAnalytics.trackEvent(eventName: "Btn_SubTbr_Note", parameters: [
                KMAnalytics.Parameter.categoryKey : KMAnalytics.Category.subTbr_annotation,
                KMAnalytics.Parameter.labelKey : KMAnalytics.Label.subTbr_Btn], platform: .AppCenter, appTarget: .all)
        } else if (type == .square) {
            KMAnalytics.trackEvent(eventName: "Btn_SubTbr_Shape", parameters: [
                KMAnalytics.Parameter.categoryKey : KMAnalytics.Category.subTbr_annotation,
                KMAnalytics.Parameter.labelKey : KMAnalytics.Label.subTbr_Btn], platform: .AppCenter, appTarget: .all)
        } else if (type == .link) {
            KMAnalytics.trackEvent(eventName: "Btn_SubTbr_Link", parameters: [
                KMAnalytics.Parameter.categoryKey : KMAnalytics.Category.subTbr_annotation,
                KMAnalytics.Parameter.labelKey : KMAnalytics.Label.subTbr_Btn], platform: .AppCenter, appTarget: .all)
        } else if (type == .stamp) {
            KMAnalytics.trackEvent(eventName: "Btn_SubTbr_Stamp", parameters: [
                KMAnalytics.Parameter.categoryKey : KMAnalytics.Category.subTbr_annotation,
                KMAnalytics.Parameter.labelKey : KMAnalytics.Label.subTbr_Btn], platform: .AppCenter, appTarget: .all)
        } else if (type == .signSignature) {
            KMAnalytics.trackEvent(eventName: "Btn_SubTbr_Sign", parameters: [
                KMAnalytics.Parameter.categoryKey : KMAnalytics.Category.subTbr_annotation,
                KMAnalytics.Parameter.labelKey : KMAnalytics.Label.subTbr_Btn], platform: .AppCenter, appTarget: .all)
        } else if (type == .addText) {
            KMAnalytics.trackEvent(eventName: "Btn_SubTbr_AddText", parameters: [
                KMAnalytics.Parameter.categoryKey : KMAnalytics.Category.subTbr_editPDF,
                KMAnalytics.Parameter.labelKey : KMAnalytics.Label.subTbr_Btn], platform: .AppCenter, appTarget: .all)
        } else if (type == .addImage) {
            KMAnalytics.trackEvent(eventName: "Btn_SubTbr_AddImage", parameters: [
                KMAnalytics.Parameter.categoryKey : KMAnalytics.Category.subTbr_editPDF,
                KMAnalytics.Parameter.labelKey : KMAnalytics.Label.subTbr_Btn], platform: .AppCenter, appTarget: .all)
        } else {
            
        }
    }
    
    func trackEvent(toolMode mode: CToolMode) -> Void {
        if (mode == .selectToolMode) {
            KMAnalytics.trackEvent(eventName: "Btn_SubTbr_ContentSelection", parameters: [
                KMAnalytics.Parameter.categoryKey : KMAnalytics.Category.subTbr_annotation,
                KMAnalytics.Parameter.labelKey : KMAnalytics.Label.subTbr_Btn], platform: .AppCenter, appTarget: .all)
        } else if (mode == .moveToolMode) {
            KMAnalytics.trackEvent(eventName: "Btn_SubTbr_Scroll", parameters: [
                KMAnalytics.Parameter.categoryKey : KMAnalytics.Category.subTbr_annotation,
                KMAnalytics.Parameter.labelKey : KMAnalytics.Label.subTbr_Btn], platform: .AppCenter, appTarget: .all)
        }
    }
    
    func trackEvent(toolBarType type: KMToolbarType) -> Void {
        if (type == .word) {
            KMAnalytics.trackEvent(eventName: "Btn_SubTbr_toWord", parameters: [
                KMAnalytics.Parameter.categoryKey : KMAnalytics.Category.subTbr_Converter,
                KMAnalytics.Parameter.labelKey : KMAnalytics.Label.subTbr_Btn], platform: .AppCenter, appTarget: .all)
        } else if (type == .excel) {
            KMAnalytics.trackEvent(eventName: "Btn_SubTbr_toExcel", parameters: [
                KMAnalytics.Parameter.categoryKey : KMAnalytics.Category.subTbr_Converter,
                KMAnalytics.Parameter.labelKey : KMAnalytics.Label.subTbr_Btn], platform: .AppCenter, appTarget: .all)
        } else if (type == .ppt) {
            KMAnalytics.trackEvent(eventName: "Btn_SubTbr_toPPT", parameters: [
                KMAnalytics.Parameter.categoryKey : KMAnalytics.Category.subTbr_Converter,
                KMAnalytics.Parameter.labelKey : KMAnalytics.Label.subTbr_Btn], platform: .AppCenter, appTarget: .all)
        } else if (type == .rtf) {
            KMAnalytics.trackEvent(eventName: "Btn_SubTbr_toRTF", parameters: [
                KMAnalytics.Parameter.categoryKey : KMAnalytics.Category.subTbr_Converter,
                KMAnalytics.Parameter.labelKey : KMAnalytics.Label.subTbr_Btn], platform: .AppCenter, appTarget: .all)
        } else if (type == .csv) {
            KMAnalytics.trackEvent(eventName: "Btn_SubTbr_toCSV", parameters: [
                KMAnalytics.Parameter.categoryKey : KMAnalytics.Category.subTbr_Converter,
                KMAnalytics.Parameter.labelKey : KMAnalytics.Label.subTbr_Btn], platform: .AppCenter, appTarget: .all)
        } else if (type == .html) {
            KMAnalytics.trackEvent(eventName: "Btn_SubTbr_toHTML", parameters: [
                KMAnalytics.Parameter.categoryKey : KMAnalytics.Category.subTbr_Converter,
                KMAnalytics.Parameter.labelKey : KMAnalytics.Label.subTbr_Btn], platform: .AppCenter, appTarget: .all)
        } else if (type == .conversion_text) {
            KMAnalytics.trackEvent(eventName: "Btn_SubTbr_toText", parameters: [
                KMAnalytics.Parameter.categoryKey : KMAnalytics.Category.subTbr_Converter,
                KMAnalytics.Parameter.labelKey : KMAnalytics.Label.subTbr_Btn], platform: .AppCenter, appTarget: .all)
        } else if (type == .conversion_image) {
            KMAnalytics.trackEvent(eventName: "Btn_SubTbr_toImage", parameters: [
                KMAnalytics.Parameter.categoryKey : KMAnalytics.Category.subTbr_Converter,
                KMAnalytics.Parameter.labelKey : KMAnalytics.Label.subTbr_Btn], platform: .AppCenter, appTarget: .all)
        } else if (type == .compress) {
            KMAnalytics.trackEvent(eventName: "Btn_SubTbr_Compress", parameters: [
                KMAnalytics.Parameter.categoryKey : KMAnalytics.Category.subTbr_Tools,
                KMAnalytics.Parameter.labelKey : KMAnalytics.Label.subTbr_Btn], platform: .AppCenter, appTarget: .all)
        } else if (type == .merge) {
            KMAnalytics.trackEvent(eventName: "Btn_SubTbr_Merge", parameters: [
                KMAnalytics.Parameter.categoryKey : KMAnalytics.Category.subTbr_Tools,
                KMAnalytics.Parameter.labelKey : KMAnalytics.Label.subTbr_Btn], platform: .AppCenter, appTarget: .all)
        } else if (type == .secure) {
            
        } else if (type == .crop) {
            KMAnalytics.trackEvent(eventName: "Btn_SubTbr_Crop", parameters: [
                KMAnalytics.Parameter.categoryKey : KMAnalytics.Category.subTbr_Tools,
                KMAnalytics.Parameter.labelKey : KMAnalytics.Label.subTbr_Btn], platform: .AppCenter, appTarget: .all)
        }
    }
    
    func trackEvent_setPassword() -> Void {
        KMAnalytics.trackEvent(eventName: "Btn_SubTbr_SetPassword", parameters: [
            KMAnalytics.Parameter.categoryKey : KMAnalytics.Category.subTbr_Tools,
            KMAnalytics.Parameter.labelKey : KMAnalytics.Label.subTbr_Btn], platform: .AppCenter, appTarget: .all)
    }
    
    func trackEvent_removePassword() -> Void {
        KMAnalytics.trackEvent(eventName: "Btn_SubTbr_RemovePassword", parameters: [
            KMAnalytics.Parameter.categoryKey : KMAnalytics.Category.subTbr_Tools,
            KMAnalytics.Parameter.labelKey : KMAnalytics.Label.subTbr_Btn], platform: .AppCenter, appTarget: .all)
    }
}

extension KMMainViewController {
    //文件对比
    func openContentCompareVC(with pdfCompareContent: CPDFCompareContent?, results: [CPDFCompareResults], oldDocument: CPDFDocument, document: CPDFDocument) {
        let compareContentView = KMCompareContentView()
        compareContentView.oldDocument = oldDocument
        compareContentView.document = document
        compareContentView.compareResults = results
        compareContentView.saveHandle = { [unowned self] view in
            DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 0.25) { [unowned self] in
                let saveController = KMCompareSaveWindow(windowNibName: "KMCompareSaveWindow")
                self.currentWindowController = saveController
                saveController.cancelHandle = { [unowned self] controller in
                    self.view.window!.endSheet(controller.window!)
                    self.currentWindowController = nil
                }
                
                saveController.saveHandle = { [unowned self] controller, saveType in
                    let folderPath = controller.fileSaveFolderPath
                    if folderPath != nil {
                        if !FileManager.default.fileExists(atPath: folderPath) {
                            try? FileManager.default.createDirectory(atPath: folderPath, withIntermediateDirectories: true, attributes: nil)
                        }
                        
                        var savePath: String
                        
                        
                        switch saveType {
                        case 0:
                            let filePath = oldDocument.documentURL.path
                            let fileName = filePath.deletingPathExtension.lastPathComponent
                            
                            savePath = "\(folderPath)/\(fileName)_compare\(filePath.extension)"
                            savePath = self.getValidFilePath(savePath)
                            oldDocument.write(to: URL(fileURLWithPath: savePath))
                            NSWorkspace.shared.activateFileViewerSelecting([URL(fileURLWithPath: savePath)])
                        case 1:
                            let filePath = document.documentURL.path
                            let fileName = filePath.deletingPathExtension.lastPathComponent
                            
                            savePath = "\(folderPath)/\(fileName)_compare\(filePath.extension)"
                            savePath = self.getValidFilePath(savePath)
                            document.write(to: URL(fileURLWithPath: savePath))
                            NSWorkspace.shared.activateFileViewerSelecting([URL(fileURLWithPath: savePath)])
                        case 2:
                            let filePath = oldDocument.documentURL.path
                            let fileName = filePath.deletingPathExtension.lastPathComponent
                            
                            savePath = "\(folderPath)/MergedCompareFile\(filePath.extension)"
                            savePath = self.getValidFilePath(savePath)
                            pdfCompareContent!.saveAsComparisonDocument(withFilePath: savePath)
                            NSWorkspace.shared.activateFileViewerSelecting([URL(fileURLWithPath: savePath)])
                        default:
                            break
                        }
                    }
                    
                    self.view.window!.endSheet(controller.window!)
                    self.currentWindowController = nil
                }
                
                NSWindow.currentWindow().beginSheet(saveController.window!)
            }
        }
        
        compareContentView.closeHandle = { [unowned self] view in
//            self.view.window!.endSheet(controller.window!)
            view.removeFromSuperview()
        }
        
        self.PDFContendView.addSubview(compareContentView)
        compareContentView.frame = self.PDFContendView.bounds
        compareContentView.autoresizingMask = [.width,.height]
    }

    func getValidFilePath(_ oldPath: String) -> String {
        let fileManager = FileManager.default

        do {
            let fileAttributes = try fileManager.attributesOfItem(atPath: oldPath)
            guard let fileType = fileAttributes[FileAttributeKey.type] as? String else {
                return oldPath
            }

            var i = 1
            var newPath = oldPath

            while fileManager.fileExists(atPath: newPath) {
                if fileType == FileAttributeType.typeDirectory.rawValue {
                    newPath = oldPath + "(\(i))"
                } else {
                    let fileExtension = (oldPath as NSString).pathExtension
                    newPath = ((oldPath as NSString).deletingPathExtension as NSString).appendingFormat("(\(i)).\(fileExtension)" as NSString) as String
                }
                i += 1
            }

            return newPath
        } catch {
            print("Error getting file attributes: \(error)")
            return oldPath
        }
    }

    func openCoveringCompareVC(with pdfDocument: CPDFDocument) {
        let coveringView = KMCompareCoveringView()
        coveringView.pdfDocument = pdfDocument
        coveringView.closeHandle = { [unowned self] view in
            view.removeFromSuperview()
        }
        
        coveringView.saveHandle = { [unowned self] view in
            let savePanel = NSSavePanel()
            savePanel.nameFieldStringValue = "untitled"
            savePanel.allowedFileTypes = ["pdf"]
            savePanel.beginSheetModal(for: NSWindow.currentWindow()) { result in
                if result == .OK {
                    pdfDocument.write(to: savePanel.url!)
                    NSWorkspace.shared.activateFileViewerSelecting([savePanel.url!])
                }
            }
        }
        
        
        self.PDFContendView.addSubview(coveringView)
        coveringView.frame = self.PDFContendView.bounds
        coveringView.autoresizingMask = [.width,.height]
    }

}