PDFOffice_Windows_exe/PDF Office/ViewModels/BOTA/AnnotationContentViewModel.cs

using ComPDFKit.Import;
using ComPDFKit.PDFAnnotation;
using ComPDFKit.PDFDocument;
using ComPDFKit.PDFPage;
using ComPDFKitViewer;
using ComPDFKitViewer.AnnotEvent;
using ComPDFKitViewer.PdfViewer;
using DryIoc;
using ImTools;
using Microsoft.Office.Interop.Excel;
using Microsoft.Office.Interop.PowerPoint;
using Microsoft.Office.Interop.Word;
using PDF_Office.CustomControl;
using PDF_Office.DataConvert;
using PDF_Office.Helper;
using PDF_Office.Model;
using PDF_Office.Model.BOTA;
using PDF_Office.Views.BOTA;
using PDF_Office.Views.PropertyPanel.AnnotPanel;
using PDF_Office.Views.Scan;
using Prism.Commands;
using Prism.Mvvm;
using Prism.Regions;
using Prism.Services.Dialogs;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Configuration;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Annotations;
using System.Windows.Annotations.Storage;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Forms;
using System.Windows.Markup;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;
using static Dropbox.Api.Files.SearchMatchType;
using static Dropbox.Api.TeamLog.SpaceCapsType;
using static System.Net.Mime.MediaTypeNames;
using static System.Windows.Forms.VisualStyles.VisualStyleElement;
using static System.Windows.Forms.VisualStyles.VisualStyleElement.ToolBar;
using Border = System.Windows.Controls.Border;
using ListBox = System.Windows.Controls.ListBox;
using Task = System.Threading.Tasks.Task;
using TextBox = System.Windows.Controls.TextBox;

using Winform = System.Windows.Forms;

namespace PDF_Office.ViewModels.BOTA
{
    public class AnnotationContentViewModel : BindableBase, INavigationAware
    {
        private ListBox listBox;
        private IRegionManager region;
        private IDialogService dialogs;
        private Visibility isEmptyPanelVisibility = Visibility.Visible;

        public ViewContentViewModel ViewContentViewModel { get; set; }
        public CPDFViewer PdfViewer { get; set; }

        public Visibility IsEmptyPanelVisibility
        {
            get { return isEmptyPanelVisibility; }
            set
            {
                SetProperty(ref isEmptyPanelVisibility, value);
            }
        }

        private ObservableCollection<AnnotationHandlerEventArgs> currentAnnotationArgs = new ObservableCollection<AnnotationHandlerEventArgs>();
        public ObservableCollection<AnnotationHandlerEventArgs> CurrentAnnotationArgs { get => currentAnnotationArgs; set => currentAnnotationArgs = value; }

        private AnnotationSortOrder annotationSortOrder = AnnotationSortOrder.PageIndexAscending;

        public AnnotationSortOrder AnnotationSortOrder
        {
            get { return annotationSortOrder; }
            set { annotationSortOrder = value; }
        }

        private ObservableCollection<AnnotationHandlerEventArgs> annotationListItems;

        public ObservableCollection<AnnotationHandlerEventArgs> AnnotationListItems
        {
            get { return annotationListItems; }
            set
            {
                SetProperty(ref annotationListItems, value);
            }
        }

        private List<string> colors = new List<string>();
        private List<string> authors = new List<string>();
        private List<AnnotArgsType> annotArgsTypes = new List<AnnotArgsType>();
        public DelegateCommand<object> LoadedCommand { get; set; }
        public DelegateCommand<object> ListBoxItemPreviewMouseLeftButtonDown { get; set; }
        public DelegateCommand<object> AddNotesCommand { get; set; }
        public DelegateCommand<object> ScreenCommand { get; set; }
        public DelegateCommand<object> ExportCommentsCommand { get; set; }
        public DelegateCommand<object> ImportCommentsCommand { get; set; }
        public DelegateCommand<object> DeleteCommand { get; set; }

        public DelegateCommand DeleteAllCommand { get; set; }

        public DelegateCommand PageSortCommand { get; set; }

        public DelegateCommand TimeAscendingCommand { get; set; }
        public DelegateCommand TimeDescendingCommand { get; set; }

        public AnnotationContentViewModel(IRegionManager regionManager, IDialogService dialogService)
        {
            region = regionManager;
            dialogs = dialogService;
            LoadedCommand = new DelegateCommand<object>(Loaded);
            ListBoxItemPreviewMouseLeftButtonDown = new DelegateCommand<object>(ListBoxItem_PreviewMouseLeftButtonDown);
            AddNotesCommand = new DelegateCommand<object>(AddNotesEvent);
            ScreenCommand = new DelegateCommand<object>(ScreenEvent);
            ExportCommentsCommand = new DelegateCommand<object>(ExportCommentsEvent);
            ImportCommentsCommand = new DelegateCommand<object>(ImportCommentsEvent);
            DeleteCommand = new DelegateCommand<object>(DelegateEvent);
            DeleteAllCommand = new DelegateCommand(DeleteAllEvent);
            PageSortCommand = new DelegateCommand(PageSortEvent);
            TimeAscendingCommand = new DelegateCommand(TimeAscendingEvent);
            TimeDescendingCommand = new DelegateCommand(TimeDescendingEvent);
        }

        /// <summary>
        /// 导入注释
        /// </summary>
        /// <param name="obj"></param>
        private async void ImportCommentsEvent(object obj)
        {
            Microsoft.Win32.OpenFileDialog dlg = new Microsoft.Win32.OpenFileDialog();
            dlg.Filter = "PDF|*.xfdf";
            dlg.DefaultExt = ".xfdf";
            if (dlg.ShowDialog() == true)
            {
                string fileName = dlg.FileName;
                await Task.Delay(5);
                var result = PdfViewer.ImportAnnotationFromXFDFPath(fileName);
                if (result == false)
                {
                    //MessageBoxEx.Show("导入失败", "", Winform.MessageBoxButtons.OK, Winform.MessageBoxIcon.Error);
                    AlertsMessage alertsMessage = new AlertsMessage();
                    alertsMessage.Show("提示", "导入失败!", "OK");
                    return;
                }
                PdfViewer.ReloadVisibleAnnots();
                //提取出来的注释文件 时间为空  则显示未系统当前时间
                CurrentAnnotationArgs = GetDocumentAnnotionList();

                AnnotationListItems.Clear();
                AnnotationListItems.AddRange(CurrentAnnotationArgs);
                await Task.Delay(5);
                RefreshAnnotationListItems(null);

                PdfViewer.UndoManager.CanSave = true;
            }
        }

        /// <summary>
        /// 时间倒序
        /// </summary>
        private void TimeDescendingEvent()
        {
            ICollectionView v = CollectionViewSource.GetDefaultView(AnnotationListItems);
            CreateTimeToDate createTimeToDate = new CreateTimeToDate();
            v.GroupDescriptions.Clear();
            v.GroupDescriptions.Add(new PropertyGroupDescription(nameof(AnnotHandlerEventArgs.CreateTime), createTimeToDate));
            v.SortDescriptions.Clear();
            v.SortDescriptions.Add(new SortDescription(nameof(AnnotHandlerEventArgs.CreateTime), ListSortDirection.Descending));
            v.SortDescriptions.Add(new SortDescription(nameof(AnnotHandlerEventArgs.AnnotIndex), ListSortDirection.Descending));
            AnnotationSortOrder = AnnotationSortOrder.TimeDescending;
        }

        /// <summary>
        /// 时间正序
        /// </summary>
        private void TimeAscendingEvent()
        {
            ICollectionView v = CollectionViewSource.GetDefaultView(AnnotationListItems);
            CreateTimeToDate createTimeToDate = new CreateTimeToDate();
            v.GroupDescriptions.Clear();
            v.GroupDescriptions.Add(new PropertyGroupDescription(nameof(AnnotHandlerEventArgs.CreateTime), createTimeToDate));

            v.SortDescriptions.Clear();
            v.SortDescriptions.Add(new SortDescription(nameof(AnnotHandlerEventArgs.CreateTime), ListSortDirection.Ascending));
            v.SortDescriptions.Add(new SortDescription(nameof(AnnotHandlerEventArgs.AnnotIndex), ListSortDirection.Ascending));
            AnnotationSortOrder = AnnotationSortOrder.TimeAscending;
        }

        /// <summary>
        /// 页面排序
        /// </summary>
        private void PageSortEvent()
        {
            ICollectionView v = CollectionViewSource.GetDefaultView(AnnotationListItems);
            v.GroupDescriptions.Clear();
            v.GroupDescriptions.Add(new PropertyGroupDescription(nameof(AnnotHandlerEventArgs.PageIndex)));

            v.SortDescriptions.Clear();
            v.SortDescriptions.Add(new SortDescription(nameof(AnnotHandlerEventArgs.PageIndex), ListSortDirection.Ascending));
            v.SortDescriptions.Add(new SortDescription(nameof(AnnotHandlerEventArgs.AnnotIndex), ListSortDirection.Ascending));
            AnnotationSortOrder = AnnotationSortOrder.PageIndexAscending;
        }

        /// <summary>
        /// 删除所有注释
        /// </summary>
        private void DeleteAllEvent()
        {
            //调用集中删除的接口  方便一次性undo
            Dictionary<int, List<int>> deleteLists = new Dictionary<int, List<int>>();
            for (int i = 0; i < AnnotationListItems.Count; i++)
            {
                AnnotationHandlerEventArgs item = AnnotationListItems[i] as AnnotationHandlerEventArgs;
                if (!deleteLists.ContainsKey(item.PageIndex))
                {
                    deleteLists.Add(item.PageIndex, new List<int>() { item.AnnotIndex });
                }
                else
                {
                    var pagelist = deleteLists[item.PageIndex];
                    pagelist.Add(item.AnnotIndex);
                }
            }
            PdfViewer.RemovePageAnnot(deleteLists);
            AnnotationListItems.Clear();
            CurrentAnnotationArgs.Clear();
            PdfViewer.UndoManager.CanSave = true;
        }

        /// <summary>
        /// 删除注释，单个/多个
        /// </summary>
        /// <param name="obj"></param>
        private void DelegateEvent(object obj)
        {
            if (obj is AnnotationHandlerEventArgs annotation)
            {
                if (annotation != null)
                {
                    var result = PdfViewer.RemovePageAnnot(annotation.PageIndex, annotation.AnnotIndex);
                    if (result)
                    {
                        AnnotationListItems.Remove(annotation);
                        var annotation1 = CurrentAnnotationArgs.FirstOrDefault(x => x.PageIndex == annotation.PageIndex && x.AnnotIndex == annotation.AnnotIndex);
                        CurrentAnnotationArgs.Remove(annotation1);
                        //记录是删除了哪些页面的注释，然后更新对应页面的注释即可
                        UpdateAnnotListAfterDelete(annotation.PageIndex, annotation.AnnotIndex);
                        PdfViewer.UndoManager.CanSave = true;
                    }
                }
            }
        }

        /// <summary>
        /// 删除之后，更新
        /// </summary>
        /// <param name="pageIndex"></param>
        /// <param name="annoteIndex"></param>
        private void UpdateAnnotListAfterDelete(int pageIndex, int annoteIndex)
        {
            var items = PdfViewer.GetAnnotCommentList(pageIndex, PdfViewer.Document);
            for (int j = 0; j < items.Count; j++)//用修改赋值的方式  可以解决删除后表头折叠的问题
            {
                if (items[j].AnnotIndex >= annoteIndex)//只需要更新比删除元素索引大的注释
                {
                    for (int k = 0; k < AnnotationListItems.Count; k++)
                    {
                        //相当于将后面的索引-1
                        if (AnnotationListItems[k].PageIndex == pageIndex &&
                        AnnotationListItems[k].AnnotIndex == (items[j].AnnotIndex + 1) &&
                        string.Equals(AnnotationListItems[k].MarkupContent, items[j].MarkupContent) &&
                        string.Equals(AnnotationListItems[k].Content, items[j].Content) &&
                        string.Equals(AnnotationListItems[k].CreateTime, items[j].CreateTime) &&
                        string.Equals(AnnotationListItems[k].Author, items[j].Author)
                        )
                        {
                            AnnotationListItems[k].AnnotHandlerEventArgs = items[j];
                            AnnotationListItems[k].PageIndex = items[j].PageIndex;
                            AnnotationListItems[k].AnnotIndex = items[j].AnnotIndex;
                            AnnotationListItems[k].EventType = items[j].EventType;
                            AnnotationListItems[k].CreateTime = items[j].CreateTime;
                            AnnotationListItems[k].UpdateTime = items[j].UpdateTime;
                            if (items[j].EventType == AnnotArgsType.AnnotFreehand)
                            {
                                WriteableBitmap bitmap = GetAnnotImage(PdfViewer.Document, items[j].PageIndex, items[j].AnnotIndex);
                                AnnotationListItems[k].WriteableBitmap = bitmap;
                            }
                            AnnotationListItems[k].Content = items[j].Content;
                            AnnotationListItems[k].MarkupContent = items[j].MarkupContent;
                            AnnotationListItems[k].Author = items[j].Author;
                            AnnotationListItems[k].Locked = items[j].Locked;
                            AnnotationListItems[k].ReadOnly = items[j].ReadOnly;
                            AnnotationListItems[k].FormField = items[j].FormField;
                            AnnotationListItems[k].Document = PdfViewer.Document;
                        }
                    }
                }
            }
        }

        /// <summary>
        /// 导出注释
        /// </summary>
        /// <param name="obj"></param>
        private void ExportCommentsEvent(object obj)
        {
            if (ViewContentViewModel.CanSave)
            {
                ViewContentViewModel.SaveFile.Execute();
            }
            Microsoft.Win32.SaveFileDialog dlg = new Microsoft.Win32.SaveFileDialog();
            dlg.Filter = "PDF|*.xfdf";
            dlg.DefaultExt = ".xfdf";
            dlg.FileName = PdfViewer.Document.FileName;
            if (dlg.ShowDialog() == true)
            {
                string fileName = dlg.FileName;
                var result = PdfViewer.ExportAnnotationToXFDFPath(fileName);
                if (result)
                {
                    //MessageBoxEx.Show("导出成功", "", Winform.MessageBoxButtons.OK);
                    AlertsMessage alertsMessage = new AlertsMessage();
                    alertsMessage.Show("提示", "导出成功!", "OK");
                }
                else
                {
                    AlertsMessage alertsMessage = new AlertsMessage();
                    alertsMessage.Show("提示", "导出失败!", "OK");
                    //MessageBoxEx.Show("导出失败", "", Winform.MessageBoxButtons.OK, Winform.MessageBoxIcon.Error);
                }
            }
        }

        /// <summary>
        /// 筛选注释
        /// </summary>
        /// <param name="obj"></param>
        private void ScreenEvent(object obj)
        {
            if (obj is System.Windows.Controls.Button button)
            {
                DialogParameters value = new DialogParameters();
                value.Add(ParameterNames.AnnotationList, CurrentAnnotationArgs);
                value.Add(ParameterNames.AnnotArgsTypes, annotArgsTypes);
                value.Add(ParameterNames.AnnotationColors, colors);
                value.Add(ParameterNames.AnnotationAuthor, authors);
                dialogs.ShowDialog(DialogNames.ScreenAnnotationDialog, value, e =>
                  {
                      if (e.Result == ButtonResult.OK && e.Parameters != null)
                      {
                          bool cleanState = false;
                          if (e.Parameters.ContainsKey(ParameterNames.AnnotationCleanState))
                          {
                              cleanState = e.Parameters.GetValue<bool>(ParameterNames.AnnotationCleanState);
                              if (cleanState)
                              {
                                  colors.Clear();
                                  authors.Clear();
                                  annotArgsTypes.Clear();
                                  AnnotationListItems.Clear();
                                  AnnotationListItems.AddRange(CurrentAnnotationArgs);
                                  RefreshAnnotationListItems(button);
                              }
                              else
                              {
                                  if (e.Parameters.ContainsKey(ParameterNames.AnnotArgsTypes))
                                  {
                                      annotArgsTypes = e.Parameters.GetValue<List<AnnotArgsType>>(ParameterNames.AnnotArgsTypes);
                                  }
                                  if (e.Parameters.ContainsKey(ParameterNames.AnnotationColors))
                                  {
                                      colors = e.Parameters.GetValue<List<string>>(ParameterNames.AnnotationColors);
                                  }
                                  if (e.Parameters.ContainsKey(ParameterNames.AnnotationAuthor))
                                  {
                                      authors = e.Parameters.GetValue<List<string>>(ParameterNames.AnnotationAuthor);
                                  }

                                  ObservableCollection<AnnotationHandlerEventArgs> screenAnnotationArgs = SelectAnnotationListItems(annotArgsTypes, colors, authors);
                                  AnnotationListItems.Clear();
                                  AnnotationListItems.AddRange(screenAnnotationArgs);

                                  RefreshAnnotationListItems(button);
                              }
                          }
                      }
                      else if (e.Result == ButtonResult.Cancel && e.Parameters != null)
                      {
                          colors.Clear();
                          authors.Clear();
                          annotArgsTypes.Clear();
                          AnnotationListItems.Clear();
                          AnnotationListItems.AddRange(CurrentAnnotationArgs);

                          RefreshAnnotationListItems(button);
                      }
                  });
            }
        }

        /// <summary>
        /// 刷新列表数据
        /// </summary>
        /// <param name="button"></param>
        private async void RefreshAnnotationListItems(System.Windows.Controls.Button button)
        {
            switch (AnnotationSortOrder)
            {
                case AnnotationSortOrder.TimeAscending:
                    TimeAscendingEvent();
                    break;

                case AnnotationSortOrder.TimeDescending:
                    TimeDescendingEvent();
                    break;

                case AnnotationSortOrder.PageIndexAscending:
                    PageSortEvent();
                    break;

                default:
                    break;
            }
            if (AnnotationListItems.Count > 0)
            {
                IsEmptyPanelVisibility = Visibility.Collapsed;
                await Task.Delay(2);
                //展开数据
                ExpandGroupHeader(AnnotationListItems, listBox);
            }
            else
            {
                if (button != null)
                {
                    button.IsEnabled = true;
                }
                IsEmptyPanelVisibility = Visibility.Visible;
                //AnnotationListItems.AddRange(currentAnnotationArgs);
                //RefreshAnnotationListItems();
            }
        }

        /// <summary>
        /// 根据条件筛选列表数据
        /// </summary>
        /// <param name="annotArgsTypes"></param>
        /// <param name="colors"></param>
        /// <param name="authors"></param>
        /// <returns></returns>
        private ObservableCollection<AnnotationHandlerEventArgs> SelectAnnotationListItems(List<AnnotArgsType> annotArgsTypes, List<string> colors, List<string> authors)
        {
            ObservableCollection<AnnotationHandlerEventArgs> annotationArgs = new ObservableCollection<AnnotationHandlerEventArgs>();

            #region 类型 颜色 作者

            if (annotArgsTypes.Count > 0 && colors.Count > 0 && authors.Count > 0)
            {
                foreach (var item in CurrentAnnotationArgs)
                {
                    foreach (var type in annotArgsTypes)
                    {
                        foreach (var color in colors)
                        {
                            foreach (var author in authors)
                            {
                                if (item.EventType == type && item.Author == author)
                                {
                                    SelectAnnotationColors(item, color, annotationArgs);
                                }
                            }
                        }
                    }
                }
            }

            #endregion 类型 颜色 作者

            #region 颜色 作者

            else if (colors.Count > 0 && authors.Count > 0)
            {
                foreach (var item in CurrentAnnotationArgs)
                {
                    foreach (var color in colors)
                    {
                        foreach (var author in authors)
                        {
                            if (item.Author == author)
                            {
                                SelectAnnotationColors(item, color, annotationArgs);
                            }
                        }
                    }
                }
            }

            #endregion 颜色 作者

            #region 类型 作者

            else if (annotArgsTypes.Count > 0 && authors.Count > 0)
            {
                foreach (var item in CurrentAnnotationArgs)
                {
                    foreach (var type in annotArgsTypes)
                    {
                        foreach (var author in authors)
                        {
                            if (item.EventType == type && item.Author == author)
                            {
                                annotationArgs.Add(item);
                            }
                        }
                    }
                }
            }

            #endregion 类型 作者

            #region 类型 颜色

            else if (annotArgsTypes.Count > 0 && colors.Count > 0)
            {
                foreach (var item in CurrentAnnotationArgs)
                {
                    foreach (var type in annotArgsTypes)
                    {
                        foreach (var color in colors)
                        {
                            if (item.EventType == type)
                            {
                                SelectAnnotationColors(item, color, annotationArgs);
                            }
                        }
                    }
                }
            }

            #endregion 类型 颜色

            #region 类型

            else if (annotArgsTypes.Count > 0)
            {
                foreach (var item in CurrentAnnotationArgs)
                {
                    foreach (var type in annotArgsTypes)
                    {
                        if (item.EventType == type)
                        {
                            annotationArgs.Add(item);
                        }
                    }
                }
            }

            #endregion 类型

            #region 颜色

            else if (colors.Count > 0)
            {
                foreach (var item in CurrentAnnotationArgs)
                {
                    foreach (var color in colors)
                    {
                        SelectAnnotationColors(item, color, annotationArgs);
                    }
                }
            }

            #endregion 颜色

            #region 作者

            else if (authors.Count > 0)
            {
                foreach (var item in CurrentAnnotationArgs)
                {
                    foreach (var author in authors)
                    {
                        if (item.Author == author)
                        {
                            annotationArgs.Add(item);
                        }
                    }
                }
            }

            #endregion 作者

            return annotationArgs;
        }

        /// <summary>
        /// 根据颜色筛选注释
        /// </summary>
        /// <param name="item"></param>
        /// <param name="color"></param>
        /// <param name="annotationArgs"></param>
        private void SelectAnnotationColors(AnnotationHandlerEventArgs item, string color, ObservableCollection<AnnotationHandlerEventArgs> annotationArgs)
        {
            AnnotHandlerEventArgs data = item.AnnotHandlerEventArgs;

            switch (item.EventType)
            {
                case AnnotArgsType.AnnotFreeText://文本
                    if (data is FreeTextAnnotArgs textAnnotArgs)
                    {
                        AddScreenAnnotationArgs(textAnnotArgs.FontColor, color, item, annotationArgs);
                    }
                    break;

                case AnnotArgsType.AnnotHighlight://高亮
                    if (data is TextHighlightAnnotArgs highlightAnnotArgs)
                    {
                        AddScreenAnnotationArgs(highlightAnnotArgs.Color, color, item, annotationArgs);
                    }
                    break;

                case AnnotArgsType.AnnotFreehand://手绘
                    if (data is FreehandAnnotArgs freehandAnnotArgs)
                    {
                        AddScreenAnnotationArgs(freehandAnnotArgs.InkColor, color, item, annotationArgs);
                    }
                    break;

                case AnnotArgsType.AnnotSquiggly://波浪线
                    break;

                case AnnotArgsType.AnnotStamp://图章
                    break;

                case AnnotArgsType.AnnotStrikeout://删除线
                    if (data is TextStrikeoutAnnotArgs textStrikeoutAnnotArgs)
                    {
                        AddScreenAnnotationArgs(textStrikeoutAnnotArgs.Color, color, item, annotationArgs);
                    }
                    break;

                case AnnotArgsType.AnnotSticky://便签
                    if (data is StickyAnnotArgs stickyAnnotArgs)
                    {
                        AddScreenAnnotationArgs(stickyAnnotArgs.Color, color, item, annotationArgs);
                    }
                    break;

                case AnnotArgsType.AnnotUnderline://下划线
                    if (data is TextUnderlineAnnotArgs textUnderlineAnnotArgs)
                    {
                        AddScreenAnnotationArgs(textUnderlineAnnotArgs.Color, color, item, annotationArgs);
                    }
                    break;

                case AnnotArgsType.AnnotLine:
                    //if ((item.AnnotHandlerEventArgs as LineAnnotArgs).HeadLineType >= (C_LINE_TYPE)1 || (item.AnnotHandlerEventArgs as LineAnnotArgs).TailLineType >= (C_LINE_TYPE)1)
                    //{
                    //    //箭头
                    //}
                    //else
                    //{
                    //    //线
                    //}
                    if (data is LineAnnotArgs lineAnnotArgs)
                    {
                        AddScreenAnnotationArgs(lineAnnotArgs.LineColor, color, item, annotationArgs);
                    }
                    break;

                case AnnotArgsType.AnnotSquare://矩形
                    if (data is SquareAnnotArgs squareAnnotArgs)
                    {
                        AddScreenAnnotationArgs(squareAnnotArgs.LineColor, color, item, annotationArgs);
                        AddScreenAnnotationArgs(squareAnnotArgs.BgColor, color, item, annotationArgs);
                    }
                    break;

                case AnnotArgsType.AnnotCircle://圆
                    if (data is CircleAnnotArgs circleAnnotArgs)
                    {
                        AddScreenAnnotationArgs(circleAnnotArgs.LineColor, color, item, annotationArgs);
                        AddScreenAnnotationArgs(circleAnnotArgs.BgColor, color, item, annotationArgs);
                    }
                    break;
            }
        }

        /// <summary>
        /// 对比颜色
        /// </summary>
        /// <param name="color1"></param>
        /// <param name="color"></param>
        /// <param name="item"></param>
        /// <param name="annotationArgs"></param>
        private void AddScreenAnnotationArgs(System.Windows.Media.Color color1, string color, AnnotationHandlerEventArgs item, ObservableCollection<AnnotationHandlerEventArgs> annotationArgs)
        {
            if (color1.ToString() == color)
            {
                annotationArgs.Add(item);
            }
        }

        /// <summary>
        /// 添加附注的注释
        /// </summary>
        /// <param name="obj"></param>
        private void AddNotesEvent(object obj)
        {
            if (obj is ListBoxItem listBoxItem)
            {
                if (listBoxItem.DataContext is AnnotationHandlerEventArgs args)
                {
                    if (args.EventType != AnnotArgsType.AnnotSticky && args.EventType != AnnotArgsType.AnnotFreeText && args.EventType != AnnotArgsType.AnnotLink)
                    {
                        DialogParameters value = new DialogParameters();
                        value.Add(ParameterNames.Annotation, args);
                        dialogs.ShowDialog(DialogNames.AddAnnotationDialog, value, async 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);
                                }
                            }
                        });
                    }
                }
            }
        }

        private async void RefreshOneListItem(AnnotHandlerEventArgs annotation)
        {
            for (int i = 0; i < AnnotationListItems.Count; i++)
            {
                if (AnnotationListItems[i].PageIndex == annotation.PageIndex && AnnotationListItems[i].AnnotIndex == annotation.AnnotIndex)
                {
                    AnnotationListItems[i] = GetAddAnnotEventArgs(annotation);

                    for (int j = 0; j < CurrentAnnotationArgs.Count; j++)
                    {
                        if (CurrentAnnotationArgs[j].PageIndex == annotation.PageIndex && CurrentAnnotationArgs[j].AnnotIndex == annotation.AnnotIndex)
                        {
                            CurrentAnnotationArgs[j] = GetAddAnnotEventArgs(annotation);
                            break;
                        }
                    }
                    if (!listBox.SelectedItems.Contains(AnnotationListItems[i]))
                    {
                        listBox.SelectedItem = AnnotationListItems[i];
                    }

                    await Task.Delay(1);//不加延时 每页的第一个注释不会展开
                    ExpandGroupHeader(AnnotationListItems[i], listBox);

                    await Task.Delay(1);//不加延时 会有不滚动的现象
                    listBox.ScrollIntoView(AnnotationListItems[i]);
                    break;
                }
            }
        }

        /// <summary>
        /// listboxitem鼠标左键点击，显示分组的数据
        /// </summary>
        /// <param name="obj"></param>
        private void ListBoxItem_PreviewMouseLeftButtonDown(object obj)
        {
            if (obj is ListBoxItem item)
            {
                var data = item.DataContext as AnnotationHandlerEventArgs;
                if (data != null)
                {
                    PdfViewer.SelectAnnotation(data.PageIndex, data.AnnotIndex);
                }
            }
        }

        public async void UpdateAddedAnnot(int pageIndex, int annotIndex)
        {
            var annots = PdfViewer.GetAnnotCommentList(pageIndex, PdfViewer.Document);
            foreach (var item in annots)
            {
                if (item.AnnotIndex == annotIndex && item.EventType != AnnotArgsType.AnnotRedaction)
                {
                    AnnotationHandlerEventArgs args = GetAddAnnotEventArgs(item);
                    if (args.AnnotHandlerEventArgs != null)
                    {
                        AnnotationListItems.Add(args);
                        CurrentAnnotationArgs.Add(args);
                        await Task.Delay(1);//不加延时 每页的第一个注释不会展开
                        ExpandGroupHeader(args, listBox);
                        listBox.SelectedItem = item;
                        await Task.Delay(1);//不加延时 会有不滚动的现象
                        listBox.ScrollIntoView(item);
                        if (!listBox.SelectedItems.Contains(args))
                        {
                            listBox.SelectedItem = args;
                            //PdfViewer.SelectAnnotation(args.PageIndex, args.AnnotIndex);
                        }
                    }
                }
            }
            if (IsEmptyPanelVisibility == Visibility.Visible && AnnotationListItems.Count > 0)
            {
                IsEmptyPanelVisibility = Visibility.Collapsed;
            }
        }

        public async void UpdateModifiedAnnot(int pageIndex, int annotIndex, bool isDelete)
        {
            try
            {
                var items = PdfViewer.GetAnnotCommentList(pageIndex, PdfViewer.Document);
                if (isDelete && items.Count == 0)//当前页的最后一次删除
                {
                    for (int k = 0; k < AnnotationListItems.Count; k++)
                    {
                        if (AnnotationListItems[k].PageIndex == pageIndex && AnnotationListItems[k].AnnotIndex == annotIndex)
                        {
                            AnnotationListItems.RemoveAt(k);
                            AnnotationHandlerEventArgs annotation1 = CurrentAnnotationArgs.FirstOrDefault(x => x.PageIndex == AnnotationListItems[k].PageIndex && x.AnnotIndex == AnnotationListItems[k].AnnotIndex);
                            CurrentAnnotationArgs.Remove(annotation1);
                            UpdateAnnotListAfterDelete(pageIndex, annotIndex);
                            return;
                        }
                    }
                }

                if (isDelete)//删除
                {
                    for (int k = 0; k < AnnotationListItems.Count; k++)
                    {
                        //不能加item[j].annoteIndex = annotIndex  删除后必匹配不上
                        if (AnnotationListItems[k].PageIndex == pageIndex && AnnotationListItems[k].AnnotIndex == annotIndex)
                        {
                            AnnotationListItems.RemoveAt(k);
                            AnnotationHandlerEventArgs annotation1 = CurrentAnnotationArgs.FirstOrDefault(x => x.PageIndex == AnnotationListItems[k].PageIndex && x.AnnotIndex == AnnotationListItems[k].AnnotIndex);
                            CurrentAnnotationArgs.Remove(annotation1);
                            UpdateAnnotListAfterDelete(pageIndex, annotIndex);
                            return;
                        }
                    }
                }

                for (int j = 0; j < items.Count; j++)
                {
                    for (int k = 0; k < AnnotationListItems.Count; k++)
                    {
                        if (AnnotationListItems[k].PageIndex == pageIndex && AnnotationListItems[k].AnnotIndex == annotIndex && items[j].AnnotIndex == annotIndex)
                        {
                            //AnnotationHandlerEventArgs args = GetAddAnnotEventArgs(items[j]);
                            AnnotationListItems[k] = GetAddAnnotEventArgs(items[j]);

                            for (int i = 0; i < CurrentAnnotationArgs.Count; i++)
                            {
                                if (CurrentAnnotationArgs[i].PageIndex == pageIndex && CurrentAnnotationArgs[i].AnnotIndex == annotIndex)
                                {
                                    CurrentAnnotationArgs[i] = GetAddAnnotEventArgs(items[j]);
                                    break;
                                }
                            }
                            if (!listBox.SelectedItems.Contains(AnnotationListItems[k]))
                            {
                                listBox.SelectedItem = AnnotationListItems[k];
                                //PdfViewer.SelectAnnotation(args.PageIndex, args.AnnotIndex);
                            }

                            await Task.Delay(1);//不加延时 每页的第一个注释不会展开
                            ExpandGroupHeader(AnnotationListItems[k], listBox);

                            await Task.Delay(1);//不加延时 会有不滚动的现象
                            listBox.ScrollIntoView(AnnotationListItems[k]);
                        }
                    }
                }
            }
            catch { }
        }

        /// <summary>
        /// 展开item所在分组
        /// </summary>
        private void ExpandGroupHeader(AnnotationHandlerEventArgs item, ListBox listBox)
        {
            try
            {
                var groups = listBox.Items.Groups;
                for (int i = 0; i < groups.Count; i++)
                {
                    var l = groups[i] as CollectionViewGroup;
                    if (l.Items.Contains(item))
                    {
                        var scroller = GetScrollHost(listBox);
                        var stackpanel = CommonHelper.FindVisualChild<StackPanel>(scroller);
                        int count = VisualTreeHelper.GetChildrenCount(stackpanel);
                        var groupItem = VisualTreeHelper.GetChild(stackpanel, i) as GroupItem;
                        var g = CommonHelper.FindVisualChild<Expander>(groupItem);
                        if (g != null)
                            g.IsExpanded = true;
                    }
                }
            }
            catch { }
        }

        /// <summary>
        /// 页面加载时
        /// </summary>
        /// <param name="obj"></param>
        private void Loaded(object obj)
        {
            if (obj is CompositeCommandParameter composite)
            {
                if (composite.Parameter is ListBox listBox)
                {
                    this.listBox = listBox;
                    SetGroupHeader(listBox);
                }
            }
        }

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

        public void OnNavigatedFrom(NavigationContext navigationContext)
        {
        }

        public void OnNavigatedTo(NavigationContext navigationContext)
        {
            var pdfview = navigationContext.Parameters[ParameterNames.PDFViewer] as CPDFViewer;
            var viewContentViewModel = navigationContext.Parameters[ParameterNames.ViewContentViewModel] as ViewContentViewModel;
            if (pdfview != null && viewContentViewModel != null)
            {
                ViewContentViewModel = viewContentViewModel;
                PdfViewer = pdfview;
                AnnotationListItems = new ObservableCollection<AnnotationHandlerEventArgs>();

                AnnotationListItems = GetDocumentAnnotionList();
                CurrentAnnotationArgs.AddRange(AnnotationListItems);
                AnnotationListItems.CollectionChanged += AnnotationListItems_CollectionChanged;
            }
        }

        /// <summary>
        /// 默认按照PageIndex，分组 排序
        /// </summary>
        /// <param name="listBox"></param>
        private async void SetGroupHeader(ListBox listBox)
        {
            //按照PageIndex，分组 排序
            ICollectionView iCollectionView = CollectionViewSource.GetDefaultView(AnnotationListItems);
            iCollectionView.GroupDescriptions.Add(new PropertyGroupDescription(nameof(AnnotationHandlerEventArgs.PageIndex)));
            iCollectionView.SortDescriptions.Add(new SortDescription(nameof(AnnotationHandlerEventArgs.PageIndex), ListSortDirection.Ascending));
            iCollectionView.SortDescriptions.Add(new SortDescription(nameof(AnnotationHandlerEventArgs.AnnotIndex), ListSortDirection.Ascending));
            if (AnnotationListItems.Count > 0)
            {
                IsEmptyPanelVisibility = Visibility.Collapsed;
                await Task.Delay(5);
                //展开数据
                ExpandGroupHeader(AnnotationListItems, listBox);
            }
            else
            {
                IsEmptyPanelVisibility = Visibility.Visible;
            }
        }

        /// <summary>
        /// 展开列表项
        /// </summary>
        /// <param name="annotationListItems"></param>
        /// <param name="listBox"></param>
        private void ExpandGroupHeader(ObservableCollection<AnnotationHandlerEventArgs> annotationListItems, ListBox listBox)
        {
            try
            {
                foreach (var item in annotationListItems)
                {
                    var groups = listBox.Items.Groups;
                    for (int i = 0; i < groups.Count; i++)
                    {
                        var group = groups[i] as CollectionViewGroup;
                        if (group.Items.Contains(item))
                        {
                            var scroller = GetScrollHost(listBox);
                            var stackpanel = CommonHelper.FindVisualChild<StackPanel>(scroller);
                            int count = VisualTreeHelper.GetChildrenCount(stackpanel);
                            var groupItem = VisualTreeHelper.GetChild(stackpanel, i) as GroupItem;
                            var g = CommonHelper.FindVisualChild<Expander>(groupItem);
                            if (g != null)
                            {
                                g.IsExpanded = true;
                            }
                        }
                    }
                }
            }
            catch { }
        }

        private ScrollViewer GetScrollHost(ListBox listBox)
        {
            if (VisualTreeHelper.GetChildrenCount(listBox) > 0)
            {
                int s = VisualTreeHelper.GetChildrenCount(listBox);

                Border border = VisualTreeHelper.GetChild(listBox, 0) as Border;
                if (border != null)
                {
                    return VisualTreeHelper.GetChild(border, 0) as ScrollViewer;
                }
            }
            return null;
        }

        /// <summary>
        /// 获取listbox绑定数据
        /// </summary>
        /// <returns></returns>
        private ObservableCollection<AnnotationHandlerEventArgs> GetDocumentAnnotionList()
        {
            ObservableCollection<AnnotationHandlerEventArgs> list = new ObservableCollection<AnnotationHandlerEventArgs>();
            for (int i = 0; i < PdfViewer.Document.PageCount; i++)
            {
                var items = PdfViewer.GetAnnotCommentList(i, PdfViewer.Document);
                foreach (var item in items)
                {
                    //原型图上，目前对波浪线的类型，在注释列表不显示
                    if (item.EventType != AnnotArgsType.AnnotRedaction && item.EventType != AnnotArgsType.AnnotSquiggly)
                    {
                        AnnotationHandlerEventArgs args = GetAddAnnotEventArgs(item);
                        if (args.AnnotHandlerEventArgs != null)
                        {
                            list.Add(args);
                        }
                    }
                }
            }

            return list;
        }

        private AnnotationHandlerEventArgs GetAddAnnotEventArgs(AnnotHandlerEventArgs item)
        {
            AnnotationHandlerEventArgs args = new AnnotationHandlerEventArgs();
            if (item.EventType == AnnotArgsType.AnnotFreehand)
            {
                WriteableBitmap bitmap = GetAnnotImage(PdfViewer.Document, item.PageIndex, item.AnnotIndex);
                args.WriteableBitmap = bitmap;
            }
            args.AnnotHandlerEventArgs = item;
            args.PageIndex = item.PageIndex;
            args.AnnotIndex = item.AnnotIndex;
            args.EventType = item.EventType;
            args.CreateTime = item.CreateTime;
            args.UpdateTime = item.UpdateTime;
            args.Content = item.Content;
            args.MarkupContent = item.MarkupContent;
            args.Author = item.Author;
            args.Locked = item.Locked;
            args.ReadOnly = item.ReadOnly;
            args.FormField = item.FormField;
            args.Document = PdfViewer.Document;
            return args;
        }

        /// <summary>
        /// 获取手绘图案
        /// </summary>
        /// <param name="doc"></param>
        /// <param name="pageIndex"></param>
        /// <param name="annotIndex"></param>
        /// <returns></returns>
        public WriteableBitmap GetAnnotImage(CPDFDocument doc, int pageIndex, int annotIndex)
        {
            if (doc == null)
            {
                return null;
            }
            CPDFPage docPage = doc.PageAtIndex(pageIndex, false);
            if (docPage == null)
            {
                return null;
            }

            List<CPDFAnnotation> docAnnots = docPage.GetAnnotations();
            foreach (CPDFAnnotation annot in docAnnots)
            {
                if (docAnnots.IndexOf(annot) == annotIndex)
                {
                    CRect rawRect = annot.GetRect();
                    double scaleDpi = 96.0 / 72.0;
                    Rect paintRect = new Rect(rawRect.left * scaleDpi, rawRect.top * scaleDpi, rawRect.width() * scaleDpi, rawRect.height() * scaleDpi);
                    int drawWidth = (int)paintRect.Width;
                    int drawHeight = (int)paintRect.Height;
                    byte[] bitmapArray = new byte[drawWidth * drawHeight * 4];

                    annot.RenderAnnot(drawWidth, drawHeight, bitmapArray);
                    WriteableBitmap wirteBitmap = new WriteableBitmap(drawWidth, drawHeight, 96, 96, PixelFormats.Bgra32, null);
                    wirteBitmap.WritePixels(new Int32Rect(0, 0, drawWidth, drawHeight), bitmapArray, wirteBitmap.BackBufferStride, 0);
                    return wirteBitmap;
                }
            }

            return null;
        }

        /// <summary>
        /// listbox的itemsource发生变化时
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void AnnotationListItems_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
        {
            if (sender is ObservableCollection<AnnotationHandlerEventArgs> obsSender)
            {
                //currentAnnotationArgs.Clear();
                //currentAnnotationArgs.AddRange(obsSender);
                if (obsSender.Count < 1)
                {
                    IsEmptyPanelVisibility = Visibility.Visible;
                    //currentAnnotationArgs.Clear();
                }
                else
                {
                    IsEmptyPanelVisibility = Visibility.Collapsed;
                }
            }
            else
            {
                IsEmptyPanelVisibility = Visibility.Visible;
            }
        }
    }
}