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

using ComPDFKit.PDFAnnotation;
using ComPDFKit.PDFDocument;
using ComPDFKitViewer;
using ComPDFKitViewer.AnnotEvent;
using ComPDFKitViewer.PdfViewer;
using ImTools;
using Microsoft.Win32;
using PDF_Master.CustomControl;
using PDF_Master.EventAggregators;
using PDF_Master.Helper;
using PDF_Master.Model;
using PDF_Master.Model.BOTA;
using PDF_Master.Properties;
using PDF_Master.ViewModels.BOTA;
using PDF_Master.ViewModels.PropertyPanel;
using PDF_Master.ViewModels.PropertyPanel.AnnotPanel;
using PDF_Master.ViewModels.Tools.AnnotManager;
using PDF_Master.Views.BOTA;
using PDF_Master.Views.PropertyPanel.AnnotPanel;
using PDFSettings;
using PDFSettings.Settings;
using Prism.Commands;
using Prism.Events;
using Prism.Mvvm;
using Prism.Regions;
using Prism.Services.Dialogs;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Annotations;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Forms;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using static Dropbox.Api.Paper.PaperDocPermissionLevel;
using ContextMenu = System.Windows.Controls.ContextMenu;
using KeyEventArgs = System.Windows.Input.KeyEventArgs;
using MenuItem = System.Windows.Controls.MenuItem;

namespace PDF_Master.ViewModels.Tools
{
    public sealed partial class AnnotToolContentViewModel : BindableBase, INavigationAware
    {
        #region 初始化

        public AnnotToolContentViewModel(IRegionManager regionManager, IEventAggregator eventAggregator, IDialogService dialogService)
        {
            region = regionManager;
            events = eventAggregator;
            dialogs = dialogService;
            InitCommand();
            InitDefaultValue();
            InitToolDict();
            InitToolTipDict();
            InitPopMenu();
            SubscribeEvent();
            AnnotContainerBorderColor();
        }

        //注释容器选中边框的颜色

        private void AnnotContainerBorderColor()
        {
            var pen = new Pen(new SolidColorBrush(Color.FromArgb(0xFF, 0x17, 0x70, 0xF4)), 1);
            CommonDrawData.ActiveBrush = new SolidColorBrush(Color.FromArgb(0xFF, 0x17, 0x70, 0xF4));
            CommonDrawData.ActivePen = pen;
        }

        //事件聚合器
        private void SubscribeEvent()
        {
            Unicode = App.mainWindowViewModel.SelectedItem.Unicode;
            events.GetEvent<FillAndSignEvent>().Subscribe(FromFillAndSign, e => e.AppUnicode == Unicode);
        }

        private void InitPopMenu()
        {
            InitSelectHightAnnotMenu();
            InitSelectFreeHandAnnotMenu();
            InitSelectFreeTextAnnotMenu();
            InitSelectStrickNoteAnnotMenu();
            InitSelectShapeAnnotMenu();
            InitSelectLinkAnnotMenu();
            InitSelectStampAnnotMenu();
            InitSelectMultiAnnotMenu();
        }

        private void InitCommand()
        {
            MyToolsCommand = new DelegateCommand<CustomIconToggleBtn>(BtnMyTools_Click);
            SetAddAnnotationCommand = new DelegateCommand<object>(AddAnnotation_Click);
            AddBookMarkCommand = new DelegateCommand(AddBookMark_Click);
            PropertyRegionName = Guid.NewGuid().ToString();
            HandCommand = new DelegateCommand(Hand_Click);
            ShowOrHiddenAnnotCommand = new DelegateCommand<CustomIconToggleBtn>(ShowOrHiddenAnnot_Click);

            #region 注释 - 右键菜单

            //公共command
            AnnotDefaultValue_MenuCommand = new DelegateCommand<object>(AnnotDefaultValues_Menu);
            AnnotColorPalette_MenuCommand = new DelegateCommand<object>(AnnotColorPalette_Menu);
            AnnotAddNoteText_MenuCommand = new DelegateCommand<object>(AnnotAddNoteText_Menu);
            //高亮、下划线、删除
            HightAnnotCopyText_MenuCommand = new DelegateCommand<object>(HightAnnotCopyText_Menu);
            //手绘
            FreeHandLineStyle_MenuCommand = new DelegateCommand<object>(FreeHandLineStyle_Menu);
            //文本
            FreeTextFontFamily_MenuCommand = new DelegateCommand<object>(FreeTextFontFamily_Menu);
            FreeTextAglin_MenuCommand = new DelegateCommand<object>(FreeTextAglin_Menu);
            //便签
            StrikeNoteEditStrike_MenuCommand = new DelegateCommand<object>(StrikeNoteEditStrike_Menu);
            //形状
            ShapeLineStyle_MenuCommand = new DelegateCommand<object>(ShapeLineStyle_Menu);
            ShapeLineDirect_MenuCommand = new DelegateCommand<object>(ShapeLineDirect_Menu);
            //图章
            StampExportPicture_MenuCommand = new DelegateCommand<object>(StampExportPicture_Menu);
            //链接
            Link_MenuCommand = new DelegateCommand<object>(Link_Menu);

            #endregion 注释 - 右键菜单
        }

        #endregion 初始化

        #region 注释工具栏 -》Command实现

        private void ShowOrHiddenAnnot_Click(CustomIconToggleBtn annotBtn)
        {
            if (annotBtn == null || annotBtn.Tag == null) return;

            PDFViewer.SetDrawAnnot((bool)annotBtn.IsChecked);

            bool isTabItemAnnotation = IsBOTATabItemShow(out BOTAContentViewModel bOTAContentViewModel, out BOTAContent bOTAContent, "TabItemAnnotation");
            if (annotBtn.IsChecked == true)
            {
                if (viewContentViewModel.OpenBOTA == true && isTabItemAnnotation == true)
                {
                    AnnotationContentViewModel viewModel = GetAnnotationContentViewModel(bOTAContentViewModel, out AnnotationContent annotation);
                    viewModel.DisplayAnnot();
                }
            }
            else
            {
                PDFViewer.ClearSelectAnnots();
                if (viewContentViewModel.OpenBOTA == true && isTabItemAnnotation == true)
                {
                    AnnotationContentViewModel viewModel = GetAnnotationContentViewModel(bOTAContentViewModel, out AnnotationContent annotation);
                    viewModel.HiddenAnnot();
                }
            }
        }

        //手型工具
        private void Hand_Click()
        {
            HandToolIsCheckedEvent(BtnHandIsChecked);
            if (BtnHandIsChecked)
            {
                //其余注释工具 取消选中
                StrAnnotToolChecked = "";
                BtnLinkIsChecked = false;
                viewContentViewModel.SelectedPrpoertyPanel("PropertyPanelContent", null);
            }
        }

        //手型工具按钮选中或取消
        private void HandToolIsCheckedEvent(bool isChecked)
        {
            if (isChecked == false)
            {
                //鼠标框选多选注释
                if (PDFViewer.MouseMode != MouseModes.AnnotCreate)
                {
                    PDFViewer.SetMouseMode(MouseModes.AnnotCreate);
                    var annotArgs = new SelectToolArgs();
                    PDFViewer.SetToolParam(annotArgs);
                }
                else
                {
                    PDFViewer.SetMouseMode(MouseModes.PanTool);
                }
            }
            else
            {
                //鼠标滚动页面
                PDFViewer.SetMouseMode(MouseModes.Scroll);
                PDFViewer.SetToolParam(new AnnotHandlerEventArgs());
            }
        }

        //点击注释工具
        private void BtnMyTools_Click(CustomIconToggleBtn annotBtn)
        {
            if (annotBtn == null || annotBtn.Tag == null) return;

            //不创建注释，属于注释模板
            Dictionary<string, bool> dictVar = new Dictionary<string, bool>();
            dictVar.Add("isTemplateAnnot", false);
            dictVar.Add("isSnapshotEdit", false);
            AnnotHandlerEventArgs annotArgs = null;
            var tag = annotBtn.Tag.ToString();

            if (annotBtn.IsChecked == true)
            {
                PropertyPanel.AnnotSelect = StrAnnotToolChecked;
                PropertyPanel.IsSharpAnnotSelected = true;
                PropertyPanel.IsFreeHandSelected = true;
                PropertyPanel.SaveLastAnnot();
                PDFViewer.DisableClearSelectAnnot(false);
                PDFViewer.ClearSelectAnnots();
                PDFViewer.ToolManager.DisableStickyCreate = false;

                PropertyPanel.annot = null;
                PropertyPanel.AnnotEvents = null;
                PropertyPanel.AnnotEvent = null;
                PropertyPanel.annotlists = null;

                MyToolCheckedDoing(dictVar, tag);
                FindAnnotTypeKey(tag, ref annotArgs);

                if (annotArgs != null)
                {
                    //设置点击页面会创建对应选中注释工具的注释
                    annotArgs.Author = Settings.Default.AppProperties.Description.Author;
                    PDFViewer.SetMouseMode(MouseModes.AnnotCreate);
                    PDFViewer.SetToolParam(annotArgs);
                }
                if (PropertyPanel.IsSelectedTextAddLink)
                {
                    PropertyPanel.IsSelectedTextAddLink = false;
                    PDFViewer.SelectAnnotation(PropertyPanel.annot.PageIndex, PropertyPanel.annot.AnnotIndex);
                }
                if (PropertyPanel.IsSelectedTextAddShape)
                {
                    PropertyPanel.IsSelectedTextAddShape = false;
                    PDFViewer.SelectAnnotation(PropertyPanel.annot.PageIndex, PropertyPanel.annot.AnnotIndex);
                }
            }
            else
            {
                //取消选中注释工具按钮后，恢复到未编辑注释的状态
                PropertyPanel.IsAddLink = false;
                //PropertyPanel.IsLocationLink = false;
                PDFViewer.ToolManager.EnableClickCreate = false;
                PDFViewer.SetMouseMode(MouseModes.PanTool);
                ShowPropertyPanel(false);
                if (string.IsNullOrEmpty(StrAnnotToolChecked))
                {
                    events.GetEvent<LinkAnnotTipCloseEvent>().Publish(new LinkAnnotTipCloseArgs() { UniCode = App.mainWindowViewModel.SelectedItem.Unicode });
                }
            }

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

        //选中注释工具按钮时，处理的一些系列事情
        private void MyToolCheckedDoing(Dictionary<string, bool> dict, string tag)
        {
            if (BtnHandIsChecked)
                BtnHandIsChecked = false;

            PDFViewer.ClearSelectAnnots();

            //选中内容选择工具按钮
            if (tag == "SnapshotEdit")
            {
                dict["isSnapshotEdit"] = true;
            }
            else if (tag == "Signature" || tag == "Stamp")
            {
                //选中签名、图章工具按钮
                dict["isTemplateAnnot"] = true;
            }

            //超链接工具
            //if (tag != "Link")
            //    BtnLinkIsChecked = false;
            //else
            //    StrAnnotToolChecked = "Link";
            if (tag != "Link")
            {
                events.GetEvent<LinkAnnotTipCloseEvent>().Publish(new LinkAnnotTipCloseArgs() { UniCode = App.mainWindowViewModel.SelectedItem.Unicode });

                //if (region.Regions.ContainsRegionWithName(viewContentViewModel.TipContentRegionName))
                //{
                //    var views = region.Regions[viewContentViewModel.TipContentRegionName].Views;

                //    Views.TipContent.LinkAnnotTip isHas = (Views.TipContent.LinkAnnotTip)views.FindFirst(q => q is Views.TipContent.LinkAnnotTip);
                //    if (isHas != null)
                //    {
                //        viewContentViewModel.TipVisible = System.Windows.Visibility.Collapsed;
                //        (isHas.DataContext as LinkAnnotPropertyViewModel).BtnLocationIsChecked = false;
                //    }
                //}
            }
            if (tag == "Rect" || tag == "Circle" || tag == "Arrow" || tag == "Line")
            {
                //新建形状注释，设置默认大小
                PDFViewer.ToolManager.EnableClickCreate = true;
                PDFViewer.ToolManager.ClickCreateWidth = 140;
                PDFViewer.ToolManager.ClickCreateHeight = 140;
            }
            else
            {
                PDFViewer.ToolManager.EnableClickCreate = false;
            }
        }

        #endregion 注释工具栏 -》Command实现

        #region BOTA

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

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

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

        #endregion BOTA

        #region 阅读页右键菜单

        /// <summary>
        /// 空白处-右键菜单-添加注释
        /// </summary>
        /// <param name="sender"></param>
        private void AddAnnotation_Click(object sender)
        {
            if (sender is MenuItem menuItem)
            {
                StrAnnotToolChecked = "";
                AnnotHandlerEventArgs annotHandler = null;
                string str = menuItem.Tag.ToString();
                viewContentViewModel.SelectedPrpoertyPanel("PropertyPanelContent", null);
                PropertyPanel.IsAddLink = false;
                PDFViewer.SetMouseMode(MouseModes.PanTool);
                //PropertyPanel.IsLocationLink = false;

                IsNoSelectMenu = true;
                if (str == AddAnnotType.AnnotFreehand.ToString())
                {
                    annotHandler = GetFreehand();
                }
                if (str == AddAnnotType.AnnotFreeText.ToString())
                {
                    annotHandler = GetFreetext();
                }
                if (str == AddAnnotType.AnnotSticky.ToString())
                {
                    annotHandler = GetStickyNote();
                }
                if (str == AddAnnotType.AnnotSquare.ToString())
                {
                    annotHandler = GetRect();
                }
                if (str == AddAnnotType.AnnotCircle.ToString())
                {
                    annotHandler = GetCircle();
                }
                if (str == AddAnnotType.AnnotArrow.ToString())
                {
                    annotHandler = GetArrowLine("Arrow");
                }
                if (str == AddAnnotType.AnnotLine.ToString())
                {
                    annotHandler = GetArrowLine("Line");
                }
                if (str == AddAnnotType.AnnotLink.ToString())
                {
                    PropertyPanel.IsAddLink = true;
                    viewContentViewModel.IsRightMenuCreateLink = true;
                    annotHandler = GetLink();
                }
                if (str == AddAnnotType.AnnotStamp.ToString())
                {
                    annotHandler = GetStamp();
                }
                if (str == AddAnnotType.AnnotAutograph.ToString())
                {
                    annotHandler = GetSignature();
                }
                if (annotHandler != null)
                {
                    //是否展开右侧面板 =>否（链接、图章、签名除外）
                    if (str == AddAnnotType.AnnotLink.ToString()
                    || str == AddAnnotType.AnnotStamp.ToString()
                    || str == AddAnnotType.AnnotAutograph.ToString()
                    )
                    {
                        ShowPropertyPanel(true);
                    }
                    else
                    {
                        ShowPropertyPanel(false);
                    }

                    annotHandler.Author = Settings.Default.AppProperties.Description.Author;
                    PDFViewer.SetMouseMode(MouseModes.AnnotCreate);
                    PDFViewer.SetToolParam(annotHandler);
                }
            }
        }

        /// <summary>
        /// 选择文本、图片，右键菜单
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void AnnotToolMenu_Click(object sender, RoutedEventArgs e)
        {
            if (sender is MenuItem clickMenu && clickMenu.CommandParameter is AnnotCommandArgs)
            {
                AnnotCommandArgs annotCommand = clickMenu.CommandParameter as AnnotCommandArgs;

                switch (clickMenu.Tag.ToString())
                {
                    case "HighLight"://字体高亮
                        TextHighlightAnnotArgs highlightArgs = (TextHighlightAnnotArgs)GetHighLight();
                        highlightArgs.ClientRect = annotCommand.TextRect;
                        highlightArgs.Content = annotCommand.Text;
                        highlightArgs.Author = Settings.Default.AppProperties.Description.Author;
                        PDFViewer.SetMouseMode(MouseModes.AnnotCreate);
                        PDFViewer.SetToolParam(highlightArgs);
                        PDFViewer.SetMouseMode(MouseModes.PanTool);
                        viewContentViewModel.SelectedPrpoertyPanel("PropertyPanelContent", null);
                        break;

                    case "UnderLine"://下划线
                        TextUnderlineAnnotArgs underlineArgs = (TextUnderlineAnnotArgs)GetUnderLine();
                        underlineArgs.ClientRect = annotCommand.TextRect;
                        underlineArgs.Content = annotCommand.Text;
                        underlineArgs.Author = Settings.Default.AppProperties.Description.Author;
                        PDFViewer.SetMouseMode(MouseModes.AnnotCreate);
                        PDFViewer.SetToolParam(underlineArgs);
                        PDFViewer.SetMouseMode(MouseModes.PanTool);
                        viewContentViewModel.SelectedPrpoertyPanel("PropertyPanelContent", null);
                        break;

                    case "Strikeout"://删除线
                        TextStrikeoutAnnotArgs strikeoutArgs = (TextStrikeoutAnnotArgs)GetStrikeout();
                        strikeoutArgs.ClientRect = annotCommand.TextRect;
                        strikeoutArgs.Content = annotCommand.Text;
                        strikeoutArgs.Author = Settings.Default.AppProperties.Description.Author;
                        PDFViewer.SetMouseMode(MouseModes.AnnotCreate);
                        PDFViewer.SetToolParam(strikeoutArgs);
                        PDFViewer.SetMouseMode(MouseModes.PanTool);
                        viewContentViewModel.SelectedPrpoertyPanel("PropertyPanelContent", null);
                        break;

                    case "Freetext"://文本
                        FreeTextAnnotArgs textArgs = (FreeTextAnnotArgs)GetFreetext();
                        textArgs.ClientRect = annotCommand.TextRect;
                        //textArgs.Transparency = 1;
                        //textArgs.BgColor = Colors.Transparent;
                        //textArgs.LineColor = Colors.Red;
                        //textArgs.LineWidth = 2;
                        textArgs.TextContent = annotCommand.Text;

                        PDFViewer.CreatePageAnnot(annotCommand.PageIndex, textArgs);
                        break;

                    case "StickyNote"://便签

                        StickyAnnotArgs stickyAnnotArgs = (StickyAnnotArgs)GetStickyNote();
                        //stickyAnnotArgs.ClientRect = annotCommand.TextRect;
                        List<TextSelectNode> textSelectNodes = PDFViewer.GetSelectTextInfo();

                        //stickyAnnotArgs.ClientRect = new Rect(textSelectNodes[0].StartPoint.X, annotCommand.TextRect.Y - annotCommand.TextRect.Height, annotCommand.TextRect.Width, annotCommand.TextRect.Height);
                        Rect rect = annotCommand.TextRectList[0];

                        #region to do 转dpi

                        //int dpi = DpiHelpers.Dpi;
                        //double x = rect.X / 72D * dpi;
                        //double y = (rect.Y - rect.Height) / 72D * dpi;
                        //double width = rect.Width / 72D * dpi;
                        //double height = rect.Height / 72D * dpi;

                        #endregion to do 转dpi

                        //stickyAnnotArgs.ClientRect = new Rect(x, y, width, height);
                        //stickyAnnotArgs.ClientRect = new Rect(rect.X, rect.Y - rect.Height, rect.Width, rect.Height);
                        stickyAnnotArgs.ClientRect = rect;
                        //PDFViewer.CreatePageAnnot(annotCommand.PageIndex, stickyAnnotArgs);
                        NavigationParameters param = new NavigationParameters();
                        param.Add(ParameterNames.PDFViewer, PDFViewer);
                        param.Add(ParameterNames.StickyAnnotArgs, stickyAnnotArgs);
                        param.Add(ParameterNames.ViewContentViewModel, viewContentViewModel);
                        param.Add(ParameterNames.AnnotCommandArgs, annotCommand);

                        System.Windows.Controls.ContentControl window = null;
                        if (PDFViewer.Parent as ContentControl != null)
                        {
                            window = PDFViewer.Parent as ContentControl;
                        }
                        else
                        {
                            window = App.Current.MainWindow;
                        }

                        var point = Mouse.GetPosition(window);
                        viewContentViewModel.NotePopupVisible = Visibility.Visible;
                        viewContentViewModel.CanvasNoteLeft = point.X;
                        viewContentViewModel.CanvasNoteBottom = point.Y;
                        if (point.Y > window.ActualHeight / 2)
                        {
                            viewContentViewModel.CanvasNoteBottom = point.Y - window.ActualHeight / 2;
                        }

                        viewContentViewModel.IsNoteAdd = true;
                        region.RequestNavigate(viewContentViewModel.NotePopupRegionName, "StickyNotePopup", param);

                        //stickyAnnotArgs.Author = Settings.Default.AppProperties.Description.Author;
                        //PDFViewer.SetMouseMode(MouseModes.AnnotCreate);
                        //PDFViewer.SetToolParam(stickyAnnotArgs);

                        //PDFViewer.SetMouseMode(MouseModes.PanTool);
                        break;

                    case "Rect"://矩形
                        SquareAnnotArgs squareAnnotArgs = (SquareAnnotArgs)GetRect();
                        squareAnnotArgs.ClientRect = annotCommand.TextRect;
                        PDFViewer.CreatePageAnnot(annotCommand.PageIndex, squareAnnotArgs);
                        break;

                    case "Circle"://圆
                        CircleAnnotArgs circleAnnotArgs = (CircleAnnotArgs)GetCircle();
                        circleAnnotArgs.ClientRect = annotCommand.TextRect;
                        PDFViewer.CreatePageAnnot(annotCommand.PageIndex, circleAnnotArgs);
                        break;

                    case "Line"://线
                        LineAnnotArgs lineAnnotArgs = (LineAnnotArgs)GetArrowLine(clickMenu.Tag.ToString());
                        lineAnnotArgs.ClientRect = annotCommand.TextRect;
                        lineAnnotArgs.LinePoints.Add(new Point(annotCommand.TextRect.Left, annotCommand.TextRect.Top));
                        lineAnnotArgs.LinePoints.Add(new Point(annotCommand.TextRect.Right, annotCommand.TextRect.Bottom));
                        PDFViewer.CreatePageAnnot(annotCommand.PageIndex, lineAnnotArgs);
                        break;

                    case "Link"://链接
                        LinkAnnotArgs linkArgs = new LinkAnnotArgs();
                        linkArgs.ClientRect = annotCommand.TextRect;
                        linkArgs.URI = string.Empty;
                        linkArgs.LinkType = LINK_TYPE.GOTO;
                        linkArgs.DestIndex = annotCommand.PageIndex;
                        PDFViewer.CreatePageAnnot(annotCommand.PageIndex, linkArgs);
                        //BtnLinkIsChecked = true;
                        //StrAnnotToolChecked = "Link";
                        //List<AnnotHandlerEventArgs> lists = new List<AnnotHandlerEventArgs>();
                        //lists.Add(linkArgs);
                        //PropertyPanel.IsAddLink = true;

                        //AnnotHandlerEventArgs annotArgs = GetLink(lists);
                        //PDFViewer.SetMouseMode(MouseModes.AnnotCreate);
                        //PDFViewer.SetToolParam(annotArgs);
                        viewContentViewModel.IsPropertyOpen = true;
                        PDFViewer.SelectAnnotation(linkArgs.PageIndex, linkArgs.AnnotIndex);

                        break;

                    case "OutLine":
                        bool isTabItemAnnotation = IsBOTATabItemShow(out BOTAContentViewModel bOTAContentViewModel, out BOTAContent bOTAContent, "TabItemOutLine");
                        if (isTabItemAnnotation == false)
                        {
                            bOTAContent.TabItemOutLine.IsSelected = true;
                        }
                        OutLineControlViewModel outLineControlViewModel = GetOutLineControlViewModel(bOTAContentViewModel, out OutLineControl outLineControl);
                        if (outLineControlViewModel != null && outLineControl != null)
                        {
                            string str = null;
                            if (!string.IsNullOrEmpty(annotCommand.Text))
                            {
                                str = annotCommand.Text;
                            }

                            #region 选择图片

                            //if (string.IsNullOrEmpty(annotCommand.Text))
                            //{
                            //    str = (annotCommand.PageIndex + 1).ToString();
                            //}
                            //else
                            //{
                            //    str = annotCommand.Text;
                            //}

                            #endregion 选择图片

                            outLineControl.AddOutlineNode(str);
                        }

                        break;

                    case "ExportPicture":
                        ExportPicture_MenuItemClick();
                        break;
                }
                ExitAnnotationTool();
                //ShowPropertyPanel(false);
            }
        }

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

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

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

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

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

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

        private void ViewZoom(ItemCollection items)
        {
            foreach (var item in items)
            {
                if (item is MenuItem menuItem)
                {
                    //switch (PDFViewer.ModeFit)
                    //{
                    //    case FitMode.FitWidth:
                    //        break;

                    //    case FitMode.FitHeight:
                    //        break;

                    //    case FitMode.FitSize:
                    //        break;

                    //    case FitMode.FitFree:
                    //        break;

                    //    default:
                    //        break;
                    //}
                    menuItem.IsCheckable = false;
                    menuItem.Click -= ViewZoom_Click;
                    menuItem.Click += ViewZoom_Click;
                }
            }
        }

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

                        break;

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

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

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

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

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

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

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

        private void ToolMode_Click(object sender, RoutedEventArgs e)
        {
            if (sender is MenuItem menuItem)
            {
                switch (menuItem.Tag.ToString())
                {
                    case "default":
                        StrAnnotToolChecked = "";
                        PDFViewer.SetMouseMode(MouseModes.PanTool);
                        HandToolIsCheckedEvent(false);
                        BtnHandIsChecked = false;
                        ShowPropertyPanel(false);
                        break;

                    case "roll":
                        StrAnnotToolChecked = "";
                        HandToolIsCheckedEvent(true);
                        BtnHandIsChecked = true;
                        ShowPropertyPanel(false);
                        break;

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

                        break;

                    default:
                        break;
                }
            }
        }

        private void DelBookMark_Click(object sender, RoutedEventArgs e)
        {
            CheckBOTAState(out BOTAContentViewModel bOTAContentVM, out BOTAContent bOTA);
            if (bOTAContentVM != null && bOTA != null)
            {
                BookmarkContentViewModel bookmarkContentViewModel = GetBookmarkContentViewModel(bOTAContentVM, out BookmarkContent bookmark);

                int index = PDFViewer.CurrentIndex;
                //检测是否已存在相同数据
                if (PDFViewer.Document == null) return;
                if (PDFViewer.Document.GetBookmarkList().Count <= 0) return;
                CPDFBookmark list = PDFViewer.Document.GetBookmarkList().FirstOrDefault(q => q.PageIndex == index);
                if (bookmarkContentViewModel != null && bookmark != null && bOTA != null && list != null)
                {
                    bookmarkContentViewModel.DeleteCommand.Execute(list);
                    isAddBookMark = bookmarkContentViewModel.isAddBookMark;
                }
            }
        }

        private void CheckBOTAState(out BOTAContentViewModel bOTAContentVM, out BOTAContent bOTA)
        {
            if (viewContentViewModel.OpenBOTA == false)
            {
                viewContentViewModel.OpenBOTA = true;
            }
            bool isBook = IsBOTATabItemShow(out bOTAContentVM, out bOTA, "TabItemBookMark");
            if (isBook == false)
            {
                bOTA.TabItemBookMark.IsSelected = true;
            }
        }

        private void AddBookMark_Click()
        {
            CheckBOTAState(out BOTAContentViewModel bOTAContentVM, out BOTAContent bOTA);
            //if (viewContentViewModel.mainViewModel.IsBookMode)
            //{
            //    this.events.GetEvent<ReadModeBOTAShowEvent>().Publish(new ReadModeBOTAShowArgs() { Unicode = App.mainWindowViewModel.SelectedItem.Unicode, IsBOTAShow = true });
            //}
            if (bOTAContentVM != null && bOTA != null)
            {
                BookmarkContentViewModel bookmarkContentViewModel = GetBookmarkContentViewModel(bOTAContentVM, out BookmarkContent bookmark);

                if (bookmarkContentViewModel != null && bookmark != null && bOTA != null)
                {
                    //bookmarkContentViewModel.AddBookmarkCommand.Execute(bookmark.BookMarkListView);
                    bookmark.BtnAddBookmark_Click(null, null);
                    isAddBookMark = bookmarkContentViewModel.isAddBookMark;
                    return;
                }
            }
        }

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

        private OutLineControlViewModel GetOutLineControlViewModel(BOTAContentViewModel bOTAContentViewModel, out OutLineControl outLineControl)
        {
            OutLineControlViewModel viewModel = null;
            outLineControl = null;
            if (bOTAContentViewModel != null)
            {
                if (region.Regions.ContainsRegionWithName(bOTAContentViewModel.BOTAContentRegionName))
                {
                    var views = region.Regions[bOTAContentViewModel.BOTAContentRegionName].Views;
                    foreach (var item in views)
                    {
                        if (item is OutLineControl outLineControl1)
                        {
                            outLineControl = outLineControl1;
                            viewModel = outLineControl1.DataContext as OutLineControlViewModel;
                            break;
                        }
                    }
                }
            }
            return viewModel;
        }

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

            bool isTabItemAnnotation = IsBOTATabItemShow(out BOTAContentViewModel bOTAContentViewModel, out BOTAContent bOTAContent, "TabItemAnnotation");

            if (viewContentViewModel.OpenBOTA == true && isTabItemAnnotation == true)
            {
                AnnotationContentViewModel viewModel = GetAnnotationContentViewModel(bOTAContentViewModel, out AnnotationContent annotation);
                viewModel.DisplayAnnot();
            }
        }

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

            bool isTabItemAnnotation = IsBOTATabItemShow(out BOTAContentViewModel bOTAContentViewModel, out BOTAContent bOTAContent, "TabItemAnnotation");

            if (viewContentViewModel.OpenBOTA == true && isTabItemAnnotation == true)
            {
                AnnotationContentViewModel viewModel = GetAnnotationContentViewModel(bOTAContentViewModel, out AnnotationContent annotation);
                viewModel.HiddenAnnot();
            }
        }

        private void SetAddAnnotation(ItemCollection items)
        {
            foreach (var item in items)
            {
                if (item is MenuItem menuItem)
                {
                    string str = menuItem.Tag.ToString();
                    //if (str == AddAnnotType.AnnotLink.ToString()
                    //|| str == AddAnnotType.AnnotStamp.ToString()
                    //|| str == AddAnnotType.AnnotAutograph.ToString()
                    //)
                    //{
                    //    InBookModeSetIsEnabled(menuItem);
                    //}
                    menuItem.CommandParameter = item;
                    menuItem.Command = SetAddAnnotationCommand;
                }
            }
        }

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

        #endregion 阅读页右键菜单

        #region 注释右键菜单事件

        //高亮、下划线、删除
        private void HightAnnotCopyText_Menu(object obj)
        {
            if (obj as CusMenuItem != null)
            {
                var menu = obj as CusMenuItem;
                var annot = menu.Parameter as AnnotHandlerEventArgs;
                if (annot != null)
                {
                    System.Windows.Clipboard.SetText(annot.Content);
                }
            }
        }

        /// <summary>
        /// 更改为当前注释属性默认值
        /// </summary>
        /// <param name="obj"></param>
        private void AnnotDefaultValues_Menu(object obj)
        {
            if (obj as CusMenuItem != null)
            {
                var menu = obj as CusMenuItem;
                var annot = menu.Parameter as AnnotHandlerEventArgs;
                if (annot != null)
                {
                    if (annot is TextHighlightAnnotArgs)
                    {
                        var color = (annot as TextHighlightAnnotArgs).Color;
                        HighLightColor = new SolidColorBrush(color);

                        Settings.Default.AppProperties.Annotate.HighLightColor = color;

                        var hightlight = GetAnnotDefault(AnnotArgsType.AnnotHighlight);
                        hightlight.ForgoundColor = color;
                        hightlight.Opacity = (annot as TextHighlightAnnotArgs).Transparency;
                        SettingHelper.SetAnnotDefaultProperty(hightlight);
                    }
                    else if (annot is TextUnderlineAnnotArgs)
                    {
                        var color = (annot as TextUnderlineAnnotArgs).Color;
                        UnderLineColor = new SolidColorBrush(color);

                        Settings.Default.AppProperties.Annotate.UnderLineColor = color;

                        var Underline = GetAnnotDefault(AnnotArgsType.AnnotUnderline);
                        Underline.ForgoundColor = color;
                        Underline.Opacity = (annot as TextUnderlineAnnotArgs).Transparency;
                        SettingHelper.SetAnnotDefaultProperty(Underline);
                    }
                    else if (annot is TextStrikeoutAnnotArgs)
                    {
                        var color = (annot as TextStrikeoutAnnotArgs).Color;
                        StrikeoutColor = new SolidColorBrush(color);

                        Settings.Default.AppProperties.Annotate.StrikethroughColor = color;

                        var Strikeout = GetAnnotDefault(AnnotArgsType.AnnotStrikeout);
                        Strikeout.ForgoundColor = color;
                        Strikeout.Opacity = (annot as TextStrikeoutAnnotArgs).Transparency;
                        SettingHelper.SetAnnotDefaultProperty(Strikeout);
                    }
                    else if (annot is FreehandAnnotArgs)
                    {
                        var freeHand = annot as FreehandAnnotArgs;
                        var color = freeHand.InkColor;

                        Settings.Default.AppProperties.Annotate.FreeHandColor = color;

                        var FreehandDefault = GetAnnotDefault(AnnotArgsType.AnnotFreehand);
                        FreehandDefault.ForgoundColor = color;
                        FreehandDefault.Opacity = freeHand.Transparency;
                        FreehandDefault.Thickness = freeHand.LineWidth;

                        var isSolid = AnnotTransfer.IsSolidStyle(freeHand.LineDash);
                        if (isSolid)
                        {
                            FreehandDefault.DashArray = null;
                        }
                        else
                        {
                            FreehandDefault.DashArray = new List<double>();
                            foreach (var item in freeHand.LineDash.Dashes)
                            {
                                FreehandDefault.DashArray.Add(item);
                            }
                        }

                        SettingHelper.SetAnnotDefaultProperty(FreehandDefault);

                        FreehandAnnotArgs annotArgs = new FreehandAnnotArgs()
                        {
                            InkColor = freeHand.InkColor,
                            Transparency = freeHand.Transparency,
                            LineWidth = freeHand.LineWidth,
                            LineDash = freeHand.LineDash
                        };

                        PDFViewer.SetToolParam(annotArgs);
                    }
                    else if (annot is FreeTextAnnotArgs freeText)
                    {
                        //var freeText = annot as FreeTextAnnotArgs;
                        Settings.Default.AppProperties.Annotate.TextAnnoteColor = freeText.FontColor;
                        Settings.Default.AppProperties.Annotate.TextFontFamaily = freeText.FontFamily.ToString();
                        Settings.Default.AppProperties.Annotate.TextAlign = freeText.Align;

                        var FreeTextDefalut = GetAnnotDefault(AnnotArgsType.AnnotFreeText);
                        FreeTextDefalut.ForgoundColor = freeText.FontColor;
                        FreeTextDefalut.FontFamily = freeText.FontFamily.ToString();
                        FreeTextDefalut.TextAlign = freeText.Align;
                        FreeTextDefalut.FontSize = freeText.FontSize;
                        FreeTextDefalut.FontWeight = freeText.FontWeight;
                        FreeTextDefalut.FontStyle = freeText.FontStyle;
                        FreeTextDefalut.BackgroundColor = freeText.BgColor;
                        FreeTextDefalut.Opacity = (annot as FreeTextAnnotArgs).Transparency;
                        SettingHelper.SetAnnotDefaultProperty(FreeTextDefalut);
                        //FreeTextAnnotArgs freeTextAnnotArgs = new FreeTextAnnotArgs()
                        //{
                        //    FontColor = freeText.FontColor,
                        //    FontFamily = freeText.FontFamily,
                        //    Align = freeText.Align,
                        //    FontSize = freeText.FontSize,
                        //    FontWeight = freeText.FontWeight,
                        //    FontStyle = freeText.FontStyle,
                        //    BgColor = freeText.BgColor,
                        //    Transparency = (annot as FreeTextAnnotArgs).Transparency
                        //};

                        //PDFViewer.SetToolParam(freeTextAnnotArgs);
                    }
                    else if (annot is StickyAnnotArgs)
                    {
                        var color = (annot as StickyAnnotArgs).Color;
                        Settings.Default.AppProperties.Annotate.NoteAnnoteColor = color;
                        var StickyDefalut = GetAnnotDefault(AnnotArgsType.AnnotSticky);
                        StickyDefalut.ForgoundColor = color;

                        SettingHelper.SetAnnotDefaultProperty(StickyDefalut);
                    }
                    else if (annot is SquareAnnotArgs)
                    {
                        var square = annot as SquareAnnotArgs;
                        var bgColor = square.BgColor;
                        Settings.Default.AppProperties.Annotate.RectangleFillColor = bgColor;
                        var borderColor = square.LineColor;
                        Settings.Default.AppProperties.Annotate.RectangleBorderColor = borderColor;

                        var SquareDefalut = GetAnnotDefault(AnnotArgsType.AnnotSquare);
                        SquareDefalut.BorderColor = borderColor;
                        SquareDefalut.BackgroundColor = bgColor;
                        SquareDefalut.Opacity = square.Transparency;
                        SquareDefalut.Thickness = square.LineWidth;

                        var isSolid = AnnotTransfer.IsSolidStyle(square.LineDash);
                        if (isSolid)
                        {
                            SquareDefalut.DashArray = null;
                        }
                        else
                        {
                            SquareDefalut.DashArray = new List<double>();
                            foreach (var item in square.LineDash.Dashes)
                            {
                                SquareDefalut.DashArray.Add(item);
                            }
                        }

                        SettingHelper.SetAnnotDefaultProperty(SquareDefalut);
                    }
                    else if (annot is CircleAnnotArgs)
                    {
                        var circle = annot as CircleAnnotArgs;
                        var bgColor = circle.BgColor;
                        Settings.Default.AppProperties.Annotate.CircleFillColor = bgColor;
                        var borderColor = circle.LineColor;
                        Settings.Default.AppProperties.Annotate.CircleBorderColor = borderColor;

                        var CircleDefalut = GetAnnotDefault(AnnotArgsType.AnnotCircle);
                        CircleDefalut.BorderColor = borderColor;
                        CircleDefalut.BackgroundColor = bgColor;
                        CircleDefalut.Opacity = circle.Transparency;
                        CircleDefalut.Thickness = circle.LineWidth;

                        var isSolid = AnnotTransfer.IsSolidStyle(circle.LineDash);
                        if (isSolid)
                        {
                            CircleDefalut.DashArray = null;
                        }
                        else
                        {
                            CircleDefalut.DashArray = new List<double>();
                            foreach (var item in circle.LineDash.Dashes)
                            {
                                CircleDefalut.DashArray.Add(item);
                            }
                        }

                        SettingHelper.SetAnnotDefaultProperty(CircleDefalut);
                    }
                    else if (annot is LineAnnotArgs lineAnnotArgs)
                    {
                        var color = lineAnnotArgs.LineColor;
                        var lineDefalut = GetAnnotDefault(AnnotArgsType.AnnotLine);
                        //箭头
                        if (lineAnnotArgs.HeadLineType >= (C_LINE_TYPE)1 || lineAnnotArgs.TailLineType >= (C_LINE_TYPE)1)
                        {
                            Settings.Default.AppProperties.Annotate.ArrowColor = color;
                            lineDefalut.HeadLineType = lineAnnotArgs.HeadLineType;
                            lineDefalut.TailLineType = lineAnnotArgs.TailLineType;
                        }
                        else
                        {
                            Settings.Default.AppProperties.Annotate.LineColor = color;
                        }

                        lineDefalut.BorderColor = color;
                        lineDefalut.Opacity = lineAnnotArgs.Transparency;
                        lineDefalut.Thickness = lineAnnotArgs.LineWidth;

                        var isSolid = AnnotTransfer.IsSolidStyle(lineAnnotArgs.LineDash);
                        if (isSolid)
                        {
                            lineDefalut.DashArray = null;
                        }
                        else
                        {
                            lineDefalut.DashArray = new List<double>();
                            foreach (var item in lineAnnotArgs.LineDash.Dashes)
                            {
                                lineDefalut.DashArray.Add(item);
                            }
                        }

                        SettingHelper.SetAnnotDefaultProperty(lineDefalut);
                    }

                    Settings.Default.Save();
                    PropertyPanel.annot = annot;
                    PropertyPanel.SaveLastAnnot();
                }
            }
        }

        private DefaultAnnotProperty GetAnnotDefault(AnnotArgsType annotArgsType)
        {
            var Annot = SettingHelper.GetAnnotDefaultProperty(annotArgsType);
            if (Annot == null)
            {
                Annot = new DefaultAnnotProperty();
                Annot.AnnotToolType = annotArgsType;
            }
            return Annot;
        }

        private System.Windows.Controls.Primitives.Popup popup = null;

        //更改颜色
        private async void AnnotColorPalette_Menu(object obj)
        {
            if (obj as CusMenuItem != null)
            {
                var menu = obj as CusMenuItem;
                var annot = menu.Parameter as AnnotHandlerEventArgs;
                if (annot != null)
                {
                    var item = new ColorDropBoxPop();
                    item.DataContext = menu;
                    item.ColorSelected -= AnnotMenu_ColorSelected;
                    item.ColorSelected += AnnotMenu_ColorSelected;

                    if (popup == null)
                        popup = new System.Windows.Controls.Primitives.Popup();

                    ContentControl window = null;
                    if (PDFViewer.Parent as ContentControl != null)
                        window = PDFViewer.Parent as ContentControl;
                    else
                        window = App.Current.MainWindow;

                    popup.Child = item;
                    popup.PlacementRectangle = new Rect(Mouse.GetPosition(window), new Size(item.Width, item.Height));
                    popup.Placement = System.Windows.Controls.Primitives.PlacementMode.MousePoint;
                    popup.PlacementTarget = window;
                    popup.IsOpen = true;

                    Window parentWnd = Window.GetWindow(App.Current.MainWindow);
                    if (parentWnd != null)
                    {
                        parentWnd.MouseDown -= parentWnd_MouseDown;
                        parentWnd.MouseDown += parentWnd_MouseDown;
                    }

                    while (popup.IsOpen)
                        await Task.Delay(20);

                    parentWnd.MouseDown -= parentWnd_MouseDown;
                    popup = null;
                }
            }
        }

        private void parentWnd_MouseDown(object sender, MouseButtonEventArgs e)
        {
            var ui = Mouse.DirectlyOver as FrameworkElement;
            if (ui != null)
            {
                if (popup != null)
                {
                    popup.IsOpen = false;
                }
            }
        }

        private void AnnotMenu_ColorSelected(object sender, Color e)
        {
            if (sender != null)
            {
                var menu = (sender as FrameworkElement).DataContext as CusMenuItem;
                if (menu == null) return;

                var annot = menu.Parameter as AnnotHandlerEventArgs;
                if (annot != null)
                {
                    if (annot is FreehandAnnotArgs || annot is StickyAnnotArgs || annot is LineAnnotArgs)
                    {
                        var AnnotEvent = AnnotAttribEvent.GetAnnotAttribEvent(annot, annot.GetAnnotAttrib());
                        AnnotEvent?.UpdateAttrib(AnnotAttrib.Color, e);
                        AnnotEvent?.UpdateAnnot();
                    }
                    else if (annot is FreeTextAnnotArgs)
                    {
                        var AnnotEvent = AnnotAttribEvent.GetAnnotAttribEvent(annot, annot.GetAnnotAttrib());
                        if (menu.tag.ToString() == "FontColor")
                            AnnotEvent?.UpdateAttrib(AnnotAttrib.FontColor, e);
                        else
                            AnnotEvent?.UpdateAttrib(AnnotAttrib.FillColor, e);

                        AnnotEvent?.UpdateAnnot();
                    }
                    else if (annot is SquareAnnotArgs || annot is CircleAnnotArgs)
                    {
                        var AnnotEvent = AnnotAttribEvent.GetAnnotAttribEvent(annot, annot.GetAnnotAttrib());
                        if (menu.tag.ToString() == "FillColor")
                            AnnotEvent?.UpdateAttrib(AnnotAttrib.FillColor, e);
                        else
                            AnnotEvent?.UpdateAttrib(AnnotAttrib.Color, e);

                        AnnotEvent?.UpdateAnnot();
                    }
                    else if (annot is TextHighlightAnnotArgs || annot is TextUnderlineAnnotArgs || annot is TextStrikeoutAnnotArgs)
                    {
                        var AnnotEvent = AnnotAttribEvent.GetAnnotAttribEvent(annot, annot.GetAnnotAttrib());
                        AnnotEvent?.UpdateAttrib(AnnotAttrib.Color, e);
                        AnnotEvent?.UpdateAnnot();
                    }
                }
            }
        }

        //添加笔记
        private void AnnotAddNoteText_Menu(object obj)
        {
            if (obj as CusMenuItem != null)
            {
                var menu = obj as CusMenuItem;
                var annot = menu.Parameter as AnnotHandlerEventArgs;
                PopAnnotNoteText(annot);
            }
        }

        private void PopAnnotNoteText(AnnotHandlerEventArgs annot)
        {
            if (annot != null)
            {
                AnnotationHandlerEventArgs args = new AnnotationHandlerEventArgs();

                args.ClientRect = annot.ClientRect;
                args.AnnotHandlerEventArgs = annot;
                args.PageIndex = annot.PageIndex;
                args.AnnotIndex = annot.AnnotIndex;
                args.EventType = annot.EventType;
                args.CreateTime = annot.CreateTime;
                args.UpdateTime = annot.UpdateTime;
                args.Content = annot.Content;
                args.MarkupContent = annot.MarkupContent;
                args.Author = annot.Author;
                args.Locked = annot.Locked;
                args.ReadOnly = annot.ReadOnly;
                args.FormField = annot.FormField;
                args.Document = PDFViewer.Document;

                DialogParameters value = new DialogParameters();
                value.Add(ParameterNames.Annotation, args);
                dialogs.ShowDialog(DialogNames.AddAnnotationDialog, value, e =>
                {
                    if (e.Result == ButtonResult.OK && e.Parameters != null)
                    {
                        PDFViewer.UndoManager.CanSave = true;
                        if (e.Parameters.ContainsKey(ParameterNames.Annotation) && e.Parameters.ContainsKey(ParameterNames.AnnotEvent))
                        {
                            AnnotationHandlerEventArgs annotation = e.Parameters.GetValue<AnnotationHandlerEventArgs>(ParameterNames.Annotation);
                            //RefreshOneListItem(annotation.AnnotHandlerEventArgs);
                            events.GetEvent<RefreshAnnotEvent>().Publish(new RefreshAnnotArgs() { Unicode = App.mainWindowViewModel.SelectedItem.Unicode, Annotation = annotation });
                        }
                    }
                });
            }
        }

        //手绘
        private void FreeHandLineStyle_Menu(object obj)
        {
            if (obj as CusMenuItem != null)
            {
                var menu = obj as CusMenuItem;
                var annot = menu.Parameter as FreehandAnnotArgs;
                if (annot != null)
                {
                    var AnnotEvent = AnnotAttribEvent.GetAnnotAttribEvent(annot, annot.GetAnnotAttrib());
                    if (menu.tag.ToString() == "Solid")
                    {
                        AnnotEvent?.UpdateAttrib(AnnotAttrib.LineStyle, AnnotTransfer.GetLineDashStyle(true));
                    }
                    else
                    {
                        AnnotEvent?.UpdateAttrib(AnnotAttrib.LineStyle, AnnotTransfer.GetLineDashStyle(false));
                    }

                    AnnotEvent?.UpdateAnnot();
                }
            }
        }

        //文本

        private void FreeTextFontFamily_Menu(object obj)
        {
            if (obj as CusMenuItem != null)
            {
                var menu = obj as CusMenuItem;
                var annot = menu.Parameter as AnnotHandlerEventArgs;
                if (annot != null)
                {
                    var AnnotEvent = AnnotAttribEvent.GetAnnotAttribEvent(annot, annot.GetAnnotAttrib());
                    AnnotEvent?.UpdateAttrib(AnnotAttrib.FontFamily, new FontFamily(menu.tag.ToString()));
                    AnnotEvent?.UpdateAnnot();
                }
            }
        }

        private void FreeTextAglin_Menu(object obj)
        {
            if (obj as CusMenuItem != null)
            {
                var menu = obj as CusMenuItem;
                var annot = menu.Parameter as AnnotHandlerEventArgs;
                var tag = menu.control.Tag;
                if (annot != null && tag != null)
                {
                    var strTag = tag.ToString();

                    var AnnotEvent = AnnotAttribEvent.GetAnnotAttribEvent(annot, annot.GetAnnotAttrib());
                    if (strTag == "Left")
                    {
                        AnnotEvent?.UpdateAttrib(AnnotAttrib.TextAlign, TextAlignment.Left);
                    }
                    else if (strTag == "Center")
                    {
                        AnnotEvent?.UpdateAttrib(AnnotAttrib.TextAlign, TextAlignment.Center);
                    }
                    else if (strTag == "Right")
                    {
                        AnnotEvent?.UpdateAttrib(AnnotAttrib.TextAlign, TextAlignment.Right);
                    }
                    else if (strTag == "Justify")
                    {
                        AnnotEvent?.UpdateAttrib(AnnotAttrib.TextAlign, TextAlignment.Justify);
                    }

                    AnnotEvent?.UpdateAnnot();
                }
            }
        }

        //便签

        private void StrikeNoteEditStrike_Menu(object obj)
        {
            if (obj as CusMenuItem != null)
            {
                var menu = obj as CusMenuItem;
                var annot = menu.Parameter as AnnotHandlerEventArgs;
                if (annot != null)
                {
                    var sticky = annot as StickyAnnotArgs;
                    sticky.PopupEditWnd();

                    #region 设计重新调整，阅读页空白处，右键菜单，添加链接需要显示，其他和pro mac一样的效果，不显示属性栏

                    //isRightMenuAddAnnot = false;

                    #endregion 设计重新调整，阅读页空白处，右键菜单，添加链接需要显示，其他和pro mac一样的效果，不显示属性栏
                }
            }
        }

        //形状

        private void ShapeLineStyle_Menu(object obj)
        {
            if (obj as CusMenuItem != null)
            {
                var menu = obj as CusMenuItem;
                var annot = menu.Parameter as AnnotHandlerEventArgs;
                var tag = menu.control.Tag;
                if (annot != null && tag != null)
                {
                    var strTag = tag.ToString();
                    var AnnotEvent = AnnotAttribEvent.GetAnnotAttribEvent(annot, annot.GetAnnotAttrib());
                    if (strTag == "Solid")
                    {
                        var dashStyle = AnnotTransfer.GetLineDashStyle(true);
                        AnnotEvent?.UpdateAttrib(AnnotAttrib.LineStyle, dashStyle);
                    }
                    else
                    {
                        var dashStyle = AnnotTransfer.GetLineDashStyle(false);
                        AnnotEvent?.UpdateAttrib(AnnotAttrib.LineStyle, dashStyle);
                    }
                    AnnotEvent?.UpdateAnnot();
                }
            }
        }

        private void ShapeLineDirect_Menu(object obj)
        {
            if (obj as CusMenuItem != null)
            {
                var menu = obj as CusMenuItem;
                var annot = menu.Parameter as LineAnnotArgs;
                var tag = menu.control.Tag;
                if (annot != null && tag != null)
                {
                    var strTag = tag.ToString();
                    var AnnotEvent = AnnotAttribEvent.GetAnnotAttribEvent(annot, annot.GetAnnotAttrib());
                    if (strTag == "Ver")
                    {
                        annot.SetLineVertical();
                    }
                    else
                    {
                        annot.SetLineHorizontal();
                    }
                }
            }
        }

        private void Link_Menu(object obj)
        {
            if (obj is CusMenuItem menuItem)
            {
                if (menuItem.Parameter is LinkAnnotArgs linkAnnotArgs)
                {
                    var result = PDFViewer.RemovePageAnnot(linkAnnotArgs.PageIndex, linkAnnotArgs.AnnotIndex);
                    if (result)
                    {
                        viewContentViewModel.SelectedPrpoertyPanel("PropertyPanelContent", null);
                        bool isTabItemAnnotation = IsBOTATabItemShow(out BOTAContentViewModel bOTAContentViewModel, out BOTAContent bOTAContent, "TabItemAnnotation");
                        if (isTabItemAnnotation)
                        {
                            AnnotationContentViewModel viewModel = GetAnnotationContentViewModel(bOTAContentViewModel, out AnnotationContent annotation);
                            if (viewModel != null)
                            {
                                viewModel.DeleteModifiedAnnot(linkAnnotArgs.PageIndex, linkAnnotArgs.AnnotIndex);
                            }
                        }
                    }
                }
            }
        }

        //图章
        private void StampExportPicture_Menu(object obj)
        {
            if (obj as CusMenuItem != null)
            {
                var menu = obj as CusMenuItem;
                var annot = menu.Parameter as StampAnnotArgs;
                if (annot != null)
                {
                    Microsoft.Win32.SaveFileDialog dlg = new Microsoft.Win32.SaveFileDialog();
                    var format = menu.tag.ToString();
                    if (format == "PDF")
                        dlg.Filter = "PDF|*.pdf";
                    else
                        dlg.Filter = format + "|*." + format.ToLower();

                    dlg.DefaultExt = "." + menu.tag.ToString().ToLower();
                    dlg.FileName = PDFViewer.Document.FileName;
                    if (dlg.ShowDialog() == true)
                    {
                        var stampPicture = dlg.FileName;
                        if (menu.tag.ToString() == "PDF")
                        {
                            var writeStamp = annot.GetStampDrawing();
                            var tempDoc = new CPDFViewer();
                            tempDoc.CreateDocument();
                            if (tempDoc.Document == null)
                            {
                                AlertsMessage alertsMessage = new AlertsMessage();
                                alertsMessage.ShowDialog("", "创建文件失败.", "OK");
                                return;
                            }
                            byte[] buffer;
                            var encoder = new PngBitmapEncoder();
                            encoder.Frames.Add(BitmapFrame.Create(writeStamp));
                            using (var memoryStream = new MemoryStream())
                            {
                                encoder.Save(memoryStream);
                                buffer = memoryStream.ToArray();
                            }

                            tempDoc.Document.InsertPage(0, writeStamp.PixelWidth, writeStamp.PixelHeight, buffer, CPDFDocumentImageMode.CPDFDocumentImageModeScaleAspectFit);
                            var result = tempDoc.Document.WriteToFilePath(dlg.FileName);
                            if (result)
                            {
                            }
                        }
                        else
                        {
                            var writeStamp = annot.GetStampDrawing();
                            using (FileStream stream5 = new FileStream(stampPicture, FileMode.Create))
                            {
                                PngBitmapEncoder encoder5 = new PngBitmapEncoder();
                                encoder5.Frames.Add(BitmapFrame.Create(writeStamp));
                                encoder5.Save(stream5);
                            }
                        }
                    }
                }
            }
        }

        #endregion 注释右键菜单事件

        #region 快捷键

        private void ShortCut_KeyDown(object sender, KeyEventArgs e)
        {
            //之前取消逻辑

            //    if (KeyEventsHelper.IsSingleKey(Key.Escape))
            //    {
            //        if (StrAnnotToolChecked != "Freetext")
            //        {
            //            ExitAnnotationTool();
            //        }
            //        else if (StrAnnotToolChecked == "Freetext")
            //        {
            //            if (PDFViewer.ToolManager.CurrentAnnotArgs is FreeTextAnnotArgs textAnnotArgs)
            //            {
            //                if (PDFViewer.ToolManager.HasTool)
            //                {
            //                    PDFViewer.RemoveTool(true);
            //                }
            //                else
            //                {
            //                    ExitAnnotationTool();
            //                }
            //            }
            //        }
            //    }
            //

            if (e.Key == Key.Escape && PDFViewer.MouseMode == MouseModes.AnnotCreate)
            {
                if (PDFViewer.ToolManager != null && PDFViewer.ToolManager.CurrentAnnotArgs != null)
                {
                    AnnotHandlerEventArgs annotArgs = PDFViewer.ToolManager.CurrentAnnotArgs;
                    switch (annotArgs.EventType)
                    {
                        case AnnotArgsType.AnnotLine:
                        case AnnotArgsType.AnnotSquare:
                        case AnnotArgsType.AnnotCircle:

                        case AnnotArgsType.AnnotSticky:
                        case AnnotArgsType.AnnotFreeText:
                            Trace.WriteLine(StrAnnotToolChecked);
                            if (PDFViewer.ToolManager.HasTool)
                            {
                                PDFViewer.RemoveTool(false);
                            }
                            else { ExitAnnotationTool(); }
                            break;

                        case AnnotArgsType.AnnotHighlight:
                        case AnnotArgsType.AnnotUnderline:
                        case AnnotArgsType.AnnotStrikeout:
                        case AnnotArgsType.AnnotStamp:
                        case AnnotArgsType.AnnotLink:
                        case AnnotArgsType.AnnotFreehand:
                            ExitAnnotationTool();
                            break;
                    }
                }
            }
            else if (KeyEventsHelper.IsModifierKey(ModifierKeys.Shift, Key.None))
            {
                //按住Shift等比缩放
            }
            else if (e.Key == Key.F && e.KeyboardDevice.Modifiers == ModifierKeys.Control)
            {
                if (viewContentViewModel.OpenBOTA == false)
                {
                    viewContentViewModel.OpenBOTA = true;
                }
                bool isBook = IsBOTATabItemShow(out BOTAContentViewModel bOTAContentViewModel, out BOTAContent bOTAContent, "TabItemSearch");
                if (isBook == false)
                {
                    bOTAContent.TabItemSearch.IsSelected = true;
                }
            }

            AnnotToolCtrlAltKey();
        }

        private void ExitAnnotationTool()
        {
            PDFViewer.DisableClearSelectAnnot(false);
            PDFViewer.ClearSelectAnnots();
            StrAnnotToolChecked = "";
            PDFViewer.SetMouseMode(MouseModes.PanTool);
            HandToolIsCheckedEvent(false);
            BtnHandIsChecked = false;
            ShowPropertyPanel(false);
        }

        /// <summary>
        /// 按下Ctrl + Alt + 序列键，响应注释工具
        /// </summary>
        private void AnnotToolCtrlAltKey()
        {
            var tuple = GetCtrlAltKey();
            if (tuple != null)
            {
                if (tuple.Item1 == Key.L)
                    BtnLinkIsChecked = false;

                if (tuple.Item2 == "Eraser")
                {
                    CreateEraseArgs();
                    StrAnnotToolChecked = "Freehand";
                    return;
                }

                AnnotHandlerEventArgs annotArgs = null;
                StrAnnotToolChecked = tuple.Item2;
                FindAnnotTypeKey(tuple.Item2, ref annotArgs);
                if (annotArgs != null)
                {
                    annotArgs.Author = Settings.Default.AppProperties.Description.Author;
                    PDFViewer.SetMouseMode(MouseModes.AnnotCreate);
                    PDFViewer.SetToolParam(annotArgs);
                    PDFViewer.ToolManager.EnableClickCreate = false;
                }
            }
        }

        private Tuple<Key, string> GetCtrlAltKey()
        {
            Dictionary<Key, bool> AnnotToolDir = new Dictionary<Key, bool>();
            AnnotToolDir.Add(Key.H, KeyEventsHelper.IsModifierKey(ModifierKeys.Control | ModifierKeys.Alt, Key.H));
            AnnotToolDir.Add(Key.U, KeyEventsHelper.IsModifierKey(ModifierKeys.Control | ModifierKeys.Alt, Key.U));
            AnnotToolDir.Add(Key.S, KeyEventsHelper.IsModifierKey(ModifierKeys.Control | ModifierKeys.Alt, Key.S));
            AnnotToolDir.Add(Key.P, KeyEventsHelper.IsModifierKey(ModifierKeys.Control | ModifierKeys.Alt, Key.P));
            AnnotToolDir.Add(Key.E, KeyEventsHelper.IsModifierKey(ModifierKeys.Control | ModifierKeys.Alt, Key.E));
            AnnotToolDir.Add(Key.T, KeyEventsHelper.IsModifierKey(ModifierKeys.Control | ModifierKeys.Alt, Key.T));
            AnnotToolDir.Add(Key.N, KeyEventsHelper.IsModifierKey(ModifierKeys.Control | ModifierKeys.Alt, Key.N));
            AnnotToolDir.Add(Key.R, KeyEventsHelper.IsModifierKey(ModifierKeys.Control | ModifierKeys.Alt, Key.R));
            AnnotToolDir.Add(Key.O, KeyEventsHelper.IsModifierKey(ModifierKeys.Control | ModifierKeys.Alt, Key.O));
            AnnotToolDir.Add(Key.A, KeyEventsHelper.IsModifierKey(ModifierKeys.Control | ModifierKeys.Alt, Key.A));
            AnnotToolDir.Add(Key.L, KeyEventsHelper.IsModifierKey(ModifierKeys.Control | ModifierKeys.Alt, Key.L));

            Key key = Key.None;
            foreach (var item in AnnotToolDir.Keys)
            {
                if (AnnotToolDir[item] == true)
                {
                    key = item;
                    break;
                }
            }

            if (key == Key.None)
                return null;

            var tag = "";
            if (key == Key.H || key == Key.U || key == Key.S)
            {
                var str = PDFViewer.GetSelectedText();
                if (string.IsNullOrEmpty(str) == false)
                {
                    if (key == Key.H)
                        tag = "HighLight";
                    else if (key == Key.U)
                        tag = "UnderLine";
                    else if (key == Key.S)
                        tag = "Strikeout";
                }
                else
                {
                    return null;
                }
            }
            else
            {
                if (AnnotToolDir[Key.P])
                    tag = "Freehand";
                else if (AnnotToolDir[Key.T])
                    tag = "Freetext";
                else if (AnnotToolDir[Key.N])
                    tag = "StickyNote";
                else if (AnnotToolDir[Key.R])
                    tag = "Rect";
                else if (AnnotToolDir[Key.O])
                    tag = "Circle";
                else if (AnnotToolDir[Key.A])
                    tag = "Arrow";
                else if (AnnotToolDir[Key.L])
                    tag = "Line";
                else if (AnnotToolDir[Key.E])
                    tag = "Eraser";
            }

            if (tag == "")
                return null;

            return new Tuple<Key, string>(key, tag);
        }

        #endregion 快捷键

        #region Navigation

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

        public void OnNavigatedFrom(NavigationContext navigationContext)
        {
            StrAnnotToolChecked = "";
            //UnBindingPDFViewerHandler();
            //UnBindingEvent();
        }

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

            if (viewContentViewModel != null)
            {
                OpenFileInfo = viewContentViewModel.OpenFileInfo;
            }
            BindingPDFViewerHandler();
            BindingEvent();
            LoaedStickyNotePopup();
            //获取当前是否为滚动状态
            // BtnHandIsChecked = (PDFViewer.MouseMode == MouseModes.Scroll ? true : false);
            BtnHandIsChecked = false;
            HandToolIsCheckedEvent(false);
        }

        #endregion Navigation
    }
}