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 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, itemDidClick toolbarItem: KMToolbarItemView)
    @objc optional func toolbarViewController(_ viewController:KMToolbarViewController, searchAction searchString: String)
    @objc optional func toolbarViewController(_ viewController:KMToolbarViewController, menuItemDidClick toolbarItem: KMToolbarItemView, index: Int, info: Any?)
}

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
    private var _currentItemView: KMToolbarItemView?
    
    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 _itemAction(_ item: KMToolbarClickButton) {
        if let data = item.clickObject as? KMToolbarItemView {
            if data.itemIdentifier == KMToolbarComparisonItemIdentifier {
                self._currentItemView = data
                if let subMenu = data.menuFormRepresentation?.submenu {
                    subMenu.popUp(positioning: nil, at: item.frame.origin, in: item.superview)
                }
                return
            }
        }
        self.delegate?.toolbarViewController?(self, itemDidClick: item.clickObject as! KMToolbarItemView)
    }
    
    @objc private func _comparisonAction(sender: NSMenuItem) {
        if let data = self._currentItemView {
            self.delegate?.toolbarViewController?(self, menuItemDidClick: data, index: sender.tag, info: nil)
        }
    }
    
    @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._currentItemView = sender.clickObject as? KMToolbarItemView
        if let subMenu = (sender.clickObject as? KMToolbarItemView)?.menuFormRepresentation?.submenu {
            subMenu.popUp(positioning: nil, at: sender.frame.origin, in: sender.superview)
        }
    }
    @objc private func _batesAction(sender: NSMenuItem) {
        if let data = self._currentItemView {
            self.delegate?.toolbarViewController?(self, menuItemDidClick: data, index: sender.tag, info: nil)
        }
    }
    
    @objc func headerfooterMenuAction(sender: KMToolbarClickButton) {
        self._currentItemView = sender.clickObject as? KMToolbarItemView
        if let subMenu = (sender.clickObject as? KMToolbarItemView)?.menuFormRepresentation?.submenu {
            subMenu.popUp(positioning: nil, at: sender.frame.origin, in: sender.superview)
        }
    }
    @objc private func _headerfooterAction(sender: NSMenuItem) {
        if let data = self._currentItemView {
            self.delegate?.toolbarViewController?(self, menuItemDidClick: data, index: sender.tag, info: nil)
        }
    }
    
    @objc func backgroundMenuAction(sender: KMToolbarClickButton) {
        self._currentItemView = sender.clickObject as? KMToolbarItemView
        if let subMenu = (sender.clickObject as? KMToolbarItemView)?.menuFormRepresentation?.submenu {
            subMenu.popUp(positioning: nil, at: sender.frame.origin, in: sender.superview)
        }
    }
    @objc private func _backgroundAction(sender: NSMenuItem) {
        if let data = self._currentItemView {
            self.delegate?.toolbarViewController?(self, menuItemDidClick: data, index: sender.tag, info: nil)
        }
    }
    
    @objc func watermarkMenuAction(sender: KMToolbarClickButton) {
        self._currentItemView = sender.clickObject as? KMToolbarItemView
        if let subMenu = (sender.clickObject as? KMToolbarItemView)?.menuFormRepresentation?.submenu {
            subMenu.popUp(positioning: nil, at: sender.frame.origin, in: sender.superview)
        }
    }
    @objc private func _watermarkAction(sender: NSMenuItem) {
        if let data = self._currentItemView {
            self.delegate?.toolbarViewController?(self, menuItemDidClick: data, index: sender.tag, info: nil)
        } else {
            self.delegate?.toolbarViewController?(self, menuItemDidClick: self.toolbarItemFindItemIdentifiers(value: KMToolbarToolWatermarkItemIdentifier), index: sender.tag, info: nil)
        }
    }
    
    @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 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) {
       
    }
    
    @objc private func _alignmentAction(sender: NSMenuItem) {
        if let data = self._currentItemView {
            self.delegate?.toolbarViewController?(self, menuItemDidClick: data, index: sender.tag, info: nil)
        } else {
            self.delegate?.toolbarViewController?(self, menuItemDidClick: self.toolbarItemFindItemIdentifiers(value: KMToolbarToolFormAlignIdentifier), index: sender.tag, info: nil)
        }
    }
    
    // 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
        }
    }
}

// MARK: - Public Methods

extension KMToolbarViewController {
    func itemAction(_ item: KMToolbarItemView) {
        self._itemAction(item.clickButton)
    }
}

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,
                    KMToolbarToolProfileIdentifier,
                    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 isMainToolItem(identifier) {
                self._setupMainItem(item)
            } else {
                if (annotationToolIdentifiers.contains(identifier)) {
                    self._setupAnnotationItem(item)
                } else if editPDFItemIdentifiers.contains(identifier) {
                    self._setupEditItem(item)
                } else if conversionToolIdentifiers.contains(identifier) {
                    self._setupConvertItem(item)
                } else if fillSignToolIdentifiers.contains(identifier) {
                    self._setupFillSignItem(item)
                } else if formToolIdentifiers.contains(identifier) {
                    self._setupFormItem(item)
                } else if toolToolIdentifiers.contains(identifier) {
                    self._setupToolItem(item)
                }
            }

        }
        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 {

}

extension KMToolbarViewController {
    private func _setupMainItem(_ item: KMToolbarItemView?) {
        let identifier = item?.itemIdentifier
        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(_itemAction)
        } 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?.toolTip = NSLocalizedString("Recognize text from Image-based or Scanned PDF with OCR", comment: "")
            item?.btnAction = #selector(_itemAction)
        } 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?.toolTip = NSLocalizedString("Mark for redaction", comment: "")
            item?.btnAction = #selector(_itemAction)
        } 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(_itemAction)
        } 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(_itemAction)
        } else if identifier == KMToolbarToolRedactItemIdentifier {
            item?.image = 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
        }
    }
    
    private func _setupAnnotationItem(_ item: KMToolbarItemView?) {
        let identifier = item?.itemIdentifier
        if identifier == KMToolbarMoveToolModeItemIdentifier {
            item?.titleName = NSLocalizedString("Scroll Tool", comment: "")
            item?.image = NSImage(named: KMImageNameUXIconSubtoolbarMytoolsPantool)
            item?.target = self
            item?.btnTag = KMToolbarViewType.Move.rawValue
            item?.toolTip = NSLocalizedString("Scroll Tool", comment: "")
            item?.boxImagePosition = .imageOnly
            item?.btnAction = #selector(leftControllButtonAction)
        } else if identifier == KMToolbarMagnifyToolModeItemIdentifier {
            item?.titleName = NSLocalizedString("Magnify Tool", comment: "")
            item?.image = NSImage(named: KMImageNameUXIconSubtoolbarMytoolsMagnifier)
            item?.target = self
            item?.btnTag = KMToolbarViewType.Magnify.rawValue
            item?.toolTip = NSLocalizedString("Magnify Tool", comment: "")
            item?.boxImagePosition = .imageOnly
            item?.btnAction = #selector(leftControllButtonAction)
        } else if identifier == KMToolbarSelectToolModeItemIdentifier {
            item?.titleName = NSLocalizedString("Content Selection Tool", comment: "")
            item?.image = 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)
        } else if identifier == KMToolbarZoomToSelectionItemIdentifier {
            item?.titleName = NSLocalizedString("Zoom to selected area", comment: "")
            item?.image = 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)
        } else if identifier == KMToolbarHighlightAnnotationItemIdentifier {
            item?.titleName = NSLocalizedString("Highlight", comment: "")
            item?.image = 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)
        } else if identifier == KMToolbarUnderlineAnnotationItemIdentifier {
            item?.titleName = NSLocalizedString("Underline", comment: "")
            item?.image = 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)
        } else if identifier == KMToolbarStrikeOutAnnotationItemIdentifier {
            item?.titleName = NSLocalizedString("Strikethrough", comment: "")
            item?.image = 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)
        } else if identifier == KMToolbarInkAnnotationItemIdentifier {
            item?.titleName = NSLocalizedString("Freehand", comment: "")
            item?.image = 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)
        } else if identifier == KMToolbarFreeTextAnnotationItemIdentifier {
            item?.titleName = NSLocalizedString("Text Note", comment: "")
            item?.image = 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)
        } else if identifier == KMToolbarAnchoredAnnotationItemIdentifier {
            item?.titleName = NSLocalizedString("Anchored Note", comment: "")
            item?.image = 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)
        } else if identifier == KMToolbarSquareAnnotationItemIdentifier {
            item?.titleName = NSLocalizedString("Square", comment: "")
            item?.image = 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)
        }else if identifier == KMToolbarCircleAnnotationItemIdentifier {
            item?.titleName = NSLocalizedString("oval", comment: "")
            item?.image = 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)
        }  else if identifier == KMToolbarArrowAnnotationItemIdentifier {
            item?.titleName = NSLocalizedString("Arrow", comment: "")
            item?.image = 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)
        }  else if identifier == KMToolbarLineAnnotationItemIdentifier {
            item?.titleName = NSLocalizedString("Square", comment: "")
            item?.image = 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)
        }  else if identifier ==  KMToolbarLinkAnnotationItemIdentifier {
            item?.titleName = NSLocalizedString("Link", comment: "")
            item?.image = 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)
        } else if identifier == KMToolbarSignSignatureAnnotationItemIdentifier {
            item?.titleName = NSLocalizedString("SignSignature", comment: "")
            item?.image = 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)
        } else if identifier == KMAnnotationStampToolbarItemIdentifier {
            item?.titleName = NSLocalizedString("Stamp", comment: "")
            item?.image = 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)
        } 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)
        } else if identifier == KMToolbarAnnotationSettingItemIdentifier {
            item?.image = NSImage(named: "KMImageNameUXIconBtnSetNor")
            item?.target = self
            item?.titleName = NSLocalizedString("Setting", comment: "")
            item?.boxImagePosition = .imageOnly
            item?.btnAction = #selector(_itemAction)
        }
    }
    
    private func _setupEditItem(_ item: KMToolbarItemView?) {
        let identifier = item?.itemIdentifier
        if identifier == KMToolbarAddTextEditPDFItemIdentifier {
            item?.image = 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)
        }  else if identifier == KMToolbarAddImageEditPDFItemIdentifier {
            item?.image = 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)
        }
    }
    
    private func _setupConvertItem(_ item: KMToolbarItemView?) {
        let identifier = item?.itemIdentifier
        if identifier == KMToolbarConversionWordItemIdentifier {
            item?.image = 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)
        } else if identifier == KMToolbarConversionExcelItemIdentifier {
            item?.image = 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)
        } else if identifier == KMToolbarConversionPPTItemIdentifier {
            item?.image = 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)
        } else if identifier == KMToolbarConversionRTFItemIdentifier {
            item?.image = 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)
        } else if identifier == KMToolbarConversionCSVItemIdentifier {
            item?.image = 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)
        } else if identifier == KMToolbarConversionHTMLItemIdentifier {
            item?.image = 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)
        } else if identifier == KMToolbarConversionTextItemIdentifier {
            item?.image = 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)
        } else if identifier == KMToolbarConversionImageItemIdentifier {
            item?.image = 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)
        }
    }
    
    private func _setupFillSignItem(_ item: KMToolbarItemView?) {
        let identifier = item?.itemIdentifier
        if identifier == KMToolbarToolHookItemIdentifier {
            item?.image = NSImage(named: "KMImageNameFillSignHook")
            item?.target = self
            item?.btnTag = CAnnotationType.signTure.rawValue
            item?.toolTip = NSLocalizedString("Signature", comment: "")
            item?.titleName = NSLocalizedString("Signature", comment: "")
            item?.boxImagePosition = .imageOnly
            item?.btnAction = #selector(changeAnnotationMode)
        } else if identifier == KMToolbarToolForkItemIdentifier {
            item?.image = NSImage(named: KMImageNameUXIconSubtoolbarFillsignFork)
            item?.target = self
            item?.btnTag = CAnnotationType.signFalse.rawValue
            item?.toolTip = NSLocalizedString("Add X", comment: "")
            item?.boxImagePosition = .imageOnly
            item?.btnAction = #selector(changeAnnotationMode)
        } else if identifier == KMToolbarToolLineItemIdentifier {
            item?.image = NSImage(named: KMImageNameUXIconSubtoolbarFillsignLine)
            item?.target = self
            item?.btnTag = CAnnotationType.signLine.rawValue
            item?.toolTip = NSLocalizedString("Add line", comment: "")
            item?.boxImagePosition = .imageOnly
            item?.btnAction = #selector(changeAnnotationMode)
        } else if identifier == KMToolbarToolDotItemIdentifier {
            item?.image = NSImage(named: KMImageNameUXIconSubtoolbarFillsignPoint)
            item?.target = self
            item?.btnTag = CAnnotationType.signDot.rawValue
            item?.toolTip = NSLocalizedString("Add dot", comment: "")
            item?.boxImagePosition = .imageOnly
            item?.btnAction = #selector(changeAnnotationMode)
        } else if identifier == KMToolbarToolRectangleIdentifier {
            item?.image = NSImage(named: KMImageNameUXIconSubtoolbarFillsignRoundedrec)
            item?.target = self
            item?.btnTag = CAnnotationType.signCircle.rawValue
            item?.toolTip = NSLocalizedString("Add circle", comment: "")
            item?.boxImagePosition = .imageOnly
            item?.btnAction = #selector(changeAnnotationMode)
        } else if identifier == KMToolbarToolTextIdentifier {
            item?.image = NSImage(named: KMImageNameToolbarFreeText)
            item?.target = self
            item?.btnTag = CAnnotationType.signText.rawValue
            item?.toolTip = NSLocalizedString("Add text", comment: "")
            item?.titleName = NSLocalizedString("Text", comment: "")
            item?.boxImagePosition = .imageOnly
            item?.btnAction = #selector(changeAnnotationMode)
        } else if identifier == KMToolbarToolDateIdentifier {
            item?.image = NSImage(named: KMImageNameUXIconSubtoolbarFillsignDate)
            item?.target = self
            item?.btnTag = CAnnotationType.signDate.rawValue
            item?.toolTip = NSLocalizedString("Date", comment: "")
            item?.boxImagePosition = .imageOnly
            item?.btnAction = #selector(changeAnnotationMode)
        } else if (identifier == KMToolbarToolProfileIdentifier) {
            item?.image = NSImage(named: KMImageNameUXIconSubtoolbarFillsignMyprofile)
            item?.target = self
            item?.toolTip = NSLocalizedString("My Profile", comment: "")
            item?.boxImagePosition = .imageOnly
            item?.btnAction = #selector(_itemAction)
        }else if (identifier == KMToolbarFillSignSignatureIdentifier) {
            item?.image = NSImage(named: KMImageNameUXIconSubtoolbarFillsignMysignature)
            item?.target = self
            item?.btnTag = CAnnotationType.signSignature.rawValue
            item?.toolTip = NSLocalizedString("Sign document by typing or drawing a signature", comment: "")
            item?.boxImagePosition = .imageOnly
            item?.btnAction = #selector(changeAnnotationMode)
        }
    }
    
    private func _setupFormItem(_ item: KMToolbarItemView?) {
        let identifier = item?.itemIdentifier
        if identifier == KMToolbarToolTextFieldItemIdentifier {
            item?.image = NSImage(named: KMImageNameUXIconSubtoolbarFormTextfield)
            item?.target = self
            item?.btnTag = CAnnotationType.textField.rawValue
            item?.toolTip = NSLocalizedString("Text Field", comment: "")
            item?.titleName = NSLocalizedString("Text Field", comment: "")
            item?.boxImagePosition = .imageLeft
            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: KMImageNameUXIconSubtoolbarFormCheckbox)
            item?.target = self
            item?.btnTag = CAnnotationType.checkBox.rawValue
            item?.toolTip = NSLocalizedString("Check Box", comment: "")
            item?.titleName = NSLocalizedString("Check Box", comment: "")
            item?.boxImagePosition = .imageLeft
            item?.btnAction = #selector(changeAnnotationMode)
        } else if identifier == KMToolbarToolRadioButtonItemIdentifier {
            item?.image = NSImage(named: KMImageNameUXIconSubtoolbarFormRadiobutton)
            item?.target = self
            item?.btnTag = CAnnotationType.radioButton.rawValue
            item?.toolTip = NSLocalizedString("Radio Button", comment: "")
            item?.titleName = NSLocalizedString("Radio Button", comment: "")
            item?.boxImagePosition = .imageLeft
            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: KMImageNameUXIconSubtoolbarFormListbox)
            item?.target = self
            item?.btnTag = CAnnotationType.listMenu.rawValue
            item?.toolTip = NSLocalizedString("List Box", comment: "")
            item?.titleName = NSLocalizedString("List Box", comment: "")
            item?.boxImagePosition = .imageLeft
            item?.btnAction = #selector(changeAnnotationMode)
            
            let menuItem = NSMenuItem.init(title: "List Box", action: #selector(changeAnnotationMode), target: self)
            menuItem.tag = item!.btnTag
            item?.menuFormRepresentation = menuItem
        } else if identifier == KMToolbarToolPullDownmenuItemIdentifier {
            item?.image = NSImage(named: KMImageNameUXIconSubtoolbarFormPulldownmenu)
            item?.target = self
            item?.btnTag = CAnnotationType.comboBox.rawValue
            item?.toolTip = NSLocalizedString("Combo Box", comment: "")
            item?.titleName = NSLocalizedString("Combo Box", comment: "")
            item?.boxImagePosition = .imageLeft
            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: KMImageNameUXIconSubtoolbarFormButton)
            item?.target = self
            item?.btnTag = CAnnotationType.actionButton.rawValue
            item?.toolTip = NSLocalizedString("Button", comment: "")
            item?.titleName = NSLocalizedString("Button", comment: "")
            item?.boxImagePosition = .imageLeft
            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: KMImageNameUXIconSubtoolbarFormSign)
            item?.target = self
            item?.btnTag = CAnnotationType.signature.rawValue
            item?.toolTip = NSLocalizedString("Signature", comment: "")
            item?.titleName = NSLocalizedString("Signature", comment: "")
            item?.boxImagePosition = .imageLeft
            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: KMImageNameUXIconPropertybarAlignLeftToor)
            item?.target = self
            item?.toolTip = NSLocalizedString("Alignment", comment: "")
            item?.titleName = NSLocalizedString("Alignment", comment: "")
            item?.boxImagePosition = .imageExpandLeft
            item?.needExpandAction = true
            item?.btnAction = #selector(formsAlignmentAction)
            
            let menuItem = NSMenuItem.init(title: "Alignment", action: #selector(formsAlignmentAction), target: self)
            let subMenu = NSMenu()
            subMenu.addItem(title: NSLocalizedString("Align Left", comment: ""), imageNamed: "KMImageNameUXIconPropertybarAlignLeftNor", action: #selector(_alignmentAction), target: self, tag: 0)
            subMenu.addItem(title: NSLocalizedString("Align Vertically", comment: ""), imageNamed: "KMImageNameUXIconPropertybarAlignVercenterNor", action: #selector(_alignmentAction), target: self, tag: 1)
            subMenu.addItem(title: NSLocalizedString("Align Right", comment: ""), imageNamed: "KMImageNameUXIconPropertybarAlignRightNor", action: #selector(_alignmentAction), target: self, tag: 2)
            subMenu.addItem(NSMenuItem.separator())
            subMenu.addItem(title: NSLocalizedString("Align Top", comment: ""), imageNamed: "KMImageNameUXIconPropertybarAlignUpNor", action: #selector(_alignmentAction), target: self, tag: 3)
            subMenu.addItem(title: NSLocalizedString("Align Horizontally", comment: ""), imageNamed: "KMImageNameUXIconPropertybarAlignHorcenterNor", action: #selector(_alignmentAction), target: self, tag: 4)
            subMenu.addItem(title: NSLocalizedString("Align Bottom", comment: ""), imageNamed: "KMImageNameUXIconPropertybarAlignDownNor", action: #selector(_alignmentAction), target: self, tag: 5)
            subMenu.addItem(NSMenuItem.separator())
            subMenu.addItem(title: NSLocalizedString("Distribute Horizontally", comment: ""), imageNamed: "KMImageNameUXIconPropertybarAlignHorsplitNor", action: #selector(_alignmentAction), target: self, tag: 6)
            subMenu.addItem(title: NSLocalizedString("Distribute Vertically", comment: ""), imageNamed: "KMImageNameUXIconPropertybarAlignVersplitNor", action: #selector(_alignmentAction), target: self, tag: 7)
            
            menuItem.submenu = subMenu
            menuItem.tag = item!.btnTag
            item?.menuFormRepresentation = menuItem
        } else if identifier == KMToolbarToolFormMoreIdentifier {
            item?.image = 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
        }
    }
    
    private func _setupToolItem(_ item: KMToolbarItemView?) {
        let identifier = item?.itemIdentifier
        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?.target = self
            item?.btnTag = KMToolbarType.comparison.rawValue
            item?.toolTip = NSLocalizedString("Compare", comment: "")
            item?.titleName = NSLocalizedString("Compare", comment: "")
            item?.boxImagePosition = .imageExpandLeft
            item?.btnAction = #selector(_itemAction)
            
            let menuItem = NSMenuItem.init(title: "Bates Number", action: #selector(batesMenuAction), target: self)
            let subMenu = NSMenu()
            subMenu.addItem(title: NSLocalizedString("Side-by-Side View", comment: ""), action: #selector(_comparisonAction), target: self, tag: 1)
            subMenu.addItem(title: NSLocalizedString("Compare by File Overlay", comment: ""), action: #selector(_comparisonAction), target: self, tag: 2)
            menuItem.submenu = subMenu
            item?.menuFormRepresentation = menuItem
        } else if identifier == KMToolbarToolBatesItemIdentifier {
            item?.image = 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 = .imageExpandLeft
            item?.needExpandAction = true
            item?.btnAction = #selector(batesMenuAction)
            
            let menuItem = NSMenuItem.init(title: "Bates Number", action: #selector(batesMenuAction), target: self)
            let subMenu = NSMenu()
            subMenu.addItem(title: NSLocalizedString("Add Bates Numbers", comment: ""), action: #selector(_batesAction), target: self, tag: 1)
            subMenu.addItem(title: NSLocalizedString("Remove Bates Numbers", comment: ""), action: #selector(_batesAction), target: self, tag: 2)
            subMenu.addItem(title: NSLocalizedString("Batch Add Batch Numbers", comment: ""), action: #selector(_batesAction), target: self, tag: 3)
            subMenu.addItem(title: NSLocalizedString("Batch Remove Bates Numbers", comment: ""), action: #selector(_batesAction), target: self, tag: 4)
            subMenu.addItem(title: NSLocalizedString("Manage Templates", comment: ""), action: #selector(_batesAction), target: self, tag: 5)
            menuItem.submenu = subMenu
            item?.menuFormRepresentation = menuItem
        } else if identifier == KMToolbarToolHeaderFooterItemIdentifier {
            item?.image = 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 = .imageExpandLeft
            item?.needExpandAction = true
            item?.btnAction = #selector(headerfooterMenuAction)
            
            let menuItem = NSMenuItem.init(title: "Header & Footer", action: #selector(headerfooterMenuAction), target: self)
            let subMenu = NSMenu()
            subMenu.addItem(title: NSLocalizedString("Add Header & Footer", comment: ""), action: #selector(_headerfooterAction), target: self, tag: 1)
            subMenu.addItem(title: NSLocalizedString("Remove Header & Footer", comment: ""), action: #selector(_headerfooterAction), target: self, tag: 2)
            subMenu.addItem(title: NSLocalizedString("Batch Add Header & Footer", comment: ""), action: #selector(_headerfooterAction), target: self, tag: 3)
            subMenu.addItem(title: NSLocalizedString("Batch Remove Header & Footer", comment: ""), action: #selector(_headerfooterAction), target: self, tag: 4)
            subMenu.addItem(title: NSLocalizedString("Manage Templates", comment: ""), action: #selector(_headerfooterAction), target: self, tag: 5)
            menuItem.submenu = subMenu
            item?.menuFormRepresentation = menuItem
        } else if identifier == KMToolbarToolBackgroundItemIdentifier {
            item?.image = 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 = .imageExpandLeft
            item?.needExpandAction = true
            item?.btnAction = #selector(backgroundMenuAction)
            
            let menuItem = NSMenuItem.init(title: "Backgroud", action: #selector(backgroundMenuAction), target: self)
            let subMenu = NSMenu()
            subMenu.addItem(title: NSLocalizedString("Add Background", comment: ""), action: #selector(_backgroundAction), target: self, tag: 1)
            subMenu.addItem(title: NSLocalizedString("Remove Background", comment: ""), action: #selector(_backgroundAction), target: self, tag: 2)
            subMenu.addItem(title: NSLocalizedString("Batch Add Background", comment: ""), action: #selector(_backgroundAction), target: self, tag: 3)
            subMenu.addItem(title: NSLocalizedString("Batch Remove Background", comment: ""), action: #selector(_backgroundAction), target: self, tag: 4)
            subMenu.addItem(title: NSLocalizedString("Manage Templates", comment: ""), action: #selector(_backgroundAction), target: self, tag: 5)
            menuItem.submenu = subMenu
            item?.menuFormRepresentation = menuItem
        } else if identifier == KMToolbarToolWatermarkItemIdentifier {
            item?.image = NSImage(named: "KMImageNameMainToolsWatermark")
            item?.target = self
            item?.btnTag = KMToolbarType.watermark.rawValue
            item?.toolTip = NSLocalizedString("Watermark", comment: "")
            item?.titleName = NSLocalizedString("Watermark", comment: "")
            item?.boxImagePosition = .imageExpandLeft
            item?.needExpandAction = true
            item?.btnAction = #selector(watermarkMenuAction)
            
            let menuItem = NSMenuItem.init(title: "Watermark", action: #selector(watermarkMenuAction), target: self)
            let subMenu = NSMenu()
            subMenu.addItem(title: NSLocalizedString("Add Watermark", comment: ""), action: #selector(_watermarkAction), target: self, tag: 1)
            subMenu.addItem(title: NSLocalizedString("Remove Watermark", comment: ""), action: #selector(_watermarkAction), target: self, tag: 2)
            subMenu.addItem(title: NSLocalizedString("Batch Add Watermarks", comment: ""), action: #selector(_watermarkAction), target: self, tag: 3)
            subMenu.addItem(title: NSLocalizedString("Batch Remove Watermarks", comment: ""), action: #selector(_watermarkAction), target: self, tag: 4)
            subMenu.addItem(title: NSLocalizedString("Manage Templates", comment: ""), action: #selector(_watermarkAction), target: self, tag: 5)
            menuItem.submenu = subMenu
            item?.menuFormRepresentation = menuItem
        } else if identifier == KMToolbarToolCompressItemIdentifier {
            item?.image = 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)
        } else if identifier == KMToolbarToolSecureItemIdentifier {
            item?.image = NSImage(named: "KMImageNameUXIconBatchSafeNor")
            item?.target = self
            item?.toolTip = NSLocalizedString("Batch encrypting PDF documents", comment: "")
            item?.titleName = NSLocalizedString("Security", comment: "")
            item?.boxImagePosition = .imageExpandLeft
            item?.needExpandAction = true
            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 == KMToolbarToolMergeItemIdentifier {
            item?.image = 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)
        }
    }
}