PDFOffice_Windows_exe/PDF Office/Views/BOTA/AnnotationContent.xaml.cs

using ComPDFKit.PDFAnnotation;
using ComPDFKit.PDFPage;
using ComPDFKitViewer;
using ComPDFKitViewer.AnnotEvent;
using ImTools;
using PDF_Master.DataConvert;
using PDF_Master.EventAggregators;
using PDF_Master.Helper;
using PDF_Master.Model.BOTA;
using PDF_Master.ViewModels;
using PDF_Master.ViewModels.BOTA;
using Prism.Events;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Linq;
using System.Runtime.InteropServices.Expando;
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.Data;
using System.Windows.Documents;
using System.Windows.Forms;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using static Dropbox.Api.Paper.ListPaperDocsSortBy;
using static Dropbox.Api.TeamLog.PaperDownloadFormat;
using static System.Windows.Forms.VisualStyles.VisualStyleElement.StartPanel;
using ListBox = System.Windows.Controls.ListBox;
using MenuItem = System.Windows.Controls.MenuItem;
using UserControl = System.Windows.Controls.UserControl;

namespace PDF_Master.Views.BOTA
{
    /// <summary>
    /// AnnotationContent.xaml 的交互逻辑
    /// </summary>
    public partial class AnnotationContent : UserControl
    {
        public AnnotationContentViewModel viewModel;

        private string unicode;

        public AnnotationContent(IEventAggregator eventAggregator)
        {
            InitializeComponent();
            unicode = App.mainWindowViewModel.SelectedItem.Unicode;
            viewModel = this.DataContext as AnnotationContentViewModel;
            if (AnnotationList.Items.Count < 0)
            {
                MenuExpandAll.IsEnabled = false;
            }

            eventAggregator.GetEvent<CleanSelectAllEvent>().Subscribe(CleanSelectAll, e => e.Unicode == unicode);
            eventAggregator.GetEvent<RefreshAnnotationEvent>().Subscribe(ExpandGroupHeader, e => e.Unicode == unicode);
        }

        public async void ExpandGroupHeader(RefreshAnnotationArgs obj)
        {
            if (obj.IsAll)
            {
                ExpandAllGroupHeader(obj);
            }
            else
            {
                //需要时间加载完 listbox所有的控件模板
                await Task.Delay(200);
                ExpandOneGroupHeader(obj);
            }
        }

        private async void ExpandAllGroupHeader(RefreshAnnotationArgs obj)
        {
            try
            {
                foreach (var item in AnnotationList.Items)
                {
                    var groups = AnnotationList.Items.Groups;

                    for (int i = 0; i < groups.Count; i++)
                    {
                        if (groups[i] is CollectionViewGroup group)
                        {
                            if (group.Items.Contains(item))
                            {
                                var scroller = GetScrollHost(AnnotationList);
                                var stackpanel = CommonHelper.FindVisualChild<StackPanel>(scroller);
                                if (stackpanel == null)
                                {
                                    await Task.Delay(1);
                                }
                                else
                                {
                                    GroupItemExpanded(stackpanel, i);
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception ex) { }
        }

        public async void ExpandOneGroupHeader(RefreshAnnotationArgs obj)
        {
            if (obj.annotHandlerArgs == null)
            {
                if (obj.Pageindex != -1 && obj.AnnotIndex != -1)
                {
                    List<AnnotationHandlerEventArgs> annotations = AnnotationList.Items.Cast<AnnotationHandlerEventArgs>().ToList();
                    obj.annotHandlerArgs = annotations.FirstOrDefault(x => x.PageIndex == obj.Pageindex && x.AnnotIndex == obj.AnnotIndex);
                }
            }

            if (obj.annotHandlerArgs != null)
            {
                try
                {
                    var groups = AnnotationList.Items.Groups;
                    if (groups != null && groups.Count > 0)
                    {
                        for (int i = 0; i < groups.Count; i++)
                        {
                            if (groups[i] is CollectionViewGroup group)
                            {
                                if (group.Items.Contains(obj.annotHandlerArgs))
                                {
                                    var scroller = GetScrollHost(AnnotationList);
                                    var stackpanel = CommonHelper.FindVisualChild<StackPanel>(scroller);
                                    if (stackpanel != null)
                                    {
                                        GroupItemExpanded(stackpanel, i);
                                    }
                                    else
                                    {
                                        ItemsPresenter itemsPresenter = CommonHelper.FindVisualChild<ItemsPresenter>(scroller);
                                        if (itemsPresenter != null)
                                        {
                                            var tt = VisualTreeHelper.GetChild(itemsPresenter, i);
                                            int count = VisualTreeHelper.GetChildrenCount(tt);
                                        }
                                    }
                                }
                            }
                        }
                    }

                    if (obj.IsDel)
                    {
                        viewModel.IsModified = true;
                    }
                    await Task.Delay(10);//不加延时 会有不滚动的现象
                    SelectedItems(obj);
                }
                catch (Exception ex) { }
            }
        }

        private void GroupItemExpanded(StackPanel stackpanel, int i)
        {
            int count = VisualTreeHelper.GetChildrenCount(stackpanel);
            if (count > 0)
            {
                if (VisualTreeHelper.GetChild(stackpanel, i) is GroupItem groupItem)
                {
                    var expander = CommonHelper.FindVisualChild<Expander>(groupItem);
                    if (expander != null)
                    {
                        if (expander.IsExpanded == false)
                        {
                            expander.IsExpanded = true;
                        }
                    }
                }
            }
        }

        private async void SelectedItems(RefreshAnnotationArgs obj)
        {
            if (obj.IsSelect && obj.annotHandlerArgs != null)
            {
                if (viewModel.ViewContentViewModel.IsMultiSelected == false)
                {
                    if (AnnotationList.SelectedItems.IndexOf(obj.annotHandlerArgs) == -1)
                    {
                        viewModel.IsModified = false;
                        AnnotationList.SelectedItem = obj.annotHandlerArgs;
                        AnnotationList.SelectedIndex = AnnotationList.Items.IndexOf(obj.annotHandlerArgs);
                    }
                    await Task.Delay(10);//不加延时 会有不滚动的现象
                    AnnotationList.ScrollIntoView(AnnotationList.SelectedItem);
                }
            }
        }

        private void CleanSelectAll(CleanSelectAllArgs obj)
        {
            AnnotationList.SelectedIndex = -1;
        }

        private void ListBoxItem_PreviewMouseDown(object sender, MouseButtonEventArgs e)
        {
            if (e.ClickCount == 1)
            {
                //if (Mouse.LeftButton == e.ButtonState)
                //{
                //    viewModel.ListBoxItemPreviewMouseLeftButtonDown.Execute(sender);
                //}
                if (Mouse.RightButton == e.ButtonState)
                {
                    var pos = e.GetPosition(AnnotationList);

                    var result = VisualTreeHelper.HitTest(AnnotationList, pos);
                    if (result != null)
                    {
                        ListBoxItem myListBoxItem = sender as System.Windows.Controls.ListBoxItem;
                        MenuItem copyText = myListBoxItem.ContextMenu.Items[0] as MenuItem;
                        MenuItem import = myListBoxItem.ContextMenu.Items[1] as MenuItem;
                        MenuItem export = myListBoxItem.ContextMenu.Items[2] as MenuItem;
                        if (AnnotationList.SelectedItems.Count > 1)
                        {
                            import.IsEnabled = false;
                            export.IsEnabled = true;
                            export.Command = viewModel.ExportCommentsCommand;
                            copyText.IsEnabled = false;
                        }
                        else
                        {
                            //直接右键菜单不需要选中Viewer中注释
                            //viewModel.ListBoxItemPreviewMouseLeftButtonDown.Execute(sender);
                            if (myListBoxItem.DataContext is AnnotationHandlerEventArgs annotation)
                            {
                                //文本、高亮、下划线、删除线、便签
                                if (annotation.EventType == AnnotArgsType.AnnotFreeText ||
                                annotation.EventType == AnnotArgsType.AnnotHighlight ||
                                annotation.EventType == AnnotArgsType.AnnotUnderline ||
                                annotation.EventType == AnnotArgsType.AnnotStrikeout ||
                                annotation.EventType == AnnotArgsType.AnnotSticky)
                                {
                                    copyText.IsEnabled = true;
                                }
                                else
                                {
                                    copyText.IsEnabled = false;
                                }
                            }
                            import.IsEnabled = true;
                            import.Command = viewModel.ImportCommentsCommand;
                            export.IsEnabled = true;
                            export.Command = viewModel.ExportCommentsCommand;
                        }
                    }
                    //拦截响应选中事件
                    e.Handled = true;
                }
            }
        }

        private void ListBoxItem_PreviewMouseDoubleClick(object sender, MouseButtonEventArgs e)
        {
            if (Mouse.LeftButton == e.ButtonState)
            {
                viewModel.AddNotesCommand.Execute(sender);
            }
        }

        private async void MenuExpandAll_Click(object sender, RoutedEventArgs e)
        {
            SetAllExpander(true);
            await Task.Delay(1);
            for (int i = 0; i < AnnotationList.Items.Count; i++)
            {
                ListBoxItem item = AnnotationList.ItemContainerGenerator.ContainerFromIndex(i) as ListBoxItem;

                if (item != null)
                {
                    ToggleButton button = GetExpandButton(item);
                    if (button != null && button.Visibility == Visibility.Visible)
                    {
                        button.IsChecked = true;
                    }
                }
            }
        }

        private void MenuCollapseAll_Click(object sender, RoutedEventArgs e)
        {
            for (int i = 0; i < AnnotationList.Items.Count; i++)
            {
                ListBoxItem item = AnnotationList.ItemContainerGenerator.ContainerFromIndex(i) as ListBoxItem;
                ToggleButton button = GetExpandButton(item);
                if (button != null && button.Visibility == Visibility.Visible)
                {
                    button.IsChecked = false;
                }
            }
            SetAllExpander(false);
        }

        private void SetAllExpander(bool isexpand)
        {
            AnnotationList.Dispatcher.Invoke(() =>
              {
                  //开启虚拟化之后 全部展开和折叠会有问题
                  var scroller = GetScrollHost(AnnotationList);
                  var stackpanel = CommonHelper.FindVisualChild<StackPanel>(scroller);
                  int count = VisualTreeHelper.GetChildrenCount(stackpanel);
                  for (int i = 0; i < count; i++)
                  {
                      var item = VisualTreeHelper.GetChild(stackpanel, i) as GroupItem;
                      var g = CommonHelper.FindVisualChild<Expander>(item);
                      if (g != null)
                          g.IsExpanded = isexpand;
                  }
              });
        }

        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;
        }

        private ToggleButton GetExpandButton(ListBoxItem item)
        {
            if (item == null) return null;
            Border border = VisualTreeHelper.GetChild(item, 0) as Border;
            var btn = CommonHelper.FindVisualChild<ToggleButton>(border);
            return btn;
        }

        private void MenuTimeRightSort_Click(object sender, RoutedEventArgs e)
        {
            ICollectionView v = CollectionViewSource.GetDefaultView(AnnotationList.ItemsSource);
            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));
        }

        private void MenuTimeBackSort_Click(object sender, RoutedEventArgs e)
        {
            ICollectionView v = CollectionViewSource.GetDefaultView(AnnotationList.ItemsSource);
            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));
        }

        private void MenuPageSort_Click(object sender, RoutedEventArgs e)
        {
            ICollectionView v = CollectionViewSource.GetDefaultView(AnnotationList.ItemsSource);
            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));
        }

        private void MenuItemCopyText_Click(object sender, RoutedEventArgs e)
        {
            //没有权限解密时，拦截复制文本操作
            if (!viewModel.ViewContentViewModel.CheckPermissionBeforeOption())
            {
                return;
            }
            if (AnnotationList.SelectedItems.Count == 1)
            {
                if (AnnotationList.SelectedItem is AnnotationHandlerEventArgs annotation)
                {
                    //文本、高亮、下划线、删除线、便签
                    if (annotation.EventType == AnnotArgsType.AnnotFreeText ||
                    annotation.EventType == AnnotArgsType.AnnotHighlight ||
                    annotation.EventType == AnnotArgsType.AnnotUnderline ||
                    annotation.EventType == AnnotArgsType.AnnotStrikeout ||
                    annotation.EventType == AnnotArgsType.AnnotSticky)
                    {
                        StringBuilder Copystr = new StringBuilder();
                        if (annotation.MarkupContent != null)
                        {
                            Copystr.Append(annotation.MarkupContent);
                            Copystr.Append(Environment.NewLine);
                        }
                        if (annotation.Content != null)
                        {
                            Copystr.Append(annotation.Content);
                        }

                        System.Windows.Clipboard.SetText(Copystr.ToString());
                        //CustomControl.MessageBoxEx.Show("数据复制成功");
                    }
                }
            }
        }

        private void MenuItemDelete_Click(object sender, RoutedEventArgs e)
        {
            List<int> pagelist = new List<int>();
            if (AnnotationList.SelectedItems.Count > 1)
            {
                //for (int i = 0; i < AnnotationList.SelectedItems.Count; i++)
                //{
                //    AnnotationHandlerEventArgs annotation = AnnotationList.SelectedItems[i] as AnnotationHandlerEventArgs;
                //    pagelist.Add(AnnotationList.Items.IndexOf(annotation));
                //}
                //pagelist.Sort();
                //for (int i = 0; i < pagelist.Count; i++)
                //{
                //    AnnotationHandlerEventArgs annotation = AnnotationList.Items[pagelist[pagelist.Count - i - 1]] as AnnotationHandlerEventArgs;
                //    if (annotation == null)
                //    {
                //        continue;
                //    }

                //    viewModel.DeleteCommand.Execute(annotation);
                //}

                Dictionary<int, List<int>> selectedItemDics = new Dictionary<int, List<int>>();
                List<AnnotationHandlerEventArgs> eventArgs = new List<AnnotationHandlerEventArgs>();
                foreach (var item in AnnotationList.SelectedItems)
                {
                    if (item is AnnotationHandlerEventArgs annotation)
                    {
                        if (eventArgs.Contains(annotation) == false)
                        {
                            eventArgs.Add(annotation);
                        }
                    }
                }
                var result = eventArgs.GroupBy(d => d.PageIndex);
                foreach (var item in result)
                {
                    if (selectedItemDics.ContainsKey(item.Key) == false)
                    {
                        var ai = item.Select(w => w.AnnotIndex).ToList();
                        selectedItemDics.Add(item.Key, ai);
                    }
                }
                viewModel.DeleteCommand.Execute(selectedItemDics);
            }
            else
            {
                AnnotationHandlerEventArgs annotation = (AnnotationHandlerEventArgs)(sender as MenuItem).DataContext;
                if (annotation == null)
                {
                    return;
                }

                viewModel.DeleteCommand.Execute(annotation);
            }
        }

        private void BtnMore_Initialized(object sender, EventArgs e)
        {
            BtnMore.ContextMenu = null;
        }

        private void BtnMore_Click(object sender, RoutedEventArgs e)
        {
            MenuMore.PlacementTarget = BtnMore;
            MenuMore.IsOpen = true;
        }

        private void AnnotationList_PreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            var pos = e.GetPosition(AnnotationList);

            var result = VisualTreeHelper.HitTest(AnnotationList, pos);
            if (result != null)
            {
                //获取当前鼠标指针下的容器
                var listBoxItem = CommonHelper.FindVisualParent<ListBoxItem>(result.VisualHit);
                if (listBoxItem == null)
                {
                    viewModel.ViewContentViewModel.mainViewModel.AnnotMouseLeftButtonDown = false;
                }
            }
        }

        private void AnnotationList_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            var selectedItems = (sender as ListBox).SelectedItems.Cast<AnnotationHandlerEventArgs>().ToList();
            if (selectedItems.Count == 1)
            {
                if (viewModel.IsModified)
                {
                    viewModel.ListBoxItemPreviewMouseLeftButtonDown.Execute(selectedItems[0]);
                }
                viewModel.IsModified = true;
            }
            else if (selectedItems.Count > 1)
            {
                #region 阅读视图 多选

                Dictionary<int, List<int>> selectedItemDics = new Dictionary<int, List<int>>();
                List<AnnotationHandlerEventArgs> eventArgs = new List<AnnotationHandlerEventArgs>();
                foreach (var item in selectedItems)
                {
                    if (item is AnnotationHandlerEventArgs annotation)
                    {
                        if (eventArgs.Contains(annotation) == false)
                        {
                            eventArgs.Add(annotation);
                        }
                    }
                }
                var result = eventArgs.GroupBy(d => d.PageIndex);
                foreach (var item in result)
                {
                    if (selectedItemDics.ContainsKey(item.Key) == false)
                    {
                        var ai = item.Select(w => w.AnnotIndex).ToList();
                        selectedItemDics.Add(item.Key, ai);
                    }
                }

                #endregion 阅读视图 多选

                viewModel.ListBoxItemPreviewMouseLeftButtonDown.Execute(selectedItemDics);
            }
        }

        private void AnnotationList_KeyDown(object sender, System.Windows.Input.KeyEventArgs e)
        {
            if (AnnotationList.SelectedItems == null)
            {
                return;
            }
            if (e.Key == Key.Escape)
            {
                //Windows:BOTA列表，移除Esc取消选中逻辑
                //AnnotationList.SelectedItems.Clear();
            }
        }

        private void Grid_PreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            var pos = e.GetPosition(this);
            var result = VisualTreeHelper.HitTest(this, pos);
            if (result != null)
            {
                //点击按钮和listboxitem时 不清空多选 其余区域取消多选
                var item = CommonHelper.FindVisualParent<ListBoxItem>(result.VisualHit);
                if (item != null)
                {
                    return;
                }
                var btn = CommonHelper.FindVisualParent<System.Windows.Controls.Button>(result.VisualHit);
                if (btn != null)
                {
                    return;
                }
            }
        }

        private void ListBox_MouseDown(object sender, MouseButtonEventArgs e)
        {
            AnnotationList.SelectedIndex = -1;
        }

        private void ContextMenu_Loaded(object sender, RoutedEventArgs e)
        {
            var menu = sender as System.Windows.Controls.ContextMenu;
            if (menu != null)
            {
                (menu.Items[0] as MenuItem).Header = viewModel.T_CopyText;
                (menu.Items[1] as MenuItem).Header = viewModel.T_Import;
                (menu.Items[2] as MenuItem).Header = viewModel.T_Export;
                (menu.Items[3] as MenuItem).Header = viewModel.T_Delete;
                if (AnnotationList.SelectedItems.Count > 1)
                {
                    (menu.Items[3] as MenuItem).Header = viewModel.T_DeleteAll;
                }
            }
        }
    }
}