PDFOffice_Windows_exe/PDF Office/ViewModels/Tools/AnnotToolContentViewModel.cs

using ComPDFKit.PDFAnnotation;
using ComPDFKit.PDFDocument;
using ComPDFKitViewer;
using ComPDFKitViewer.AnnotEvent;
using ComPDFKitViewer.PdfViewer;
using Microsoft.Office.Interop.Excel;
using Microsoft.Office.Interop.Word;
using Microsoft.Win32;
using PDF_Office.CustomControl;
using PDF_Office.EventAggregators;
using PDF_Office.Helper;
using PDF_Office.Model;
using PDF_Office.Properties;
using PDF_Office.ViewModels.BOTA;
using PDF_Office.ViewModels.PropertyPanel;
using PDF_Office.ViewModels.PropertyPanel.AnnotPanel;
using PDF_Office.Views.BOTA;
using PDF_Office.Views.PropertyPanel.AnnotPanel;
using PDFSettings;
using Prism.Commands;
using Prism.Events;
using Prism.Mvvm;
using Prism.Regions;
using Prism.Services.Dialogs;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Forms;
using System.Windows.Input;
using System.Windows.Media;
using ContextMenu = System.Windows.Controls.ContextMenu;
using MenuItem = System.Windows.Controls.MenuItem;

namespace PDF_Office.ViewModels.Tools
{
    public sealed partial class AnnotToolContentViewModel : BindableBase, INavigationAware
    {
        private IEventAggregator events;
        public IDialogService dialogs;

        public AnnotToolContentViewModel(IRegionManager regionManager, IEventAggregator eventAggregator, IDialogService dialogService)
        {
            region = regionManager;
            events = eventAggregator;
            dialogs = dialogService;
            MyToolsCommand = new DelegateCommand<CustomIconToggleBtn>(BtnMyTools_Click);
            SetAddAnnotationCommand = new DelegateCommand<object>(AddAnnotation_Click);
            PropertyRegionName = Guid.NewGuid().ToString();
            BindingEvent();
            InitDefaultValue();
            InitToolDict();
        }

        private void InitToolDict()
        {
            ToolExpandDict.Add("SnapshotEdit", AnnotArgsType.SnapshotWithEditTool);
            ToolExpandDict.Add("HighLight", AnnotArgsType.AnnotHighlight);
            ToolExpandDict.Add("UnderLine", AnnotArgsType.AnnotUnderline);
            ToolExpandDict.Add("Squiggly", AnnotArgsType.AnnotSquiggly);
            ToolExpandDict.Add("Strikeout", AnnotArgsType.AnnotStrikeout);
            ToolExpandDict.Add("Freehand", AnnotArgsType.AnnotFreehand);
            ToolExpandDict.Add("Freetext", AnnotArgsType.AnnotFreeText);
            ToolExpandDict.Add("StickyNote", AnnotArgsType.AnnotSticky);
            ToolExpandDict.Add("Rect", AnnotArgsType.AnnotSquare);
            ToolExpandDict.Add("Circle", AnnotArgsType.AnnotCircle);
            ToolExpandDict.Add("Arrow", AnnotArgsType.AnnotLine);
            ToolExpandDict.Add("Line", AnnotArgsType.AnnotLine);
            ToolExpandDict.Add("Link", AnnotArgsType.AnnotLink);
        }

        private Dictionary<string, AnnotArgsType> ToolExpandDict = new Dictionary<string, AnnotArgsType>();

        public void BtnMyTools_Click(CustomIconToggleBtn annotBtn)
        {
            //不创建注释，属于注释模板
            bool isTemplateAnnot = false;
            bool isSnapshotEdit = false;
            AnnotHandlerEventArgs annotArgs = null;

            if (annotBtn.IsChecked == true)
            {
                var tag = annotBtn.Tag.ToString();
                FindAnnotTypeKey(tag, ref annotArgs);

                if (tag == "SnapshotEdit")
                {
                    isSnapshotEdit = true;
                }
                else if (tag == "Signature" || tag == "Stamp")
                {
                    isTemplateAnnot = true;
                }

                if (annotArgs != null)
                {
                    annotArgs.Author = Settings.Default.AppProperties.Description.Author;
                    PDFViewer.SetMouseMode(MouseModes.AnnotCreate);
                    PDFViewer.SetToolParam(annotArgs);
                }
            }

            //当不是注释模板，且无创建注释时，属性面板显示为空内容
            if (isTemplateAnnot == false && annotArgs == null)
            {
                PDFViewer.SetMouseMode(MouseModes.PanTool);
                viewContentViewModel.SelectedPrpoertyPanel("PropertyPanelContent", null);
            }
            if (isSnapshotEdit == true)
            {
                ShowPropertyPanel(false);
                isSnapshotEdit = false;
            }
            else
            {
                ShowPropertyPanel((bool)annotBtn.IsChecked);
            }
        }

        private void FindAnnotTypeKey(string tag, ref AnnotHandlerEventArgs annotArgs)
        {
            switch (tag)
            {
                case "SnapshotEdit"://内容选择
                    annotArgs = GetSnapshotEdit();
                    break;

                case "HighLight"://字体高亮
                    annotArgs = GetHighLight();
                    break;

                case "UnderLine"://下划线
                    annotArgs = GetUnderLine();
                    break;

                case "Squiggly"://波浪线
                    annotArgs = GetSquiggly();
                    break;

                case "Strikeout"://删除线
                    annotArgs = GetStrikeout();
                    break;

                case "Freehand"://手绘
                    annotArgs = GetFreehand();
                    break;

                case "Freetext"://文本
                    annotArgs = GetFreetext();
                    break;

                case "StickyNote"://便签
                    annotArgs = GetStickyNote();
                    break;

                case "Rect"://矩形
                    annotArgs = GetRect();
                    break;

                case "Circle"://圆
                    annotArgs = GetCircle();
                    break;

                case "Arrow"://箭头
                case "Line"://线
                    annotArgs = GetArrowLine(tag);
                    break;

                case "Stamp"://图章
                    annotArgs = GetStamp();
                    break;

                case "Image":
                    annotArgs = GetImage();
                    break;

                case "Signature"://签名
                    annotArgs = GetSignature();
                    PDFViewer.SetMouseMode(MouseModes.PanTool);//清空其他注释
                    break;

                case "Link"://链接
                    //viewContentViewModel.IsCreateLink = false;
                    annotArgs = GetLink();
                    break;
            }
        }

        private void AnnotProperty_DefaultStored(object sender, object e)
        {
        }

        private void AnnotPropertyPanel_AnnotTypeChanged(object sender, Dictionary<AnnotArgsType, object> e)
        {
            if (e != null)
            {
                AnnotHandlerEventArgs annotArgs = null;
                foreach (AnnotArgsType argsType in e.Keys)
                {
                    switch (argsType)
                    {
                        case AnnotArgsType.AnnotSquare:
                            annotArgs = GetRect();
                            break;

                        case AnnotArgsType.AnnotCircle:
                            annotArgs = GetCircle();
                            break;

                        case AnnotArgsType.AnnotLine:
                            var LineTag = e[argsType] as string;
                            annotArgs = GetArrowLine(LineTag);
                            break;
                    }
                    if (annotArgs != null)
                    {
                        annotArgs.Author = Settings.Default.AppProperties.Description.Author;
                        PDFViewer.SetMouseMode(MouseModes.AnnotCreate);
                        PDFViewer.SetToolParam(annotArgs);
                    }
                    ShowPropertyPanel();
                }
            }
        }

        private void AnnotPropertyPanel_DataChanged(object sender, Dictionary<AnnotArgsType, object> e)
        {
            if (e != null)
            {
                foreach (AnnotArgsType argsType in e.Keys)
                {
                    switch (argsType)
                    {
                        case AnnotArgsType.AnnotHighlight:
                            if (e[argsType] is Color)
                            {
                                HighLightColor = new SolidColorBrush((Color)e[argsType]);
                            }
                            if (e[argsType] is double)
                            {
                                HighLightOpacity = (double)e[argsType];
                            }
                            break;

                        case AnnotArgsType.AnnotUnderline:
                            if (e[argsType] is Color)
                            {
                                UnderLineColor = new SolidColorBrush((Color)e[argsType]);
                            }
                            if (e[argsType] is double)
                            {
                                underLineOpacity = (double)e[argsType];
                            }
                            break;

                        case AnnotArgsType.AnnotSquiggly:
                            if (e[argsType] is Color)
                            {
                                SquigglyColor = new SolidColorBrush((Color)e[argsType]);
                            }
                            if (e[argsType] is double)
                            {
                                SquigglyOpacity = (double)e[argsType];
                            }
                            break;

                        case AnnotArgsType.AnnotStrikeout:
                            if (e[argsType] is Color)
                            {
                                StrikeoutColor = new SolidColorBrush((Color)e[argsType]);
                            }
                            if (e[argsType] is double)
                            {
                                StrikeoutOpacity = (double)e[argsType];
                            }
                            break;

                        case AnnotArgsType.AnnotFreehand:
                            if (e[argsType] is Color)
                            {
                                // FreehandPath.Fill = new SolidColorBrush((Color)e[argsType]);
                            }
                            if (e[argsType] is double)
                            {
                                //  FreehandPath.Opacity = (double)e[argsType];
                            }
                            break;

                        case AnnotArgsType.AnnotErase:
                            if (e[argsType] is ToggleButton)
                            {
                                ToggleButton clickBtn = e[argsType] as ToggleButton;
                                //PDFViewerCtrl viewCtrl = GetCurrentViewer();
                                // ClearSelectedToolPanel(BtnFreeHand);
                                //     if (viewCtrl != null && viewCtrl.PdfViewer != null)
                                {
                                    if (clickBtn.IsChecked == true)
                                    {
                                        if (clickBtn.Tag.ToString() == "PenBtn")
                                        {
                                            CustomIconToggleBtn btn = new CustomIconToggleBtn();
                                            btn.Tag = "Freehand"; btn.IsChecked = true;
                                            BtnMyTools_Click(btn);
                                            break;
                                        }
                                        EraseArgs eraseArgs = new EraseArgs();
                                        eraseArgs.UIBorderColor = Color.FromArgb(0x1A, 0x00, 0x00, 0x00);
                                        eraseArgs.UIFillColor = Color.FromArgb(0x1A, 0x00, 0x00, 0x00);
                                        eraseArgs.Thickness = 10;
                                        DefaultAnnotProperty annotProperty = SettingHelper.GetAnnotDefaultProperty(AnnotArgsType.AnnotErase);
                                        if (annotProperty != null)
                                        {
                                            eraseArgs.Thickness = annotProperty.Thickness;
                                        }

                                        PDFViewer.ClearSelectAnnots(false);
                                        PDFViewer.SetMouseMode(MouseModes.AnnotCreate);
                                        PDFViewer.SetToolParam(eraseArgs);

                                        Dictionary<AnnotAttrib, object> annotAttribsList = new Dictionary<AnnotAttrib, object>();
                                        annotAttribsList[AnnotAttrib.Color] = eraseArgs.UIBorderColor;
                                        annotAttribsList[AnnotAttrib.FillColor] = eraseArgs.UIFillColor;
                                        annotAttribsList[AnnotAttrib.Thickness] = eraseArgs.Thickness;
                                        AddToPropertyPanel("FreehandAnnotProperty", "Freehand", eraseArgs, annotAttribsList);
                                        //清空选中注释
                                        //viewCtrl.PdfViewer.ClearSelectAnnots(false);
                                        //viewCtrl.PdfViewer.SetMouseMode(MouseModes.AnnotCreate);
                                        //viewCtrl.PdfViewer.SetToolParam(eraseArgs);
                                        //if (viewCtrl.PropPanel.Children.Count > 0)
                                        //{
                                        //    FreehandAnnotProperty freehandPropPanel = viewCtrl.PropPanel.Children[0] as FreehandAnnotProperty;
                                        //    if (freehandPropPanel == null)
                                        //    {
                                        //        viewCtrl.PropPanel.Children.Clear();
                                        //        freehandPropPanel = new FreehandAnnotProperty();
                                        //        freehandPropPanel.EraseSet = true;
                                        //        freehandPropPanel.SetInkThickness(eraseArgs.Thickness);
                                        //        freehandPropPanel.DataChanged += AnnotPropertyPanel_DataChanged;
                                        //        viewCtrl.PropPanel.Children.Add(freehandPropPanel);
                                        //    }
                                        //    Dictionary<AnnotAttrib, object> annotAttribsList = new Dictionary<AnnotAttrib, object>();
                                        //    annotAttribsList[AnnotAttrib.Color] = eraseArgs.UIBorderColor;
                                        //    annotAttribsList[AnnotAttrib.FillColor] = eraseArgs.UIFillColor;
                                        //    annotAttribsList[AnnotAttrib.Thickness] = eraseArgs.Thickness;
                                        //    freehandPropPanel.AnnotEvent = null;
                                        //    freehandPropPanel.SetEraseMode(true);
                                        //    freehandPropPanel.AnnotEvent = AnnotAttribEvent.GetAnnotAttribEvent(eraseArgs, annotAttribsList);
                                        //}
                                        //else
                                        //{
                                        //    FreehandAnnotProperty freehandProperty = new FreehandAnnotProperty();
                                        //    freehandProperty.DataChanged += AnnotPropertyPanel_DataChanged;
                                        //    Dictionary<AnnotAttrib, object> annotAttribsList = new Dictionary<AnnotAttrib, object>();
                                        //    annotAttribsList[AnnotAttrib.Color] = eraseArgs.UIBorderColor;
                                        //    annotAttribsList[AnnotAttrib.FillColor] = eraseArgs.UIFillColor;
                                        //    annotAttribsList[AnnotAttrib.Thickness] = eraseArgs.Thickness;
                                        //    freehandProperty.SetInkThickness(eraseArgs.Thickness);
                                        //    freehandProperty.EraseSet = true;
                                        //    freehandProperty.SetEraseMode(true);
                                        //    freehandProperty.AnnotEvent = AnnotAttribEvent.GetAnnotAttribEvent(eraseArgs, annotAttribsList);
                                        //    viewCtrl.AddAnnotPropertyPanel(freehandProperty);

                                        //}
                                    }
                                    else
                                    {
                                        //  BtnFreeHand.IsChecked = true;
                                        //   BtnTool_Click(BtnFreeHand, new RoutedEventArgs());
                                    }
                                }
                            }
                            break;
                    }
                }
            }
        }

        public IRegionManager region;

        public string PropertyRegionName { get; set; }

        public bool IsNavigationTarget(NavigationContext navigationContext)
        {
            return true;
        }

        public void OnNavigatedFrom(NavigationContext navigationContext)
        {
        }

        public void OnNavigatedTo(NavigationContext navigationContext)
        {
            navigationContext.Parameters.TryGetValue<ViewContentViewModel>(ParameterNames.ViewContentViewModel, out viewContentViewModel);
            navigationContext.Parameters.TryGetValue<CPDFViewer>(ParameterNames.PDFViewer, out PDFViewer);

            //  navigationContext.Parameters.TryGetValue<PropertyPanelContentViewModel>(ParameterNames.PropertyPanelContentViewModel, out propertyPanelContentViewModel);

            if (PDFViewer != null)
            {
                PDFViewer.AnnotEditHandler -= PDFViewer_AnnotEditHandler;
                PDFViewer.AnnotEditHandler += PDFViewer_AnnotEditHandler;

                PDFViewer.AnnotActiveHandler -= PDFViewer_AnnotActiveHandler;
                PDFViewer.AnnotActiveHandler += PDFViewer_AnnotActiveHandler;

                PDFViewer.AnnotCommandHandler -= PDFViewer_AnnotCommandHandler;
                PDFViewer.AnnotCommandHandler += PDFViewer_AnnotCommandHandler;

                PDFViewer.WidgetClickHander -= PDFViewer_WidgetClickHander;
                PDFViewer.WidgetClickHander += PDFViewer_WidgetClickHander;

                PDFViewer.SnapshotCommandHandler -= PDFViewer_SnapshotCommandHandler;
                PDFViewer.SnapshotCommandHandler += PDFViewer_SnapshotCommandHandler;
            }
        }

        private void PDFViewer_SnapshotCommandHandler(object sender, SnapshotCommandArgs e)
        {
            SnapshotEditToolArgs snapToolArgs = (SnapshotEditToolArgs)PDFViewer.ToolManager.CurrentAnnotArgs;

            SnapshotEditMenuViewModel.SnapToolArgs = snapToolArgs;
            SnapshotEditMenuViewModel.PDFViewer = PDFViewer;
            SnapshotEditMenuViewModel.SnapToolEvent += SnapshotEditMenuViewModel_SnapToolEvent; ;
            var popMenu = App.Current.FindResource("SnapshotContextMenu") as ContextMenu;

            if (e.HitSnapshotTool && e.SnapshotRect.Width > 0 && e.SnapshotRect.Height > 0)
            {
                e.PopupMenu = popMenu;
                e.Handle = true;

                if (popMenu != null && popMenu.Items.Count == 5)
                {
                    //复制
                    MenuItem menuItem = popMenu.Items[0] as MenuItem;
                    menuItem.CommandTarget = PDFViewer;
                    menuItem.Command = SnapshotEditMenuViewModel.SnapCopyCommand;
                    //导出
                    menuItem = popMenu.Items[1] as MenuItem;
                    menuItem.CommandTarget = PDFViewer;
                    if (menuItem.Items.Count == 3)
                    {
                        MenuItem menuItem1 = menuItem.Items[0] as MenuItem;
                        menuItem1.CommandTarget = PDFViewer;
                        menuItem1.Command = SnapshotEditMenuViewModel.ExportPNGCommand;

                        menuItem1 = menuItem.Items[1] as MenuItem;
                        menuItem1.CommandTarget = PDFViewer;
                        menuItem1.Command = SnapshotEditMenuViewModel.ExportJPGCommand;

                        menuItem1 = menuItem.Items[2] as MenuItem;
                        menuItem1.CommandTarget = PDFViewer;
                        menuItem1.Command = SnapshotEditMenuViewModel.ExportPDFCommand;
                    }

                    //裁剪
                    menuItem = popMenu.Items[2] as MenuItem;
                    menuItem.CommandTarget = PDFViewer;
                    menuItem.Command = SnapshotEditMenuViewModel.CroppingCommand;

                    //缩放至所选区域
                    menuItem = popMenu.Items[3] as MenuItem;
                    menuItem.CommandTarget = PDFViewer;
                    menuItem.Visibility = Visibility.Collapsed;
                    //menuItem.Command = snapshotEditMenuViewModel.CroppingCommand;

                    //打印
                    menuItem = popMenu.Items[4] as MenuItem;
                    menuItem.CommandTarget = PDFViewer;
                    menuItem.Command = SnapshotEditMenuViewModel.PrintCommand;
                }
            }
        }

        private void SnapshotEditMenuViewModel_SnapToolEvent(object sender, KeyValuePair<string, object> e)
        {
            switch (e.Key)
            {
                case "CloseSnap":
                    {
                        #region to do

                        //var item = PDFViewerTab.SelectedItem as TabItem;
                        //if (item == null)
                        //{
                        //    ClearSelectedToolPanel();
                        //    return;
                        //}
                        //Grid grid = item.Content as Grid;
                        //if (grid == null || grid.Children.Count == 0)
                        //{
                        //    ClearSelectedToolPanel();
                        //    return;
                        //}
                        //PDFViewerCtrl pdfViewer = grid.Children[0] as PDFViewerCtrl;
                        //if (pdfViewer == null)
                        //{
                        //    ClearSelectedToolPanel();
                        //    return;
                        //}

                        #endregion to do

                        switch (PDFViewer.MouseMode)
                        {
                            case MouseModes.SelectTextTool:
                                break;

                            default:
                                BtnSelecttoolIsChecked = false;
                                break;
                        }
                    }
                    break;

                default:
                    break;
            }
        }

        private void PDFViewer_WidgetClickHander(object sender, WidgetArgs e)
        {
        }

        private void PDFViewer_AnnotEditHandler(object sender, List<AnnotEditEvent> e)
        {
            if (e != null && e.Count > 0)
            {
                for (int i = 0; i < e.Count; i++)
                {
                    AnnotEditEvent editEvent = e[i];
                    switch (editEvent.EditAction)
                    {
                        case ActionType.Add:
                            BOTAContentViewModel bOTAContentViewModel = null;
                            BOTAContent bOTAContent = null;
                            bool isTabItemAnnotation = IsBOTATabItemShow(out bOTAContentViewModel, out bOTAContent, "TabItemAnnotation");

                            if (viewContentViewModel.OpenBOTA == true && isTabItemAnnotation == true)
                            {
                                AnnotationContentViewModel viewModel = GetAnnotationContentViewModel(bOTAContentViewModel);

                                if (viewModel != null)
                                {
                                    int pageindex = editEvent.PageIndex;
                                    int annotindex = editEvent.AnnotIndex;
                                    viewModel.UpdateAddedAnnot(pageindex, annotindex);
                                }
                            }
                            break;

                        case ActionType.Del:
                            isTabItemAnnotation = IsBOTATabItemShow(out bOTAContentViewModel, out bOTAContent, "TabItemAnnotation");
                            if (isTabItemAnnotation)
                            {
                                AnnotationContentViewModel viewModel = GetAnnotationContentViewModel(bOTAContentViewModel);

                                if (viewModel != null)
                                {
                                    int pageindex = editEvent.PageIndex;
                                    int annotindex = editEvent.AnnotIndex;
                                    viewModel.UpdateModifiedAnnot(pageindex, annotindex, true);
                                }
                            }
                            break;

                        case ActionType.Modify:
                            isTabItemAnnotation = IsBOTATabItemShow(out bOTAContentViewModel, out bOTAContent, "TabItemAnnotation");
                            if (isTabItemAnnotation)
                            {
                                AnnotationContentViewModel viewModel = GetAnnotationContentViewModel(bOTAContentViewModel);

                                if (viewModel != null)
                                {
                                    int pageindex = editEvent.PageIndex;
                                    int annotindex = editEvent.AnnotIndex;
                                    viewModel.UpdateModifiedAnnot(pageindex, annotindex, false);
                                }
                            }
                            break;

                        case ActionType.TextEdit:
                            break;

                        default:
                            break;
                    }
                }
            }
        }

        private AnnotationContentViewModel GetAnnotationContentViewModel(BOTAContentViewModel bOTAContentViewModel)
        {
            AnnotationContentViewModel viewModel = null;
            if (bOTAContentViewModel != null)
            {
                if (region.Regions.ContainsRegionWithName(bOTAContentViewModel.BOTAContentRegionName))
                {
                    var views = region.Regions[bOTAContentViewModel.BOTAContentRegionName].Views;
                    foreach (var item in views)
                    {
                        if (item is AnnotationContent annotation)
                        {
                            viewModel = annotation.DataContext as AnnotationContentViewModel;
                            break;
                        }
                    }
                }
            }
            return viewModel;
        }

        /// <summary>
        /// 判断Bota的TabItem是否已显示
        /// </summary>
        /// <param name="bOTAContentViewModel"></param>
        /// <param name="bOTAContent"></param>
        /// <param name="tabItemText"></param>
        /// <returns></returns>
        private bool IsBOTATabItemShow(out BOTAContentViewModel bOTAContentViewModel, out BOTAContent bOTAContent, string tabItemText)
        {
            bool isTabItem = false;
            bOTAContentViewModel = null;
            bOTAContent = null;
            if (region.Regions.ContainsRegionWithName(viewContentViewModel.BOTARegionName))
            {
                var views = region.Regions[viewContentViewModel.BOTARegionName].Views;
                var model = views.FirstOrDefault(q => q is BOTAContent);
                if (model is BOTAContent bOTAContent1)
                {
                    bOTAContent = bOTAContent1;
                    bOTAContentViewModel = bOTAContent.DataContext as BOTAContentViewModel;
                    if (bOTAContentViewModel.CurrentBar == tabItemText)
                    {
                        isTabItem = true;
                    }
                }
                //foreach (var item in views)
                //{
                //    if (item is BOTAContent bOTAContent1)
                //    {
                //        bOTAContent = bOTAContent1;
                //        bOTAContentViewModel = bOTAContent.DataContext as BOTAContentViewModel;
                //        if (bOTAContentViewModel.CurrentBar == tabItemText)
                //        {
                //            isTabItem = true;

                //            break;
                //        }
                //    }
                //}
            }
            return isTabItem;
        }

        private void PDFViewer_AnnotActiveHandler(object sender, AnnotAttribEvent e)
        {
            if (e != null)
            {
                var annot = e.AnnotItemsList[0];
                if (annot != null)
                {
                    if (e.AnnotItemsList.Count == 1 && e.IsAnnotCreateReset == false)
                    {
                        switch (annot.EventType)
                        {
                            case AnnotArgsType.AnnotHighlight:
                                e.IsAnnotCreateReset = false;
                                GetHighLight(annot as TextHighlightAnnotArgs);
                                break;

                            case AnnotArgsType.AnnotUnderline:
                                GetUnderLine(annot as TextUnderlineAnnotArgs);
                                break;

                            case AnnotArgsType.AnnotStrikeout:
                                GetStrikeout(annot as TextStrikeoutAnnotArgs);
                                break;

                            case AnnotArgsType.AnnotSquiggly:
                                GetSquiggly(annot as TextSquigglyAnnotArgs);
                                break;

                            case AnnotArgsType.AnnotFreehand:
                                GetFreehand(annot as FreehandAnnotArgs);
                                break;

                            case AnnotArgsType.AnnotFreeText:
                                GetFreetext(annot as FreeTextAnnotArgs);
                                break;

                            case AnnotArgsType.AnnotSquare:
                                GetRect(annot as SquareAnnotArgs);
                                break;

                            case AnnotArgsType.AnnotCircle:
                                GetCircle(annot as CircleAnnotArgs);
                                break;

                            case AnnotArgsType.AnnotLine:
                                bool isLine = true;
                                if (e.Attribs.ContainsKey(AnnotAttrib.LineStart))
                                {
                                    if ((C_LINE_TYPE)e.Attribs[AnnotAttrib.LineStart] != C_LINE_TYPE.LINETYPE_UNKNOWN && (C_LINE_TYPE)e.Attribs[AnnotAttrib.LineStart] != C_LINE_TYPE.LINETYPE_NONE)
                                    {
                                        isLine = false;
                                    }
                                }
                                if (e.Attribs.ContainsKey(AnnotAttrib.LineEnd))
                                {
                                    if ((C_LINE_TYPE)e.Attribs[AnnotAttrib.LineEnd] != C_LINE_TYPE.LINETYPE_UNKNOWN && (C_LINE_TYPE)e.Attribs[AnnotAttrib.LineEnd] != C_LINE_TYPE.LINETYPE_NONE)
                                    {
                                        isLine = false;
                                    }
                                }

                                if (isLine)
                                    GetArrowLine("Line", annot as LineAnnotArgs);
                                else
                                    GetArrowLine("Arrow", annot as LineAnnotArgs);

                                break;

                            case AnnotArgsType.AnnotLink:
                                viewContentViewModel.IsCreateLink = false;
                                GetLink(annot as LinkAnnotArgs, e);

                                break;

                            case AnnotArgsType.AnnotSticky:
                                GetStickyNote(annot as StickyAnnotArgs);
                                break;
                        }

                        ShowPropertyPanel();
                    }
                    else if (e.AnnotItemsList.Count == 1 && e.IsAnnotCreateReset == true)
                    {
                        switch (annot.EventType)
                        {
                            case AnnotArgsType.AnnotLink:
                                //viewContentViewModel.IsCreateLink = false;
                                GetLink(annot as LinkAnnotArgs, e);
                                break;

                                //case AnnotArgsType.AnnotStamp://图章
                                //    GetStamp();
                                //    break;

                                //case AnnotArgsType.AnnotStamp://签名
                                //    annotArgs = GetSignature();
                                //    isTemplateAnnot = true;
                                //    break;
                        }

                        if (ToolExpandDict.ContainsValue(e.AnnotItemsList[0].EventType))
                        {
                            foreach (var item in ToolExpandDict)
                            {
                                if (item.Value == e.AnnotItemsList[0].EventType)
                                {
                                    FindAnnotTypeKey(item.Key, ref annot);
                                    break;
                                }
                            }
                        }

                        ShowPropertyPanel();
                    }
                }
            }
            else
            {
                // PDFViewer.SetMouseMode(MouseModes.AnnotCreate);
                //  viewContentViewModel.SelectedPrpoertyPanel("PropertyPanelContent", null);
            }
        }

        private void PDFViewer_AnnotCommandHandler(object sender, AnnotCommandArgs e)
        {
            if (e.AnnotEventArgsList == null || (PDFViewer != null && PDFViewer.MouseMode == MouseModes.FormEditTool))
                return;

            // var annotlist = e.AnnotEventArgsList;
            switch (e.CommandType)
            {
                case CommandType.Context:
                    if (e.AnnotEventArgsList.Count > 0)
                    {
                        if (App.mainWindowViewModel.SelectedItem.IsInReadctonMode && e.AnnotEventArgsList[0].EventType == AnnotArgsType.AnnotRedaction)
                        {
                            //绑定标记密文处右键菜单
                            events.GetEvent<RedactionCommandEvent>().Publish(new RedactionCommandEventArgs() { UniCode = App.mainWindowViewModel.SelectedItem.Unicode, Sender = sender, args = e });
                        }
                        else
                        {
                            e.PopupMenu = SelectAnnotContextMenu(sender);
                        }
                        if (e.PopupMenu != null)
                        {
                            e.Handle = true;
                        }
                    }
                    else
                    {
                        if (e.PressOnSelectedText)
                        {
                            e.PopupMenu = NoneSelectAnnotContextMenu(sender, e);
                            if (e.PopupMenu != null)
                            {
                                e.Handle = true;
                            }
                        }
                        else
                        {
                            e.PopupMenu = ViewerContextMenu();
                            if (e.PopupMenu != null)
                            {
                                e.Handle = true;
                            }
                        }
                    }

                    break;
            }
        }

        private ContextMenu ViewerContextMenu()
        {
            ContextMenu contextMenu = App.Current.FindResource("ViewerContextMenu") as ContextMenu;
            //contextMenu.Loaded += ContextMenu_Loaded;
            ContextMenu_Loaded(contextMenu, null);
            return contextMenu;
        }

        private bool isHiddenAnnot = true;
        private bool isAddBookMark = true;
        //private BookmarkContentViewModel bookmarkContentViewModel = null;
        //private BookmarkContent bookmark = null;
        //private BOTAContent bOTAContent = null;

        private void ContextMenu_Loaded(object sender, RoutedEventArgs e)
        {
            ContextMenu contextMenu = sender as ContextMenu;
            if (contextMenu.Items.Count > 0)
            {
                int index = PDFViewer.CurrentIndex;
                //检测是否已存在相同数据
                CPDFBookmark list = PDFViewer.Document.GetBookmarkList().FirstOrDefault(q => q.PageIndex == index);
                if (list != null)
                {
                    isAddBookMark = false;
                }
                else
                {
                    isAddBookMark = true;
                }

                foreach (var item in contextMenu.Items)
                {
                    if (item is MenuItem menuItem1)
                    {
                        //if (menuItem1.Tag.ToString() == "DisplayAnnot" || menuItem1.Tag.ToString() == "HiddenAnnot")
                        //{
                        //    SetMenuItemVisibility(menuItem1, "DisplayAnnot", "HiddenAnnot", isHiddenAnnot);
                        //}

                        switch (menuItem1.Tag.ToString())
                        {
                            case "Copy":
                                //粘贴
                                if (!ApplicationCommands.Paste.CanExecute(null, (UIElement)sender))
                                {
                                    menuItem1.IsEnabled = false;
                                    menuItem1.Opacity = 0.5;
                                }
                                else
                                {
                                    menuItem1.IsEnabled = true;
                                    menuItem1.Opacity = 1;
                                }
                                menuItem1.CommandTarget = (UIElement)sender;
                                menuItem1.Command = ApplicationCommands.Copy;
                                break;

                            case "AddAnnotation":
                                if (menuItem1.Items.Count > 0)
                                {
                                    SetAddAnnotation(menuItem1.Items);
                                }
                                break;

                            case "HiddenAnnot":
                                menuItem1.Click -= HiddenAnnot_Click;

                                menuItem1.Click += HiddenAnnot_Click;
                                SetMenuItemVisibility(menuItem1, "DisplayAnnot", "HiddenAnnot", isHiddenAnnot);

                                break;

                            case "DisplayAnnot":

                                menuItem1.Click -= DisplayAnnot_Click;
                                menuItem1.Click += DisplayAnnot_Click;
                                SetMenuItemVisibility(menuItem1, "DisplayAnnot", "HiddenAnnot", isHiddenAnnot);
                                break;

                            case "AddBookMark":
                                //if (isAddBookMark)
                                //{
                                //    menuItem1.Visibility = Visibility.Visible;
                                //}
                                menuItem1.Click -= AddBookMark_Click;
                                menuItem1.Click += AddBookMark_Click;
                                SetMenuItemVisibility(menuItem1, "DelBookMark", "AddBookMark", isAddBookMark);
                                break;

                            case "DelBookMark":
                                //if (isAddBookMark == false)
                                //{
                                //    menuItem1.Visibility = Visibility.Visible;
                                //}
                                menuItem1.Click -= DelBookMark_Click;
                                menuItem1.Click += DelBookMark_Click;
                                SetMenuItemVisibility(menuItem1, "DelBookMark", "AddBookMark", isAddBookMark);
                                break;

                            case "ToolMode":
                                if (menuItem1.Items.Count > 0)
                                {
                                    SetToolMode(menuItem1.Items);
                                }
                                break;

                            case "ReadModel":
                                SetMenuItemVisibility(menuItem1, "ReadModel", "UnReadModel", App.IsBookMode);
                                menuItem1.Click -= ReadModel_Click;
                                menuItem1.Click += ReadModel_Click;
                                break;

                            case "UnReadModel":
                                SetMenuItemVisibility(menuItem1, "ReadModel", "UnReadModel", App.IsBookMode);
                                menuItem1.Click -= UnReadModel_Click;
                                menuItem1.Click += UnReadModel_Click;
                                break;

                            case "ViewZoom":
                                if (menuItem1.Items.Count > 0)
                                {
                                    ViewZoom(menuItem1.Items);
                                }
                                break;

                            case "PageDisplay":
                                if (menuItem1.Items.Count > 0)
                                {
                                    PageDisplay(menuItem1.Items);
                                }
                                break;

                            case "Select":
                                menuItem1.Click -= Select_Click;

                                menuItem1.Click += Select_Click;
                                break;

                            case "Print":
                                menuItem1.Command = viewContentViewModel.PrintCommand;
                                break;
                        }
                    }
                }
            }
        }

        private void SetMenuItemVisibility(MenuItem menuItem1, string v2, string v3, bool flag)
        {
            if (menuItem1.Tag.ToString() == v2 && flag)
            {
                menuItem1.Visibility = Visibility.Collapsed;
            }
            if (menuItem1.Tag.ToString() == v2 && flag == false)
            {
                menuItem1.Visibility = Visibility.Visible;
            }
            if (menuItem1.Tag.ToString() == v3 && flag == false)
            {
                menuItem1.Visibility = Visibility.Collapsed;
            }
            if (menuItem1.Tag.ToString() == v3 && flag)
            {
                menuItem1.Visibility = Visibility.Visible;
            }
        }

        private void Select_Click(object sender, RoutedEventArgs e)
        {
            if (viewContentViewModel.OpenBOTA == false)
            {
                viewContentViewModel.OpenBOTA = true;
            }
            bool isBook = IsBOTATabItemShow(out BOTAContentViewModel bOTAContentViewModel, out BOTAContent bOTAContent, "TabItemSearch");
            if (isBook == false)
            {
                bOTAContent.TabItemSearch.IsSelected = true;
            }
        }

        private void PageDisplay(ItemCollection items)
        {
            foreach (var item in items)
            {
                if (item is MenuItem menuItem)
                {
                    menuItem.Click -= PageDisplay_Click;
                    menuItem.Click += PageDisplay_Click;
                }
            }
        }

        private void PageDisplay_Click(object sender, RoutedEventArgs e)
        {
            if (sender is MenuItem menuItem)
            {
                switch (menuItem.Tag.ToString())
                {
                    case "SingleView":
                        PDFViewer.ChangeViewMode(ViewMode.Single);
                        break;

                    case "SingleContinueView":
                        PDFViewer.ChangeViewMode(ViewMode.SingleContinuous);
                        break;

                    case "DoubleView":
                        PDFViewer.ChangeViewMode(ViewMode.Double);
                        break;

                    case "DoubleContinueView":
                        PDFViewer.ChangeViewMode(ViewMode.DoubleContinuous);
                        break;

                    case "BookMode":
                        PDFViewer.ChangeViewMode(ViewMode.Book);
                        break;
                }
            }
        }

        private void ViewZoom(ItemCollection items)
        {
            foreach (var item in items)
            {
                if (item is MenuItem menuItem)
                {
                    menuItem.Click -= PageDisplay_Click;
                    menuItem.Click += ViewZoom_Click;
                }
            }
        }

        private void ViewZoom_Click(object sender, RoutedEventArgs e)
        {
            if (sender is MenuItem menuItem)
            {
                switch (menuItem.Tag.ToString())
                {
                    case "FitWidth":
                        PDFViewer.ChangeFitMode(FitMode.FitWidth);
                        break;

                    case "FitHeight":
                        PDFViewer.ChangeFitMode(FitMode.FitHeight);
                        break;

                    case "FitSize":
                        PDFViewer.ChangeFitMode(FitMode.FitSize);
                        break;

                    case "enlarge":
                        double newZoom = viewContentViewModel.CheckZoomLevel((PDFViewer.ZoomFactor + 0.01), true);
                        PDFViewer.Zoom(newZoom);
                        break;

                    case "narrow":
                        newZoom = viewContentViewModel.CheckZoomLevel((PDFViewer.ZoomFactor + -0.01), false);
                        PDFViewer.Zoom(newZoom);
                        break;
                }
            }
        }

        private void UnReadModel_Click(object sender, RoutedEventArgs e)
        {
            viewContentViewModel.UnReadModel();
        }

        private void ReadModel_Click(object sender, RoutedEventArgs e)
        {
            viewContentViewModel.RbtnReadMode();
        }

        private void SetToolMode(ItemCollection items)
        {
            foreach (var item in items)
            {
                if (item is MenuItem menuItem)
                {
                    menuItem.Click -= PageDisplay_Click;
                    menuItem.Click += ToolMode_Click;
                }
            }
        }

        private void ToolMode_Click(object sender, RoutedEventArgs e)
        {
            if (sender is MenuItem menuItem)
            {
                switch (menuItem.Tag.ToString())
                {
                    case "default":
                        PDFViewer.SetMouseMode(MouseModes.None);
                        //viewContentViewModel.SelectedPrpoertyPanel("PropertyPanelContent", null);
                        BtnHandIsChecked = true;
                        ShowPropertyPanel(false);
                        break;

                    case "roll":
                        PDFViewer.SetMouseMode(MouseModes.PanTool);
                        //viewContentViewModel.SelectedPrpoertyPanel("PropertyPanelContent", null);
                        BtnHandIsChecked = true;
                        ShowPropertyPanel(false);
                        break;

                    case "content":
                        AnnotHandlerEventArgs annotHandler = GetSnapshotEdit();
                        BtnSelecttoolIsChecked = true;
                        if (annotHandler != null)
                        {
                            annotHandler.Author = Settings.Default.AppProperties.Description.Author;
                            PDFViewer.SetMouseMode(MouseModes.AnnotCreate);
                            PDFViewer.SetToolParam(annotHandler);
                            ShowPropertyPanel(false);
                        }
                        break;

                    default:
                        break;
                }
            }
        }

        private void BookMark(MenuItem addBookMark, MenuItem delBookMark)
        {
            int index = PDFViewer.CurrentIndex;
            //检测是否已存在相同数据
            CPDFBookmark list = PDFViewer.Document.GetBookmarkList().FirstOrDefault(q => q.PageIndex == index);
            if (list != null)
            {
                isAddBookMark = false;
            }
            else
            {
                isAddBookMark = true;
            }

            if (isAddBookMark)
            {
                addBookMark.Visibility = Visibility.Visible;
                delBookMark.Visibility = Visibility.Collapsed;
                addBookMark.Click += AddBookMark_Click;
            }
            else
            {
                delBookMark.Visibility = Visibility.Visible;
                addBookMark.Visibility = Visibility.Collapsed;
                delBookMark.Click += DelBookMark_Click;
            }
        }

        private void DelBookMark_Click(object sender, RoutedEventArgs e)
        {
            if (viewContentViewModel.OpenBOTA == false)
            {
                viewContentViewModel.OpenBOTA = true;
            }
            bool isBook = IsBOTATabItemShow(out BOTAContentViewModel bOTAContentViewModel, out BOTAContent bOTAContent, "TabItemBookMark");
            if (isBook == false)
            {
                bOTAContent.TabItemBookMark.IsSelected = true;
            }
            BookmarkContentViewModel bookmarkContentViewModel = GetBookmarkContentViewModel(bOTAContentViewModel, out BookmarkContent bookmark);

            int index = PDFViewer.CurrentIndex;
            //检测是否已存在相同数据
            CPDFBookmark list = PDFViewer.Document.GetBookmarkList().FirstOrDefault(q => q.PageIndex == index);

            if (bookmarkContentViewModel != null && bookmark != null && bOTAContent != null && list != null)
            {
                bookmarkContentViewModel.DeleteCommand.Execute(list);
                isAddBookMark = bookmarkContentViewModel.isAddBookMark;
            }

            //        bool isBook = IsBOTATabItemShow(out BOTAContentViewModel bOTAContentViewModel, out BOTAContent bOTAContent, "TabItemBookMark");

            //if (isBook == false || viewContentViewModel.OpenBOTA == false)
            //{
            //    viewContentViewModel.OpenBOTA = true;
            //    bOTAContent.TabItemBookMark.IsSelected = true;
            //}
        }

        private void AddBookMark_Click(object sender, RoutedEventArgs e)
        {
            if (viewContentViewModel.OpenBOTA == false)
            {
                viewContentViewModel.OpenBOTA = true;
            }
            bool isBook = IsBOTATabItemShow(out BOTAContentViewModel bOTAContentViewModel, out BOTAContent bOTAContent, "TabItemBookMark");
            if (isBook == false)
            {
                bOTAContent.TabItemBookMark.IsSelected = true;
            }
            BookmarkContentViewModel bookmarkContentViewModel = GetBookmarkContentViewModel(bOTAContentViewModel, out BookmarkContent bookmark);

            if (bookmarkContentViewModel != null && bookmark != null && bOTAContent != null)
            {
                bookmarkContentViewModel.AddBookmarkCommand.Execute(bookmark.BookMarkListView);
                isAddBookMark = bookmarkContentViewModel.isAddBookMark;
                return;
            }
        }

        private BookmarkContentViewModel GetBookmarkContentViewModel(BOTAContentViewModel bOTAContentViewModel, out BookmarkContent bookmark)
        {
            BookmarkContentViewModel viewModel = null;
            bookmark = null;
            if (bOTAContentViewModel != null)
            {
                if (region.Regions.ContainsRegionWithName(bOTAContentViewModel.BOTAContentRegionName))
                {
                    var views = region.Regions[bOTAContentViewModel.BOTAContentRegionName].Views;
                    foreach (var item in views)
                    {
                        if (item is BookmarkContent bookmark1)
                        {
                            bookmark = bookmark1;
                            viewModel = bookmark1.DataContext as BookmarkContentViewModel;
                            break;
                        }
                    }
                }
            }
            return viewModel;
        }

        private void DisplayAnnot_Click(object sender, RoutedEventArgs e)
        {
            PDFViewer.SetDrawAnnot(true);
            isHiddenAnnot = true;
        }

        private void HiddenAnnot_Click(object sender, RoutedEventArgs e)
        {
            PDFViewer.SetDrawAnnot(false);
            isHiddenAnnot = false;
        }

        private void SetAddAnnotation(ItemCollection items)
        {
            foreach (var item in items)
            {
                if (item is MenuItem menuItem)
                {
                    menuItem.CommandParameter = item;
                    menuItem.Command = SetAddAnnotationCommand;
                }
            }
        }

        /// <summary>
        /// 右键菜单-添加注释
        /// </summary>
        /// <param name="sender"></param>
        private void AddAnnotation_Click(object sender)
        {
            if (sender is MenuItem menuItem)
            {
                AnnotHandlerEventArgs annotHandler = null;
                string str = menuItem.Tag.ToString();
                if (str == AddAnnotType.AnnotFreehand.ToString())
                {
                    annotHandler = GetFreehand();
                }
                if (str == AddAnnotType.AnnotFreeText.ToString())
                {
                    annotHandler = GetFreetext();
                }
                if (str == AddAnnotType.AnnotSticky.ToString())
                {
                    annotHandler = GetStickyNote();
                }
                if (str == AddAnnotType.AnnotSquare.ToString())
                {
                    annotHandler = GetRect();
                }
                if (str == AddAnnotType.AnnotCircle.ToString())
                {
                    annotHandler = GetCircle();
                }
                if (str == AddAnnotType.AnnotArrow.ToString())
                {
                    annotHandler = GetArrowLine("Arrow");
                }
                if (str == AddAnnotType.AnnotLine.ToString())
                {
                    annotHandler = GetArrowLine("Line");
                }
                if (str == AddAnnotType.AnnotLink.ToString())
                {
                    annotHandler = GetLink();
                }
                if (str == AddAnnotType.AnnotStamp.ToString())
                {
                    annotHandler = GetStamp();
                }
                if (str == AddAnnotType.AnnotAutograph.ToString())
                {
                    annotHandler = GetSignature();
                }
                if (annotHandler != null)
                {
                    annotHandler.Author = Settings.Default.AppProperties.Description.Author;
                    PDFViewer.SetMouseMode(MouseModes.AnnotCreate);
                    PDFViewer.SetToolParam(annotHandler);
                    ShowPropertyPanel(true);
                }
            }
        }

        private ContextMenu SelectAnnotContextMenu(object sender)
        {
            var popMenu = App.Current.FindResource("SelectAnnotContextMenu") as ContextMenu;
            if (popMenu != null && popMenu.Items.Count == 4)
            {
                //剪切
                MenuItem menuItem = popMenu.Items[0] as MenuItem;
                menuItem.CommandTarget = (UIElement)sender;
                menuItem.Command = ApplicationCommands.Cut;
                //复制
                menuItem = popMenu.Items[1] as MenuItem;
                menuItem.CommandTarget = (UIElement)sender;
                menuItem.Command = ApplicationCommands.Copy;
                //删除
                menuItem = popMenu.Items[2] as MenuItem;
                menuItem.CommandTarget = (UIElement)sender;
                menuItem.Command = ApplicationCommands.Delete;

                //笔记
                //menuItem = popMenu.Items[2] as MenuItem;
                //menuItem.CommandTarget = (UIElement)sender;
                //menuItem.Command = ApplicationCommands.no;
            }
            return popMenu;
        }

        private ContextMenu NoneSelectAnnotContextMenu(object sender, AnnotCommandArgs annotCommand)
        {
            ContextMenu popMenu = new ContextMenu();
            popMenu.FontSize = 14;

            MenuItem menuItem = new MenuItem();
            menuItem = new MenuItem();
            menuItem.CommandTarget = (UIElement)sender;
            menuItem.Command = ApplicationCommands.Copy;
            popMenu.Items.Add(menuItem);

            menuItem = new MenuItem();
            menuItem.CommandTarget = (UIElement)sender;
            menuItem.Command = ApplicationCommands.Paste;
            popMenu.Items.Add(menuItem);

            menuItem = new MenuItem();
            menuItem.CommandTarget = (UIElement)sender;
            menuItem.Header = "创建链接";
            menuItem.CommandParameter = new object[] { this, annotCommand };
            menuItem.Command = viewContentViewModel.CreateLinkCommand;
            menuItem.Click += MenuItem_Click;
            popMenu.Items.Add(menuItem);
            return popMenu;
        }

        private void MenuItem_Click(object sender, RoutedEventArgs e)
        {
            var args = PDFViewer.ToolManager.CurrentAnnotArgs;
            BtnLinkIsChecked = true;
        }

        /// <summary>
        /// 展开显示属性面板
        /// </summary>
        private void ShowPropertyPanel(bool show = true)
        {
            viewContentViewModel.IsPropertyOpen = show;
        }
    }
}