注释工具 - 优化代码逻辑

PDF Office/PDF Office.csproj

@@ -509,6 +509,7 @@
     <Compile Include="ViewModels\PropertyPanel\ViewModular\PageContentViewModel.cs" />
     <Compile Include="ViewModels\Scan\ScanViwerViewModel.cs" />
     <Compile Include="ViewModels\TipContent\LinkAnnotTipViewModel.cs" />
+    <Compile Include="ViewModels\Tools\AnnotToolContentViewModel.Command.cs" />
     <Compile Include="ViewModels\Tools\ConverterBarContentViewModel.cs" />
     <Compile Include="ViewModels\Dialog\ExtractDialogViewModel.cs" />
     <Compile Include="ViewModels\Dialog\FullScreenWindowViewModel.cs" />

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

@@ -0,0 +1,580 @@
+using ComPDFKit.PDFAnnotation;
+using ComPDFKitViewer;
+using ComPDFKitViewer.AnnotEvent;
+using ComPDFKitViewer.PdfViewer;
+using PDF_Office.CustomControl;
+using PDF_Office.EventAggregators;
+using PDF_Office.Helper;
+using PDF_Office.Properties;
+using PDF_Office.ViewModels.BOTA;
+using PDF_Office.Views.BOTA;
+using PDFSettings;
+using Prism.Mvvm;
+using Prism.Regions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using System.Windows.Media;
+
+namespace PDF_Office.ViewModels.Tools
+{
+    public sealed partial class AnnotToolContentViewModel : BindableBase, INavigationAware
+    {
+        #region 事件绑定和解绑
+        private void BindingEvent()
+        {
+            //属性面板与注释工具栏绑定：属性面板的属性变化，会同步注释工具栏的属性值
+            //比如在属性面板里更改注释颜色，会同时更新工具栏对应的工具颜色
+            propertyPanel.DataChanged -= AnnotPropertyPanel_DataChanged;
+            propertyPanel.DataChanged += AnnotPropertyPanel_DataChanged;
+            propertyPanel.DefaultStored -= AnnotProperty_DefaultStored;
+            propertyPanel.DefaultStored += AnnotProperty_DefaultStored;
+            propertyPanel.AnnotTypeChanged -= AnnotPropertyPanel_AnnotTypeChanged;
+            propertyPanel.AnnotTypeChanged += AnnotPropertyPanel_AnnotTypeChanged;
+        }
+
+        private void UnBindingEvent()
+        {
+            propertyPanel.DataChanged -= AnnotPropertyPanel_DataChanged;
+            propertyPanel.DefaultStored -= AnnotProperty_DefaultStored;
+            propertyPanel.AnnotTypeChanged -= AnnotPropertyPanel_AnnotTypeChanged;
+        }
+
+        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.WidgetClickHander -= PDFViewer_WidgetClickHander;
+                PDFViewer.WidgetClickHander += PDFViewer_WidgetClickHander;
+
+                PDFViewer.SnapshotCommandHandler -= PDFViewer_SnapshotCommandHandler;
+                PDFViewer.SnapshotCommandHandler += PDFViewer_SnapshotCommandHandler;
+            }
+        }
+        private void UnBindingPDFViewerHandler()
+        {
+            if (PDFViewer != null)
+            {
+                PDFViewer.AnnotEditHandler -= PDFViewer_AnnotEditHandler;
+                PDFViewer.AnnotActiveHandler -= PDFViewer_AnnotActiveHandler;
+                PDFViewer.AnnotCommandHandler -= PDFViewer_AnnotCommandHandler;
+                PDFViewer.WidgetClickHander -= PDFViewer_WidgetClickHander;
+                PDFViewer.SnapshotCommandHandler -= PDFViewer_SnapshotCommandHandler;
+            }
+        }
+        #endregion
+
+        #region PDFViewer事件
+        //选中和非选中注释，右键菜单
+        private void PDFViewer_AnnotActiveHandler(object sender, AnnotAttribEvent e)
+        {
+            if (e != null)
+            {
+                var annot = e.AnnotItemsList[0];
+                if (annot != null)
+                {
+                    //IsAnnotCreateReset：是否为创建注释的状态
+                    if (e.AnnotItemsList.Count == 1 && e.IsAnnotCreateReset == false)
+                    {
+                        switch (annot.EventType)
+                        {
+                            case AnnotArgsType.AnnotHighlight:
+                                e.IsAnnotCreateReset = false;
+                                GetHighLight(annot as TextHighlightAnnotArgs);
+                                break;
+
+                            case AnnotArgsType.AnnotUnderline:
+                                GetUnderLine(annot as TextUnderlineAnnotArgs);
+                                break;
+
+                            case AnnotArgsType.AnnotStrikeout:
+                                GetStrikeout(annot as TextStrikeoutAnnotArgs);
+                                break;
+
+                            case AnnotArgsType.AnnotSquiggly:
+                                GetSquiggly(annot as TextSquigglyAnnotArgs);
+                                break;
+
+                            case AnnotArgsType.AnnotFreehand:
+                                GetFreehand(annot as FreehandAnnotArgs);
+                                break;
+
+                            case AnnotArgsType.AnnotFreeText:
+                                GetFreetext(annot as FreeTextAnnotArgs);
+                                break;
+
+                            case AnnotArgsType.AnnotSquare:
+                                GetRect(annot as SquareAnnotArgs);
+                                break;
+
+                            case AnnotArgsType.AnnotCircle:
+                                GetCircle(annot as CircleAnnotArgs);
+                                break;
+
+                            case AnnotArgsType.AnnotLine:
+                                bool isLine = true;
+                                if (e.Attribs.ContainsKey(AnnotAttrib.LineStart))
+                                {
+                                    if ((C_LINE_TYPE)e.Attribs[AnnotAttrib.LineStart] != C_LINE_TYPE.LINETYPE_UNKNOWN && (C_LINE_TYPE)e.Attribs[AnnotAttrib.LineStart] != C_LINE_TYPE.LINETYPE_NONE)
+                                    {
+                                        isLine = false;
+                                    }
+                                }
+                                if (e.Attribs.ContainsKey(AnnotAttrib.LineEnd))
+                                {
+                                    if ((C_LINE_TYPE)e.Attribs[AnnotAttrib.LineEnd] != C_LINE_TYPE.LINETYPE_UNKNOWN && (C_LINE_TYPE)e.Attribs[AnnotAttrib.LineEnd] != C_LINE_TYPE.LINETYPE_NONE)
+                                    {
+                                        isLine = false;
+                                    }
+                                }
+
+                                if (isLine)
+                                    GetArrowLine("Line", annot as LineAnnotArgs);
+                                else
+                                    GetArrowLine("Arrow", annot as LineAnnotArgs);
+
+                                break;
+
+                            case AnnotArgsType.AnnotLink:
+                                viewContentViewModel.IsCreateLink = false;
+                                GetLink(annot as LinkAnnotArgs, e);
+
+                                break;
+
+                            case AnnotArgsType.AnnotSticky:
+                                GetStickyNote(annot as StickyAnnotArgs);
+                                break;
+                        }
+                        //记录这次选中的注释，之后创建注释会跟随上次选中注释的属性值
+                        PDFViewer.SetToolParam(annot);
+
+                    }
+                    else if (e.AnnotItemsList.Count == 1 && e.IsAnnotCreateReset == true)
+                    {
+                        switch (annot.EventType)
+                        {
+                            case AnnotArgsType.AnnotLink:
+                                viewContentViewModel.IsCreateLink = false;
+                                GetLink(annot as LinkAnnotArgs, e);
+                                break;
+
+                                //case AnnotArgsType.AnnotStamp://图章
+                                //    GetStamp();
+                                //    break;
+
+                                //case AnnotArgsType.AnnotStamp://签名
+                                //    annotArgs = GetSignature();
+                                //    isTemplateAnnot = true;
+                                //    break;
+                        }
+
+                        //TODO:设计已重新调整为：修改注释后，会作用到之后添加的注释中。因此先把此逻辑“创建注释后，会自动回到默认值”注释掉
+                        //if (ToolExpandDict.ContainsValue(e.AnnotItemsList[0].EventType))
+                        //{
+                        //    foreach(var item in ToolExpandDict)
+                        //    {
+                        //        if(item.Value == e.AnnotItemsList[0].EventType)
+                        //        {
+                        //            FindAnnotTypeKey(item.Key, ref annot);
+                        //            break;
+                        //        }
+                        //    }
+                        //}
+                        ShowPropertyPanel();
+                    }
+                }
+            }
+            else
+            {
+                viewContentViewModel.SelectedPrpoertyPanel("PropertyPanelContent", null);
+            }
+        }
+
+        //在注释工具的状态下，右键菜单
+        private void PDFViewer_AnnotCommandHandler(object sender, AnnotCommandArgs e)
+        {
+            if (e.AnnotEventArgsList == null || (PDFViewer != null && PDFViewer.MouseMode == MouseModes.FormEditTool))
+                return;
+
+            switch (e.CommandType)
+            {
+                case CommandType.Context:
+                    if (e.AnnotEventArgsList.Count > 0)
+                    {
+                        if (App.mainWindowViewModel.SelectedItem.IsInReadctonMode && e.AnnotEventArgsList[0].EventType == AnnotArgsType.AnnotRedaction)
+                        {
+                            //绑定标记密文处右键菜单
+                            events.GetEvent<RedactionCommandEvent>().Publish(new RedactionCommandEventArgs() { UniCode = App.mainWindowViewModel.SelectedItem.Unicode, Sender = sender, args = e });
+                        }
+                        else
+                        {
+                            e.PopupMenu = SelectAnnotContextMenu(sender);
+                        }
+                        if (e.PopupMenu != null)
+                        {
+                            e.Handle = true;
+                        }
+                    }
+                    else
+                    {
+                        if (e.PressOnSelectedText)
+                        {
+                            e.PopupMenu = NoneSelectAnnotContextMenu(sender, e);
+                            if (e.PopupMenu != null)
+                            {
+                                e.Handle = true;
+                            }
+                        }
+                        else
+                        {
+                            e.PopupMenu = ViewerContextMenu();
+                            if (e.PopupMenu != null)
+                            {
+                                e.Handle = true;
+                            }
+                        }
+                    }
+
+                    break;
+            }
+        }
+        
+        private void PDFViewer_SnapshotCommandHandler(object sender, SnapshotCommandArgs e)
+        {
+            SnapshotEditToolArgs snapToolArgs = (SnapshotEditToolArgs)PDFViewer.ToolManager.CurrentAnnotArgs;
+
+            SnapshotEditMenuViewModel.SnapToolArgs = snapToolArgs;
+            SnapshotEditMenuViewModel.PDFViewer = PDFViewer;
+            SnapshotEditMenuViewModel.SnapToolEvent += SnapshotEditMenuViewModel_SnapToolEvent; ;
+            var popMenu = App.Current.FindResource("SnapshotContextMenu") as ContextMenu;
+
+            if (e.HitSnapshotTool && e.SnapshotRect.Width > 0 && e.SnapshotRect.Height > 0)
+            {
+                e.PopupMenu = popMenu;
+                e.Handle = true;
+
+                if (popMenu != null && popMenu.Items.Count == 5)
+                {
+                    //复制
+                    MenuItem menuItem = popMenu.Items[0] as MenuItem;
+                    menuItem.CommandTarget = PDFViewer;
+                    menuItem.Command = SnapshotEditMenuViewModel.SnapCopyCommand;
+                    //导出
+                    menuItem = popMenu.Items[1] as MenuItem;
+                    menuItem.CommandTarget = PDFViewer;
+                    if (menuItem.Items.Count == 3)
+                    {
+                        MenuItem menuItem1 = menuItem.Items[0] as MenuItem;
+                        menuItem1.CommandTarget = PDFViewer;
+                        menuItem1.Command = SnapshotEditMenuViewModel.ExportPNGCommand;
+
+                        menuItem1 = menuItem.Items[1] as MenuItem;
+                        menuItem1.CommandTarget = PDFViewer;
+                        menuItem1.Command = SnapshotEditMenuViewModel.ExportJPGCommand;
+
+                        menuItem1 = menuItem.Items[2] as MenuItem;
+                        menuItem1.CommandTarget = PDFViewer;
+                        menuItem1.Command = SnapshotEditMenuViewModel.ExportPDFCommand;
+                    }
+
+                    //裁剪
+                    menuItem = popMenu.Items[2] as MenuItem;
+                    menuItem.CommandTarget = PDFViewer;
+                    menuItem.Command = SnapshotEditMenuViewModel.CroppingCommand;
+
+                    //缩放至所选区域
+                    menuItem = popMenu.Items[3] as MenuItem;
+                    menuItem.CommandTarget = PDFViewer;
+                    menuItem.Visibility = Visibility.Collapsed;
+                    //menuItem.Command = snapshotEditMenuViewModel.CroppingCommand;
+
+                    //打印
+                    menuItem = popMenu.Items[4] as MenuItem;
+                    menuItem.CommandTarget = PDFViewer;
+                    menuItem.Command = SnapshotEditMenuViewModel.PrintCommand;
+                }
+            }
+        }
+        private void SnapshotEditMenuViewModel_SnapToolEvent(object sender, KeyValuePair<string, object> e)
+        {
+            switch (e.Key)
+            {
+                case "CloseSnap":
+                    {
+                        #region to do
+
+                        //var item = PDFViewerTab.SelectedItem as TabItem;
+                        //if (item == null)
+                        //{
+                        //    ClearSelectedToolPanel();
+                        //    return;
+                        //}
+                        //Grid grid = item.Content as Grid;
+                        //if (grid == null || grid.Children.Count == 0)
+                        //{
+                        //    ClearSelectedToolPanel();
+                        //    return;
+                        //}
+                        //PDFViewerCtrl pdfViewer = grid.Children[0] as PDFViewerCtrl;
+                        //if (pdfViewer == null)
+                        //{
+                        //    ClearSelectedToolPanel();
+                        //    return;
+                        //}
+
+                        #endregion to do
+
+                        switch (PDFViewer.MouseMode)
+                        {
+                            case MouseModes.SelectTextTool:
+                                break;
+
+                            default:
+                                BtnSelecttoolIsChecked = false;
+                                break;
+                        }
+                    }
+                    break;
+
+                default:
+                    break;
+            }
+        }
+
+
+        private void PDFViewer_AnnotEditHandler(object sender, List<AnnotEditEvent> e)
+        {
+            if (e != null && e.Count > 0)
+            {
+                for (int i = 0; i < e.Count; i++)
+                {
+                    AnnotEditEvent editEvent = e[i];
+                    switch (editEvent.EditAction)
+                    {
+                        case ActionType.Add:
+                            BOTAContentViewModel bOTAContentViewModel = null;
+                            BOTAContent bOTAContent = null;
+                            bool isTabItemAnnotation = IsBOTATabItemShow(out bOTAContentViewModel, out bOTAContent, "TabItemAnnotation");
+
+                            if (viewContentViewModel.OpenBOTA == true && isTabItemAnnotation == true)
+                            {
+                                AnnotationContentViewModel viewModel = GetAnnotationContentViewModel(bOTAContentViewModel);
+
+                                if (viewModel != null)
+                                {
+                                    int pageindex = editEvent.PageIndex;
+                                    int annotindex = editEvent.AnnotIndex;
+                                    viewModel.UpdateAddedAnnot(pageindex, annotindex);
+                                }
+                            }
+                            break;
+
+                        case ActionType.Del:
+                            isTabItemAnnotation = IsBOTATabItemShow(out bOTAContentViewModel, out bOTAContent, "TabItemAnnotation");
+                            if (isTabItemAnnotation)
+                            {
+                                AnnotationContentViewModel viewModel = GetAnnotationContentViewModel(bOTAContentViewModel);
+
+                                if (viewModel != null)
+                                {
+                                    int pageindex = editEvent.PageIndex;
+                                    int annotindex = editEvent.AnnotIndex;
+                                    viewModel.UpdateModifiedAnnot(pageindex, annotindex, true);
+                                }
+                            }
+                            break;
+
+                        case ActionType.Modify:
+                            isTabItemAnnotation = IsBOTATabItemShow(out bOTAContentViewModel, out bOTAContent, "TabItemAnnotation");
+                            if (isTabItemAnnotation)
+                            {
+                                AnnotationContentViewModel viewModel = GetAnnotationContentViewModel(bOTAContentViewModel);
+
+                                if (viewModel != null)
+                                {
+                                    int pageindex = editEvent.PageIndex;
+                                    int annotindex = editEvent.AnnotIndex;
+                                    viewModel.UpdateModifiedAnnot(pageindex, annotindex, false);
+                                }
+                            }
+                            break;
+
+                        case ActionType.TextEdit:
+                            break;
+
+                        default:
+                            break;
+                    }
+                }
+            }
+        }
+
+        private void PDFViewer_WidgetClickHander(object sender, WidgetArgs e)
+        {
+        }
+        #endregion
+
+        #region BindingEvent事件
+        private void AnnotProperty_DefaultStored(object sender, object e)
+        {
+
+        }
+
+        private void AnnotPropertyPanel_AnnotTypeChanged(object sender, Dictionary<AnnotArgsType, object> e)
+        {
+            if (e != null)
+            {
+                AnnotHandlerEventArgs annotArgs = null;
+                foreach (AnnotArgsType argsType in e.Keys)
+                {
+                    switch (argsType)
+                    {
+                        case AnnotArgsType.AnnotSquare:
+                            annotArgs = GetRect();
+                            break;
+
+                        case AnnotArgsType.AnnotCircle:
+                            annotArgs = GetCircle();
+                            break;
+
+                        case AnnotArgsType.AnnotLine:
+                            var LineTag = e[argsType] as string;
+                            annotArgs = GetArrowLine(LineTag);
+                            break;
+                    }
+                    if (annotArgs != null)
+                    {
+                        annotArgs.Author = Settings.Default.AppProperties.Description.Author;
+                        PDFViewer.SetMouseMode(MouseModes.AnnotCreate);
+                        PDFViewer.SetToolParam(annotArgs);
+                    }
+                    ShowPropertyPanel();
+                }
+            }
+        }
+
+        private void AnnotPropertyPanel_DataChanged(object sender, Dictionary<AnnotArgsType, object> e)
+        {
+            if (e != null)
+            {
+                foreach (AnnotArgsType argsType in e.Keys)
+                {
+                    switch (argsType)
+                    {
+                        case AnnotArgsType.AnnotHighlight:
+                            if (e[argsType] is Color)
+                            {
+                                HighLightColor = new SolidColorBrush((Color)e[argsType]);
+                            }
+                            if (e[argsType] is double)
+                            {
+                                HighLightOpacity = (double)e[argsType];
+                            }
+                            break;
+
+                        case AnnotArgsType.AnnotUnderline:
+                            if (e[argsType] is Color)
+                            {
+                                UnderLineColor = new SolidColorBrush((Color)e[argsType]);
+                            }
+                            if (e[argsType] is double)
+                            {
+                                underLineOpacity = (double)e[argsType];
+                            }
+                            break;
+
+                        case AnnotArgsType.AnnotSquiggly:
+                            if (e[argsType] is Color)
+                            {
+                                SquigglyColor = new SolidColorBrush((Color)e[argsType]);
+                            }
+                            if (e[argsType] is double)
+                            {
+                                SquigglyOpacity = (double)e[argsType];
+                            }
+                            break;
+
+                        case AnnotArgsType.AnnotStrikeout:
+                            if (e[argsType] is Color)
+                            {
+                                StrikeoutColor = new SolidColorBrush((Color)e[argsType]);
+                            }
+                            if (e[argsType] is double)
+                            {
+                                StrikeoutOpacity = (double)e[argsType];
+                            }
+                            break;
+
+                        case AnnotArgsType.AnnotFreehand:
+                            if (e[argsType] is Color)
+                            {
+                                // FreehandPath.Fill = new SolidColorBrush((Color)e[argsType]);
+                            }
+                            if (e[argsType] is double)
+                            {
+                                //  FreehandPath.Opacity = (double)e[argsType];
+                            }
+                            break;
+
+                        case AnnotArgsType.AnnotErase:
+                            if (e[argsType] is ToggleButton)
+                            {
+                                ToggleButton clickBtn = e[argsType] as ToggleButton;
+
+                                if (clickBtn.IsChecked == true)
+                                {
+                                    if (clickBtn.Tag.ToString() == "PenBtn")
+                                    {
+                                        CustomIconToggleBtn btn = new CustomIconToggleBtn();
+                                        btn.Tag = "Freehand"; btn.IsChecked = true;
+                                        BtnMyTools_Click(btn);
+                                        break;
+                                    }
+                                    EraseArgs eraseArgs = new EraseArgs();
+                                    eraseArgs.UIBorderColor = Color.FromArgb(0x1A, 0x00, 0x00, 0x00);
+                                    eraseArgs.UIFillColor = Color.FromArgb(0x1A, 0x00, 0x00, 0x00);
+                                    eraseArgs.Thickness = 10;
+                                    DefaultAnnotProperty annotProperty = SettingHelper.GetAnnotDefaultProperty(AnnotArgsType.AnnotErase);
+                                    if (annotProperty != null)
+                                    {
+                                        eraseArgs.Thickness = annotProperty.Thickness;
+                                    }
+
+                                    PDFViewer.ClearSelectAnnots(false);
+                                    PDFViewer.SetMouseMode(MouseModes.AnnotCreate);
+                                    PDFViewer.SetToolParam(eraseArgs);
+
+                                    Dictionary<AnnotAttrib, object> annotAttribsList = new Dictionary<AnnotAttrib, object>();
+                                    annotAttribsList[AnnotAttrib.Color] = eraseArgs.UIBorderColor;
+                                    annotAttribsList[AnnotAttrib.FillColor] = eraseArgs.UIFillColor;
+                                    annotAttribsList[AnnotAttrib.Thickness] = eraseArgs.Thickness;
+                                    AddToPropertyPanel("FreehandAnnotProperty", "Freehand", eraseArgs, annotAttribsList);
+
+                                }
+                            }
+                            break;
+                    }
+                }
+            }
+        }
+
+        #endregion
+
+    }
+
+}

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

@@ -1,4 +1,5 @@
 using ComPDFKit.PDFAnnotation;
+using ComPDFKit.PDFDocument;
 using ComPDFKitViewer;
 using ComPDFKitViewer.AnnotEvent;
 using ComPDFKitViewer.PdfViewer;
@@ -18,6 +19,7 @@ using System.Text;
 using System.Threading.Tasks;
 using System.Windows;
 using System.Windows.Controls;
+using System.Windows.Input;
 using System.Windows.Media;
 
 namespace PDF_Office.ViewModels.Tools
@@ -26,13 +28,8 @@ namespace PDF_Office.ViewModels.Tools
     {
         #region 初始化
 
-        private void BindingEvent()
-        {
-            propertyPanel.DataChanged += AnnotPropertyPanel_DataChanged;
-            propertyPanel.DefaultStored += AnnotProperty_DefaultStored;
-            propertyPanel.AnnotTypeChanged += AnnotPropertyPanel_AnnotTypeChanged;
-        }
-
+        #region 初始化数据
+        //初始化注释的属性值，并存在本地缓存数据集里
         private void InitDefaultValue()
         {
             InitAnnotHighlight();
@@ -117,9 +114,97 @@ namespace PDF_Office.ViewModels.Tools
             }
         }
 
-        #endregion 初始化
+        //用来记录选中和创建注释的标识
+        private void InitToolDict()
+        {
+            ToolExpandDict.Add("SnapshotEdit", AnnotArgsType.SnapshotWithEditTool);
+            ToolExpandDict.Add("HighLight", AnnotArgsType.AnnotHighlight);
+            ToolExpandDict.Add("UnderLine", AnnotArgsType.AnnotUnderline);
+            ToolExpandDict.Add("Squiggly", AnnotArgsType.AnnotSquiggly);
+            ToolExpandDict.Add("Strikeout", AnnotArgsType.AnnotStrikeout);
+            ToolExpandDict.Add("Freehand", AnnotArgsType.AnnotFreehand);
+            ToolExpandDict.Add("Freetext", AnnotArgsType.AnnotFreeText);
+            ToolExpandDict.Add("StickyNote", AnnotArgsType.AnnotSticky);
+            ToolExpandDict.Add("Rect", AnnotArgsType.AnnotSquare);
+            ToolExpandDict.Add("Circle", AnnotArgsType.AnnotCircle);
+            ToolExpandDict.Add("Arrow", AnnotArgsType.AnnotLine);
+            ToolExpandDict.Add("Line", AnnotArgsType.AnnotLine);
+            ToolExpandDict.Add("Link", AnnotArgsType.AnnotLink);
+        }
+        #endregion
+
+        #endregion
 
         #region 注释工具
+        //注释工具
+        private void FindAnnotTypeKey(string tag, ref AnnotHandlerEventArgs annotArgs)
+        {
+            switch (tag)
+            {
+                case "SnapshotEdit"://内容选择
+                    annotArgs = GetSnapshotEdit();
+                    break;
+
+                case "HighLight"://字体高亮
+                    annotArgs = GetHighLight();
+                    break;
+
+                case "UnderLine"://下划线
+                    annotArgs = GetUnderLine();
+                    break;
+
+                case "Squiggly"://波浪线
+                    annotArgs = GetSquiggly();
+                    break;
+
+                case "Strikeout"://删除线
+                    annotArgs = GetStrikeout();
+                    break;
+
+                case "Freehand"://手绘
+                    annotArgs = GetFreehand();
+                    break;
+
+                case "Freetext"://文本
+                    annotArgs = GetFreetext();
+                    break;
+
+                case "StickyNote"://便签
+                    annotArgs = GetStickyNote();
+                    break;
+
+                case "Rect"://矩形
+                    annotArgs = GetRect();
+                    break;
+
+                case "Circle"://圆
+                    annotArgs = GetCircle();
+                    break;
+
+                case "Arrow"://箭头
+                case "Line"://线
+                    annotArgs = GetArrowLine(tag);
+                    break;
+
+                case "Stamp"://图章
+                    annotArgs = GetStamp();
+                    break;
+
+                case "Image":
+                    annotArgs = GetImage();
+                    break;
+
+                case "Signature"://签名
+                    annotArgs = GetSignature();
+                    PDFViewer.SetMouseMode(MouseModes.PanTool);//清空其他注释
+                    break;
+
+                case "Link"://链接
+                    viewContentViewModel.IsCreateLink = false;
+                    annotArgs = GetLink();
+                    break;
+            }
+        }
 
         /// <summary>
         /// 高亮注释
@@ -749,5 +834,238 @@ namespace PDF_Office.ViewModels.Tools
         }
 
         #endregion 注释工具
+
+
+        #region 属性面板
+
+        /// <summary>
+        /// 展开显示属性面板
+        /// </summary>
+        private void ShowPropertyPanel(bool show = true)
+        {
+            viewContentViewModel.IsPropertyOpen = show;
+        }
+
+        #endregion
+
+        #region 菜单
+
+        private ContextMenu ViewerContextMenu()
+        {
+            ContextMenu contextMenu = App.Current.FindResource("ViewerContextMenu") as ContextMenu;
+            //contextMenu.Loaded += ContextMenu_Loaded;
+            ContextMenu_Loaded(contextMenu, null);
+            return contextMenu;
+        }
+
+        private void ContextMenu_Loaded(object sender, RoutedEventArgs e)
+        {
+            ContextMenu contextMenu = sender as ContextMenu;
+            if (contextMenu.Items.Count > 0)
+            {
+                int index = PDFViewer.CurrentIndex;
+                //检测是否已存在相同数据
+                CPDFBookmark list = PDFViewer.Document.GetBookmarkList().FirstOrDefault(q => q.PageIndex == index);
+                if (list != null)
+                {
+                    isAddBookMark = false;
+                }
+                else
+                {
+                    isAddBookMark = true;
+                }
+
+                foreach (var item in contextMenu.Items)
+                {
+                    if (item is MenuItem menuItem1)
+                    {
+                        //if (menuItem1.Tag.ToString() == "DisplayAnnot" || menuItem1.Tag.ToString() == "HiddenAnnot")
+                        //{
+                        //    SetMenuItemVisibility(menuItem1, "DisplayAnnot", "HiddenAnnot", isHiddenAnnot);
+                        //}
+
+                        switch (menuItem1.Tag.ToString())
+                        {
+                            case "Copy":
+                                //粘贴
+                                if (!ApplicationCommands.Paste.CanExecute(null, (UIElement)sender))
+                                {
+                                    menuItem1.IsEnabled = false;
+                                    menuItem1.Opacity = 0.5;
+                                }
+                                else
+                                {
+                                    menuItem1.IsEnabled = true;
+                                    menuItem1.Opacity = 1;
+                                }
+                                menuItem1.CommandTarget = (UIElement)sender;
+                                menuItem1.Command = ApplicationCommands.Copy;
+                                break;
+
+                            case "AddAnnotation":
+                                if (menuItem1.Items.Count > 0)
+                                {
+                                    SetAddAnnotation(menuItem1.Items);
+                                }
+                                break;
+
+                            case "HiddenAnnot":
+                                menuItem1.Click -= HiddenAnnot_Click;
+
+                                menuItem1.Click += HiddenAnnot_Click;
+                                SetMenuItemVisibility(menuItem1, "DisplayAnnot", "HiddenAnnot", isHiddenAnnot);
+
+                                break;
+
+                            case "DisplayAnnot":
+
+                                menuItem1.Click -= DisplayAnnot_Click;
+                                menuItem1.Click += DisplayAnnot_Click;
+                                SetMenuItemVisibility(menuItem1, "DisplayAnnot", "HiddenAnnot", isHiddenAnnot);
+                                break;
+
+                            case "AddBookMark":
+                                //if (isAddBookMark)
+                                //{
+                                //    menuItem1.Visibility = Visibility.Visible;
+                                //}
+                                menuItem1.Click -= AddBookMark_Click;
+                                menuItem1.Click += AddBookMark_Click;
+                                SetMenuItemVisibility(menuItem1, "DelBookMark", "AddBookMark", isAddBookMark);
+                                break;
+
+                            case "DelBookMark":
+                                //if (isAddBookMark == false)
+                                //{
+                                //    menuItem1.Visibility = Visibility.Visible;
+                                //}
+                                menuItem1.Click -= DelBookMark_Click;
+                                menuItem1.Click += DelBookMark_Click;
+                                SetMenuItemVisibility(menuItem1, "DelBookMark", "AddBookMark", isAddBookMark);
+                                break;
+
+                            case "ToolMode":
+                                if (menuItem1.Items.Count > 0)
+                                {
+                                    SetToolMode(menuItem1.Items);
+                                }
+                                break;
+
+                            case "ReadModel":
+                                SetMenuItemVisibility(menuItem1, "ReadModel", "UnReadModel", App.IsBookMode);
+                                menuItem1.Click -= ReadModel_Click;
+                                menuItem1.Click += ReadModel_Click;
+                                break;
+
+                            case "UnReadModel":
+                                SetMenuItemVisibility(menuItem1, "ReadModel", "UnReadModel", App.IsBookMode);
+                                menuItem1.Click -= UnReadModel_Click;
+                                menuItem1.Click += UnReadModel_Click;
+                                break;
+
+                            case "ViewZoom":
+                                if (menuItem1.Items.Count > 0)
+                                {
+                                    ViewZoom(menuItem1.Items);
+                                }
+                                break;
+
+                            case "PageDisplay":
+                                if (menuItem1.Items.Count > 0)
+                                {
+                                    PageDisplay(menuItem1.Items);
+                                }
+                                break;
+
+                            case "Select":
+                                menuItem1.Click -= Select_Click;
+
+                                menuItem1.Click += Select_Click;
+                                break;
+
+                            case "Print":
+                                menuItem1.Command = viewContentViewModel.PrintCommand;
+                                break;
+                        }
+                    }
+                }
+
+
+            }
+        }
+
+        private void SetMenuItemVisibility(MenuItem menuItem1, string v2, string v3, bool flag)
+        {
+            if (menuItem1.Tag.ToString() == v2 && flag)
+            {
+                menuItem1.Visibility = Visibility.Collapsed;
+            }
+            if (menuItem1.Tag.ToString() == v2 && flag == false)
+            {
+                menuItem1.Visibility = Visibility.Visible;
+            }
+            if (menuItem1.Tag.ToString() == v3 && flag == false)
+            {
+                menuItem1.Visibility = Visibility.Collapsed;
+            }
+            if (menuItem1.Tag.ToString() == v3 && flag)
+            {
+                menuItem1.Visibility = Visibility.Visible;
+            }
+        }
+
+        private ContextMenu SelectAnnotContextMenu(object sender)
+        {
+            var popMenu = App.Current.FindResource("SelectAnnotContextMenu") as ContextMenu;
+            if (popMenu != null && popMenu.Items.Count == 4)
+            {
+                //剪切
+                MenuItem menuItem = popMenu.Items[0] as MenuItem;
+                menuItem.CommandTarget = (UIElement)sender;
+                menuItem.Command = ApplicationCommands.Cut;
+                //复制
+                menuItem = popMenu.Items[1] as MenuItem;
+                menuItem.CommandTarget = (UIElement)sender;
+                menuItem.Command = ApplicationCommands.Copy;
+                //删除
+                menuItem = popMenu.Items[2] as MenuItem;
+                menuItem.CommandTarget = (UIElement)sender;
+                menuItem.Command = ApplicationCommands.Delete;
+
+                //笔记
+                //menuItem = popMenu.Items[2] as MenuItem;
+                //menuItem.CommandTarget = (UIElement)sender;
+                //menuItem.Command = ApplicationCommands.no;
+            }
+            return popMenu;
+        }
+
+        private ContextMenu NoneSelectAnnotContextMenu(object sender, AnnotCommandArgs annotCommand)
+        {
+            ContextMenu popMenu = new ContextMenu();
+            popMenu.FontSize = 14;
+
+            MenuItem menuItem = new MenuItem();
+            menuItem = new MenuItem();
+            menuItem.CommandTarget = (UIElement)sender;
+            menuItem.Command = ApplicationCommands.Copy;
+            popMenu.Items.Add(menuItem);
+
+            menuItem = new MenuItem();
+            menuItem.CommandTarget = (UIElement)sender;
+            menuItem.Command = ApplicationCommands.Paste;
+            popMenu.Items.Add(menuItem);
+
+            menuItem = new MenuItem();
+            menuItem.CommandTarget = (UIElement)sender;
+            menuItem.Header = "创建链接";
+            menuItem.CommandParameter = new object[] { this, annotCommand };
+            menuItem.Command = viewContentViewModel.CreateLinkCommand;
+            menuItem.Click += MenuItem_Click;
+            popMenu.Items.Add(menuItem);
+            return popMenu;
+        }
+        #endregion
+
     }
 }

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

@@ -3,6 +3,9 @@ using ComPDFKitViewer.PdfViewer;
 using PDF_Office.CustomControl;
 using PDF_Office.ViewModels.PropertyPanel.AnnotPanel;
 using Prism.Commands;
+using Prism.Events;
+using Prism.Regions;
+using Prism.Services.Dialogs;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -136,15 +139,31 @@ namespace PDF_Office.ViewModels.Tools
 
         #endregion 属性
 
+        public string PropertyRegionName { get; set; }
+        private IEventAggregator events;
+        public IDialogService dialogs;
+        public IRegionManager region;
+
         private CPDFViewer PDFViewer;
         private ViewContentViewModel viewContentViewModel;
+        private AnnotPropertyPanel propertyPanel = new AnnotPropertyPanel();
+        private Dictionary<string, AnnotArgsType> ToolExpandDict = new Dictionary<string, AnnotArgsType>();
+        private bool isHiddenAnnot = true;
+        private bool isAddBookMark = true;
+        //private BookmarkContentViewModel bookmarkContentViewModel = null;
+        //private BookmarkContent bookmark = null;
+        //private BOTAContent bOTAContent = null;
+        #region 事件
         public DelegateCommand<CustomIconToggleBtn> MyToolsCommand { get; set; }
 
         private SnapshotEditMenuViewModel snapshotEditMenuViewModel = new SnapshotEditMenuViewModel();
         public SnapshotEditMenuViewModel SnapshotEditMenuViewModel { get => snapshotEditMenuViewModel; set => snapshotEditMenuViewModel = value; }
         public DelegateCommand<object> SetAddAnnotationCommand { get; set; }
 
-        private AnnotPropertyPanel propertyPanel = new AnnotPropertyPanel();
+        #endregion
+
+
+
     }
 
     public enum AddAnnotType