PDF_Office/PDF Office/PDF Master/Class/PDFWindowController/Toolbar/KMToolbarViewController.swift

//
//  KMToolbarViewController.swift
//  PDF Master
//
//  Created by lxy on 2022/12/2.
//

import Cocoa

@objc enum KMToolbarViewType : Int {
    case None
    case Main
    case Annatiton
    case Page
    case Conversion
    case ScanOCR
    case editPDF
    case Form
    case FillSign
    case Tool
    case redact
    case Move
    case Magnify
    case Select
    case SelectZoom
    case LeftPanel
    case RightPanel
    
    func isToolMode() -> Bool {
        return (self == .Move || self == .Magnify || self == .Select || self == .SelectZoom)
    }
    
    func itemIdentifier() -> String {
        if (self == .Annatiton) {
            return KMDocumentAnnotationToolbarItemIdentifier
        } else if (self == .Page) {
            return KMDocumentPageToolbarItemIdentifier
        } else if (self == .Conversion) {
            return KMDocumentConversonToolbarItemIdentifier
        } else if (self == .ScanOCR) {
            return KMDocumentScanOCRToolbarItemIdentifier
        } else if (self == .editPDF) {
            return KMDocumentEditToolbarItemIdentifier
        } else if (self == .Form) {
            return KMDocumentFormToolbarItemIdentifier
        } else if (self == .FillSign) {
            return KMDocumentFillSginToolbarItemIdentifier
        } else if (self == .Tool) {
            return KMDocumentToolToolbarItemIdentifier
        } else if (self == .Move) {
            return KMToolbarMoveToolModeItemIdentifier
        } else if (self == .Magnify) {
            return KMToolbarMagnifyToolModeItemIdentifier
        } else if (self == .Select) {
            return KMToolbarSelectToolModeItemIdentifier
        } else if (self == .SelectZoom) {
            return KMToolbarZoomToSelectionItemIdentifier
        } else if (self == .LeftPanel) {
            return KMLeftControlToolbarItemIdentifier
        } else if (self == .RightPanel) {
            return KMRightControlToolbarItemIdentifier
        }
        return ""
    }
}

@objc enum KMToolbarType: Int {
    /// conversion
    case word = 3000
    case excel = 3001
    case ppt = 3002
    case rtf = 3003
    case csv = 3004
    case html = 3005
    case conversion_text = 3006
    case conversion_image = 3007
    
    /// tool
    case compress = 8000
    case merge = 8001
    case fileCompare = 8002
    case secure = 8003
    case redact = 8004
    case watermark = 8005
    case background = 8006
    case headerAndFooter = 8007
    case bates = 8008
    case crop = 8009
    case comparison = 8010
}

@objc protocol KMToolbarViewControllerDelegate {
    @objc optional func changeAnnotationModeAction(item:KMToolbarClickButton)
    @objc optional func showPDFLayoutModeAction(show:Bool)
    @objc optional func changePDFViewZoomInAction()
    @objc optional func changePDFViewZoomOutAction()
    @objc optional func changePDFViewGotoNextPageAction()
    @objc optional func changePDFViewGoToPreviousPageAction()
    @objc optional func changePDFViewGotoBackAction()
    @objc optional func changePDFViewGoToForwardAction()
    @objc optional func showPDFViewPrintViewController()
    @objc optional func aiTranslationPDFFileAction()
    @objc optional func toolbarViewController(_ viewController:KMToolbarViewController, zoomSting : String)
    @objc optional func toolbarViewController(_ viewController:KMToolbarViewController, zoomModel selectedTag:Int)
    @objc optional func toolbarViewController(_ viewController:KMToolbarViewController, shareAction toolbarItem: KMToolbarItemView)
    @objc optional func toolbarViewController(_ viewController:KMToolbarViewController, shareDocument item:NSMenuItem)
    @objc optional func toolbarViewController(_ viewController:KMToolbarViewController, shareFlatten item:NSMenuItem)
    @objc optional func toolbarViewController(_ viewController:KMToolbarViewController, shareOriginalPDF item:NSMenuItem)
    @objc optional func toolbarViewController(_ viewController: KMToolbarViewController, clickMode toolMode: KMToolbarViewType, toolbar toolbarItem: KMToolbarItemView, _ pages: [Int])
    @objc optional func toolbarViewController(_ viewController: KMToolbarViewController, clickChaildToolType: KMToolbarType, toolbar toolbarItem: KMToolbarItemView)
    @objc optional func toolbarViewController(_ viewController:KMToolbarViewController, scanOCRModel selectedTag:Int)
    @objc optional func toolbarViewController(_ viewController:KMToolbarViewController, rightPanel toolbarItem: KMToolbarItemView)
    @objc optional func toolbarViewController(_ viewController:KMToolbarViewController, leftPanel toolbarItem: KMToolbarItemView)
    
    @objc optional func toolbarViewController(_ viewController:KMToolbarViewController, itemDidClick toolbarItem: KMToolbarItemView)
    @objc optional func toolbarViewController(_ viewController:KMToolbarViewController, searchAction searchString: String)
}

class KMToolbarViewController: NSViewController, NSTextFieldDelegate {

    var toolbar : KMToolbarView!
    var toolbarType : KMToolbarViewType = KMToolbarViewType.None
    var toolbarItems : [String : Any] = [:]
    @IBOutlet weak  var mainWindowController : MainWindowController!
    open weak var delegate: KMToolbarViewControllerDelegate?
    @IBOutlet var zoomButton: NSPopUpButton!
    @IBOutlet var zoomView: NSView!
    @IBOutlet weak var zoomTextField: NSTextField!
    var pdfView : CPDFListView = CPDFListView()
    var shareButton = KMToolbarClickButton()
    private var bottomLine = NSView()
    
    // 是否显示所有注释
    var isShowAllAnnotations = true
    var ignoreCurrentAnnotationTypeChange = false
    
    override func viewDidLoad() {
        super.viewDidLoad()
        self.zoomTextField.delegate = self
        NotificationCenter.default.addObserver(self, selector: #selector(listViewAnnotationTypeChangeNotification), name: Notification.Name("CPDFListViewAnnotationTypeChangeNotification"), object: nil)
        NotificationCenter.default.addObserver(self, selector: #selector(listViewAnnotationTypeChangeNotification), name: Notification.Name("CPDFListViewToolModeChangeNotification"), object: nil)
    }
    
    override func loadView() {
        super.loadView()
        
        self.toolbar = KMToolbarView.init(identifier: "KMToolbar_New")
        self.toolbar.frame = self.view.bounds
        self.toolbar.autoresizingMask = [.width,.height]
        self.toolbar.delegate = self
        self.view.addSubview(self.toolbar)
        
        self.view.addSubview(self.bottomLine)
        self.bottomLine.frame = NSMakeRect(0, 0, NSWidth(self.view.bounds), 1)
        self.bottomLine.autoresizingMask = [.width]
        self.bottomLine.wantsLayer = true
        self.bottomLine.layer?.backgroundColor = NSColor.km_init(hex: "#0000001A").cgColor
    }
    
    func updateType(newType:KMToolbarViewType) {
        if newType != toolbarType {
            toolbarType = newType
            if self.toolbar != nil && self.toolbar.superview != nil {
                self.toolbar.removeFromSuperview()
            }
            self.toolbar = KMToolbarView.init(identifier: "KMToolbar_New")
            self.toolbar.frame = self.view.bounds
            self.toolbar.autoresizingMask = [.width,.height]
            self.toolbar.delegate = self
            self.view.addSubview(self.toolbar)
        }
    }
    
    func reloadateToolbar() -> Void {
        toolbar.reloadData()
    }
    
    func resetToolbar() -> Void {
        for item in toolbar.items {
            item.isSelected = false
        }
    }
    
    // MARK: Action
    
    @IBAction func changeAnnotationMode(item: KMToolbarClickButton) {
        self.delegate?.changeAnnotationModeAction?(item: item)
    }
    
    @IBAction func leftControllButtonAction(item: KMToolbarClickButton) {
        
        let tag = KMToolbarViewType(rawValue: item.tag) ?? .None
        
        if tag == .editPDF {
            Task { @MainActor in
                #if VERSION_DMG
                if await (KMLightMemberManager.manager.canUseAdvanced() == false) {
                    let _ =  KMComparativeTableViewController.show(window: self.view.window!)
                    return
                }
                #endif

                self.delegate?.toolbarViewController?(self, clickMode: tag, toolbar: item.clickObject as! KMToolbarItemView, [])
            }
        } else {
            self.delegate?.toolbarViewController?(self, clickMode: tag, toolbar: item.clickObject as! KMToolbarItemView, [])
        }
    }
    
    @objc private func leftPanelAction(sender: KMToolbarClickButton) {
        self.delegate?.toolbarViewController?(self, leftPanel: sender.clickObject as! KMToolbarItemView)
    }
    
    @objc private func itemAction(_ item: KMToolbarClickButton) {
        self.delegate?.toolbarViewController?(self, itemDidClick: item.clickObject as! KMToolbarItemView)
    }
    
    @IBAction func rightPanelControllButtonAction(item: KMToolbarClickButton) {
        let tag = KMToolbarViewType(rawValue: item.tag) ?? .None
        
        self.delegate?.toolbarViewController?(self, rightPanel: item.clickObject as! KMToolbarItemView)
    }
    
    @IBAction func showPDFLayoutMode(sender: KMToolbarClickButton) {
        let item = sender.clickObject as? KMToolbarItemView
        if (item != nil) {
            item?.isSelected = !item!.isSelected
        }
        self.delegate?.showPDFLayoutModeAction?(show: true)
    }
    
    @objc func cropMenuAction(item: KMToolbarItemView) {
        self.delegate?.toolbarViewController?(self, clickChaildToolType: .crop, toolbar: item)
    }
    
    @objc func batesMenuAction(sender: KMToolbarClickButton) {
        self.delegate?.toolbarViewController?(self, clickChaildToolType: .bates, toolbar: sender.clickObject as! KMToolbarItemView)
    }
    
    @objc func headerfooterMenuAction(sender: KMToolbarClickButton) {
        self.delegate?.toolbarViewController?(self, clickChaildToolType: .headerAndFooter, toolbar: sender.clickObject as! KMToolbarItemView)
    }
    
    @objc func backgroundMenuAction(sender: KMToolbarClickButton) {
        self.delegate?.toolbarViewController?(self, clickChaildToolType: .background, toolbar: sender.clickObject as! KMToolbarItemView)
    }
    
    @objc func watermarkMenuAction(sender: KMToolbarClickButton) {
        self.delegate?.toolbarViewController?(self, clickChaildToolType: .watermark, toolbar: sender.clickObject as! KMToolbarItemView)
    }
    
    @objc func redactMenuAction(sender: KMToolbarClickButton) {
        self.delegate?.toolbarViewController?(self, clickChaildToolType: .redact, toolbar: sender.clickObject as! KMToolbarItemView)
    }
    
    @objc func compressMenuAction(sender: KMToolbarClickButton) {
        self.delegate?.toolbarViewController?(self, clickChaildToolType: .compress, toolbar: sender.clickObject as! KMToolbarItemView)
    }
    
    @objc func secureMenuAction(sender: KMToolbarClickButton) {
        self.delegate?.toolbarViewController?(self, clickChaildToolType: .secure, toolbar: sender.clickObject as! KMToolbarItemView)
    }
    
    @objc func conversionMenuItemAction(sender: KMToolbarClickButton) {
        let item: KMToolbarItemView = sender.clickObject as! KMToolbarItemView
        var type: KMToolbarType = .word
        if (item.btnTag == KMToolbarType.excel.rawValue) {
            type = .excel
        } else if (item.btnTag == KMToolbarType.ppt.rawValue) {
            type = .ppt
        } else if (item.btnTag == KMToolbarType.rtf.rawValue) {
            type = .rtf
        } else if (item.btnTag == KMToolbarType.csv.rawValue) {
            type = .csv
        } else if (item.btnTag == KMToolbarType.html.rawValue) {
            type = .html
        } else if (item.btnTag == KMToolbarType.conversion_text.rawValue) {
            type = .conversion_text
        } else if (item.btnTag == KMToolbarType.conversion_image.rawValue) {
            type = .conversion_image
        }
        self.delegate?.toolbarViewController?(self, clickChaildToolType: type, toolbar: item)
    }
    
    
    @IBAction func zoomModelSelectButtonAction(_ sender: NSPopUpButton) {
        self.delegate?.toolbarViewController?(self, zoomModel: sender.selectedTag())
        for item in sender.itemArray {
            item.state = .off
        }
        sender.selectedItem?.state = .on
    }
    
    @IBAction func zoomPDFViewButtonAction(sender:KMToolbarClickButton) {
        if sender.tag == 0 {
            self.delegate?.changePDFViewZoomOutAction?()
        } else if sender.tag == 1 {
            self.delegate?.changePDFViewZoomInAction?()
        } else if sender.tag == 2 {
            self.delegate?.changePDFViewGotoBackAction?()
        } else if sender.tag == 3 {
            self.delegate?.changePDFViewGoToForwardAction?()
        }
    }
    
    @IBAction func printPDFViewButtonAction(sender:KMToolbarClickButton) {
        self.delegate?.showPDFViewPrintViewController?()
    }
    
    @IBAction func aiTranslationButtonAction(sender:KMToolbarClickButton) {
        self.delegate?.aiTranslationPDFFileAction?()
    }
    
    @IBAction func shareButtonAction(sender:KMToolbarClickButton) {
        self.shareButton = sender
        let menu = NSMenu()
        menu.addItem(withTitle: NSLocalizedString("Document", comment: ""), action: #selector(shareViaWithDocument), target: self)
        menu.addItem(withTitle: NSLocalizedString("Flattened Copy", comment: ""), action: #selector(shareViaWithFlatten), target: self)
        menu.addItem(withTitle: NSLocalizedString("Original PDF", comment: ""), action: #selector(shareViaWithOriginalPDF), target: self)
        menu.popUp(positioning: nil, at: NSPoint(x: sender.frame.origin.x, y: sender.frame.origin.y-10), in: sender.superview)
        
        self.delegate?.toolbarViewController?(self, shareAction: sender.clickObject as! KMToolbarItemView)
    }
    
    @IBAction func shareViaWithDocument(sender:NSMenuItem) {
        self.delegate?.toolbarViewController?(self, shareDocument: sender)
    }
    
    @IBAction func shareViaWithFlatten(sender:NSMenuItem) {
        self.delegate?.toolbarViewController?(self, shareFlatten: sender)
    }
    
    @IBAction func shareViaWithOriginalPDF(sender:NSMenuItem) {
        self.delegate?.toolbarViewController?(self, shareOriginalPDF: sender)
    }
    
    @objc func mergeMenuItemAction(sender: KMToolbarClickButton) {
        self.delegate?.toolbarViewController?(self, clickChaildToolType: .merge, toolbar: sender.clickObject as! KMToolbarItemView)
    }
    
    @IBAction func scanOCRModelSelect(sender:KMToolbarClickButton) {
        self.delegate?.toolbarViewController?(self, scanOCRModel: sender.tag)
    }
    
    // Form 对齐
    @IBAction func formsAlignmentAction(sender:KMToolbarClickButton) {
       
    }
    
    // Form 更多操作
    @IBAction func formsMoreOperationAction(sender:KMToolbarClickButton) {
        
    }
    
    func toolbarItemFindItemIdentifiers(value : String) -> KMToolbarItemView{
        for item in self.toolbarItems {
            if item.key == value {
                return item.value as! KMToolbarItemView
            }
        }
        return KMToolbarItemView()
    }
    
    func controlTextDidEndEditing(_ obj: Notification) {
        let textField = obj.object as? NSTextField
        if textField == self.zoomTextField {
            self.delegate?.toolbarViewController?(self, zoomSting: self.zoomTextField.stringValue)
        }
    }
    
    func controlTextDidChange(_ obj: Notification) {
        
    }
    
    func control(_ control: NSControl, textView: NSTextView, doCommandBy commandSelector: Selector) -> Bool {
        switch commandSelector {
        case #selector(NSResponder.insertNewline(_:)):
            if let inputView = control as? NSTextField {
//                //当当前TextField按下enter
                if inputView == zoomTextField {
                    KMPrint("按下 enter")
                    self.delegate?.toolbarViewController?(self, zoomSting: self.zoomTextField.stringValue)
                } else if let _ = control as? NSSearchField {
                    self.delegate?.toolbarViewController?(self, searchAction: control.stringValue)
                }
            }
            return true
        default:
            return false
        }
    }
}

extension KMToolbarViewController : KMToolbarViewDelegate,NSToolbarItemValidation {
    func toolbarLeftDefaultItemIdentifiers(_ toolbar: KMToolbarView) -> [String] {
        if toolbarType == .Main {
            return [KMLeftControlToolbarItemIdentifier,
                    KMDocumentZoomViewToolbarItemIdentifier, KMDocumentZoomOutToolbarItemIdentifier, KMDocumentZoomToolbarItemIdentifier,
                    KMDocumentPreviousPageToolbarItemIdentifier, KMDocumentNextPageToolbarItemIdentifier, KMDocumentHomeToolbarItemIdentifier]
        }
        return []
    }
    
    func toolbarRightDefaultItemIdentifiers(_ toolbar: KMToolbarView) -> [String] {
        if toolbarType == .Main {
            return [KMDocumentViewSettingToolbarItemIdentifier, KMDocumentShareToolbarItemIdentifier,
                    KMDocumentSearchToolbarItemIdentifier, KMRightControlToolbarItemIdentifier]
        } else if [.Annatiton,.Magnify,.Move,.Select,.SelectZoom].contains(toolbarType) {
            return [KMToolbarAnnotationSettingItemIdentifier]
        }
        return []
    }
    
    func toolbarAllowedItemIdentifiers(_ toolbar: KMToolbarView) -> [String] {
        if [.Annatiton,.Magnify,.Move,.Select,.SelectZoom].contains(toolbarType) {
            return [KMNewToolbarSpaceItemIdentifier,
                    KMToolbarPageEditInsetItemIdentifier, KMToolbarToolMergeItemIdentifier, KMToolbarPageEditSplitItemIdentifier,
                    KMToolbarToolCompressItemIdentifier, KMToolbarToolSecureItemIdentifier, KMToolbarToolWatermarkItemIdentifier,
                    KMToolbarToolBackgroundItemIdentifier, KMToolbarToolHeaderFooterItemIdentifier, KMToolbarToolBatesItemIdentifier,
                    KMToolbarToolCropItemIdentifier,
                    KMToolbarConversionWordItemIdentifier, KMToolbarConversionExcelItemIdentifier, KMToolbarConversionPPTItemIdentifier,
                    KMToolbarConversionRTFItemIdentifier, KMToolbarConversionCSVItemIdentifier, KMToolbarConversionHTMLItemIdentifier,
                    KMToolbarConversionTextItemIdentifier, KMToolbarConversionImageItemIdentifier,
                    
                    KMToolbarMoveToolModeItemIdentifier,
                    KMToolbarMagnifyToolModeItemIdentifier,
                    KMToolbarSelectToolModeItemIdentifier,
                    KMToolbarZoomToSelectionItemIdentifier,
                    KMNewToolbarSpaceItemIdentifier,
                    KMToolbarDividerItemIdentifier,
                    KMNewToolbarSpaceItemIdentifier,
                    KMToolbarHighlightAnnotationItemIdentifier,
                    KMToolbarUnderlineAnnotationItemIdentifier,
                    KMToolbarStrikeOutAnnotationItemIdentifier,
                    KMToolbarInkAnnotationItemIdentifier,
                    KMToolbarFreeTextAnnotationItemIdentifier,
                    KMToolbarAnchoredAnnotationItemIdentifier,
                    KMToolbarSquareAnnotationItemIdentifier, KMToolbarCircleAnnotationItemIdentifier, KMToolbarArrowAnnotationItemIdentifier, KMToolbarLineAnnotationItemIdentifier,
                    KMToolbarLinkAnnotationItemIdentifier,
                    KMAnnotationStampToolbarItemIdentifier,
                    KMToolbarSignSignatureAnnotationItemIdentifier,
                    KMToolbarDividerItemIdentifier,
                    KMToolbarShowToolbarItemIdentifier,
                    
                    KMToolbarToolRadioButtonItemIdentifier]
        }
        return []
    }
    
    func toolbarDefaultItemIdentifiers(_ toolbar: KMToolbarView) -> [String] {
        switch toolbarType {
        case .None:
            return []
        case .Main:
            return [KMDocumentAnnotationToolbarItemIdentifier,
                    KMDocumentPageToolbarItemIdentifier,
                    KMDocumentToolToolbarItemIdentifier,
                    KMDocumentConversonToolbarItemIdentifier,
                    KMDocumentFormToolbarItemIdentifier,
                    KMDocumentFillSginToolbarItemIdentifier,
                    KMDocumentEditToolbarItemIdentifier,
                    KMDocumentRedactToolbarItemIdentifier,
                    KMDocumentScanOCRToolbarItemIdentifier]
        case .Annatiton,.Magnify,.Move,.Select,.SelectZoom:
            let itemIdentifiers: [String]? = self.toolbar?.toolbarIdentifier != nil ? (UserDefaults.standard.object(forKey: self.toolbar!.toolbarIdentifier!) as? [String]) : []
            if itemIdentifiers == nil || itemIdentifiers!.count <= 0 {
                return [KMToolbarMoveToolModeItemIdentifier,
                        KMToolbarMagnifyToolModeItemIdentifier,
                        KMToolbarSelectToolModeItemIdentifier,
                        KMToolbarZoomToSelectionItemIdentifier,
                        KMNewToolbarSpaceItemIdentifier,
                        KMToolbarDividerItemIdentifier,
                        KMNewToolbarSpaceItemIdentifier,
                        KMToolbarHighlightAnnotationItemIdentifier,
                        KMToolbarUnderlineAnnotationItemIdentifier,
                        KMToolbarStrikeOutAnnotationItemIdentifier,
                        KMToolbarInkAnnotationItemIdentifier,
                        KMToolbarFreeTextAnnotationItemIdentifier,
                        KMToolbarAnchoredAnnotationItemIdentifier,
                        KMToolbarSquareAnnotationItemIdentifier, KMToolbarCircleAnnotationItemIdentifier, KMToolbarArrowAnnotationItemIdentifier, KMToolbarLineAnnotationItemIdentifier,
                        KMToolbarLinkAnnotationItemIdentifier,
                        KMAnnotationStampToolbarItemIdentifier,
                        KMToolbarSignSignatureAnnotationItemIdentifier,
                        KMToolbarDividerItemIdentifier,
                        KMToolbarShowToolbarItemIdentifier]
            }
            return itemIdentifiers!
        case .editPDF:
            return [KMToolbarAddTextEditPDFItemIdentifier,
                    KMToolbarAddImageEditPDFItemIdentifier]
        case .Page:
            return []
        case .Tool:
            return [KMToolbarToolCompressItemIdentifier, KMToolbarToolMergeItemIdentifier,
                    KMToolbarToolSecureItemIdentifier, KMToolbarComparisonItemIdentifier,
                    KMToolbarToolWatermarkItemIdentifier, KMToolbarToolBackgroundItemIdentifier,
                    KMToolbarToolHeaderFooterItemIdentifier, KMToolbarToolBatesItemIdentifier]
        case .Form:
            return [KMToolbarToolTextFieldItemIdentifier,
                    KMToolbarToolCheckBoxItemIdentifier,
                    KMToolbarToolRadioButtonItemIdentifier,
                    KMToolbarToolListBoxItemIdentifier,
                    KMToolbarToolPullDownmenuItemIdentifier,
                    KMToolbarToolButtonIdentifier,
                    KMToolbarToolSignBoxIdentifier,
                    KMToolbarDividerItemIdentifier,
                    KMToolbarToolFormAlignIdentifier,
                    KMToolbarToolFormMoreIdentifier]
        case .FillSign:
            return [KMToolbarToolTextIdentifier,
                    KMToolbarToolHookItemIdentifier,
                    KMToolbarToolForkItemIdentifier,
                    KMToolbarToolRectangleIdentifier,
                    KMToolbarToolLineItemIdentifier,
                    KMToolbarToolDotItemIdentifier,
                    KMToolbarToolDateIdentifier,
                    KMToolbarFillSignSignatureIdentifier]
        case .Conversion:
            return [KMToolbarConversionWordItemIdentifier,
                    KMToolbarConversionExcelItemIdentifier,
                    KMToolbarConversionPPTItemIdentifier,
                    KMToolbarConversionRTFItemIdentifier,
                    KMToolbarConversionCSVItemIdentifier,
                    KMToolbarConversionHTMLItemIdentifier,
                    KMToolbarConversionTextItemIdentifier,
                    KMToolbarConversionImageItemIdentifier]
        case .ScanOCR:
            return [KMToolbarToolEnhancedScanIdentifier,
                KMToolbarToolOCRTextIdentifier]
        default:
            break
        }

        return []
    }
    
    func toolbar(_ toolbar: KMToolbarView, itemFor identifier: String) -> KMToolbarItemView {
        var item: KMToolbarItemView? = self.toolbarItems[identifier] as? KMToolbarItemView
        var create = true
        if let data = item {
            let pId = parentIdentifier(data.itemIdentifier ?? "")
            if [.Annatiton,.Magnify,.Move,.Select,.SelectZoom].contains(toolbarType) && (pId != KMDocumentAnnotationToolbarItemIdentifier || data.itemIdentifier! == KMToolbarAnnotationSettingItemIdentifier) {
                create = true
            }
        }
        if item == nil || create {
            item = KMToolbarItemView.init(itemIdentifier: identifier)
            self.toolbarItems[identifier] = item
            if identifier == KMLeftControlToolbarItemIdentifier {
                item?.image = NSImage(named: "KMImageNameUXIconBtnTriLeftNor")
                item?.titleName = NSLocalizedString("Panel", comment: "")
                item?.target = self
                item?.toolTip = NSLocalizedString("View Settings", comment: "")
                item?.boxImagePosition = .imageAbove
                item?.btnAction = #selector(leftPanelAction)
            } else if identifier == KMDocumentZoomToolbarItemIdentifier {
                item?.image = NSImage(named: "KMImageNameUXIconToolbarZoominNor")
                item?.titleName = NSLocalizedString("", comment: "")
                item?.target = self
                item?.btnTag = 1
                item?.toolTip = NSLocalizedString("Zoom In", comment: "")
                item?.boxImagePosition = .imageAbove
                item?.btnAction = #selector(zoomPDFViewButtonAction)
            } else if identifier == KMDocumentZoomOutToolbarItemIdentifier {
                item?.image = NSImage(named: "KMImageNameUXIconToolbarZoomoutNor")
                item?.titleName = NSLocalizedString("", comment: "")
                item?.target = self
                item?.btnTag = 0
                item?.toolTip = NSLocalizedString("Zoom Out", comment: "")
                item?.boxImagePosition = .imageAbove
                item?.btnAction = #selector(zoomPDFViewButtonAction)
            } else if identifier == KMDocumentZoomViewToolbarItemIdentifier{
                item?.titleName = NSLocalizedString("Zoom", comment: "")
                item?.target = self
                let view = NSView()
                view.frame = NSMakeRect(0, 0, 70, 40)
                let boxView = NSView()
                boxView.frame = NSMakeRect(0, 16, 70, 22)
                view.addSubview(boxView)
                boxView.addSubview(self.zoomView)
                self.zoomView.frame = NSMakeRect(10, 3, NSWidth(self.zoomView.frame), NSHeight(self.zoomView.frame))
                let titleLabel = NSTextField(labelWithString: NSLocalizedString("Zoom", comment: ""))
                view.addSubview(titleLabel)
                titleLabel.frame = NSMakeRect(0, 0, 70, 16)
                titleLabel.alignment = .right
                
                boxView.wantsLayer = true
                boxView.layer?.borderWidth = 1
                boxView.layer?.borderColor = NSColor.lightGray.cgColor
                item?.customizeView = view
            } else if identifier == KMDocumentNextPageToolbarItemIdentifier {
                item?.image = NSImage(named: "KMImageNameToolbarPagenextNor")
                item?.titleName = NSLocalizedString("Next", comment: "")
                item?.target = self
                item?.toolTip = NSLocalizedString("Go To Next Page", comment: "")
                item?.boxImagePosition = .imageAbove
                item?.btnAction = #selector(itemAction)
            } else if identifier == KMDocumentPreviousPageToolbarItemIdentifier {
                item?.image = NSImage(named: "KMImageNameToolbarPagepreviousNor")
                item?.titleName = NSLocalizedString("Previous", comment: "")
                item?.target = self
                item?.toolTip = NSLocalizedString("Go To Previous Page", comment: "")
                item?.boxImagePosition = .imageAbove
                item?.btnAction = #selector(itemAction)
            } else if identifier == KMDocumentHomeToolbarItemIdentifier {
                item?.image = NSImage(named: "KMImageNameToolbarHomeNor")
                item?.titleName = NSLocalizedString("Home", comment: "")
                item?.target = self
                item?.toolTip = NSLocalizedString("A Welcome Gift from Us", comment: "")
                item?.boxImagePosition = .imageAbove
                item?.btnAction = #selector(itemAction)
            } else if identifier == KMDocumentAnnotationToolbarItemIdentifier {
                item?.titleName = NSLocalizedString("Tools", comment: "")
                item?.image = NSImage(named: "KMImageNameUXIconToolbarMytoolsNor")
                item?.target = self
                item?.toolTip = String(format: "%@: %@, %@, %@, %@",  KMLocalizedString("Tool Mode", nil),KMLocalizedString("Annotate", nil),KMLocalizedString("Scroll", nil),KMLocalizedString("Magnify", nil),KMLocalizedString("Select", nil))
                item?.btnTag = KMToolbarViewType.Annatiton.rawValue
                item?.btnAction = #selector(leftControllButtonAction)
                item?.boxImagePosition = .imageAbove
            } else if identifier == KMDocumentPageToolbarItemIdentifier {
                item?.titleName = NSLocalizedString("Page Edit", comment: "")
                item?.target = self
                item?.image = NSImage(named: "KMImageNameUXIconToolbarPageeditNor")
                item?.toolTip = NSLocalizedString("PDF page editor: insert, delete, extract, rotate, reposition, and replace pages in a PDF", comment: "")
                item?.btnTag = KMToolbarViewType.Page.rawValue
                item?.btnAction = #selector(leftControllButtonAction)
                item?.boxImagePosition = .imageAbove
            } else if identifier == KMDocumentConversonToolbarItemIdentifier {
                item?.titleName = NSLocalizedString("Converter", comment: "")
                item?.target = self
                item?.image = NSImage(named: "KMImageNameUXIconToolbarConvertNor")
                item?.toolTip = NSLocalizedString("Convert PDFs to Microsoft Word, PowerPoint, Excel, RTF, Text, Image, CSV, and more Offline", comment: "")
                item?.btnTag = KMToolbarViewType.Conversion.rawValue
                item?.btnAction = #selector(leftControllButtonAction)
                item?.boxImagePosition = .imageAbove
            } else if identifier == KMDocumentScanOCRToolbarItemIdentifier {
                item?.titleName = NSLocalizedString("OCR", comment: "")
                item?.target = self
                item?.image = NSImage(named: "KMImageNameToolbarOCRNor")
                item?.boxImagePosition = .imageAbove
                item?.btnTag = KMToolbarViewType.ScanOCR.rawValue
                item?.toolTip = NSLocalizedString("Recognize text from Image-based or Scanned PDF with OCR", comment: "")
                item?.btnAction = #selector(leftControllButtonAction)
            } else if identifier == KMToolbarToolEnhancedScanIdentifier {
                item?.image = NSImage(named: "KMImageNameMainToolEnhancedScan")
                item?.target = self
                item?.btnTag = 0
                item?.toolTip = NSLocalizedString("Enhanced Scan", comment: "")
                item?.titleName = NSLocalizedString("Enhanced Scan", comment: "")
                item?.boxImagePosition = .imageLeft
                item?.btnAction = #selector(scanOCRModelSelect)
            } else if identifier == KMToolbarToolOCRTextIdentifier {
                item?.image = NSImage(named: "KMImageNameMainToolOCRText")
                item?.target = self
                item?.toolTip = NSLocalizedString("OCR Text Recognition", comment: "")
                item?.titleName = NSLocalizedString("OCR Text Recognition", comment: "")
                item?.boxImagePosition = .imageLeft
                item?.btnAction = #selector(scanOCRModelSelect)
            } else if identifier == KMDocumentEditToolbarItemIdentifier {
                item?.titleName = NSLocalizedString("Edit PDF", comment: "")
                item?.target = self
                item?.image = NSImage(named: "KMImageNameUXIconToolbarEditNor")
                item?.boxImagePosition = .imageAbove
                item?.btnTag = KMToolbarViewType.editPDF.rawValue
                item?.toolTip = NSLocalizedString("Edit text and image in PDF", comment: "")
                item?.btnAction = #selector(leftControllButtonAction)
            } else if identifier == KMDocumentFormToolbarItemIdentifier {
                item?.titleName = NSLocalizedString("Forms", comment: "")
                item?.target = self
                item?.image = NSImage(named: "KMImageNameUXIconToolbarFormNor")
                item?.boxImagePosition = .imageAbove
                item?.btnTag = KMToolbarViewType.Form.rawValue
                item?.toolTip = NSLocalizedString("Edit PDF Form", comment: "")
                item?.btnAction = #selector(leftControllButtonAction)
            } else if identifier == KMDocumentFillSginToolbarItemIdentifier {
                item?.titleName = NSLocalizedString("Fill & Sign", comment: "")
                item?.target = self
                item?.image = NSImage(named: "KMImageNameUXIconToolbarFillsignNor")
                item?.boxImagePosition = .imageAbove
                item?.btnTag = KMToolbarViewType.FillSign.rawValue
                item?.toolTip = NSLocalizedString("Fill and sign forms", comment: "")
                item?.btnAction = #selector(leftControllButtonAction)
            } else if identifier == KMDocumentToolToolbarItemIdentifier {
                item?.titleName = NSLocalizedString("Editor", comment: "")
                item?.target = self
                item?.image = NSImage(named: "KMImageNameUXIconToolbarEdittoolNor")
                item?.boxImagePosition = .imageAbove
                item?.btnTag = KMToolbarViewType.Tool.rawValue
                item?.toolTip = NSLocalizedString("Edit, delete, cut, copy, paste, and insert text in PDFs", comment: "")
                item?.btnAction = #selector(leftControllButtonAction)
            } else if identifier == KMDocumentRedactToolbarItemIdentifier {
                item?.titleName = NSLocalizedString("Redact Text", comment: "")
                item?.target = self
                item?.image = NSImage(named: "KMImageNameUXIconToolbarRedactNor")
                item?.boxImagePosition = .imageAbove
                item?.btnTag = KMToolbarViewType.redact.rawValue
                item?.toolTip = NSLocalizedString("Mark for redaction", comment: "")
                item?.btnAction = #selector(leftControllButtonAction)
            } else if identifier == KMDocumentAITranslationToolbarItemIdentifier {
                item?.image = NSImage(named: "ic_function_other_AITranslation")
                item?.titleName = "AI Translation"
                item?.target = self
                item?.toolTip = NSLocalizedString("AI Translation", comment: "")
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(aiTranslationButtonAction)
            } else if identifier == KMDocumentPrintToolbarItemIdentifier {
                item?.image = NSImage(named: "KMImageNameMainToolbarPrint")
                item?.titleName = "Print"
                item?.target = self
                item?.toolTip = NSLocalizedString("Print", comment: "")
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(printPDFViewButtonAction)
            } else if identifier == KMDocumentViewSettingToolbarItemIdentifier {
                item?.image = NSImage(named: "KMImageNameUXIconToolbarPageviewNor")
                item?.titleName = NSLocalizedString("Page Display", comment: "")
                item?.target = self
                item?.toolTip = NSLocalizedString("Page Display", comment: "")
                item?.boxImagePosition = .imageAbove
                item?.btnAction = #selector(itemAction)
            } else if identifier == KMDocumentShareToolbarItemIdentifier {
                item?.image = NSImage(named: "KMImageNameUXIconToolbarShareNor")
                item?.titleName = NSLocalizedString("Share", comment: "")
                item?.target = self
                item?.toolTip = NSLocalizedString("Share the file with others", comment: "")
                item?.boxImagePosition = .imageAbove
                item?.btnAction = #selector(shareButtonAction)
                
                let menuItem = NSMenuItem.init(title: item!.titleName ?? "", action: nil, target: self)
                let menu = NSMenu()
                menu.addItem(withTitle: NSLocalizedString("Document", comment: ""), action: #selector(shareViaWithDocument), target: self)
                menu.addItem(withTitle: NSLocalizedString("Flattened Copy", comment: ""), action: #selector(shareViaWithFlatten), target: self)
                menu.addItem(withTitle: NSLocalizedString("Original PDF", comment: ""), action: #selector(shareViaWithOriginalPDF), target: self)
                menuItem.submenu = menu
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMDocumentSearchToolbarItemIdentifier {
                item?.titleName = NSLocalizedString("Search", comment: "")
                item?.target = self
                let view = NSView()
                view.frame = NSMakeRect(0, 0, 150, 40)
                let boxView = NSView()
                boxView.frame = NSMakeRect(0, 16, 150, 22)
                view.addSubview(boxView)
                let searchView = NSSearchField()
                searchView.frame = NSMakeRect(0, 0, 150, 22)
                searchView.placeholderString = NSLocalizedString("Search", comment: "")
                searchView.sendsWholeSearchString = true
                searchView.sendsSearchStringImmediately = true
                searchView.drawsBackground = false
                searchView.delegate = self
                
                boxView.addSubview(searchView)
                let titleLabel = NSTextField(labelWithString: NSLocalizedString("Search", comment: ""))
                view.addSubview(titleLabel)
                titleLabel.frame = NSMakeRect(0, 0, 130, 16)
                titleLabel.alignment = .center

                item?.customizeView = view
            } else if identifier == KMRightControlToolbarItemIdentifier {
                item?.image = NSImage(named: "KMImageNameUXIconBtnTriRightNor")
                item?.titleName = NSLocalizedString("Properties", comment: "")
                item?.target = self
                item?.toolTip = NSLocalizedString("Show/Hide Annotation Properties Panel", comment: "")
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(rightPanelControllButtonAction)
            } else if identifier == KMToolbarMoveToolModeItemIdentifier {
                item?.titleName = NSLocalizedString("Scroll Tool", comment: "")
                item?.image = NSImage(named: KMImageNameUXIconSubtoolbarMytoolsPantool)
                item?.alternateImage = NSImage(named: KMImageNameUXIconSubtoolbarMytoolsPantool)
                item?.target = self
                item?.btnTag = KMToolbarViewType.Move.rawValue
                item?.toolTip = NSLocalizedString("Scroll Tool", comment: "")
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(leftControllButtonAction)
                
                let menuItem = NSMenuItem.init(title: "Scroll Tool", action: #selector(leftControllButtonAction), target: self)
                menuItem.tag = KMToolbarViewType.Move.rawValue
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarMagnifyToolModeItemIdentifier {
                item?.titleName = NSLocalizedString("Magnify Tool", comment: "")
                item?.image = NSImage(named: KMImageNameUXIconSubtoolbarMytoolsMagnifier)
                item?.alternateImage = NSImage(named: KMImageNameUXIconSubtoolbarMytoolsMagnifier)
                item?.target = self
                item?.btnTag = KMToolbarViewType.Magnify.rawValue
                item?.toolTip = NSLocalizedString("Magnify Tool", comment: "")
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(leftControllButtonAction)
                
                let menuItem = NSMenuItem.init(title: "Magnify Tool", action: #selector(leftControllButtonAction), target: self)
                menuItem.tag = KMToolbarViewType.Magnify.rawValue
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarSelectToolModeItemIdentifier {
                item?.titleName = NSLocalizedString("Content Selection Tool", comment: "")
                item?.image = NSImage(named: KMImageNameUXIconSubtoolbarMytoolsContentsel)
                item?.alternateImage = NSImage(named: KMImageNameUXIconSubtoolbarMytoolsContentsel)
                item?.target = self
                item?.btnTag = KMToolbarViewType.Select.rawValue
                item?.toolTip = NSLocalizedString("Content Selection Tool", comment: "")
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(leftControllButtonAction)
                
                let menuItem = NSMenuItem.init(title: "Content Selection", action: #selector(leftControllButtonAction), target: self)
                menuItem.tag = KMToolbarViewType.Select.rawValue
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarZoomToSelectionItemIdentifier {
                item?.titleName = NSLocalizedString("Zoom to selected area", comment: "")
                item?.image = NSImage(named: KMImageNameUXIconSubtoolbarMytoolsAreazoom)
                item?.alternateImage = NSImage(named: KMImageNameUXIconSubtoolbarMytoolsAreazoom)
                item?.target = self
                item?.btnTag = KMToolbarViewType.SelectZoom.rawValue
                item?.toolTip = NSLocalizedString("Zoom to selected area", comment: "")
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(leftControllButtonAction)
                
                let menuItem = NSMenuItem.init(title: "", action: #selector(leftControllButtonAction), target: self)
                menuItem.tag = KMToolbarViewType.SelectZoom.rawValue
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarHighlightAnnotationItemIdentifier {
                item?.titleName = NSLocalizedString("Highlight", comment: "")
                item?.image = NSImage(named: KMImageNameUXIconSubtoolbarMytoolsUnderline)
                item?.alternateImage = NSImage(named: KMImageNameUXIconSubtoolbarMytoolsUnderline)
                item?.target = self
                item?.btnTag = CAnnotationType.highlight.rawValue
                item?.toolTip = String(format: "%@ (⌃⌘H)", NSLocalizedString("Highlight", comment: ""))
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(changeAnnotationMode)
                
                let menuItem = NSMenuItem.init(title: "highlight", action: #selector(changeAnnotationMode), target: self)
                menuItem.tag = CAnnotationType.highlight.rawValue
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarUnderlineAnnotationItemIdentifier {
                item?.titleName = NSLocalizedString("Underline", comment: "")
                item?.image = NSImage(named: KMImageNameUXIconSubtoolbarMytoolsUnderline)
                item?.alternateImage = NSImage(named: KMImageNameUXIconSubtoolbarMytoolsUnderline)
                item?.target = self
                item?.btnTag = CAnnotationType.underline.rawValue
                item?.toolTip = String(format: "%@ (⇧⌘M)", NSLocalizedString("Underline", comment: ""))
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(changeAnnotationMode)
                
                let menuItem = NSMenuItem.init(title: "underline", action: #selector(changeAnnotationMode), target: self)
                menuItem.tag = CAnnotationType.underline.rawValue
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarStrikeOutAnnotationItemIdentifier {
                item?.titleName = NSLocalizedString("Strikethrough", comment: "")
                item?.image = NSImage(named: KMImageNameUXIconSubtoolbarMytoolsStrikeout)
                item?.alternateImage = NSImage(named: KMImageNameUXIconSubtoolbarMytoolsStrikeout)
                item?.target = self
                item?.btnTag = CAnnotationType.strikeOut.rawValue
                item?.toolTip = String(format: "%@ (⌃⌘M)", NSLocalizedString("Strikethrough", comment: ""))
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(changeAnnotationMode)
                
                let menuItem = NSMenuItem.init(title: "strikeOut", action: #selector(changeAnnotationMode), target: self)
                menuItem.tag = CAnnotationType.strikeOut.rawValue
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarInkAnnotationItemIdentifier {
                item?.titleName = NSLocalizedString("Freehand", comment: "")
                item?.image = NSImage(named: KMImageNameUXIconSubtoolbarMytoolsPen)
                item?.alternateImage = NSImage(named: KMImageNameUXIconSubtoolbarMytoolsPen)
                item?.target = self
                item?.btnTag = CAnnotationType.ink.rawValue
                item?.toolTip = NSLocalizedString("Add freehand drawings by hand writing just like you do with a pen.", comment: "")
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(changeAnnotationMode)
                
                let menuItem = NSMenuItem.init(title: "Freehand", action: #selector(changeAnnotationMode), target: self)
                menuItem.tag = CAnnotationType.ink.rawValue
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarFreeTextAnnotationItemIdentifier {
                item?.titleName = NSLocalizedString("Text Note", comment: "")
                item?.image = NSImage(named: KMImageNameUXIconSubtoolbarMytoolsText)
                item?.alternateImage = NSImage(named: KMImageNameUXIconSubtoolbarMytoolsText)
                item?.target = self
                item?.btnTag = CAnnotationType.freeText.rawValue
                item?.toolTip = String(format: "%@ (⌘N)", NSLocalizedString("Text Note", comment: ""))
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(changeAnnotationMode)
                
                let menuItem = NSMenuItem.init(title: "FreeText", action: #selector(changeAnnotationMode), target: self)
                menuItem.tag = CAnnotationType.freeText.rawValue
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarAnchoredAnnotationItemIdentifier {
                item?.titleName = NSLocalizedString("Anchored Note", comment: "")
                item?.image = NSImage(named: KMImageNameUXIconSubtoolbarMytoolsNote)
                item?.alternateImage = NSImage(named: KMImageNameUXIconSubtoolbarMytoolsNote)
                item?.target = self
                item?.btnTag = CAnnotationType.anchored.rawValue
                item?.toolTip = String(format: "%@ (⌥⌘N)", NSLocalizedString("Anchored Note", comment: ""))
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(changeAnnotationMode)
                
                let menuItem = NSMenuItem.init(title: "Anchored", action: #selector(changeAnnotationMode), target: self)
                menuItem.tag = CAnnotationType.anchored.rawValue
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarSquareAnnotationItemIdentifier {
                item?.titleName = NSLocalizedString("Square", comment: "")
                item?.image = NSImage(named: KMImageNameUXIconSubtoolbarMytoolsRec)
                item?.alternateImage = NSImage(named: KMImageNameUXIconSubtoolbarMytoolsRec)
                item?.target = self
                item?.btnTag = CAnnotationType.square.rawValue
                item?.toolTip = NSLocalizedString("Draw rectangle; draw square by holding Shift key", comment: "")
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(changeAnnotationMode)
                
                let menuItem = NSMenuItem.init(title: "Square", action: #selector(changeAnnotationMode), target: self)
                menuItem.tag = CAnnotationType.square.rawValue
                item?.menuFormRepresentation = menuItem
            }else if identifier == KMToolbarCircleAnnotationItemIdentifier {
                item?.titleName = NSLocalizedString("oval", comment: "")
                item?.image = NSImage(named: KMImageNameUXIconSubtoolbarMytoolsOval)
                item?.alternateImage = NSImage(named: KMImageNameUXIconSubtoolbarMytoolsOval)
                item?.target = self
                item?.btnTag = CAnnotationType.circle.rawValue
                item?.toolTip = NSLocalizedString("Draw oval; draw circle by holding Shift key", comment: "")
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(changeAnnotationMode)
                
                let menuItem = NSMenuItem.init(title: "Square", action: #selector(changeAnnotationMode), target: self)
                menuItem.tag = CAnnotationType.square.rawValue
                item?.menuFormRepresentation = menuItem
            }  else if identifier == KMToolbarArrowAnnotationItemIdentifier {
                item?.titleName = NSLocalizedString("Arrow", comment: "")
                item?.image = NSImage(named: KMImageNameUXIconSubtoolbarMytoolsArrow)
                item?.alternateImage = NSImage(named: KMImageNameUXIconSubtoolbarMytoolsArrow)
                item?.target = self
                item?.btnTag = CAnnotationType.arrow.rawValue
                item?.toolTip = NSLocalizedString("Draw arrow; draw straight arrow by holding Shift key", comment: "")
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(changeAnnotationMode)
                
                let menuItem = NSMenuItem.init(title: "Square", action: #selector(changeAnnotationMode), target: self)
                menuItem.tag = CAnnotationType.square.rawValue
                item?.menuFormRepresentation = menuItem
            }  else if identifier == KMToolbarLineAnnotationItemIdentifier {
                item?.titleName = NSLocalizedString("Square", comment: "")
                item?.image = NSImage(named: KMImageNameUXIconSubtoolbarMytoolsLine)
                item?.alternateImage = NSImage(named: KMImageNameUXIconSubtoolbarMytoolsLine)
                item?.target = self
                item?.btnTag = CAnnotationType.line.rawValue
                item?.toolTip = NSLocalizedString("Draw line; draw straight line by holding Shift key", comment: "")
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(changeAnnotationMode)
                
                let menuItem = NSMenuItem.init(title: "Square", action: #selector(changeAnnotationMode), target: self)
                menuItem.tag = CAnnotationType.square.rawValue
                item?.menuFormRepresentation = menuItem
            }  else if identifier ==  KMToolbarLinkAnnotationItemIdentifier {
                item?.titleName = NSLocalizedString("Link", comment: "")
                item?.image = NSImage(named: KMImageNameUXIconSubtoolbarMytoolsLink)
                item?.alternateImage = NSImage(named: KMImageNameUXIconSubtoolbarMytoolsLink)
                item?.target = self
                item?.btnTag = CAnnotationType.link.rawValue
                item?.toolTip = NSLocalizedString("Select an area or text on a page for a link to be inserted.", comment: "")
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(changeAnnotationMode)
                
                let menuItem = NSMenuItem.init(title: "Link", action: #selector(changeAnnotationMode), target: self)
                menuItem.tag = CAnnotationType.link.rawValue
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarSignSignatureAnnotationItemIdentifier {
                item?.titleName = NSLocalizedString("SignSignature", comment: "")
                item?.image = NSImage(named: KMImageNameUXIconSubtoolbarMytoolsSign)
                item?.alternateImage = NSImage(named: KMImageNameUXIconSubtoolbarMytoolsSign)
                item?.target = self
                item?.btnTag = CAnnotationType.signSignature.rawValue
                item?.toolTip = NSLocalizedString("Add beautiful handwriting or use your trackpad to create your own signature.", comment: "")
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(changeAnnotationMode)
                
                let menuItem = NSMenuItem.init(title: "SignSignature", action: #selector(changeAnnotationMode), target: self)
                menuItem.tag = CAnnotationType.signSignature.rawValue
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMAnnotationStampToolbarItemIdentifier {
                item?.titleName = NSLocalizedString("Stamp", comment: "")
                item?.image = NSImage(named: KMImageNameUXIconSubtoolbarMytoolsStamp)
                item?.alternateImage = NSImage(named: KMImageNameUXIconSubtoolbarMytoolsStamp)
                item?.target = self
                item?.btnTag = CAnnotationType.stamp.rawValue
                item?.toolTip = NSLocalizedString("Add New Stamp", comment: "")
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(changeAnnotationMode)
                
                let menuItem = NSMenuItem.init(title: "Stamp", action: #selector(changeAnnotationMode), target: self)
                menuItem.tag = CAnnotationType.stamp.rawValue
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarShowToolbarItemIdentifier {
                item?.image = NSImage(named: "KMImageNameMainToolShow")
                item?.selectedImage = NSImage(named: "KMImageNameMainToolHide")
                item?.alternateImage = NSImage(named: "KMImageNameMainToolShow")
                item?.selectedBackgroundColor = NSColor.clear
                item?.target = self
                item?.toolTip = NSLocalizedString("Hide", comment: "")
                item?.titleName = NSLocalizedString("Hide", comment: "")
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(showPDFLayoutMode)
                
                let menuItem = NSMenuItem.init(title: "Hide", action: #selector(showPDFLayoutMode), target: self)
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarAddTextEditPDFItemIdentifier {
                item?.image = NSImage(named: "KMImageNameMainToolFreeText")
                item?.alternateImage = NSImage(named: "KMImageNameMainToolFreeText")
                item?.target = self
                item?.btnTag = CAnnotationType.addText.rawValue
                item?.toolTip = NSLocalizedString("Add Text", comment: "")
                item?.titleName = NSLocalizedString("Add Text", comment: "")
                item?.boxImagePosition = .imageLeft
                item?.btnAction = #selector(changeAnnotationMode)
                
                let menuItem = NSMenuItem.init(title: "Add Text", action: #selector(changeAnnotationMode), target: self)
                menuItem.tag = CAnnotationType.addText.rawValue
                item?.menuFormRepresentation = menuItem
            }  else if identifier == KMToolbarAddImageEditPDFItemIdentifier {
                item?.image = NSImage(named: "KMImageNameMainToolEditImage")
                item?.alternateImage = NSImage(named: "KMImageNameMainToolEditImage")
                item?.target = self
                item?.btnTag = CAnnotationType.addImage.rawValue
                item?.toolTip = NSLocalizedString("Add Image", comment: "")
                item?.titleName = NSLocalizedString("Add Image", comment: "")
                item?.boxImagePosition = .imageLeft
                item?.btnAction = #selector(changeAnnotationMode)
                
                let menuItem = NSMenuItem.init(title: "Add Image", action: #selector(changeAnnotationMode), target: self)
                menuItem.tag = CAnnotationType.addImage.rawValue
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarToolCropItemIdentifier {
                item?.image = NSImage(named: "KMImageNameMainToolsCrop")
                item?.alternateImage = NSImage(named: "KMImageNameMainToolsCrop")
                item?.target = self
                item?.btnTag = KMToolbarType.crop.rawValue
                item?.toolTip = NSLocalizedString("Crop pages", comment: "")
                item?.titleName = NSLocalizedString("Crop", comment: "")
                item?.boxImagePosition = .imageExpandLeft
                item?.btnAction = #selector(cropMenuAction)
                
                let menuItem = NSMenuItem.init(title: "Crop", action: #selector(cropMenuAction), target: self)
                
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarComparisonItemIdentifier {
                item?.image = NSImage(named: KMImageNameUXIconBatchComparison)
                item?.alternateImage = NSImage(named: KMImageNameUXIconBatchComparison)
                item?.target = self
                item?.btnTag = KMToolbarType.comparison.rawValue
                item?.toolTip = NSLocalizedString("Compare", comment: "")
                item?.titleName = NSLocalizedString("Compare", comment: "")
                item?.boxImagePosition = .imageLeft
                item?.btnAction = #selector(itemAction)
                
                let menuItem = NSMenuItem.init(title: "Compare", action: #selector(batesMenuAction), target: self)
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarToolBatesItemIdentifier {
                item?.image = NSImage(named: "KMImageNameUXIconBatchBatesNor")
                item?.alternateImage = NSImage(named: "KMImageNameUXIconBatchBatesNor")
                item?.target = self
                item?.btnTag = KMToolbarType.bates.rawValue
                item?.toolTip = NSLocalizedString("Add PDF Bates numbering to your legal, medical, or business documents", comment: "")
                item?.titleName = NSLocalizedString("Bates Number", comment: "")
                item?.boxImagePosition = .imageLeft
                item?.btnAction = #selector(batesMenuAction)
                
                let menuItem = NSMenuItem.init(title: "Bates Number", action: #selector(batesMenuAction), target: self)
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarToolHeaderFooterItemIdentifier {
                item?.image = NSImage(named: "KMImageNameUXIconBatchHeaderandfooterNor")
                item?.alternateImage = NSImage(named: "KMImageNameUXIconBatchHeaderandfooterNor")
                item?.target = self
                item?.btnTag = KMToolbarType.headerAndFooter.rawValue
                item?.toolTip = NSLocalizedString("Insert header, footer, and page numbers to PDF", comment: "")
                item?.titleName = NSLocalizedString("Header & Footer", comment: "")
                item?.boxImagePosition = .imageLeft
                item?.btnAction = #selector(headerfooterMenuAction)
                
                let menuItem = NSMenuItem.init(title: "Header&Footer", action: #selector(headerfooterMenuAction), target: self)
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarToolBackgroundItemIdentifier {
                item?.image = NSImage(named: "KMImageNameUXIconBatchBackgroundNor")
                item?.alternateImage = NSImage(named: "KMImageNameUXIconBatchBackgroundNor")
                item?.target = self
                item?.btnTag = KMToolbarType.background.rawValue
                item?.toolTip = NSLocalizedString("Insert PDF page background by color or image", comment: "")
                item?.titleName = NSLocalizedString("Backgroud", comment: "")
                item?.boxImagePosition = .imageLeft
                item?.btnAction = #selector(backgroundMenuAction)
                
                let menuItem = NSMenuItem.init(title: "Backgroud", action: #selector(backgroundMenuAction), target: self)
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarToolWatermarkItemIdentifier {
                item?.image = NSImage(named: "KMImageNameMainToolsWatermark")
                item?.alternateImage = NSImage(named: "KMImageNameMainToolsWatermark")
                item?.target = self
                item?.btnTag = KMToolbarType.watermark.rawValue
                item?.toolTip = NSLocalizedString("Watermark", comment: "")
                item?.titleName = NSLocalizedString("Watermark", comment: "")
                item?.boxImagePosition = .imageLeft
                item?.btnAction = #selector(watermarkMenuAction)
                
                let menuItem = NSMenuItem.init(title: "Watermark", action: #selector(watermarkMenuAction), target: self)
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarToolTextFieldItemIdentifier {
                item?.image = NSImage(named: "KMImageNameMainToolFormText")
                item?.alternateImage = NSImage(named: "KMImageNameMainToolFormText")
                item?.target = self
                item?.btnTag = CAnnotationType.textField.rawValue
                item?.toolTip = NSLocalizedString("TextField", comment: "")
                item?.titleName = NSLocalizedString("TextField", comment: "")
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(changeAnnotationMode)
                
                let menuItem = NSMenuItem.init(title: "TextField", action: #selector(changeAnnotationMode), target: self)
                menuItem.tag = item!.btnTag
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarToolCheckBoxItemIdentifier {
                item?.image = NSImage(named: "KMImageNameMainToolFormCheckbox")
                item?.alternateImage = NSImage(named: "KMImageNameMainToolFormCheckbox")
                item?.target = self
                item?.btnTag = CAnnotationType.checkBox.rawValue
                item?.toolTip = NSLocalizedString("CheckBox", comment: "")
                item?.titleName = NSLocalizedString("CheckBox", comment: "")
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(changeAnnotationMode)
                
                let menuItem = NSMenuItem.init(title: "CheckBox", action: #selector(changeAnnotationMode), target: self)
                menuItem.tag = item!.btnTag
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarToolRadioButtonItemIdentifier {
                item?.image = NSImage(named: "KMImageNameMainToolFormRadio")
                item?.alternateImage = NSImage(named: "KMImageNameMainToolFormRadio")
                item?.target = self
                item?.btnTag = CAnnotationType.radioButton.rawValue
                item?.toolTip = NSLocalizedString("RadioButton", comment: "")
                item?.titleName = NSLocalizedString("RadioButton", comment: "")
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(changeAnnotationMode)
                
                let menuItem = NSMenuItem.init(title: "RadioButton", action: #selector(changeAnnotationMode), target: self)
                menuItem.tag = item!.btnTag
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarToolListBoxItemIdentifier {
                item?.image = NSImage(named: "KMImageNameMainToolFormListBox")
                item?.alternateImage = NSImage(named: "KMImageNameMainToolFormListBox")
                item?.target = self
                item?.btnTag = CAnnotationType.listMenu.rawValue
                item?.toolTip = NSLocalizedString("ListBox", comment: "")
                item?.titleName = NSLocalizedString("ListBox", comment: "")
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(changeAnnotationMode)
                
                let menuItem = NSMenuItem.init(title: "ListBox", action: #selector(changeAnnotationMode), target: self)
                menuItem.tag = item!.btnTag
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarToolPullDownmenuItemIdentifier {
                item?.image = NSImage(named: "KMImageNameMainToolFormPulldown")
                item?.alternateImage = NSImage(named: "KMImageNameMainToolFormPulldown")
                item?.target = self
                item?.btnTag = CAnnotationType.comboBox.rawValue
                item?.toolTip = NSLocalizedString("PullDownmenu", comment: "")
                item?.titleName = NSLocalizedString("PullDownmenu", comment: "")
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(changeAnnotationMode)
                
                let menuItem = NSMenuItem.init(title: "PullDownmenu", action: #selector(changeAnnotationMode), target: self)
                menuItem.tag = item!.btnTag
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarToolButtonIdentifier {
                item?.image = NSImage(named: "KMImageNameMainToolFormButton")
                item?.alternateImage = NSImage(named: "KMImageNameMainToolFormButton")
                item?.target = self
                item?.btnTag = CAnnotationType.actionButton.rawValue
                item?.toolTip = NSLocalizedString("Button", comment: "")
                item?.titleName = NSLocalizedString("Button", comment: "")
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(changeAnnotationMode)
                
                let menuItem = NSMenuItem.init(title: "Button", action: #selector(changeAnnotationMode), target: self)
                menuItem.tag = item!.btnTag
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarToolSignBoxIdentifier {
                item?.image = NSImage(named: "KMImageNameMainToolFormSign")
                item?.alternateImage = NSImage(named: "KMImageNameMainToolFormSign")
                item?.target = self
                item?.btnTag = CAnnotationType.signature.rawValue
                item?.toolTip = NSLocalizedString("SignBox", comment: "")
                item?.titleName = NSLocalizedString("SignBox", comment: "")
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(changeAnnotationMode)
                
                let menuItem = NSMenuItem.init(title: "SignBox", action: #selector(changeAnnotationMode), target: self)
                menuItem.tag = item!.btnTag
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarToolFormAlignIdentifier {
                item?.image = NSImage(named: "KMImageNameMainToolFormAlignment")
                item?.alternateImage = NSImage(named: "KMImageNameMainToolFormAlignment")
                item?.target = self
                item?.toolTip = NSLocalizedString("Alignment", comment: "")
                item?.titleName = NSLocalizedString("Alignment", comment: "")
                item?.boxImagePosition = .imageExpandLeft
                item?.btnAction = #selector(formsAlignmentAction)
                
                let menuItem = NSMenuItem.init(title: "Alignment", action: #selector(formsAlignmentAction), target: self)
                menuItem.tag = item!.btnTag
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarToolFormMoreIdentifier {
                item?.image = NSImage(named: "KMImageNameMainToolFormMore")
                item?.alternateImage = NSImage(named: "KMImageNameMainToolFormMore")
                item?.target = self
                item?.toolTip = NSLocalizedString("More", comment: "")
                item?.titleName = NSLocalizedString("More", comment: "")
                item?.boxImagePosition = .imageExpandLeft
                item?.btnAction = #selector(formsMoreOperationAction)
                
                let menuItem = NSMenuItem.init(title: "More", action: #selector(formsMoreOperationAction), target: self)
                menuItem.tag = item!.btnTag
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarToolRedactItemIdentifier {
                item?.image = NSImage(named: "KMImageNameMainToolsRedact")
                item?.alternateImage = NSImage(named: "KMImageNameMainToolsRedact")
                item?.target = self
                item?.btnTag = KMToolbarType.redact.rawValue
                item?.toolTip = NSLocalizedString("Redact", comment: "")
                item?.titleName = NSLocalizedString("Redact", comment: "")
                item?.btnAction = #selector(redactMenuAction)
                
                let menuItem = NSMenuItem.init(title: "Redact", action: #selector(changeAnnotationMode), target: self)
                menuItem.tag = item!.btnTag
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarToolCompressItemIdentifier {
                item?.image = NSImage(named: "KMImageNameUXIconBatchOptimizeNor")
                item?.alternateImage = NSImage(named: "KMImageNameUXIconBatchOptimizeNor")
                item?.target = self
                item?.btnTag = KMToolbarType.compress.rawValue
                item?.boxImagePosition = .imageLeft
                item?.toolTip = NSLocalizedString("Reduce file size", comment: "")
                item?.titleName = NSLocalizedString("Compress", comment: "")
                item?.btnAction = #selector(compressMenuAction)
                
                let menuItem = NSMenuItem.init(title: "Compress", action: #selector(compressMenuAction), target: self)
                menuItem.tag = item!.btnTag
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarToolSecureItemIdentifier {
                item?.image = NSImage(named: "KMImageNameUXIconBatchSafeNor")
                item?.alternateImage = NSImage(named: "KMImageNameUXIconBatchSafeNor")
                item?.target = self
                item?.btnTag = KMToolbarType.secure.rawValue
                item?.toolTip = NSLocalizedString("Batch encrypting PDF documents", comment: "")
                item?.titleName = NSLocalizedString("Security", comment: "")
                item?.boxImagePosition = .imageExpandLeft
                item?.btnAction = #selector(secureMenuAction)
                
                let menuItem = NSMenuItem.init(title: "Security", action: #selector(secureMenuAction), target: self)
                menuItem.tag = item!.btnTag
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarToolHookItemIdentifier {
                item?.image = NSImage(named: "KMImageNameFillSignHook")
                item?.alternateImage = NSImage(named: "KMImageNameFillSignHook")
                item?.target = self
                item?.btnTag = CAnnotationType.signTure.rawValue
                item?.toolTip = NSLocalizedString("Check", comment: "")
                item?.titleName = NSLocalizedString("Signature", comment: "")
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(changeAnnotationMode)
                
                let menuItem = NSMenuItem.init(title: "Signature", action: #selector(changeAnnotationMode), target: self)
                menuItem.tag = item!.btnTag
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarToolForkItemIdentifier {
                item?.image = NSImage(named: "KMImageNameFillSignFork")
                item?.alternateImage = NSImage(named: "KMImageNameFillSignFork")
                item?.target = self
                item?.btnTag = CAnnotationType.signFalse.rawValue
                item?.toolTip = NSLocalizedString("X", comment: "")
                item?.titleName = NSLocalizedString("signFalse", comment: "")
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(changeAnnotationMode)
                
                let menuItem = NSMenuItem.init(title: "signFalse", action: #selector(changeAnnotationMode), target: self)
                menuItem.tag = item!.btnTag
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarToolLineItemIdentifier {
                item?.image = NSImage(named: "KMImageNameFillSignLine")
                item?.alternateImage = NSImage(named: "KMImageNameFillSignLine")
                item?.target = self
                item?.btnTag = CAnnotationType.signLine.rawValue
                item?.toolTip = NSLocalizedString("Line", comment: "")
                item?.titleName = NSLocalizedString("Line", comment: "")
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(changeAnnotationMode)
                
                let menuItem = NSMenuItem.init(title: "Line", action: #selector(changeAnnotationMode), target: self)
                menuItem.tag = item!.btnTag
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarToolDotItemIdentifier {
                item?.image = NSImage(named: "KMImageNameFillSignDot")
                item?.alternateImage = NSImage(named: "KMImageNameFillSignDot")
                item?.target = self
                item?.btnTag = CAnnotationType.signDot.rawValue
                item?.toolTip = NSLocalizedString("Dot", comment: "")
                item?.titleName = NSLocalizedString("Dot", comment: "")
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(changeAnnotationMode)
                
                let menuItem = NSMenuItem.init(title: "Dot", action: #selector(changeAnnotationMode), target: self)
                menuItem.tag = item!.btnTag
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarToolRectangleIdentifier {
                item?.image = NSImage(named: "KMImageNameFillSignRectangle")
                item?.alternateImage = NSImage(named: "KMImageNameFillSignRectangle")
                item?.target = self
                item?.btnTag = CAnnotationType.signCircle.rawValue
                item?.toolTip = NSLocalizedString("Rectangle", comment: "")
                item?.titleName = NSLocalizedString("Rectangle", comment: "")
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(changeAnnotationMode)
                
                let menuItem = NSMenuItem.init(title: "Rectangle", action: #selector(changeAnnotationMode), target: self)
                menuItem.tag = item!.btnTag
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarToolTextIdentifier {
                item?.image = NSImage(named: "KMImageNameMainToolFreeText")
                item?.alternateImage = NSImage(named: "KMImageNameMainToolFreeText")
                item?.target = self
                item?.btnTag = CAnnotationType.signText.rawValue
                item?.toolTip = NSLocalizedString("Add a handwritten signature or create a signature via the trackpad", comment: "")
                item?.titleName = NSLocalizedString("signText", comment: "")
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(changeAnnotationMode)
                
                let menuItem = NSMenuItem.init(title: "signText", action: #selector(changeAnnotationMode), target: self)
                menuItem.tag = item!.btnTag
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarToolDateIdentifier {
                item?.image = NSImage(named: "KMImageNameFillSignDate")
                item?.alternateImage = NSImage(named: "KMImageNameFillSignDate")
                item?.target = self
                item?.btnTag = CAnnotationType.signDate.rawValue
                item?.toolTip = NSLocalizedString("Date", comment: "")
                item?.titleName = NSLocalizedString("Date", comment: "")
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(changeAnnotationMode)
                
                let menuItem = NSMenuItem.init(title: "Date", action: #selector(changeAnnotationMode), target: self)
                menuItem.tag = item!.btnTag
                item?.menuFormRepresentation = menuItem
            } else if (identifier == KMToolbarFillSignSignatureIdentifier) {
                item?.image = NSImage(named: "KMImageNameMainToolSignSignature")
                item?.alternateImage = NSImage(named: "KMImageNameMainToolSignSignature")
                item?.target = self
                item?.btnTag = CAnnotationType.signSignature.rawValue
                item?.toolTip = NSLocalizedString("Add a handwritten signature or create a signature via the trackpad", comment: "")
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(changeAnnotationMode)
                
                let menuItem = NSMenuItem.init(title: "SignSignature", action: #selector(changeAnnotationMode), target: self)
                menuItem.tag = CAnnotationType.signSignature.rawValue
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarConversionWordItemIdentifier {
                item?.image = NSImage(named: KMImageNameUXIconSubtoolbarConvertWord)
                item?.alternateImage = NSImage(named: KMImageNameUXIconSubtoolbarConvertWord)
                item?.target = self
                item?.btnTag = KMToolbarType.word.rawValue
                item?.toolTip = NSLocalizedString("Convert all the great work stored in your PDF to a Word document that’s easy to update. Keep the fonts and layouts intact — including bullets and tables.", comment: "")
                item?.titleName = NSLocalizedString("To Word", comment: "")
                item?.boxImagePosition = .imageLeft
                item?.btnAction = #selector(conversionMenuItemAction)
                
                let menuItem = NSMenuItem.init(title: "To Word", action: #selector(conversionMenuItemAction), target: self)
                menuItem.tag = item!.btnTag
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarConversionExcelItemIdentifier {
                item?.image = NSImage(named: KMImageNameUXIconSubtoolbarConvertExcel)
                item?.alternateImage = NSImage(named: KMImageNameUXIconSubtoolbarConvertExcel)
                item?.target = self
                item?.btnTag = KMToolbarType.excel.rawValue
                item?.toolTip = NSLocalizedString("Skip the data entry steps and tedious reformatting tasks, too. When you convert to Excel, your data is preserved along with your columns, layouts, and formatting.", comment: "")
                item?.titleName = NSLocalizedString("To Excel", comment: "")
                item?.boxImagePosition = .imageLeft
                item?.btnAction = #selector(conversionMenuItemAction)
                
                let menuItem = NSMenuItem.init(title: "To Excel", action: #selector(conversionMenuItemAction), target: self)
                menuItem.tag = item!.btnTag
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarConversionPPTItemIdentifier {
                item?.image = NSImage(named: KMImageNameUXIconSubtoolbarConvertPPT)
                item?.alternateImage = NSImage(named: KMImageNameUXIconSubtoolbarConvertPPT)
                item?.target = self
                item?.btnTag = KMToolbarType.ppt.rawValue
                item?.toolTip = NSLocalizedString("When you use PDF Reader Pro to convert PDFs to PowerPoint, you know your formats will be saved, too. So you don’t have to bother redoing bullets, tables, objects, or master layouts.", comment: "")
                item?.titleName = NSLocalizedString("To PPT", comment: "")
                item?.boxImagePosition = .imageLeft
                item?.btnAction = #selector(conversionMenuItemAction)
                
                let menuItem = NSMenuItem.init(title: "To PPT", action: #selector(conversionMenuItemAction), target: self)
                menuItem.tag = item!.btnTag
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarConversionRTFItemIdentifier {
                item?.image = NSImage(named: KMImageNameUXIconSubtoolbarConvertRTF)
                item?.alternateImage = NSImage(named: KMImageNameUXIconSubtoolbarConvertRTF)
                item?.target = self
                item?.btnTag = KMToolbarType.rtf.rawValue
                item?.toolTip = NSLocalizedString("Turn PDF documents into Rich Text Format (RTF) files that can be opened in virtually any word processor.", comment: "")
                item?.titleName = NSLocalizedString("To RTF", comment: "")
                item?.boxImagePosition = .imageLeft
                item?.btnAction = #selector(conversionMenuItemAction)
                
                let menuItem = NSMenuItem.init(title: "To RTF", action: #selector(conversionMenuItemAction), target: self)
                menuItem.tag = item!.btnTag
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarConversionCSVItemIdentifier {
                item?.image = NSImage(named: KMImageNameUXIconSubtoolbarConvertCSV)
                item?.alternateImage = NSImage(named: KMImageNameUXIconSubtoolbarConvertCSV)
                item?.target = self
                item?.btnTag = KMToolbarType.csv.rawValue
                item?.toolTip = NSLocalizedString("PDF To CSV", comment: "")
                item?.titleName = NSLocalizedString("To CSV", comment: "")
                item?.boxImagePosition = .imageLeft
                item?.btnAction = #selector(conversionMenuItemAction)
                
                let menuItem = NSMenuItem.init(title: "To CSV", action: #selector(conversionMenuItemAction), target: self)
                menuItem.tag = item!.btnTag
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarConversionHTMLItemIdentifier {
                item?.image = NSImage(named: KMImageNameUXIconSubtoolbarConvertHtml)
                item?.alternateImage = NSImage(named: KMImageNameUXIconSubtoolbarConvertHtml)
                item?.target = self
                item?.btnTag = KMToolbarType.html.rawValue
                item?.toolTip = NSLocalizedString("PDF To HTML", comment: "")
                item?.titleName = NSLocalizedString("To HTML", comment: "")
                item?.boxImagePosition = .imageLeft
                item?.btnAction = #selector(conversionMenuItemAction)
                
                let menuItem = NSMenuItem.init(title: "To HTML", action: #selector(conversionMenuItemAction), target: self)
                menuItem.tag = item!.btnTag
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarConversionTextItemIdentifier {
                item?.image = NSImage(named: KMImageNameUXIconSubtoolbarConvertText)
                item?.alternateImage = NSImage(named: KMImageNameUXIconSubtoolbarConvertText)
                item?.target = self
                item?.btnTag = KMToolbarType.conversion_text.rawValue
                item?.toolTip = NSLocalizedString("PDF To Text", comment: "")
                item?.titleName = NSLocalizedString("To Text", comment: "")
                item?.boxImagePosition = .imageLeft
                item?.btnAction = #selector(conversionMenuItemAction)
                
                let menuItem = NSMenuItem.init(title: "To Text", action: #selector(conversionMenuItemAction), target: self)
                menuItem.tag = item!.btnTag
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarConversionImageItemIdentifier {
                item?.image = NSImage(named: KMImageNameUXIconSubtoolbarConvertPDFToIMG)
                item?.alternateImage = NSImage(named: KMImageNameUXIconSubtoolbarConvertPDFToIMG)
                item?.target = self
                item?.btnTag = KMToolbarType.conversion_image.rawValue
                item?.toolTip = NSLocalizedString("Convert PDF to JPEG, PNG, TIFF, BMP, GIF or TGA files", comment: "")
                item?.titleName = NSLocalizedString("To Image", comment: "")
                item?.boxImagePosition = .imageLeft
                item?.btnAction = #selector(conversionMenuItemAction)
                
                let menuItem = NSMenuItem.init(title: "To Image", action: #selector(conversionMenuItemAction), target: self)
                menuItem.tag = item!.btnTag
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarToolMergeItemIdentifier {
                item?.image = NSImage(named: "KMImageNameUXIconBatchMergeNor")
                item?.alternateImage = NSImage(named: "KMImageNameUXIconBatchMergeNor")
                item?.target = self
                item?.btnTag = KMToolbarType.merge.rawValue
                item?.toolTip = NSLocalizedString("Combine multiple documents into a new PDF, or borrow individual pages", comment: "")
                item?.titleName = NSLocalizedString("Merge", comment: "")
                item?.boxImagePosition = .imageLeft
                item?.btnAction = #selector(mergeMenuItemAction)
                
                let menuItem = NSMenuItem.init(title: "Merge", action: #selector(mergeMenuItemAction), target: self)
                menuItem.tag = item!.btnTag
                item?.menuFormRepresentation = menuItem
            } else if identifier == KMToolbarAnnotationSettingItemIdentifier {
                item?.image = NSImage(named: "KMImageNameUXIconBtnSetNor")
                item?.alternateImage = NSImage(named: "KMImageNameUXIconBtnSetNor")
                item?.target = self
//                item?.btnTag = KMToolbarType.merge.rawValue
//                item?.toolTip = NSLocalizedString("Combine multiple files into a new PDF.", comment: "")
                item?.titleName = NSLocalizedString("Setting", comment: "")
                item?.boxImagePosition = .imageOnly
                item?.btnAction = #selector(itemAction)

                let menuItem = NSMenuItem.init(title: "Setting", action: #selector(mergeMenuItemAction), target: self)
                menuItem.tag = item!.btnTag
                item?.menuFormRepresentation = menuItem
            }
        }
        return item!
    }
    
    func validateToolbarItem(_ item: NSToolbarItem) -> Bool {
        return true
    }
    
    @objc func listViewAnnotationTypeChangeNotification(sender: Notification?) {
//        if let notiName = sender?.name, notiName == NSNotification.Name.CPDFListViewAnnotationTypeChange, self.ignoreCurrentAnnotationTypeChange {
            
//        }
        if (self.ignoreCurrentAnnotationTypeChange) {
            // 忽略后重置 这个属性是基于单次添加，所以使用后会重置
//            self.ignoreCurrentAnnotationTypeChange = false
            return
        }
        
        let annotationType : CAnnotationType = pdfView.annotationType
        if annotationType == .square || annotationType == .circle || annotationType == .arrow || annotationType == .line{
            UserDefaults.standard.set(pdfView.annotationType.rawValue, forKey: KMToolBarToolPDFShapeStyle)
            UserDefaults.standard.synchronize()
        }
        for item in self.toolbar.items {
            if self.toolbarType == .Annatiton || self.toolbarType == .Move || self.toolbarType == .Magnify ||
                self.toolbarType == .Select || self.toolbarType == .SelectZoom {
                item.isSelected = false
                if item.itemIdentifier == KMDocumentAnnotationToolbarItemIdentifier {
                    item.isSelected = true
                } else if item.itemIdentifier == KMToolbarHighlightAnnotationItemIdentifier {
                    if annotationType == .highlight {
                        item.isSelected = true
                    }
                } else if item.itemIdentifier == KMToolbarUnderlineAnnotationItemIdentifier {
                    if annotationType == .underline {
                        item.isSelected = true
                    }
                } else if item.itemIdentifier == KMToolbarStrikeOutAnnotationItemIdentifier {
                    if annotationType == .strikeOut {
                        item.isSelected = true
                    }
                } else if item.itemIdentifier == KMToolbarInkAnnotationItemIdentifier {
                    if annotationType == .ink || annotationType == .eraser {
                        item.isSelected = true
                    }
                } else if item.itemIdentifier == KMToolbarFreeTextAnnotationItemIdentifier {
                    if annotationType == .freeText {
                        item.isSelected = true
                    }
                } else if item.itemIdentifier == KMToolbarAnchoredAnnotationItemIdentifier {
                    if annotationType == .anchored {
                        item.isSelected = true
                    }
                } else if item.itemIdentifier == KMToolbarSquareAnnotationItemIdentifier {
                    if annotationType == .square {
                        item.isSelected = true
                    }
                } else if item.itemIdentifier == KMToolbarCircleAnnotationItemIdentifier {
                    if annotationType == .circle {
                        item.isSelected = true
                    }
                } else if item.itemIdentifier == KMToolbarArrowAnnotationItemIdentifier {
                    if annotationType == .arrow {
                        item.isSelected = true
                    }
                } else if item.itemIdentifier == KMToolbarLineAnnotationItemIdentifier {
                    if annotationType == .line {
                        item.isSelected = true
                    }
                } else if item.itemIdentifier == KMToolbarLinkAnnotationItemIdentifier {
                    if annotationType == .link {
                        item.isSelected = true
                    }
                } else if item.itemIdentifier == KMAnnotationStampToolbarItemIdentifier {
                    if annotationType == .stamp {
                        item.isSelected = true
                    }
                } else if item.itemIdentifier == KMToolbarSignSignatureAnnotationItemIdentifier {
                    if annotationType == .signSignature {
                        item.isSelected = true
                    }
                } else if pdfView.toolMode == .moveToolMode {
                    if item.itemIdentifier == KMToolbarMoveToolModeItemIdentifier {
                        item.isSelected = true
                    }
                } else if pdfView.toolMode == .magnifyToolMode {
                    if item.itemIdentifier == KMToolbarMagnifyToolModeItemIdentifier {
                        item.isSelected = true
                    }
                } else if pdfView.toolMode == .selectToolMode {
                    if item.itemIdentifier == KMToolbarSelectToolModeItemIdentifier {
                        item.isSelected = true
                    }
                } else if pdfView.toolMode == .selectZoomToolMode {
                    if item.itemIdentifier == KMToolbarZoomToSelectionItemIdentifier {
                        item.isSelected = true
                    }
                }
                
                if (item.itemIdentifier == KMToolbarShowToolbarItemIdentifier) {
                    item.isSelected = !self.isShowAllAnnotations
                }
            } else if self.toolbarType == .FillSign {
                item.isSelected = false
                if pdfView.toolMode == .selfSignMode {
                    if item.itemIdentifier == KMToolbarToolHookItemIdentifier {
                       if annotationType == .signTure {
                            item.isSelected = true
                        }
                    } else if item.itemIdentifier == KMToolbarToolForkItemIdentifier {
                        if annotationType == .signFalse {
                            item.isSelected = true
                        }
                    } else if item.itemIdentifier == KMToolbarToolLineItemIdentifier {
                        if annotationType == .signLine {
                            item.isSelected = true
                        }
                    } else if item.itemIdentifier == KMToolbarToolDotItemIdentifier {
                        if annotationType == .signDot {
                            item.isSelected = true
                        }
                    } else if item.itemIdentifier == KMToolbarToolRectangleIdentifier {
                        if annotationType == .signCircle {
                            item.isSelected = true
                        }
                    } else if item.itemIdentifier == KMToolbarToolDateIdentifier {
                        if annotationType == .signDate {
                            item.isSelected = true
                        }
                    } else if item.itemIdentifier == KMToolbarToolTextIdentifier {
                        if annotationType == .signText {
                            item.isSelected = true
                        }
                    } else if (item.itemIdentifier == KMToolbarFillSignSignatureIdentifier) {
                        if (annotationType == .signSignature) {
                            item.isSelected = true
                        }
                    }
                }
            }
        }
    }
}

extension KMToolbarViewController: NSSearchFieldDelegate {

}