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

using ComDocumentAIKit;
using ComPDFKit.Import;
using ComPDFKit.PDFAnnotation;
using ComPDFKit.PDFDocument;
using ComPDFKit.PDFDocument.Action;
using ComPDFKit.PDFPage;
using ComPDFKitViewer;
using ComPDFKitViewer.AnnotEvent;
using ComPDFKitViewer.PdfViewer;
using DryIoc;
using ImTools;
using PDF_Master.CustomControl;
using PDF_Master.EventAggregators;
using PDF_Master.Helper;
using PDF_Master.Model.AnnotPanel;
using PDF_Master.Model.BOTA;
using PDF_Master.Model.FillAndSign;
using PDF_Master.Properties;
using PDF_Master.ViewModels.BOTA;
using PDF_Master.ViewModels.PropertyPanel.AnnotPanel;
using PDF_Master.ViewModels.Tools.AnnotManager;
using PDF_Master.Views;
using PDF_Master.Views.BOTA;
using PDF_Master.Views.PropertyPanel.AnnotPanel;
using PDFSettings;
using Prism.Mvvm;
using Prism.Regions;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Input;
using System.Windows.Markup;
using System.Windows.Media;

namespace PDF_Master.ViewModels.Tools
{
    public sealed partial class AnnotToolContentViewModel : BindableBase, INavigationAware
    {
        #region 事件绑定和解绑

        private void BindingEvent()
        {
            //属性面板与注释工具栏绑定：属性面板的属性变化，会同步注释工具栏的属性值
            //比如在属性面板里更改注释颜色，会同时更新工具栏对应的工具颜色
            PropertyPanel.DataChanged -= AnnotPropertyPanel_DataChanged;
            PropertyPanel.DataChanged += AnnotPropertyPanel_DataChanged;
            PropertyPanel.AnnotTypeChanged -= AnnotPropertyPanel_AnnotTypeChanged;
            PropertyPanel.AnnotTypeChanged += AnnotPropertyPanel_AnnotTypeChanged;
            //快捷键
            KeyEventsHelper.KeyDown -= ShortCut_KeyDown;
            KeyEventsHelper.KeyDown += ShortCut_KeyDown;
        }

        private void UnBindingEvent()
        {
            PropertyPanel.DataChanged -= AnnotPropertyPanel_DataChanged;
            PropertyPanel.AnnotTypeChanged -= AnnotPropertyPanel_AnnotTypeChanged;
            //快捷盘解绑
            KeyEventsHelper.KeyDown -= ShortCut_KeyDown;
        }

        private void BindingPDFViewerHandler()
        {
            //来自PDFViewer的响应事件
            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.SnapshotCommandHandler -= PDFViewer_SnapshotCommandHandler;
                PDFViewer.SnapshotCommandHandler += PDFViewer_SnapshotCommandHandler;

                PDFViewer.PDFActionHandler -= PDFViewer_PDFActionHandler;
                PDFViewer.PDFActionHandler += PDFViewer_PDFActionHandler;
                PDFViewer.AnnotHoverHandler -= PDFViewer_AnnotHoverHandler;
                PDFViewer.AnnotHoverHandler += PDFViewer_AnnotHoverHandler;

                PDFViewer.PreviewMouseLeftButtonDown -= PDFViewer_PreviewMouseLeftButtonDown;
                PDFViewer.PreviewMouseLeftButtonDown += PDFViewer_PreviewMouseLeftButtonDown;

                PDFViewer.MouseLeftButtonUp -= PDFViewer_MouseLeftButtonUp;
                PDFViewer.MouseLeftButtonUp += PDFViewer_MouseLeftButtonUp;
                CommandManager.AddPreviewExecutedHandler(PDFViewer, PreviewExcutePDFViewer);
            }
        }

        //判断
        private void PreviewExcutePDFViewer(object sender, ExecutedRoutedEventArgs e)
        {
            if (e.Command == ApplicationCommands.Paste)
            {
                IsPasteShape = true;
                ShapeNames.Clear();
                var items = PDFViewer.GetCopyAnnotData();
                foreach (var item in items)
                {
                    bool IsShape = false;
                    if (item is FreehandAnnotArgs)
                    {
                        foreach (var point in ViewContentViewModel.FillAndSign)
                        {
                            if ((item as FreehandAnnotArgs).PageIndex == point.PageIndex && (item as FreehandAnnotArgs).AnnotIndex == point.AnnotIndex)
                            {
                                ShapeNames.Add(point.Shape);
                                IsShape = true;
                                continue;
                            }
                        }
                        if (!IsShape)
                        {
                            ShapeNames.Add("Annot");
                        }
                    }
                    else
                    {
                        ShapeNames.Add("Annot");
                    }
                }
            }
            if (e.Command == ApplicationCommands.Copy)
            {
            }
        }

        private void UnBindingPDFViewerHandler()
        {
            if (PDFViewer != null)
            {
                PDFViewer.AnnotEditHandler -= PDFViewer_AnnotEditHandler;
                PDFViewer.AnnotActiveHandler -= PDFViewer_AnnotActiveHandler;
                PDFViewer.AnnotCommandHandler -= PDFViewer_AnnotCommandHandler;
                PDFViewer.SnapshotCommandHandler -= PDFViewer_SnapshotCommandHandler;
                PDFViewer.PDFActionHandler -= PDFViewer_PDFActionHandler;
                PDFViewer.AnnotHoverHandler -= PDFViewer_AnnotHoverHandler;

                PDFViewer.PreviewMouseLeftButtonDown -= PDFViewer_PreviewMouseLeftButtonDown;
            }
        }

        #endregion 事件绑定和解绑

        #region 与触发事件调用相关的函数
        public StickyAnnotArgs GetCurrentAnnot { get; set; }

        //鼠标左键双击注释
        private void PDFViewer_PreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            if (e.ClickCount == 1)
            {
                //不禁止取消选中注释
                //PDFViewer.DisableClearSelectAnnot(false);
                //if (viewContentViewModel.mainViewModel.IsBookMode)
                //{
                //    PDFViewer.SetMouseMode(MouseModes.PanTool);
                //    var annotArgs = new SelectToolArgs();
                //    PDFViewer.SetToolParam(annotArgs);
                //}
                //PropertyPanel.IsSharpAnnotSelected = true;
                //PropertyPanel.IsFreeHandSelected = true;
                //PDFViewer.ClearSelectAnnots();

                //注释工具 选中图章，阅读页选择其他注释后，点击阅读页空白，属性面板需要显示图章面板
                //if (StrAnnotToolChecked == "Stamp")
                //{
                //    GetStamp();
                //}

                //AnnotHandlerEventArgs annotArgs = CurrentSelectedAnnot;

                //if (annotArgs != null)
                //{
                //    var type = annotArgs.EventType;
                //    if (type == AnnotArgsType.AnnotSticky)
                //    {
                //        customStickyPopup.GetCurrentAnnot = GetCurrentAnnot;
                //        customStickyPopup.GetPDFViewer = PDFViewer;
                //        //多个文档时候，未知原因弹窗对象没有更改，导致PDFViewer以及GetCurrentAnnot，没有及时刷新
                //        PDFViewer.SetStickyNotePop(customStickyPopup);
                //        (annotArgs as StickyAnnotArgs).PopupEditWnd();
                //    }
                //}
            }
            #region 0515调整的双击逻辑
            //if (e.ClickCount == 2)
            //{
            //    if (CurrentSelectedAnnot != null)
            //    {
            //        var type = CurrentSelectedAnnot.EventType;
            //        if (type != AnnotArgsType.AnnotSticky && type != AnnotArgsType.AnnotFreeText && type != AnnotArgsType.AnnotLink
            //            /*&&
            //            type != AnnotArgsType.AnnotHighlight && type != AnnotArgsType.AnnotUnderline
            //            && type != AnnotArgsType.AnnotStrikeout*/)
            //        {
            //            int dpi = DpiHelpers.Dpi;
            //            var rect = CurrentSelectedAnnot.ClientRect;
            //            rect = new Rect(
            //                rect.Left * PDFViewer.ZoomFactor,
            //                rect.Top * PDFViewer.ZoomFactor,
            //                rect.Width * PDFViewer.ZoomFactor,
            //                rect.Height * PDFViewer.ZoomFactor);
            //            if (PDFViewer.Parent is ContentControl ui)
            //            {
            //                //var ui = PDFViewer.Parent as ContentControl;
            //                if (ui != null)
            //                {
            //                    var point = e.GetPosition(ui);
            //                    int pageIndex = 0;
            //                    Point pagePoint = new Point(0, 0);

            //                    PDFViewer.ConvertViewPointToPage(point, out pageIndex, out pagePoint);
            //                    if (pagePoint.X >= rect.Left && pagePoint.X <= rect.Right && pagePoint.Y >= rect.Top && pagePoint.Y <= rect.Bottom)
            //                        PopAnnotNoteText(CurrentSelectedAnnot);
            //                }
            //            }
            //        }

            //        if (type == AnnotArgsType.AnnotSticky)
            //        {
            //            customStickyPopup.GetCurrentAnnot = GetCurrentAnnot;
            //            customStickyPopup.GetPDFViewer = PDFViewer;
            //            //多个文档时候，未知原因弹窗对象没有更改，导致PDFViewer以及GetCurrentAnnot，没有及时刷新
            //            PDFViewer.SetStickyNotePop(customStickyPopup);
            //            (CurrentSelectedAnnot as StickyAnnotArgs).PopupEditWnd();
            //        }
            //    }
            //}
            #endregion 0515调整的双击逻辑
        }

        private void PDFViewer_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
        {
            //BOTA所有列表都需要响应 单击阅读页取消多选
            if (ViewContentViewModel.OpenBOTA == true)
            {
                int annotCount = PDFViewer.GetSelectAnnotCount();
                if (annotCount == 0)
                {
                    //2023/08/23 Windows:BOTA列表，移除点击阅读页取消选中逻辑
                    //this.events.GetEvent<CleanSelectAllEvent>().Publish(new CleanSelectAllArgs() { Unicode = App.mainWindowViewModel.SelectedItem.Unicode, IsCleanSelectAll = true });
                }
            }
        }

        //超链接跳转
        private void PDFViewer_PDFActionHandler(object sender, ComPDFKit.PDFDocument.Action.CPDFAction action)
        {
            if (action == null)
            {
                return;
            }
            switch (action.ActionType)
            {
                case C_ACTION_TYPE.ACTION_TYPE_GOTO:
                    if (PDFViewer != null)
                    {
                        CPDFGoToAction gotoAction = action as CPDFGoToAction;
                        CPDFDestination dest = gotoAction.GetDestination(PDFViewer.Document);
                        if (dest != null)
                        {
                            CPDFPage docPage = PDFViewer.Document.PageAtIndex(dest.PageIndex, false);
                            if (docPage != null)
                            {
                                PDFViewer.GoToPage(dest.PageIndex, new System.Windows.Point(dest.Position_X, docPage.PageSize.Height - dest.Position_Y));
                            }
                            else
                            {
                                PDFViewer.GoToPage(dest.PageIndex, new System.Windows.Point(dest.Position_X, dest.Position_Y));
                            }
                        }
                    }
                    break;

                case C_ACTION_TYPE.ACTION_TYPE_URI:
                    {
                        CPDFUriAction uriAction = action as CPDFUriAction;
                        string uri = uriAction.GetUri();
                        try
                        {
                            if (!string.IsNullOrEmpty(uri))
                            {
                                Process.Start(uri);
                            }
                        }
                        catch
                        {
                        }
                    }
                    break;
            }
        }

        private void GetSelectedAnnots(AnnotAttribEvent e, bool isActive = false)
        {
            var annot = e.AnnotItemsList[0];
            switch (annot.EventType)
            {
                case AnnotArgsType.AnnotHighlight:
                    if (e.IsAnnotCreateReset)
                    {
                        GetHighLight();
                    }
                    else
                    {
                        GetHighLight(e.AnnotItemsList);
                    }

                    break;

                case AnnotArgsType.AnnotUnderline:
                    if (e.IsAnnotCreateReset)
                    {
                        GetUnderLine();
                    }
                    else
                    {
                        GetUnderLine(e.AnnotItemsList);
                    }

                    break;

                case AnnotArgsType.AnnotStrikeout:
                    if (e.IsAnnotCreateReset)
                    {
                        GetStrikeout();
                    }
                    else
                    {
                        GetStrikeout(e.AnnotItemsList);
                    }
                    break;

                case AnnotArgsType.AnnotSquiggly:
                    GetSquiggly(e.AnnotItemsList);
                    break;

                case AnnotArgsType.AnnotFreehand:
                    GetFreehand(e.AnnotItemsList);
                    break;

                case AnnotArgsType.AnnotFreeText:
                    //根据状态设置对应的界面
                    //if (e.IsAnnotCreateReset)
                    //{
                    //    GetFreetext();
                    //}
                    //else
                    //{
                    //    GetFreetext(e.AnnotItemsList);
                    //}

                    //暂时不根据状态设置对应的界面，需要拿到数据
                    //文本注释 （字体大小样式）修改属性后，点击阅读页会置原
                    //先这样操作，若有问题再改回来
                    GetFreetext(e.AnnotItemsList);
                    break;

                case AnnotArgsType.AnnotSquare:
                    GetRect(e.AnnotItemsList);
                    break;

                case AnnotArgsType.AnnotCircle:
                    GetCircle(e.AnnotItemsList);
                    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", e.AnnotItemsList);
                    else
                        GetArrowLine("Arrow", e.AnnotItemsList);

                    break;

                case AnnotArgsType.AnnotLink:
                    //viewContentViewModel.IsCreateLink = false;
                    //e.IsAnnotCreateReset= true;

                    if (StrAnnotToolChecked == "Link")
                    {
                        PropertyPanel.IsAddLink = false;
                    }

                    GetLink(e.AnnotItemsList, e);
                    break;

                case AnnotArgsType.AnnotSticky:
                    GetStickyNote(e.AnnotItemsList);
                    GetCurrentAnnot = e.AnnotItemsList[0] as StickyAnnotArgs;
                    customStickyPopup.GetCurrentAnnot = GetCurrentAnnot;
                    customStickyPopup.GetPDFViewer = PDFViewer;
                    customStickyPopup.AnnotToolContentVM = this;
                    //多个文档时候，未知原因弹窗对象没有更改，导致PDFViewer以及GetCurrentAnnot，没有及时刷新
                    PDFViewer.SetStickyNotePop(customStickyPopup);
                    if (e.IsAnnotCreateReset)
                    {
                        PropertyPanel.annot = e.AnnotItemsList[0];
                        var AnnotEvent = AnnotAttribEvent.GetAnnotAttribEvent(annot, annot.GetAnnotAttrib(), PDFViewer);
                        PropertyPanel.AnnotEvents = null;
                        PropertyPanel.AnnotEvent = AnnotEvent;
                        PropertyPanel.annotlists = e.AnnotItemsList;
                    }
                    //0515 调整单击 便签弹窗
                    if (e.AnnotItemsList.Count == 1 && e.IsMouseRightActive == false)
                    {
                        if (e.AnnotItemsList[0] is StickyAnnotArgs stickyAnnotArgs)
                        {
                            stickyAnnotArgs.PopupEditWnd();
                            CloseAnnotToolTip();
                        }
                    }
                    else
                    {
                        customStickyPopup.Close();
                    }

                    break;

                case AnnotArgsType.AnnotStamp:
                    if (e.IsAnnotCreateReset == false)
                    {
                        GetStamp();
                    }
                    break;
            }
        }

        /// <summary>
        /// 选中注释 区分签名、图章、手绘
        /// </summary>
        /// <param name="annotlist"></param>
        private void SelectedSignature(List<AnnotHandlerEventArgs> annotlist)
        {
            if (annotlist == null || annotlist.Count == 0)
                return;

            var annot = annotlist[0];

            if (annot.EventType != AnnotArgsType.AnnotStamp && annot.EventType != AnnotArgsType.AnnotFreehand)
                return;
            if (annot.PageIndex < 0 || annot.AnnotIndex < 0)
                return;

            var signAnnot = ViewContentViewModel.AnnotSignatures.FirstOrDefault(temp => temp.Item1 == annot.PageIndex && temp.Item2 == annot.AnnotIndex);
            if (signAnnot == null)
            {
                //var key = ToolExpandDict.FirstOrDefault(q => q.Value == annot.EventType);
                //if (!string.IsNullOrEmpty(StrAnnotToolChecked))
                //    StrAnnotToolChecked = key.Key.ToString();

                //if (annot.EventType == AnnotArgsType.AnnotStamp)
                //{
                //    StrAnnotToolChecked = "Stamp";
                //}
                //else
                //{
                //    StrAnnotToolChecked = "";
                //}
            }
            else
            {
                if (string.IsNullOrEmpty(StrAnnotToolChecked))
                {
                    ViewContentViewModel.SelectedPrpoertyPanel("PropertyPanelContent", null);
                    //GetSignature();
                    //StrAnnotToolChecked = "Signature";
                }
            }
        }

        private void AddAnnotSignature(AnnotHandlerEventArgs annot)
        {
            if ((annot.EventType != AnnotArgsType.AnnotStamp && annot.EventType != AnnotArgsType.AnnotFreehand) ||
            (annot.PageIndex < 0 || annot.AnnotIndex < 0)) return;

            if (StrAnnotToolChecked == "Signature")
            {
                if (ViewContentViewModel.AnnotSignatures == null)
                    ViewContentViewModel.AnnotSignatures = new List<Tuple<int, int>>();

                var signAnnot = ViewContentViewModel.AnnotSignatures.FirstOrDefault(temp => temp.Item1 == annot.PageIndex && temp.Item2 == annot.AnnotIndex);
                if (signAnnot == null)
                {
                    ViewContentViewModel.AnnotSignatures.Add(new Tuple<int, int>(annot.PageIndex, annot.AnnotIndex));
                }
            }
        }

        #endregion 与触发事件调用相关的函数

        #region PDFViewer事件

        private AnnotHandlerEventArgs CurrentSelectedAnnot = null;

        private bool isShowPropertyPanel = false;

        //选中和非选中注释
        private void PDFViewer_AnnotActiveHandler(object sender, AnnotAttribEvent e)
        {
            CurrentSelectedAnnot = null;
            if (ViewContentViewModel.CurrentBar != "TabItemAnnotation")
            {
                //viewContentViewModel.SelectedPrpoertyPanel("PropertyPanelContent", null);
                return;
            }
            if (e == null)
            {
                ViewContentViewModel.mainViewModel.AnnotMouseLeftButtonDown = false;
                if (ViewContentViewModel.IsRightMenuSelectedTextAddLink || ViewContentViewModel.IsRightMenuCreateLink)
                {
                    ViewContentViewModel.IsRightMenuSelectedTextAddLink = false;
                    ViewContentViewModel.IsRightMenuCreateLink = false;

                    ViewContentViewModel.SelectedPrpoertyPanel("PropertyPanelContent", null);
                    var annotArgs = new SelectToolArgs();
                    PDFViewer.SetToolParam(annotArgs);
                    return;
                }
                if (string.IsNullOrWhiteSpace(StrAnnotToolChecked))
                {
                    //PDFViewer.ClearSelectAnnots();
                    CleanPropertyPanel();

                    if (PropertyPanel.IsAddLink == false && ViewContentViewModel.IsReadModeShow == false)
                    {
                        bool iso = ViewContentViewModel.mainViewModel.IsBookMode;
                        ViewContentViewModel.SelectedPrpoertyPanel("PropertyPanelContent", null);
                    }

                    //PDFViewer.SetMouseMode(MouseModes.PanTool);
                    //HandToolIsCheckedEvent(false);
                    return;
                }
                else
                {
                    SetTextAnnotProperty();

                    SetSharpsAnnotProperty();

                    //不可以写，手绘 改透明度 会有问题
                    //if (StrAnnotToolChecked == "Freehand")
                    //{
                    //    GetFreehand();
                    //}
                    //if (StrAnnotToolChecked== "StickyNote")
                    //{
                    //    CleanPropertyPanel();
                    //    GetStickyNote();

                    //}
                    //点击空白需要清空
                    if (StrAnnotToolChecked == "Freetext")
                    {
                        CleanPropertyPanel();
                    }
                    //注释工具 选中图章，阅读页选择其他注释后，点击阅读页空白，属性面板需要显示图章面板
                    if (StrAnnotToolChecked == "Stamp")
                    {
                        GetStamp();
                    }
                }
            }

            if (e != null)
            {
                if (e.IsMouseRightActive)
                {
                    ViewContentViewModel.mainViewModel.AnnotMouseLeftButtonDown = true;
                    CloseAnnotToolTip();
                    if (string.IsNullOrEmpty(StrAnnotToolChecked))
                    {
                        ShowPropertyPanel(false);
                        return;
                    }
                }

                var annot = e.AnnotItemsList[0];
                if (annot != null)
                {
                    if (e.AnnotItemsList.Count == 1)
                    {
                        ViewContentViewModel.IsMultiSelected = false;
                        //IsAnnotCreateReset：是否为创建注释的状态
                        if (e.IsAnnotCreateReset == false)
                        {
                            CurrentSelectedAnnot = annot;
                            //未选注释工具-形状注释，选中形状注释，属性面板不显示（矩形、圆、线、箭头）
                            //未选注释工具-手绘，选中手绘注释，属性面板不显示橡皮擦
                            SetPropertyPanelValue(annot);

                            if (ViewContentViewModel.mainViewModel.IsBookMode == false)
                            {
                                GetSelectedAnnots(e, true);
                            }

                            PropertyPanelShowOrVisibility(e, annot);

                            //注释列表同步选中
                            SelectedBotaAnnotationList(e);
                        }
                        else
                        {
                            if (!string.IsNullOrEmpty(StrAnnotToolChecked) || PropertyPanel.IsAddLink == true)
                            {
                                GetSelectedAnnots(e);
                                PDFViewer.SetToolParam(annot);
                            }
                            else
                            {
                                if (IsNoSelectMenu)
                                {
                                    return;
                                }
                                CleanPropertyPanel();
                                PDFViewer.SetMouseMode(MouseModes.PanTool);
                                HandToolIsCheckedEvent(false);
                                ViewContentViewModel.SelectedPrpoertyPanel("PropertyPanelContent", null);
                            }

                            #region //TODO: 修改注释后，会作用到之后添加的注释中。因此先把此逻辑“创建注释后，会自动回到默认值”注释掉

                            //注释代码原因：设计已经重新调整逻辑：所有注释创建后，编辑属性，所有属性会作用于下次创建的注释中。
                            //if (annot.EventType != AnnotArgsType.AnnotStrikeout &&
                            //annot.EventType != AnnotArgsType.AnnotUnderline &&
                            //annot.EventType != AnnotArgsType.AnnotHighlight &&
                            //annot.EventType != AnnotArgsType.AnnotSquiggly &&
                            //annot.EventType != AnnotArgsType.AnnotLink &&
                            //annot.EventType != AnnotArgsType.AnnotFreehand &&
                            //annot.EventType != AnnotArgsType.AnnotSticky &&
                            //)
                            //{
                            //    if (ToolExpandDict.ContainsValue(e.AnnotItemsList[0].EventType))
                            //    {
                            //        var strLineAnnotTag = "";
                            //        if (e.AnnotItemsList[0] is LineAnnotArgs)
                            //        {
                            //            var lineAnnot = e.AnnotItemsList[0] as LineAnnotArgs;
                            //            if (lineAnnot.HeadLineType == C_LINE_TYPE.LINETYPE_NONE && lineAnnot.TailLineType == C_LINE_TYPE.LINETYPE_NONE)
                            //            {
                            //                strLineAnnotTag = "Line";
                            //            }
                            //            else
                            //            {
                            //                strLineAnnotTag = "Arrow";
                            //            }
                            //        }

                            //        foreach (var item in ToolExpandDict)
                            //        {
                            //            if (item.Value == e.AnnotItemsList[0].EventType)
                            //            {
                            //                annot = null;//新建注释时，回到默认值
                            //                if (string.IsNullOrEmpty(strLineAnnotTag))
                            //                {
                            //                    FindAnnotTypeKey(item.Key, ref annot);
                            //                    break;
                            //                }
                            //                else
                            //                {
                            //                    if (strLineAnnotTag == item.Key)
                            //                    {
                            //                        FindAnnotTypeKey(item.Key, ref annot);
                            //                        break;
                            //                    }
                            //                }
                            //            }
                            //        }

                            //        PDFViewer.SetToolParam(annot);
                            //    }
                            //}

                            //设计重新调整，阅读页空白处，右键菜单，添加链接需要显示，其他和pro mac一样的效果，不显示属性栏
                            //if (isRightMenuAddAnnot && annot.EventType!=AnnotArgsType.AnnotLink)
                            //{
                            //    ShowPropertyPanel(false);
                            //}
                            //else
                            //{
                            //    ShowPropertyPanel();
                            //}

                            #endregion //TODO: 修改注释后，会作用到之后添加的注释中。因此先把此逻辑“创建注释后，会自动回到默认值”注释掉
                        }
                    }
                    else
                    {
                        //框选注释
                        BoxAnnotation(e);
                    }
                }
            }
        }

        /// <summary>
        /// 框选注释
        /// </summary>
        /// <param name="e"></param>
        private void BoxAnnotation(AnnotAttribEvent e)
        {
            PropertyPanel.annotlists = e.AnnotItemsList;
            ViewContentViewModel.IsMultiSelected = true;
            //viewContentViewModel.SelectedPrpoertyPanel("PropertyPanelContent", null);

            // MVP 在对多选注释做处理
            bool isDifferentAnnotTyle = AnnotTransfer.IsDifferentTypeAnnots(e.AnnotItemsList);

            if (ViewContentViewModel.mainViewModel.IsBookMode)
            {
                ShowPropertyPanel(false);
            }
            else
            {
                BottomToolContent bottomTool = null;
                BottomToolContentViewModel bottomToolVM = ViewContentViewModel.GetBottomToolContentVM(ref bottomTool);
                if (isDifferentAnnotTyle)
                {
                    if (bottomToolVM != null)
                    {
                        if (bottomToolVM.IsShowViewModular == false)
                        {
                            //viewContentViewModel.IsReadModeShow = false;
                            ViewContentViewModel.SelectedPrpoertyPanel("PropertyPanelContent", null);
                            ShowPropertyPanel(false);
                        }
                    }
                    else
                    {
                        //viewContentViewModel.IsReadModeShow = false;
                        ViewContentViewModel.SelectedPrpoertyPanel("PropertyPanelContent", null);
                        ShowPropertyPanel(false);
                    }
                }
                else
                {
                    ViewContentViewModel.IsReadModeShow = false;
                    if (bottomToolVM != null)
                    {
                        bottomToolVM.IsShowViewModular = false;
                    }
                    GetSelectedAnnots(e);
                    if (string.IsNullOrEmpty(StrAnnotToolChecked) == true)
                    {
                        var count = e.AnnotItemsList.FindAll(r => r.EventType == AnnotArgsType.AnnotStamp).Count;
                        if (count > 0)
                        {
                            ShowPropertyPanel(false);
                        }
                        else
                        {
                            ShowPropertyPanel(true);
                        }
                    }
                    else
                    {
                        ShowPropertyPanel(true);
                    }
                }
            }
        }

        /// <summary>
        /// 设置选中注释工具 签名，面板的显示
        /// </summary>
        /// <param name="e"></param>
        /// <param name="annot"></param>
        private void PropertyPanelShowOrVisibility(AnnotAttribEvent e, AnnotHandlerEventArgs annot)
        {
            SelectedSignature(e.AnnotItemsList);

            if (Settings.Default.AppProperties.InitialVIew.AutoExpandProperty
                && annot.EventType != AnnotArgsType.AnnotStamp && StrAnnotToolChecked != "Signature"
                && annot.EventType != AnnotArgsType.AnnotLink && ViewContentViewModel.mainViewModel.IsBookMode == false)
            {
                var signAnnot = ViewContentViewModel.AnnotSignatures.FirstOrDefault(temp => temp.Item1 == annot.PageIndex && temp.Item2 == annot.AnnotIndex);
                if (signAnnot == null)
                {
                    if (e.IsMouseRightActive)
                    {
                        ShowPropertyPanel(isShowPropertyPanel);
                    }
                    else
                    {
                        ShowPropertyPanel(true);
                    }
                }
            }
            else if (StrAnnotToolChecked == "Signature")
            {
                GetSignature();
            }
        }

        /// <summary>
        /// 设置选中注释工具形状， 点击阅读页空白时候显示内容
        /// </summary>
        private void SetSharpsAnnotProperty()
        {
            if (StrAnnotToolChecked == "Rect" && PropertyPanel.IsSelectedTextAddShape == false)
            {
                //AnnotHandlerEventArgs annotArgs = null;//暂时不知道会不会影响效果，先注释
                //此处不能用这个方法更新创建注释的属性  会导致死循环
                //选择文字 点击矩形 会导致死循环
                // FindAnnotTypeKey(StrAnnotToolChecked, ref annotArgs);

                CleanPropertyPanel();
                switch (PropertyPanel.SharpsAnnot)
                {
                    case "Rect":
                        GetRect();
                        break;

                    case "Circle":
                        GetCircle();
                        break;

                    case "Arrow":
                        GetArrowLine("Arrow");
                        break;

                    case "Line":
                        GetArrowLine("Line");
                        break;
                }
                //return; //暂时不知道会不会影响效果，先注释
            }
        }

        /// <summary>
        /// 设置选中注释工具高亮、下划线、删除线， 点击阅读页空白时候显示内容
        /// </summary>
        private void SetTextAnnotProperty()
        {
            switch (StrAnnotToolChecked)
            {
                case "HighLight"://字体高亮
                    CleanPropertyPanel();
                    if (selectedAnnotation != null)
                    {
                        if (selectedAnnotation.EventType == AnnotArgsType.AnnotHighlight)
                        {
                            GetHighLight();
                        }
                    }
                    else
                    {
                        GetHighLight();
                    }

                    break;

                case "UnderLine"://下划线
                    CleanPropertyPanel();
                    if (selectedAnnotation != null)
                    {
                        if (selectedAnnotation.EventType == AnnotArgsType.AnnotUnderline)
                        {
                            GetUnderLine();
                        }
                    }
                    else
                    {
                        GetUnderLine();
                    }
                    break;

                case "Strikeout"://删除线
                    CleanPropertyPanel();

                    if (selectedAnnotation != null)
                    {
                        if (selectedAnnotation.EventType == AnnotArgsType.AnnotStrikeout)
                        {
                            GetStrikeout();
                        }
                    }
                    else
                    {
                        GetStrikeout();
                    }
                    break;
            }
        }

        /// <summary>
        ///未选注释工具-形状注释，选中形状注释，属性面板不显示（矩形、圆、线、箭头）
        ///未选注释工具-手绘，选中手绘注释，属性面板不显示橡皮擦
        /// </summary>
        /// <param name="annot"></param>
        private void SetPropertyPanelValue(AnnotHandlerEventArgs annot)
        {
            if (StrAnnotToolChecked != "Rect"
                                && (annot.EventType == AnnotArgsType.AnnotSquare ||
                                        annot.EventType == AnnotArgsType.AnnotCircle ||
                                        annot.EventType == AnnotArgsType.AnnotLine))
            {
                PropertyPanel.IsSharpAnnotSelected = false;
            }
            else
            {
                PropertyPanel.IsSharpAnnotSelected = true;
            }
            if (StrAnnotToolChecked != "Freehand" && annot.EventType == AnnotArgsType.AnnotFreehand)
            {
                PropertyPanel.IsFreeHandSelected = false;
            }
            else
            {
                PropertyPanel.IsFreeHandSelected = true;
            }
            isShowPropertyPanel = ViewContentViewModel.IsPropertyOpen;
        }

        private void CleanPropertyPanel()
        {
            PropertyPanel.annot = null;
            PropertyPanel.AnnotEvents = null;
            PropertyPanel.AnnotEvent = null;
            PropertyPanel.annotlists = null;
        }

        /// <summary>
        /// 注释列表同步选中
        /// </summary>
        /// <param name="e"></param>
        private void SelectedBotaAnnotationList(AnnotAttribEvent e)
        {
            #region 之前版本
            //var list = e.GetPageAnnotsIndex();
            //bool isTabItemAnnotation = IsBOTATabItemShow(out BOTAContentViewModel bOTAContentViewModel, out BOTAContent bOTAContent, "TabItemAnnotation");
            ////if (viewContentViewModel.OpenBOTA == false || isTabItemAnnotation == false || bOTAContent.TabItemAnnotation.IsSelected == false)
            ////{
            ////    viewContentViewModel.OpenBOTA = true;
            ////    bOTAContent.TabItemAnnotation.IsSelected = true;
            ////}
            //if (ViewContentViewModel.OpenBOTA == true && isTabItemAnnotation == true /*&& bOTAContent.TabItemAnnotation.IsSelected == true*/ && list != null && list.Count > 0)
            //{
            //    if (list.Keys.Count == 0)
            //    {
            //        return;
            //    }
            //    var pageindex = new List<int>(list.Keys);
            //    List<int> annotes = new List<int>();
            //    list.TryGetValue(pageindex[0], out annotes);
            //    int annoteindex = annotes[0];
            //    AnnotationContentViewModel viewModel = GetAnnotationContentViewModel(bOTAContentViewModel, out AnnotationContent annotation);

            //    if (viewModel != null)
            //    {
            //        selectedAnnotation = viewModel.AnnotationListItems.FindFirst(a => a.PageIndex == pageindex[0] && a.AnnotIndex == annoteindex);
            //        viewModel.ScrollToAnnot(pageindex[0], annoteindex, annotation.AnnotationList);
            //    }
            //}
            #endregion 之前版本
            var list = e.GetPageAnnotsIndex();
            if (list != null && list.Count > 0 && ViewContentViewModel.mainViewModel.AnnotMouseLeftButtonDown == false)
            {
                if (list.Keys.Count == 0)
                {
                    return;
                }
                var pageindex = new List<int>(list.Keys);
                List<int> annotes = new List<int>();
                list.TryGetValue(pageindex[0], out annotes);
                int annoteindex = annotes[0];

                bool isTabItemAnnotation = IsBOTATabItemShow(out BOTAContentViewModel bOTAContentViewModel, out BOTAContent bOTAContent, "TabItemAnnotation");
                if (ViewContentViewModel.OpenBOTA == false)
                {
                    bOTAContentViewModel.OpenBOTA();
                }
                if (bOTAContent.TabItemAnnotation.IsSelected == false)
                {
                    bOTAContent.TabItemAnnotation.IsSelected = true;
                }

                AnnotationContentViewModel viewModel = GetAnnotationContentViewModel(bOTAContentViewModel, out AnnotationContent annotation);

                if (viewModel != null)
                {
                    selectedAnnotation = viewModel.AnnotationListItems.FindFirst(a => a.PageIndex == pageindex[0] && a.AnnotIndex == annoteindex);
                    viewModel.ScrollToAnnot(pageindex[0], annoteindex, annotation.AnnotationList);
                }
            }
        }

        //在注释工具的状态下，右键菜单
        private void PDFViewer_AnnotCommandHandler(object sender, AnnotCommandArgs e)
        {
            if (e.AnnotEventArgsList == null || (PDFViewer != null && PDFViewer.MouseMode == MouseModes.FormEditTool))
                return;

            if ((UIElement)sender != null)
            {
                //绑定命令执行前的拦截事件，对于未解密权限的文档进行复制限制
                CommandManager.AddPreviewExecutedHandler((UIElement)sender, PreviewExcute);
            }

            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
                        {
                            if (e.AnnotEventArgsList.Count == 1)
                            {
                                var selectedAnnot = e.AnnotEventArgsList[0];
                                PopMenuCheckedLineDash(selectedAnnot);
                                PopMenuCheckedFontFamily(selectedAnnot);
                                PopMenuCheckedTextAglin(selectedAnnot);

                                switch (selectedAnnot.EventType)
                                {
                                    case AnnotArgsType.AnnotHighlight:
                                    case AnnotArgsType.AnnotUnderline:
                                    case AnnotArgsType.AnnotStrikeout:
                                    case AnnotArgsType.AnnotSquiggly:
                                        if (selectedAnnot.EventType == AnnotArgsType.AnnotHighlight)
                                        {
                                            colorContent.ItemSource = AnnotColorList.GetColorList(ColorSelectorType.Highlight);
                                        }
                                        else
                                        {
                                            colorContent.ItemSource = AnnotColorList.GetColorList(ColorSelectorType.Border);
                                        }

                                        e.PopupMenu = HightAnnotPopMenu.OpenMenu(selectedAnnot, sender);
                                        break;

                                    case AnnotArgsType.AnnotFreehand:
                                        e.PopupMenu = FreeHandAnnotPopMenu.OpenMenu(selectedAnnot, sender);
                                        break;

                                    case AnnotArgsType.AnnotFreeText:
                                        e.PopupMenu = FreeTextAnnotPopMenu.OpenMenu(selectedAnnot, sender);
                                        break;

                                    case AnnotArgsType.AnnotSticky:
                                        e.PopupMenu = StrickNoteAnnotPopMenu.OpenMenu(selectedAnnot, sender);
                                        break;

                                    case AnnotArgsType.AnnotSquare:
                                    case AnnotArgsType.AnnotCircle:
                                        ShapeAnnotPopMenu.SetVisual("ShapeDirect", false);
                                        ShapeAnnotPopMenu.SetVisual("ShapeFillColor", true);
                                        e.PopupMenu = ShapeAnnotPopMenu.OpenMenu(selectedAnnot, sender);
                                        break;

                                    case AnnotArgsType.AnnotLine:
                                        ShapeAnnotPopMenu.SetVisual("ShapeFillColor", false);
                                        ShapeAnnotPopMenu.SetVisual("ShapeDirect", true);
                                        e.PopupMenu = ShapeAnnotPopMenu.OpenMenu(selectedAnnot, sender);
                                        break;

                                    case AnnotArgsType.AnnotLink:
                                        e.PopupMenu = LinkAnnotPopMenu.OpenMenu(selectedAnnot, sender);
                                        break;

                                    case AnnotArgsType.AnnotStamp:
                                        e.PopupMenu = StampAnnotPopMenu.OpenMenu(selectedAnnot, sender);
                                        break;
                                }
                            }
                            else
                            {
                                bool isHigh = true;//是否为高亮
                                foreach (var item in e.AnnotEventArgsList)
                                {
                                    if (AnnotTransfer.IsHightAnnot(item) == false)
                                    {
                                        isHigh = false;
                                        break;
                                    }
                                }

                                MultiAnnotPopMenu.SetVisual("MultiCopy", !isHigh);
                                MultiAnnotPopMenu.SetVisual("MultiCut", !isHigh);
                                e.PopupMenu = MultiAnnotPopMenu.OpenMenu(e.AnnotEventArgsList, sender);
                            }
                        }
                        if (e.PopupMenu != null)
                        {
                            e.Handle = true;
                        }
                    }
                    else
                    {
                        if (e.PressOnSelectedText || e.CommandTarget == TargetType.ImageSelection)
                        {
                            //右键添加注释，形状注释添加之后会选中
                            ViewContentViewModel.mainViewModel.AnnotMouseLeftButtonDown = true;
                            e.PopupMenu = SelectedTextOrImageContextMenu(sender, e);
                            if (e.PopupMenu != null)
                            {
                                e.Handle = true;
                            }
                        }
                        else
                        {
                            e.PopupMenu = ViewerContextMenu(sender);
                            if (e.PopupMenu != null)
                            {
                                e.Handle = true;
                            }
                        }
                    }
                    break;

                default:
                    e?.DoCommand();
                    break;
            }
        }

        private void PreviewExcute(object sender, ExecutedRoutedEventArgs e)
        {
            if (e.Command == ApplicationCommands.Copy || e.Command == ApplicationCommands.Cut)
            {
                if (!ViewContentViewModel.CheckPermissionBeforeOption())
                {
                    //没有权限，或者权限解密不成功时，拦截该命令
                    e.Handled = true;
                }
            }
        }

        /// <summary>
        /// 右键菜单，选中字体样式按钮状态
        /// </summary>
        /// <param name="annot"></param>
        private void PopMenuCheckedFontFamily(AnnotHandlerEventArgs annot)
        {
            if (annot != null)
            {
                if (annot.EventType == AnnotArgsType.AnnotFreeText)
                {
                    var freeText = annot as FreeTextAnnotArgs;
                    string fontFamily = freeText.FontName;
                    if (fontFamily == "Arial")
                    {
                        fontFamily = "Helvetica";
                    }
                    if (fontFamily == "Courier New")
                    {
                        fontFamily = "Courier";
                    }
                    if (fontFamily == "Times New Roman")
                    {
                        fontFamily = "Times";
                    }
                    FreeTextAnnotPopMenu.SetIsChecked(fontFamily, true);
                }
            }
        }

        /// <summary>
        /// 右键菜单，选中文本内容对齐按钮状态
        /// </summary>
        /// <param name="annot"></param>
        private void PopMenuCheckedTextAglin(AnnotHandlerEventArgs annot)
        {
            if (annot != null)
            {
                if (annot.EventType == AnnotArgsType.AnnotFreeText)
                {
                    var freeText = annot as FreeTextAnnotArgs;
                    switch (freeText.Align)
                    {
                        case TextAlignment.Left:
                            FreeTextAnnotPopMenu.SetIsChecked("FreeTextAglinLeft", true);
                            break;

                        case TextAlignment.Center:
                            FreeTextAnnotPopMenu.SetIsChecked("FreeTextAglinCenter", true);
                            break;

                        case TextAlignment.Right:
                            FreeTextAnnotPopMenu.SetIsChecked("FreeTextAglinRight", true);
                            break;

                        case TextAlignment.Justify:
                            FreeTextAnnotPopMenu.SetIsChecked("FreeTextAglinJustify", true);
                            break;

                        default:
                            FreeTextAnnotPopMenu.SetIsChecked("FreeTextAglinLeft", false);
                            FreeTextAnnotPopMenu.SetIsChecked("FreeTextAglinCenter", false);
                            FreeTextAnnotPopMenu.SetIsChecked("FreeTextAglinRight", false);
                            FreeTextAnnotPopMenu.SetIsChecked("FreeTextAglinJustify", false);
                            break;
                    }
                }
            }
        }

        //右键菜单，选中虚实线按钮状态
        private void PopMenuCheckedLineDash(AnnotHandlerEventArgs annot)
        {
            if (annot != null)
            {
                bool isSolidLineDash = true;
                if (annot.EventType == AnnotArgsType.AnnotFreehand)
                {
                    var freeHand = annot as FreehandAnnotArgs;
                    isSolidLineDash = AnnotTransfer.IsSolidStyle(freeHand.LineDash);
                    FreeHandAnnotPopMenu.SetIsChecked(isSolidLineDash ? "FreeHandSolid" : "FreeHandDash", true);
                }
                else if (annot.EventType == AnnotArgsType.AnnotSquare)
                {
                    var square = annot as SquareAnnotArgs;
                    isSolidLineDash = AnnotTransfer.IsSolidStyle(square.LineDash);
                    ShapeAnnotPopMenu.SetIsChecked(isSolidLineDash ? "ShapeSolid" : "ShapeDash", true);
                }
                else if (annot.EventType == AnnotArgsType.AnnotCircle)
                {
                    var circle = annot as CircleAnnotArgs;
                    isSolidLineDash = AnnotTransfer.IsSolidStyle(circle.LineDash);
                    ShapeAnnotPopMenu.SetIsChecked(isSolidLineDash ? "ShapeSolid" : "ShapeDash", true);
                }
                else if (annot.EventType == AnnotArgsType.AnnotLine)
                {
                    var line = annot as LineAnnotArgs;
                    isSolidLineDash = AnnotTransfer.IsSolidStyle(line.LineDash);
                    ShapeAnnotPopMenu.SetIsChecked(isSolidLineDash ? "ShapeSolid" : "ShapeDash", true);
                }
            }
        }

        /// <summary>
        /// 内容选择工具
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void PDFViewer_SnapshotCommandHandler(object sender, SnapshotCommandArgs e)
        {
            SnapshotEditToolArgs snapToolArgs = new SnapshotEditToolArgs();
            if (PDFViewer.ToolManager.CurrentAnnotArgs is SnapshotEditToolArgs)
            {
                snapToolArgs = (SnapshotEditToolArgs)PDFViewer.ToolManager.CurrentAnnotArgs;

                SnapshotEditMenuViewModel.SnapToolArgs = snapToolArgs;
                SnapshotEditMenuViewModel.PDFViewer = PDFViewer;
                SnapshotEditMenuViewModel.areaCropPageUndoManager = new AreaCropPageUndoManager(PDFViewer);
                SnapshotEditMenuViewModel.SnapToolEvent -= SnapshotEditMenuViewModel_SnapToolEvent; ;
                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;
                    }

                    //解决内容选择器 右键菜单闪现消失的问题，sdk库有更新，需要确认哪边提交
                    System.Threading.Tasks.Task.Factory.StartNew(() =>
                    {
                        System.Threading.Thread.Sleep(200);
                        PDFViewer.Dispatcher.Invoke(() =>
                        {
                            popMenu.IsOpen = true;
                            popMenu.StaysOpen = true;
                        });
                    });
                }
            }
        }

        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;
                                //BtnHandIsChecked = true;
                                PDFViewer.EnableZoom(true);
                                PDFViewer.EnableScroll(true);
                                PDFViewer.SetMouseMode(MouseModes.PanTool);
                                HandToolIsCheckedEvent(false);
                                break;
                        }
                    }
                    break;

                default:
                    break;
            }
        }

        private void PDFViewer_AnnotEditHandler(object sender, List<AnnotEditEvent> e)
        {
            bool isTabItemAnnotation = IsBOTATabItemShow(out BOTAContentViewModel bOTAContentViewModel, out BOTAContent bOTAContent, "TabItemAnnotation");
            AnnotationContentViewModel viewModel = null;
            AnnotationContent annotation = null;
            //OpenBOTA关闭时也要进入
            //if (viewContentViewModel.OpenBOTA == false)
            //{
            viewModel = GetAnnotationContentViewModel(bOTAContentViewModel, out annotation);
            //}
            bool isMultiple = false;
            Dictionary<int, List<int>> selectAnnotDicts = new Dictionary<int, List<int>>();
            Dictionary<int, List<int>> selectFreehandDicts = new Dictionary<int, List<int>>();

            if (e != null && e.Count > 0)
            {
                for (int i = 0; i < e.Count; i++)
                {
                    AnnotEditEvent editEvent = e[i];

                    bool isVisible = PDFViewer.CheckAnnotVisible(editEvent.PageIndex, editEvent.AnnotIndex);

                    var annot = editEvent.EditAnnotArgs;
                    switch (editEvent.EditAction)
                    {
                        case ActionType.Add:

                            #region 区分复制填写签名图形

                            if (IsPasteShape)
                            {
                                if (editEvent.EditAnnotArgs.EventType == AnnotArgsType.AnnotFreehand)
                                {
                                    if (ShapeNames.Count != 0 && ShapeNames[i] != "Annot")
                                    {
                                        try
                                        {
                                            ViewContentViewModel.FillAndSign.Add(new FillAndSignIsShape(editEvent.PageIndex, editEvent.AnnotIndex, ShapeNames[i]));
                                        }
                                        catch { }
                                    }
                                }
                            }

                            #endregion 区分复制填写签名图形

                            if (ViewContentViewModel.CurrentBar != "TabItemAnnotation")
                            {
                                //填写与签名在此区域不选中，不添加selectAnnotDicts词典当中
                            }
                            else
                            {
                                if (PropertyPanel.IsMultiSelected)
                                {
                                    if (selectAnnotDicts.ContainsKey(editEvent.PageIndex) == false)
                                    {
                                        selectAnnotDicts.Add(editEvent.PageIndex, new List<int>());
                                        selectAnnotDicts[editEvent.PageIndex].Add(editEvent.AnnotIndex);
                                    }
                                    else
                                    {
                                        selectAnnotDicts[editEvent.PageIndex].Add(editEvent.AnnotIndex);
                                    }
                                    isMultiple = true;
                                }
                                else
                                {
                                    if (
                                        annot.EventType == AnnotArgsType.AnnotSquare || annot.EventType == AnnotArgsType.AnnotCircle ||
                                        annot.EventType == AnnotArgsType.AnnotLine || annot.EventType == AnnotArgsType.AnnotStamp

                                /*|| annot.EventType == AnnotArgsType.AnnotSticky ||annot.EventType == AnnotArgsType.AnnotFreeText */)
                                    {
                                        if (selectAnnotDicts.ContainsKey(editEvent.PageIndex) == false)
                                        {
                                            selectAnnotDicts.Add(editEvent.PageIndex, new List<int>());
                                            selectAnnotDicts[editEvent.PageIndex].Add(editEvent.AnnotIndex);
                                        }
                                        else
                                        {
                                            selectAnnotDicts[editEvent.PageIndex].Add(editEvent.AnnotIndex);
                                        }
                                        isMultiple = true;
                                    }
                                    //添加后不选中的注释，需要额外处理
                                    if (annot.EventType == AnnotArgsType.AnnotFreehand || annot.EventType == AnnotArgsType.AnnotSticky || annot.EventType == AnnotArgsType.AnnotFreeText)
                                    {
                                        if (selectFreehandDicts.ContainsKey(editEvent.PageIndex) == false)
                                        {
                                            selectFreehandDicts.Add(editEvent.PageIndex, new List<int>());
                                            selectFreehandDicts[editEvent.PageIndex].Add(editEvent.AnnotIndex);
                                        }
                                        else
                                        {
                                            selectFreehandDicts[editEvent.PageIndex].Add(editEvent.AnnotIndex);
                                        }
                                        isMultiple = true;
                                    }
                                    //复制后 粘贴选中
                                    if (annot.EventType == AnnotArgsType.AnnotLink)
                                    {
                                        PDFViewer.SelectAnnotation(annot.PageIndex, annot.AnnotIndex);
                                    }
                                }
                            }

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

                            //添加签名注释，用于未保存前跟图章手绘注释的区分
                            if (StrAnnotToolChecked == "Signature")
                            {
                                AddAnnotSignature(editEvent.EditAnnotArgs);
                            }

                            //if (editEvent.EditAnnotArgs.EventType == AnnotArgsType.AnnotFreeText)
                            //{
                            //    (editEvent.EditAnnotArgs as FreeTextAnnotArgs).LineWidth = 0;
                            //}

                            break;

                        case ActionType.Modify:
                            //undo/redo，字体大小联动，刷新属性面板数据
                            if (string.IsNullOrEmpty(StrAnnotToolChecked) == false)
                            {
                                List<AnnotHandlerEventArgs> selectedArgs = new List<AnnotHandlerEventArgs>() { annot };
                                switch (annot.EventType)
                                {
                                    case AnnotArgsType.AnnotFreeText://文本
                                        GetFreetext(selectedArgs);
                                        break;
                                }
                            }
                            if (viewModel != null)
                            {
                                int pageindex = editEvent.PageIndex;
                                int annotindex = editEvent.AnnotIndex;
                                viewModel.UpdateModifiedAnnot(pageindex, annotindex);
                            }
                            break;

                        case ActionType.Del:
                            //isTabItemAnnotation = IsBOTATabItemShow(out bOTAContentViewModel, out bOTAContent, "TabItemAnnotation");
                            //if (viewContentViewModel.OpenBOTA == true && bOTAContent.TabItemAnnotation.IsSelected)
                            //{
                            //    AnnotationContentViewModel viewModel = GetAnnotationContentViewModel(bOTAContentViewModel, out AnnotationContent annotation);
                            #region//填写与签名 删除缓存信息列表
                            //if (Shape != "None")
                            //{
                            for (int j = 0; j < ViewContentViewModel.FillAndSign.Count; j++)
                            {
                                if (ViewContentViewModel.FillAndSign[j].PageIndex == editEvent.PageIndex && ViewContentViewModel.FillAndSign[j].AnnotIndex == editEvent.AnnotIndex)
                                {
                                    ViewContentViewModel.FillAndSign.Remove(ViewContentViewModel.FillAndSign[j]);
                                }
                            }
                            for (int j = 0; j < ViewContentViewModel.AnnotSignatures.Count; j++)
                            {
                                if (ViewContentViewModel.AnnotSignatures[j].Item1 == editEvent.PageIndex && ViewContentViewModel.AnnotSignatures[j].Item2 == editEvent.AnnotIndex)
                                {
                                    ViewContentViewModel.AnnotSignatures.Remove(ViewContentViewModel.AnnotSignatures[j]);
                                }
                            }
                            //}
                            #endregion PDFViewer事件
                            if (viewModel != null)
                            {
                                int pageindex = editEvent.PageIndex;
                                int annotindex = editEvent.AnnotIndex;
                                viewModel.DeleteModifiedAnnot(pageindex, annotindex);
                            }
                            if (string.IsNullOrEmpty(StrAnnotToolChecked))
                            {
                                if (ViewContentViewModel.CurrentBar != "TabItemAnnotation")
                                {
                                    //填写与签名在此区域不选中，不添加selectAnnotDicts词典当中
                                }
                                else
                                {
                                    ExitAnnotationTool();
                                    ViewContentViewModel.SelectedPrpoertyPanel("PropertyPanelContent", null);
                                }
                            }
                            else
                            {
                                switch (StrAnnotToolChecked)
                                {
                                    case "Link":
                                        PropertyPanel.IsAddLink = true;
                                        GetLink();
                                        events.GetEvent<LinkAnnotTipCloseEvent>().Publish(new LinkAnnotTipCloseArgs() { UniCode = App.mainWindowViewModel.SelectedItem.Unicode });
                                        break;
                                }
                            }

                            break;

                        case ActionType.TextEdit:
                            break;

                        default:
                            break;
                    }
                }
                IsPasteShape = false;

                SetMultipleAnnot(isMultiple, selectAnnotDicts, selectFreehandDicts);
                //MultipleSelectionAnnot(e);
                //空白处 右键菜单 添加注释   为单次添加，不连续添加
                if (IsNoSelectMenu && PropertyPanel.IsAddLink == false)
                {
                    ViewContentViewModel.ReadModeIsShowProperty = false;
                    IsNoSelectMenu = false;
                    ExitAnnotationTool();
                }
                if (ViewContentViewModel.IsRightMenuSelectedTextAddLink == false)
                {
                    ViewContentViewModel.ReadModeIsShowProperty = false;
                }
            }
        }

        /// <summary>
        /// 设置多选注释
        /// </summary>
        /// <param name="isMultiple"></param>
        /// <param name="selectAnnotDicts">添加后选中的注释</param>
        /// <param name="selectFreehandDicts">添加后不选中的注释，需要额外处理</param>
        private void SetMultipleAnnot(bool isMultiple, Dictionary<int, List<int>> selectAnnotDicts, Dictionary<int, List<int>> selectFreehandDicts)
        {
            if (isMultiple)
            {
                Dictionary<int, List<int>> dict = new Dictionary<int, List<int>>();
                //阅读页多选注释，只能在当前页多选，不可以跨页多选
                if (selectAnnotDicts.Count >= 1)
                {
                    PDFViewer.ClearSelectAnnots();
                    //if (StrAnnotToolChecked != "Signature")
                    //{
                    PDFViewer.SelectAnnotation(selectAnnotDicts);

                    if (selectFreehandDicts.Count >= 1)
                    {
                        if (selectFreehandDicts.FirstOrDefault().Value.Count > 1)
                        {
                            //先把键都合并到dict中，值都是新创建的
                            foreach (var key in selectAnnotDicts.Keys)
                            {
                                if (!dict.ContainsKey(key))
                                {
                                    dict.Add(key, new List<int>());
                                }
                            }

                            foreach (var key in selectFreehandDicts.Keys)
                            {
                                if (!dict.ContainsKey(key))
                                {
                                    dict.Add(key, new List<int>());
                                }
                            }

                            //分别将值添加进去
                            foreach (var ele in selectAnnotDicts)
                            {
                                dict[ele.Key].AddRange(ele.Value);
                            }

                            foreach (var ele in selectFreehandDicts)
                            {
                                dict[ele.Key].AddRange(ele.Value);
                            }
                            //Dictionary<int, List<int>> items2 = selectAnnotDicts.Union(selectFreehandDicts).ToDictionary(k => k.Key, v => v.Value);

                            PDFViewer.ClearSelectAnnots();
                            PDFViewer.SelectAnnotation(dict);
                        }
                        //}
                    }
                }
                else
                {
                    if (selectFreehandDicts.Count >= 1)
                    {
                        if (selectFreehandDicts.FirstOrDefault().Value.Count > 1)
                        {
                            PDFViewer.ClearSelectAnnots();
                            PDFViewer.SelectAnnotation(selectFreehandDicts);
                        }
                    }
                }
            }
            #region 之前版本
            //if (isMultiple && selectAnnotDicts.Count >= 1)
            //{
            //    //PDFViewer.DisableClearSelectAnnot(false);
            //    PDFViewer.ClearSelectAnnots();

            //    if (StrAnnotToolChecked != "Signature")
            //    {
            //        //PDFViewer.DisableClearSelectAnnot(true);
            //        PDFViewer.SelectAnnotation(selectAnnotDicts);
            //        //禁止取消选中注释
            //        //PDFViewer.DisableClearSelectAnnot(false);
            //    }
            //}
            //if (isMultiple && selectFreehandDicts.Count >= 1)
            //{
            //    PDFViewer.ClearSelectAnnots();
            //    if (selectFreehandDicts.FirstOrDefault().Value.Count >= 1)
            //    {
            //        PDFViewer.SelectAnnotation(selectFreehandDicts);
            //    }
            //}
            #endregion 之前版本
        }

        //复制多个注释，粘贴后，默认注释未选中状态
        private void MultipleSelectionAnnot(List<AnnotEditEvent> e)
        {
            bool isAdd = false;
            Dictionary<int, List<int>> selectAnnotDicts = new Dictionary<int, List<int>>();

            foreach (var item in e)
            {
                if (item.EditAction == ActionType.Add || item.EditAction == ActionType.Modify)
                {
                    var annot = item.EditAnnotArgs;
                    if (annot.EventType == AnnotArgsType.AnnotSquare || annot.EventType == AnnotArgsType.AnnotCircle ||
                        annot.EventType == AnnotArgsType.AnnotLine || annot.EventType == AnnotArgsType.AnnotStamp || annot.EventType == AnnotArgsType.AnnotFreeText || annot.EventType == AnnotArgsType.AnnotFreehand)
                    {
                        if (selectAnnotDicts.ContainsKey(item.PageIndex) == false)
                        {
                            selectAnnotDicts.Add(item.PageIndex, new List<int>());
                            selectAnnotDicts[item.PageIndex].Add(item.AnnotIndex);
                        }
                        else
                        {
                            selectAnnotDicts[item.PageIndex].Add(item.AnnotIndex);
                        }

                        isAdd = true;
                    }
                }
            }

            if (isAdd && selectAnnotDicts.Count >= 1)
            {
                PDFViewer.ClearSelectAnnots();

                if (StrAnnotToolChecked != "Signature")
                {
                    PDFViewer.SelectAnnotation(selectAnnotDicts);
                }
            }
        }

        //阅读页悬浮相应
        /// <summary>
        /// 阅读页鼠标悬浮在注释上的虚线
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void PDFViewer_AnnotHoverHandler(object sender, AnnotHoverData e)
        {
            if (e != null && e.DrawContext != null)
            {
                //if (StrAnnotToolChecked == "Freetext")
                //{
                //    if ((e.Annot is CPDFFreeTextAnnotation annotation) == false)
                //    {
                //        isDown = false;
                //        Trace.WriteLine(isDown);
                //        return;
                //    }
                //    else
                //    {
                //        isDown=true;
                //        Trace.WriteLine(isDown);
                //    }
                //}
                if (StrAnnotToolChecked != "Link")
                {
                    if (e.Annot is CPDFLinkAnnotation linkAnnotation)
                    {
                        return;
                    }
                }
                if (StrAnnotToolChecked == "Freehand" || (IsNoSelectMenu && isRightMenuAddAnnot))
                {
                    return;
                }
                Rect hoverRect = new Rect(
                    e.PaintRect.Left - 2,
                    e.PaintRect.Top - 2,
                    e.PaintRect.Width + 4,
                    e.PaintRect.Height + 4);
                if (e.Annot is CPDFTextAnnotation sticky)
                {
                    hoverRect = new Rect(
                   e.PaintRect.Left - 2,
                   e.PaintRect.Top + 2,
                   e.PaintRect.Width + 5,
                   e.PaintRect.Height + 2);
                }

                Pen hoverPen = new Pen(new SolidColorBrush(Color.FromArgb(0xff, 0x11, 0x8A, 0xff)), 1);
                hoverPen.DashStyle = DashStyles.Dash;
                e.DrawContext?.DrawRectangle(null, hoverPen, hoverRect);

                //便签，显示ToolTip内容
                if (e.Annot != null && e.Annot.Type == C_ANNOTATION_TYPE.C_ANNOTATION_TEXT)
                {
                    PopAnnotToolTip(e.Annot.GetRect(), hoverRect, e.Annot.GetContent());
                    return;
                }
            }

            CloseAnnotToolTip();
        }

        private void PDFViewer_MouseMove(object sender, MouseEventArgs e)
        {
            if (sender != null && PDFViewer.ToolTip != null && PDFViewer.Parent != null)
            {
                //鼠标移到注释之外，关闭ToolTip浮窗
                var newPoint = e.GetPosition(PDFViewer.Parent as ContentControl);
                var isOutw = newPoint.X > (oldRect.X + oldRect.Width + 4);
                var isOuth = newPoint.Y > (oldRect.Y + oldRect.Height + 4);
                if (newPoint.X < oldRect.X || newPoint.Y < oldRect.Y || isOutw || isOuth)
                {
                    CloseAnnotToolTip();
                }
            }
        }

        private Rect oldRect = new Rect(0, 0, 0, 0);

        private void PopAnnotToolTip(CRect placementRect, Rect hoverRect, string content)
        {
            //便签，显示ToolTip内容
            if (PDFViewer.ToolTip == null)
            {
                if (string.IsNullOrEmpty(content) == false)
                {
                    ToolTip TipChild = new ToolTip();
                    TipChild.Style = App.Current.Resources["FlowToolTip"] as Style;
                    TipChild.MaxWidth = 246;
                    TipChild.Content = content;
                    TipChild.Visibility = Visibility.Visible;
                    TipChild.IsOpen = true;
                    TipChild.Placement = PlacementMode.Right;
                    TipChild.PlacementRectangle = new Rect(placementRect.left, placementRect.top, placementRect.right, placementRect.bottom);
                    TipChild.PlacementTarget = PDFViewer.Parent as ContentControl;
                    TipChild.Placement = PlacementMode.MousePoint;
                    PDFViewer.ToolTip = TipChild;
                    oldRect = hoverRect;
                    PDFViewer.MouseMove -= PDFViewer_MouseMove;
                    PDFViewer.MouseMove += PDFViewer_MouseMove;
                }
            }
        }

        //关闭ToolTip
        private void CloseAnnotToolTip()
        {
            if (PDFViewer.ToolTip != null && PDFViewer.ToolTip is ToolTip)
            {
                ToolTip oldTips = (ToolTip)PDFViewer.ToolTip;
                oldTips.IsOpen = false;
                oldTips.Visibility = Visibility.Collapsed;
                PDFViewer.ToolTip = null;
                PDFViewer.MouseMove -= PDFViewer_MouseMove;
                oldRect = new Rect(0, 0, 0, 0);
            }
        }

        #endregion PDFViewer事件

        #region BindingEvent事件

        //同一属性面板，不同的注释类型
        private void AnnotPropertyPanel_AnnotTypeChanged(object sender, Dictionary<AnnotArgsType, object> e)
        {
            if (e != null && sender is SharpsAnnotPropertyViewModel sharpsAnnot)
            {
                AnnotHandlerEventArgs annotArgs = null;
                //PropertyPanel.SaveLastAnnot();
                List<AnnotHandlerEventArgs> annots = new List<AnnotHandlerEventArgs>();

                foreach (AnnotArgsType argsType in e.Keys)
                {
                    if (PropertyPanel.annot != null)
                    {
                        if (PropertyPanel.annot.EventType != argsType)
                        {
                            PDFViewer.DisableClearSelectAnnot(false);
                            PDFViewer.ClearSelectAnnots();
                            PDFViewer.SetMouseMode(MouseModes.PanTool);

                            CurrentSelectedAnnot = null;
                        }
                    }
                    switch (argsType)
                    {
                        case AnnotArgsType.AnnotSquare:

                            #region TO DO

                            //选择一个形状注释A，在选择B（非多选），修改属性成功，以下操作的操作可以解决，
                            //可能会出现选择注释A，鼠标直接点击属性面板，注释A取消选中，但还可以对注释A更改属性的BUG
                            if (CurrentSelectedAnnot != null)
                            {
                                if (CurrentSelectedAnnot.EventType == AnnotArgsType.AnnotSquare)
                                {
                                    //CurrentSelectedAnnot.PageIndex = -1;
                                    //CurrentSelectedAnnot.AnnotIndex = -1;
                                    CurrentSelectedAnnot.ClientRect = Rect.Empty;
                                    annots.Add(CurrentSelectedAnnot);
                                }
                            }
                            if (annots.Count > 0)
                            {
                                annotArgs = GetRect(annots);
                            }
                            else
                            {
                                annotArgs = GetRect();
                            }

                            #endregion TO DO

                            //annotArgs = GetRect();
                            break;

                        case AnnotArgsType.AnnotCircle:

                            #region TO DO

                            if (CurrentSelectedAnnot != null)
                            {
                                if (CurrentSelectedAnnot.EventType == AnnotArgsType.AnnotCircle)
                                {
                                    //CurrentSelectedAnnot.PageIndex = -1;
                                    //CurrentSelectedAnnot.AnnotIndex = -1;
                                    CurrentSelectedAnnot.ClientRect = Rect.Empty;
                                    annots.Add(CurrentSelectedAnnot);
                                }
                            }
                            if (annots.Count > 0)
                            {
                                annotArgs = GetCircle(annots);
                            }
                            else
                            {
                                annotArgs = GetCircle();
                            }

                            #endregion TO DO

                            //annotArgs = GetCircle();
                            break;

                        case AnnotArgsType.AnnotLine:
                            var LineTag = e[argsType] as string;

                            #region TO DO

                            if (CurrentSelectedAnnot != null)
                            {
                                if (CurrentSelectedAnnot.EventType == AnnotArgsType.AnnotLine)
                                {
                                    //CurrentSelectedAnnot.PageIndex = -1;
                                    //CurrentSelectedAnnot.AnnotIndex = -1;
                                    CurrentSelectedAnnot.ClientRect = Rect.Empty;
                                    if (CurrentSelectedAnnot is LineAnnotArgs lineAnnotArgs)
                                    {
                                        if (lineAnnotArgs.HeadLineType >= (C_LINE_TYPE)1 || lineAnnotArgs.TailLineType >= (C_LINE_TYPE)1)
                                        {
                                            if (LineTag == "Arrow")
                                            {
                                                annots.Add(CurrentSelectedAnnot);
                                            }
                                        }
                                        else
                                        {
                                            if (LineTag == "Line")
                                            {
                                                annots.Add(CurrentSelectedAnnot);
                                            }
                                        }
                                    }
                                }
                            }
                            if (annots.Count > 0)
                            {
                                annotArgs = GetArrowLine(LineTag, annots);
                            }
                            else
                            {
                                annotArgs = GetArrowLine(LineTag);
                            }

                            #endregion TO DO

                            //annotArgs = GetArrowLine(LineTag);
                            break;
                    }
                    ShowPropertyPanel();
                    if (string.IsNullOrEmpty(StrAnnotToolChecked) || StrAnnotToolChecked != "Rect")
                    {
                        //PDFViewer.SetMouseMode(MouseModes.PanTool);
                        return;
                    }
                    if (annotArgs != null)
                    {
                        annotArgs.Author = Settings.Default.AppProperties.Description.Author;
                        PDFViewer.SetMouseMode(MouseModes.AnnotCreate);
                        PDFViewer.SetToolParam(annotArgs);
                    }
                }
            }
        }

        //来自属性面板的事件，更改颜色等属性而触发
        private void AnnotPropertyPanel_DataChanged(object sender, Dictionary<AnnotArgsType, object> e)
        {
            if (e != null)
            {
                PropertyPanel.annot.Author = Settings.Default.AppProperties.Description.Author;
                foreach (AnnotArgsType argsType in e.Keys)
                {
                    var key = ToolExpandDict.FirstOrDefault(q => q.Value == argsType);
                    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];
                            }
                            //创建注释后，修改注释属性，可用于下次创建的注释
                            if (PropertyPanel != null && PropertyPanel.annot != null && PDFViewer.MouseMode == MouseModes.AnnotCreate)
                            {
                                if (StrAnnotToolChecked == key.Key)
                                {
                                    PDFViewer.SetToolParam(PropertyPanel.annot);
                                }
                            }
                            break;

                        case AnnotArgsType.AnnotUnderline:
                            if (e[argsType] is Color)
                            {
                                UnderLineColor = new SolidColorBrush((Color)e[argsType]);
                            }
                            if (e[argsType] is double)
                            {
                                UnderLineOpacity = (double)e[argsType];
                            }
                            //创建注释后，修改注释属性，可用于下次创建的注释
                            if (PropertyPanel != null && PropertyPanel.annot != null && PDFViewer.MouseMode == MouseModes.AnnotCreate)
                            {
                                if (StrAnnotToolChecked == key.Key)
                                {
                                    PDFViewer.SetToolParam(PropertyPanel.annot);
                                }
                            }
                            break;

                        case AnnotArgsType.AnnotSquiggly:
                            if (e[argsType] is Color)
                            {
                                SquigglyColor = new SolidColorBrush((Color)e[argsType]);
                            }
                            if (e[argsType] is double)
                            {
                                SquigglyOpacity = (double)e[argsType];
                            }
                            //创建注释后，修改注释属性，可用于下次创建的注释
                            if (PropertyPanel != null && PropertyPanel.annot != null && PDFViewer.MouseMode == MouseModes.AnnotCreate)
                            {
                                if (StrAnnotToolChecked == key.Key)
                                {
                                    PDFViewer.SetToolParam(PropertyPanel.annot);
                                }
                            }
                            break;

                        case AnnotArgsType.AnnotStrikeout:
                            if (e[argsType] is Color)
                            {
                                StrikeoutColor = new SolidColorBrush((Color)e[argsType]);
                            }
                            if (e[argsType] is double)
                            {
                                StrikeoutOpacity = (double)e[argsType];
                            }
                            //创建注释后，修改注释属性，可用于下次创建的注释
                            if (PropertyPanel != null && PropertyPanel.annot != null && PDFViewer.MouseMode == MouseModes.AnnotCreate)
                            {
                                if (StrAnnotToolChecked == key.Key)
                                {
                                    PDFViewer.SetToolParam(PropertyPanel.annot);
                                }
                            }
                            break;

                        case AnnotArgsType.AnnotFreehand:

                            if (e[argsType] is FreehandAnnotArgs)
                            {
                                var annot = e[argsType] as FreehandAnnotArgs;
                                if (annot != null)
                                {
                                    if (PropertyPanel != null)
                                    {
                                        //属性面板，切换橡皮擦后，再回到画笔时，需要恢复最近画笔的属性值
                                        var AnnotEvent = AnnotAttribEvent.GetAnnotAttribEvent(annot, annot.GetAnnotAttrib(), PDFViewer);
                                        PropertyPanel.AnnotEvent = AnnotEvent;
                                        var AnnotEvents = new List<AnnotAttribEvent>();
                                        AnnotEvents.Add(AnnotEvent);
                                        PropertyPanel.AnnotEvents = AnnotEvents;
                                        PropertyPanel.annot = annot;
                                        //手绘注释工具按钮的属性
                                        // FreehandPath.Opacity = annot.Transparency;
                                        // FreehandPath.Fill = new SolidColorBrush(annot.InkColor);
                                    }
                                    if (PropertyPanel != null && PropertyPanel.annot != null && PDFViewer.MouseMode == MouseModes.AnnotCreate)
                                    {
                                        if (StrAnnotToolChecked == key.Key)
                                        {
                                            PDFViewer.SetToolParam(PropertyPanel.annot);
                                        }
                                    }
                                }
                            }

                            break;

                        case AnnotArgsType.AnnotErase:
                            if (e[argsType] is ToggleButton)
                            {
                                ToggleButton clickBtn = e[argsType] as ToggleButton;

                                if (clickBtn.IsChecked == true)
                                {
                                    if (clickBtn.Tag.ToString() != "PenBtn")
                                    {
                                        CustomIconToggleBtn btn = new CustomIconToggleBtn();
                                        btn.Tag = "Freehand";
                                        btn.IsChecked = true;
                                        BtnMyTools_Click(btn);
                                        break;
                                    }
                                    else
                                    {
                                        CreateEraseArgs();
                                    }
                                }
                            }
                            break;

                        case AnnotArgsType.AnnotSquare:
                        case AnnotArgsType.AnnotCircle:
                        case AnnotArgsType.AnnotLine:

                            //创建注释后，修改注释属性，可用于下次创建的注释
                            if (PropertyPanel != null && PropertyPanel.annot != null && PDFViewer.MouseMode == MouseModes.AnnotCreate)
                            {
                                if (StrAnnotToolChecked == "Rect")
                                {
                                    if (PropertyPanel.SharpsAnnot == key.Key || (PropertyPanel.SharpsAnnot != key.Key && key.Key == "Arrow"))
                                    {
                                        PDFViewer.SetToolParam(PropertyPanel.annot);
                                    }

                                    PropertyPanel.SaveLastAnnot();
                                }
                            }

                            break;

                        //预设 重新定义后 会将文本内容  带上
                        case AnnotArgsType.AnnotFreeText:

                            if (PropertyPanel != null && PropertyPanel.annot != null && PDFViewer.MouseMode == MouseModes.AnnotCreate)
                            {
                                if (StrAnnotToolChecked == key.Key)
                                {
                                    if (PropertyPanel.annot is FreeTextAnnotArgs defaultAnnot)
                                    {
                                        FreeTextAnnotArgs freetextArgs = new FreeTextAnnotArgs();
                                        freetextArgs.FontColor = defaultAnnot.FontColor;
                                        freetextArgs.LineColor = defaultAnnot.LineColor;
                                        freetextArgs.BgColor = defaultAnnot.BgColor;
                                        freetextArgs.Transparency = defaultAnnot.Transparency;
                                        freetextArgs.FontName = defaultAnnot.FontName;
                                        freetextArgs.FontSize = defaultAnnot.FontSize;
                                        freetextArgs.IsBold = defaultAnnot.IsBold;
                                        freetextArgs.IsItalic = defaultAnnot.IsItalic;
                                        freetextArgs.LineWidth = defaultAnnot.LineWidth;
                                        freetextArgs.Align = defaultAnnot.Align;

                                        PDFViewer.SetToolParam(freetextArgs);
                                    }
                                }
                            }
                            break;
                    }
                }
            }
        }

        private void CreateEraseArgs()
        {
            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);

            List<AnnotHandlerEventArgs> eraseArgsList = new List<AnnotHandlerEventArgs>();
            if (eraseArgs != null)
                eraseArgsList.Add(eraseArgs);

            AddToPropertyPanel("FreehandAnnotProperty", "Freehand", eraseArgsList);
        }

        #endregion BindingEvent事件
    }
}