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

//
//  KMMainViewController+MenuAction.swift
//  PDF Master
//
//  Created by tangchao on 2023/2/19.
//

import Foundation

// MARK: File Menu
extension KMMainViewController {
    @IBAction func menuItemClick_mergePDF(_ sender: Any) {
        self.toolbarController.delegate?.clickChildTool?(type: .merge, index: 0)
    }
    
    @IBAction func menuItemClick_Compress(_ sender: Any) {
        self.toolbarController.delegate?.clickChildTool?(type: .compress, index: 0)
    }
    
    @IBAction func menuItemClick_Convert(_ sender: Any) {

    }
    
    @IBAction func menuItemAction_ConvertToWord(_ sender: Any) {
        self.toolbarController.delegate?.clickChildTool?(type: .word, index: 0)
    }
    
    @IBAction func menuItemAction_ConvertToExcel(_ sender: Any) {
        self.toolbarController.delegate?.clickChildTool?(type: .excel, index: 0)
    }
    
    @IBAction func menuItemAction_ConvertToPPT(_ sender: Any) {
        self.toolbarController.delegate?.clickChildTool?(type: .ppt, index: 0)
    }
    
    @IBAction func menuItemAction_ConvertToRTF(_ sender: Any) {
        self.toolbarController.delegate?.clickChildTool?(type: .rtf, index: 0)
    }
    
    @IBAction func menuItemAction_ConvertToHTML(_ sender: Any) {
        self.toolbarController.delegate?.clickChildTool?(type: .html, index: 0)
    }
    
    @IBAction func menuItemAction_ConvertToText(_ sender: Any) {
        self.toolbarController.delegate?.clickChildTool?(type: .conversion_text, index: 0)
    }
    
    @IBAction func menuItemAction_ConvertToCSV(_ sender: Any) {
        self.toolbarController.delegate?.clickChildTool?(type: .csv, index: 0)
    }
    
    @IBAction func menuItemAction_ConvertToImage(_ sender: Any) {
        self.toolbarController.delegate?.clickChildTool?(type: .conversion_image, index: 0)
    }
    
    @IBAction func menuItemClick_SettingPassword(_ sender: Any) {
        self.toolbarController.delegate?.clickChildTool?(type: .secure, index: 1)
    }
    
    @IBAction func menuItemClick_RemovePassword(_ sender: Any) {
        self.toolbarController.delegate?.clickChildTool?(type: .secure, index: 2)
    }
    
    @IBAction func menuItemAction_closeWindow(_ sender: Any) {
        self.view.window?.close()
    }
    
    @IBAction func menuItemAction_closeAllWindows(_ sender: Any) {
        for window in NSApp.windows {
            window.close()
        }
    }
    
    @IBAction func menuItemAction_closeTagPage(_ sender: Any) {
        self.browserWindowController?.browser.closeTab()
    }
    
    @IBAction func menuItemAction_showInFinder(_ sender: Any) {
        NSWorkspace.shared.activateFileViewerSelecting([self.listView.document.documentURL])
    }
    
    @IBAction func menuItemAction_property(_ sender: Any) {
        SKInfoWindowController().showWindow(nil)
    }
    
    @IBAction func menuItemAction_print(_ sender: Any) {
        self.showPrintWindow()
    }
}

extension KMMainViewController: KMSystemFileMenuProtocol {
    @IBAction func menuItemClick_saveAsFlattenedPDF(_ sender: Any) {
        Task { @MainActor in
            if await (KMLightMemberManager.manager.canUseAdvanced() == false) {
                let _ = KMComparativeTableViewController.show(window: self.view.window!)
                return
            }
            if await (KMLightMemberManager.manager.canPayFunction() == false) {
                let _ = KMSubscribeWaterMarkWindowController.show(window: self.view.window!) { isSubscribeSuccess, isWaterMarkExport, isClose in
                    if (isClose) {
                        return
                    }
                    if (isSubscribeSuccess) {
                        self.saveAsFlattenedPDFAction()
                        return
                    }
                    if (isWaterMarkExport) {
                        self.saveAsFlattenedPDFAction(limit: true)
                        return
                    }
                }
                return
            }
            self.saveAsFlattenedPDFAction()
        }
    }
    
    func saveAsFlattenedPDFAction(limit: Bool = false) {
        DispatchQueue.main.async {
            NSPanel.savePanel(self.view.window!, true) { panel in
                panel.nameFieldStringValue = self.listView.document.documentURL.deletingPathExtension().lastPathComponent + "_flatten" + ".pdf"
            } completion: { response, url, isOpen in
                if (response == .cancel) {
                    return
                }
                
                var result = false
                if (limit) {
                    let data = KMTools.saveWatermarkDocumentForFlatten(document: self.listView.document, to: url!)
                    result = data != nil
                } else {
                    result = self.listView.document.writeFlatten(to: url!)
                }
                if (!result) {
                    return
                }
                
                if (isOpen) {
                    NSDocumentController.shared.km_safe_openDocument(withContentsOf: url!, display: true) { _, _, _ in
                        
                    }
                } else {
                    NSWorkspace.shared.activateFileViewerSelecting([url!])
                }
            }
        }
    }
}

// MARK: Edit Menu
@objc protocol KMEditMenuProtocol: NSObjectProtocol {
    @objc optional func undo(_ sender: Any)
    @objc optional func redo(_ sender: Any)
    
    @objc optional func cut(_ sender: Any)
    @objc optional func copy(_ sender: Any)
    @objc optional func paste(_ sender: Any)
    @objc optional func delete(_ sender: Any)
}

extension KMMainViewController: KMEditMenuProtocol {
    @IBAction func menuItemAction_find(_ sender: Any) {
        if (self.leftSideViewController.isShowPanel) {
            self.toolbarController.cancelSelected(KMLeftControlToolbarItemIdentifier)
            self.toolbarController.toolbarType = .None
            self.leftSideViewController.showPanelView(show: false)
        }
//        else {
            let isSearch = self.leftSideViewController.type.methodType == .Search
            self.leftSideViewController.refreshMethodType(methodType: .Search)
            if (isSearch) { // 关闭
                self.view.window?.makeFirstResponder(self.listView)
            }
//        }
    }
}

// MARK: View Menu

extension KMMainViewController {
    
    // scale
    
    @IBAction func menuItemAction_adjustWidth(_ sender: Any) {
        self.selectZoom(.width)
    }

    @IBAction func menuItemAction_adjustPage(_ sender: Any) {
        self.selectZoom(.fit)
    }

    @IBAction func menuItemAction_size(_ sender: Any) {
        self.selectZoom(.actualSize)
    }

    @IBAction func menuItemAction_zoomOut(_ sender: Any) {
        if (self.listView.canZoomOut) {
            self.listView.zoomOut(nil)
        }
    }

    @IBAction func menuItemAction_zoomIn(_ sender: Any) {
        if (self.listView.canZoomIn) {
            self.listView.zoomIn(nil)
        }
    }
    
    // page show
    
    @IBAction func menuItemAction_singlePage(_ sender: Any) {
        self.selectDisplay(display: .singlePage)
    }

    @IBAction func menuItemAction_singlePageContinue(_ sender: Any) {
        self.selectDisplay(display: .singlePageContinuous)
    }

    @IBAction func menuItemAction_doublePage(_ sender: Any) {
        self.selectDisplay(display: .twoUp)
    }

    @IBAction func menuItemAction_doublePageContinue(_ sender: Any) {
        self.selectDisplay(display: .twoUpContinuous)
    }

    @IBAction func menuItemAction_bookMode(_ sender: Any) {
        self.selectDisplay(display: .bookMode)
    }
    
    @IBAction func menuItemAction_readMode(_ sender: Any) {
        if (self.isReadMode) {
            self.closeReadModel()
        } else {
            self.openReadModel()
        }
    }

    @IBAction func menuItemAction_showSplitPage(_ sender: Any) {
        self.listView?.displaysPageBreaks = !(self.listView?.displaysPageBreaks ?? false)
        self.listView.layoutDocumentView()
    }

    @IBAction func menuItemAction_autoScrol(_ sender: Any) {

    }

    @IBAction func menuItemAction_autoScrolSetting(_ sender: Any) {

    }
    
    // rotate
    
    @IBAction func menuItemAction_rotateLeft(_ sender: Any) {
        Task { @MainActor in
            if await (KMLightMemberManager.manager.canUseAdvanced() == false) {
                let _ = KMComparativeTableViewController.show(window: self.view.window!)
                return
            }
            
            let page : CPDFPage = self.listView?.currentPage() ?? CPDFPage()
            let rotation = page.rotation
            page.leftRotate()
            
            self.rotatePageItems(pageItems: [KMThumbnailPageItem(page: page, rotate: page.rotation, oldRotate: rotation)])
        }
    }
    
    func rotatePageItems(pageItems: [KMThumbnailPageItem]) {
        let tempPageItems = pageItems
        for pageItem in tempPageItems {
            pageItem.page.rotation = pageItem.rotate
        }
        
        self.listView.layoutDocumentView()
        NotificationCenter.default.post(name: NSNotification.Name(rawValue: "KMPDFViewRotatePage"), object: self.listView.document)
        
        self.listView.undoManager?.registerUndo(withTarget: self) { [unowned self] targetType in
            var tempPageItems: [KMThumbnailPageItem] = []
            for pageItem in pageItems {
                let item = KMThumbnailPageItem(page: pageItem.page, rotate: pageItem.oldRotate, oldRotate: pageItem.rotate)
                tempPageItems.append(item)
            }
            self.rotatePageItems(pageItems: tempPageItems)
        }
    }

    @IBAction func menuItemAction_rotateRight(_ sender: Any) {
        Task { @MainActor in
            if await (KMLightMemberManager.manager.canUseAdvanced() == false) {
                let _ = KMComparativeTableViewController.show(window: self.view.window!)
                return
            }
            
            let page : CPDFPage = self.listView?.currentPage() ?? CPDFPage()
            let rotation = page.rotation
            page.rightRotate()
            
            self.rotatePageItems(pageItems: [KMThumbnailPageItem(page: page, rotate: page.rotation, oldRotate: rotation)])
        }
    }

    @IBAction func menuItemAction_rotateAllPageLeft(_ sender: Any) {
        Task { @MainActor in
            if await (KMLightMemberManager.manager.canUseAdvanced() == false) {
                let _ = KMComparativeTableViewController.show(window: self.view.window!)
                return
            }
            
            var pageItems: [KMThumbnailPageItem] = []
            for index in 0 ... self.listView.document.pageCount - 1 {
                let page: CPDFPage = self.listView.document.page(at: index)
                let rotation = page.rotation
                page.leftRotate()
                pageItems.append(KMThumbnailPageItem(page: page, rotate: page.rotation, oldRotate: rotation))
            }

            self.rotatePageItems(pageItems: pageItems)
        }
    }

    @IBAction func menuItemAction_rotateAllPageRight(_ sender: Any) {
        Task { @MainActor in
            if await (KMLightMemberManager.manager.canUseAdvanced() == false) {
                let _ = KMComparativeTableViewController.show(window: self.view.window!)
                return
            }
            
            var pageItems: [KMThumbnailPageItem] = []
            for index in 0 ... self.listView.document.pageCount - 1 {
                let page : CPDFPage = self.listView.document.page(at: index)
                let rotation = page.rotation
                page.rightRotate()
                pageItems.append(KMThumbnailPageItem(page: page, rotate: page.rotation, oldRotate: rotation))
            }
            self.rotatePageItems(pageItems: pageItems)
        }
    }
    
    // split screen
    
    @IBAction func menuItemAction_splitScreenVerti(_ sender: Any) {

    }

    @IBAction func menuItemAction_splitScreenHorti(_ sender: Any) {

    }

    @IBAction func menuItemAction_splitScreenNo(_ sender: Any) {

    }
    
    @IBAction func menuItemAction_view_readMode(_ sender: Any) {
        if (self.isReadMode) {
            self.closeReadModel()
        } else {
            self.openReadModel()
        }
    }

    @IBAction func menuItemAction_enterFullScreen(_ sender: Any) {

    }

    @IBAction func menuItemAction_hiddenLeftSide(_ sender: Any) {
        if (self.leftSideViewController.type.methodType != .None) {
            self.leftSideViewController.selectType(self.leftSideViewController.type.methodType)
        } else {
            self.toolbarController.selectItem(KMLeftControlToolbarItemIdentifier)
        }
    }
    
    @IBAction func menuItemAction_hiddenRightSide(_ sender: Any) {
        self.toolbarController.selectItem(KMRightControlToolbarItemIdentifier)
    }
    
    @IBAction func menuItemAction_thumai(_ sender: Any) {
        self.leftSideViewController.refreshMethodType(methodType: .Thumbnail)
    }

    @IBAction func menuItemAction_outline(_ sender: Any) {
        self.leftSideViewController.refreshMethodType(methodType: .Outline)
    }

    @IBAction func menuItemAction_bookmark(_ sender: Any) {
        self.leftSideViewController.refreshMethodType(methodType: .BookMark)
    }
    
    @IBAction func menuItemAction_annotation(_ sender: Any) {
        self.leftSideViewController.refreshMethodType(methodType: .Annotation)
    }

    @IBAction func menuItemAction_search(_ sender: Any) {
        self.leftSideViewController.refreshMethodType(methodType: .Search)
    }

    @IBAction func menuItemAction_topic(_ sender: Any) {

    }
    
    @IBAction func menuItemAction_hiddenPageIndicator(_ sender: Any) {
        
    }
}

// MARK: Annotation Menu

extension KMMainViewController {
    @IBAction func menuItemAction_highlight(_ sender: Any) {
        self.mainMenuUpdateAnnotationStyle(identifier: KMToolbarHighlightAnnotationItemIdentifier)
    }

    @IBAction func menuItemAction_underline(_ sender: Any) {
        self.mainMenuUpdateAnnotationStyle(identifier: KMToolbarUnderlineAnnotationItemIdentifier)
    }
    
    @IBAction func menuItemAction_deleteLine(_ sender: Any) {
        self.mainMenuUpdateAnnotationStyle(identifier: KMToolbarStrikeOutAnnotationItemIdentifier)
    }
    
    @IBAction func menuItemAction_freehand(_ sender: Any) {
        self.mainMenuUpdateAnnotationStyle(identifier: KMToolbarInkAnnotationItemIdentifier)
    }

    @IBAction func menuItemAction_text(_ sender: Any) {
        self.mainMenuUpdateAnnotationStyle(identifier: KMToolbarFreeTextAnnotationItemIdentifier)
    }
    
    @IBAction func menuItemAction_note(_ sender: Any) {
        self.mainMenuUpdateAnnotationStyle(identifier: KMToolbarAnchoredAnnotationItemIdentifier)
    }
    
    @IBAction func menuItemAction_squre(_ sender: Any) {
        UserDefaults.standard.set(6, forKey: KMToolBarToolPDFShapeStyle)

        if (self.listView.annotationType == .square) {
            self.toolbarController.clickItem(KMToolbarSquareAnnotationItemIdentifier)
        } else {
            if (self.listView.annotationType == .circle || self.listView.annotationType == .line || self.listView.annotationType == .arrow) {
                self.listView.annotationType = .square
                self.rightSideViewController.annotationProperties.annotationMode = .square
            } else {
                self.toolbarController.clickItem(KMToolbarSquareAnnotationItemIdentifier)
            }
        }
    }

    @IBAction func menuItemAction_circle(_ sender: Any) {
        UserDefaults.standard.set(7, forKey: KMToolBarToolPDFShapeStyle)

        if (self.listView.annotationType == .circle) { // 取消
            self.toolbarController.clickItem(KMToolbarSquareAnnotationItemIdentifier)
        } else {
            if (self.listView.annotationType == .square || self.listView.annotationType == .line || self.listView.annotationType == .arrow) { // 切换
                self.listView.annotationType = .circle
                self.rightSideViewController.annotationProperties.annotationMode = .circle
            } else { // 选中
                self.toolbarController.clickItem(KMToolbarSquareAnnotationItemIdentifier)
            }
        }
    }
    
    @IBAction func menuItemAction_arrow(_ sender: Any) {
        UserDefaults.standard.set(5, forKey: KMToolBarToolPDFShapeStyle)

        if (self.listView.annotationType == .arrow) { // 取消
            self.toolbarController.clickItem(KMToolbarSquareAnnotationItemIdentifier)
        } else { // 选中
            if (self.listView.annotationType == .square || self.listView.annotationType == .circle || self.listView.annotationType == .line) { // 切换
                self.listView.annotationType = .arrow
                self.rightSideViewController.annotationProperties.annotationMode = .arrow
            } else {
                self.toolbarController.clickItem(KMToolbarSquareAnnotationItemIdentifier)
            }
        }
    }
    
    @IBAction func menuItemAction_line(_ sender: Any) {
        UserDefaults.standard.set(4, forKey: KMToolBarToolPDFShapeStyle)

        if (self.listView.annotationType == .line) { // 取消
            self.toolbarController.clickItem(KMToolbarSquareAnnotationItemIdentifier)
        } else { // 选中
            if (self.listView.annotationType == .square || self.listView.annotationType == .circle || self.listView.annotationType == .arrow) { // 切换
                self.listView.annotationType = .line
                self.rightSideViewController.annotationProperties.annotationMode = .line
            } else {
                self.toolbarController.clickItem(KMToolbarSquareAnnotationItemIdentifier)
            }
        }
    }

    // link
    
    @IBAction func menuItemAction_link(_ sender: Any) {
        self.mainMenuUpdateAnnotationStyle(identifier: KMToolbarLinkAnnotationItemIdentifier)
    }
    
    @IBAction func menuItemAction_linkPage(_ sender: Any) {
        self.mainMenuUpdateAnnotationStyle(identifier: KMToolbarLinkAnnotationItemIdentifier)
    }
    
    @IBAction func menuItemAction_linkHttps(_ sender: Any) {

    }
    
    @IBAction func menuItemAction_linkEmail(_ sender: Any) {

    }
    
    // stamp
    
    @IBAction func menuItemAction_stamp(_ sender: Any) {
        self.mainMenuUpdateAnnotationStyle(identifier: KMAnnotationStampToolbarItemIdentifier)
    }
    
    @IBAction func menuItemAction_stampStandard(_ sender: Any) {
        
    }
    
    @IBAction func menuItemAction_stampDynamic(_ sender: Any) {

    }
    
    @IBAction func menuItemAction_stampCustom(_ sender: Any) {

    }
    
    @IBAction func menuItemAction_signure(_ sender: Any) {
        self.mainMenuUpdateAnnotationStyle(identifier: KMToolbarSignSignatureAnnotationItemIdentifier)
    }
    
    @IBAction func menuItemAction_hiddenAllAnnotation(_ sender: Any) {
        self.showOrHideNotes()
    }
    
    @IBAction func menuItemAction_clearAllAnnotation(_ sender: Any) {
        self.removeAllAnnotations()
    }
    
    private func mainMenuUpdateAnnotationStyle(identifier : String) {
        if self.toolbarController.toolbarType != .Annatiton {
            let item : KMToolBoxItem = (self.toolbarController.mainToolBarView?.toolbarItemFindItemIdentifiers(value: KMDocumentAnnotationToolbarItemIdentifier))!
            self.toolbarController.mainToolBarView?.delegate?.toolbarViewController?(self.toolbarController.mainToolBarView!, clickMode: .Annatiton, toolbar: item, [])
        }
        let childitem : KMToolBoxItem = (self.toolbarController.childToolBarView?.toolbarItemFindItemIdentifiers(value: identifier))!
        self.toolbarController.mainToolBarView?.delegate?.changeAnnotationModeAction?(item: childitem.clickButton)
    }
}

// MARK: goto Menu

extension KMMainViewController {
    @IBAction func menuItemAction_nextPage(_ sender: Any) {
        if (self.listView.canGoToNextPage()) {
            self.listView.goToNextPage(nil)
        }
    }
    
    @IBAction func menuItemAction_forwardPage(_ sender: Any) {
        if (self.listView.canGoToPreviousPage()) {
            self.listView.goToPreviousPage(nil)
        }
    }
    
    @IBAction func menuItemAction_firstPage(_ sender: Any) {
        if (self.listView.canGoToFirstPage()) {
            self.listView.goToFirstPage(nil)
        }
    }
    
    @IBAction func menuItemAction_lastPage(_ sender: Any) {
        if (self.listView.canGoToLastPage()) {
            self.listView.goToLastPage(nil)
        }
    }
    
    @IBAction func menuItemAction_forward(_ sender: Any) {
        if (self.listView.km_canGoForward()) {
            self.listView.km_goForward(nil)
        }
    }
    
    @IBAction func menuItemAction_goback(_ sender: Any) {
        if (self.listView.km_canGoBack()) {
            self.listView.km_goBack(nil)
        }
    }
    
    @IBAction func menuItemAction_gotoPage(_ sender: Any) {
        let sheet = SKTextFieldSheetController.init(windowNibName: "PageSheet")
        var pages : [String] = []
        for i in 0 ..< self.listView.document.pageCount {
            pages.append("\(i)")
        }
        sheet.callback =  { [weak self] stringValue in
            if (stringValue == nil) {
                return
            }
            guard let index = Int(stringValue!) else {
                return
            }
            if (self?.listView == nil) {
                return
            }
            if (index > 0 && index <= self!.listView.document.pageCount) {
                self?.listView.go(toPageIndex: index-1, animated: true)
            }
        }
        sheet.showWindow(nil)
        sheet.pageBox.addItems(withObjectValues: pages)
        sheet.stringValue = "\(self.listView.currentPageIndex+1)"
    }
}

// MARK: tool Menu

extension KMMainViewController {
    @IBAction func menuItemAction_textTool(_ sender: Any) {
        self.toolbarController.selectItem(KMToolbarZoomToSelectionItemIdentifier)
    }
    
    @IBAction func menuItemAction_scrolTool(_ sender: Any) {
        self.toolbarController.selectItem(KMToolbarMoveToolModeItemIdentifier)
    }
    
    @IBAction func menuItemAction_zoomOutTool(_ sender: Any) {
        self.toolbarController.selectItem(KMToolbarMagnifyToolModeItemIdentifier)
    }
    
    @IBAction func menuItemAction_selectTool(_ sender: Any) {
        self.toolbarController.selectItem(KMToolbarSelectToolModeItemIdentifier)
    }
    
    @IBAction func menuItemAction_redact(_ sender: Any) {
        self.toolbarController.enterRedact()
    }
    
    @IBAction func menuItemAction_warkmark(_ sender: Any) {
        self.toolbarController.delegate?.clickChildTool?(type: .watermark, index: 0)
    }
    
    @IBAction func menuItemAction_background(_ sender: Any) {
        self.toolbarController.delegate?.clickChildTool?(type: .background, index: 0)
    }
    
    @IBAction func menuItemAction_headerfooter(_ sender: Any) {
        self.toolbarController.delegate?.clickChildTool?(type: .headerAndFooter, index: 0)
    }
    
    @IBAction func menuItemAction_bates(_ sender: Any) {
        self.toolbarController.delegate?.clickChildTool?(type: .bates, index: 0)
    }
    
    @IBAction func menuItemAction_batch(_ sender: Any) {
        KMBatchWindowController.openFile(self.listView.document?.documentURL, .Batch)
    }
}

// MARK: window Menu

extension KMMainViewController {
    @IBAction func menuItemAction_showForwardTagPage(_ sender: Any) {
        (self.myDocument as? KMMainDocument)?.browser.selectPreviousTab()
    }
    
    @IBAction func menuItemAction_showNextTagPage(_ sender: Any) {
        (self.myDocument as? KMMainDocument)?.browser.selectNextTab()
    }
    
    @IBAction func menuItemAction_newTagPageToNewWindow(_ sender: Any) {
        self.browserWindowController?.openNewWindow(sender)
    }
    
    @IBAction func menuItemAction_mergeAllWindow(_ sender: Any) {
        ((self.myDocument as? KMMainDocument)?.browser.windowController as? KMBrowserWindowController)?.mergeAllWindow(sender)
    }
    
    @IBAction func menuItemAction_currentWindowName(_ sender: Any) {
        
    }
}

extension KMMainViewController: NSMenuItemValidation, NSMenuDelegate {
    func validateMenuItem(_ menuItem: NSMenuItem) -> Bool {
        if (menuItem.action == #selector(menuItemAction_currentWindowName)) {
            menuItem.title = (self.myDocument?.fileURL!.lastPathComponent)!
            return true
        }
        
        if (menuItem.action == #selector(menuItemAction_thumai) ||
            menuItem.action == #selector(menuItemAction_outline) ||
            menuItem.action == #selector(menuItemAction_bookmark) ||
            menuItem.action == #selector(menuItemAction_annotation) ||
            menuItem.action == #selector(menuItemAction_search)) {
            menuItem.state = .off
            let type = self.leftSideViewController.type.methodType
            if (menuItem.action == #selector(menuItemAction_thumai) && type == .Thumbnail) {
                menuItem.state = .on
            }
            if (menuItem.action == #selector(menuItemAction_outline) && type == .Outline) {
                menuItem.state = .on
            }
            if (menuItem.action == #selector(menuItemAction_bookmark) && type == .BookMark) {
                menuItem.state = .on
            }
            if (menuItem.action == #selector(menuItemAction_annotation) && type == .Annotation) {
                menuItem.state = .on
            }
            if (menuItem.action == #selector(menuItemAction_search) && type == .Search) {
                menuItem.state = .on
            }
        }
        if (menuItem.action == #selector(menuItemAction_hiddenLeftSide)) {
            if (self.leftPanelOpen) {
                menuItem.title = NSLocalizedString("Hide Left Side Panel", comment: "")
            } else {
                menuItem.title = NSLocalizedString("Show Left Side Panel", comment: "")
            }
        }
        if (menuItem.action == #selector(menuItemAction_hiddenRightSide)) {
            if (self.rightPanelIsOpen) {
                menuItem.title = NSLocalizedString("Hide Right Side Panel", comment: "")
            } else {
                menuItem.title = NSLocalizedString("Show Right Side Panel", comment: "")
            }
        }
        
        if (menuItem.action == #selector(menuItemAction_hiddenAllAnnotation)) {
            if (self.listView.hideNotes) {
                menuItem.title = NSLocalizedString("Show Notes", comment: "")
            } else {
                menuItem.title = NSLocalizedString("Hide Notes", comment: "")
            }
        }
        
        if (menuItem.action == #selector(menuItemAction_showForwardTagPage) ||
            menuItem.action == #selector(menuItemAction_showNextTagPage)) {
            let browser = self.browserWindowController?.browser
            if (browser != nil && (browser is KMBrowser)) {
                if (menuItem.action == #selector(menuItemAction_showForwardTagPage)) {
                    return (browser as! KMBrowser).canSelectPreviousTab()
                }
                if (menuItem.action == #selector(menuItemAction_showNextTagPage)) {
                    return (browser as! KMBrowser).canSelectNextTab()
                }
            }
        }
        if (menuItem.action == #selector(menuItemAction_mergeAllWindow)) {
            if let _browserWindowC = ((self.myDocument as? KMMainDocument)?.browser.windowController as? KMBrowserWindowController) {
                return _browserWindowC.canMergeAllWindow()
            }
        }
        
        if (menuItem.action == #selector(menuItemAction_nextPage) ||
            menuItem.action == #selector(menuItemAction_forwardPage) ||
            menuItem.action == #selector(menuItemAction_firstPage) ||
            menuItem.action == #selector(menuItemAction_lastPage) ||
            menuItem.action == #selector(menuItemAction_forward) ||
            menuItem.action == #selector(menuItemAction_goback)) {

            if (menuItem.action == #selector(menuItemAction_nextPage)) {
                if self.listView.isEditing() && self.listView.isEditable() {
                    return false
                }
                return (self.pdfViewCanHorizontalScroll() == false && self.listView.canGoToNextPage())
            }
            if (menuItem.action == #selector(menuItemAction_forwardPage)) {
                if self.listView.isEditing() && self.listView.isEditable() {
                    return false
                }
                return (self.pdfViewCanHorizontalScroll() == false && self.listView.canGoToPreviousPage())
            }
            if (menuItem.action == #selector(menuItemAction_firstPage)) {
                return self.listView.canGoToFirstPage()
            }
            if (menuItem.action == #selector(menuItemAction_lastPage)) {
                return self.listView.canGoToLastPage()
            }
            if (menuItem.action == #selector(menuItemAction_forward)) {
                return self.listView.km_canGoForward()
            }
            if (menuItem.action == #selector(menuItemAction_goback)) {
                return self.listView.km_canGoBack()
            }
        }

        return true
    }
}