PDFOffice_Windows_exe/PDF Office/ViewModels/BottomToolContentViewModel.cs

using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using ComPDFKitViewer.PdfViewer;
using Prism.Commands;
using Prism.Regions;
using System.Windows;
using PDF_Office.Views;
using ComPDFKitViewer;
using System.Windows.Input;
using System.Windows.Controls;
using Prism.Services.Dialogs;
using PDF_Office.CustomControl;
using PDF_Office.Model;
using PDF_Office.ViewModels.BOTA;
using PDF_Office.Views.BOTA;
using PDF_Office.Views.PropertyPanel.AnnotPanel;
using PDF_Office.Views.Tools;
using PDFSettings.Settings;
using PDF_Office.Helper;
using System.IO;

namespace PDF_Office.ViewModels
{
    public class BottomToolContentViewModel : BindableBase, INavigationAware
    {
        public DelegateCommand Load { get; set; }

        public DelegateCommand FirstPageCommand { get; set; }

        public DelegateCommand LastPageCommand { get; set; }

        public DelegateCommand PrePageCommand { get; set; }

        public DelegateCommand NextPageCommand { get; set; }

        public DelegateCommand MyPropertyCommand { get; set; }

        public DelegateCommand FullScreenCommand { get; set; }

        public DelegateCommand ReadModeCommand { get; set; }

        public DelegateCommand OpenViewCommand { get; set; }

        public DelegateCommand ZoomInCommand { get; set; }

        public DelegateCommand ZoomOutCommand { get; set; }

        public DelegateCommand SetViewModeCommand { get; set; }

        public DelegateCommand OpenFullCommand { get; set; }

        public DelegateCommand<object> PageTextKeyDownCommand { get; set; }

        public DelegateCommand<object> PageTextPreviewKeyDownCommand { get; set; }

        public DelegateCommand<object> SelectionChangedCommand { get; set; }

        public DelegateCommand<object> ShowViewModularCommand { get; set; }

        /// <summary>
        /// 上一个视图
        /// </summary>
        public DelegateCommand PreViewCommand { get; set; }

        /// <summary>
        /// 下一个视图
        /// </summary>
        public DelegateCommand NextViewCommnad { get; set; }

        private bool isShowViewModular = false;

        /// <summary>
        /// 属性栏是否展开
        /// </summary>
        public bool IsShowViewModular
        {
            get { return isShowViewModular; }
            set
            {
                SetProperty(ref isShowViewModular, value);
            }
        }

        private bool isSingleView;

        public bool IsSingleView
        {
            get { return isSingleView; }
            set
            {
                SetProperty(ref isSingleView, value);
                if (value)
                {
                    SetModeView();
                }
            }
        }

        private bool isContinue;

        public bool IsContinue
        {
            get { return isContinue; }
            set
            {
                SetProperty(ref isContinue, value);
                SetModeView();
            }
        }

        private bool isDoubleView;

        public bool IsDoubleView
        {
            get { return isDoubleView; }
            set
            {
                SetProperty(ref isDoubleView, value);
                if (value)
                {
                    SetModeView();
                }
            }
        }

        private bool isBookMode;

        public bool IsBookMode
        {
            get { return isBookMode; }
            set
            {
                SetProperty(ref isBookMode, value);
                if (value)
                {
                    SetModeView();
                }
            }
        }

        private int pageCount;

        public int PageCount
        {
            get { return pageCount; }
            set
            {
                SetProperty(ref pageCount, value);
            }
        }

        private int currentPage;

        public int CurrentPage
        {
            get { return currentPage; }
            set
            {
                SetProperty(ref currentPage, value);
            }
        }

        private double currenZoom;

        public double CurrentZoom
        {
            get { return currenZoom; }
            set { SetProperty(ref currenZoom, value); }
        }

        private int selectedIndex;

        public int SelectedIndex
        {
            get { return selectedIndex; }
            set
            {
                SetProperty(ref selectedIndex, value);
            }
        }

        private bool rightPanelEnable = true;

        public bool RightPanelEnable
        {
            get { return rightPanelEnable; }
            set
            {
                SetProperty(ref rightPanelEnable, value);
            }
        }

        private bool isPreEnable = false;

        /// <summary>
        /// 前进是否启用
        /// </summary>
        public bool IsPreEnable
        {
            get { return isPreEnable; }
            set
            {
                SetProperty(ref isPreEnable, value);
            }
        }

        private bool isNextEnable = false;

        public bool IsNextEnable
        {
            get { return isNextEnable; }
            set
            {
                SetProperty(ref isNextEnable, value);
            }
        }

        private Stack<int> UndoStack = new Stack<int>();

        private Stack<int> RedoStack = new Stack<int>();

        public CPDFViewer PDFViewer { get; set; }

        public ViewContentViewModel ViewContentViewModel { get; set; }

        public OpenFileInfo OpenFileInfo = null;

        /// <summary>
        /// 来自undo redo方法的跳页 不计入栈
        /// </summary>
        private bool isFromMethod = false;

        /// <summary>
        /// 记录上一个页面索引值
        /// </summary>

        private int oldPageIndex = 0;

        private IRegionManager region;

        private IDialogService dialogs;

        public BottomToolContentViewModel(IRegionManager regionManager, IDialogService dialogService)
        {
            region = regionManager;
            dialogs = dialogService;

            PrePageCommand = new DelegateCommand(GoPrePage, CanPrePageExcute).ObservesProperty(() => CurrentPage);
            NextPageCommand = new DelegateCommand(GoNextPage, CanNextPageExcute).ObservesProperty(() => CurrentPage);
            FirstPageCommand = new DelegateCommand(GoFirstPage, CanPrePageExcute).ObservesProperty(() => CurrentPage);
            LastPageCommand = new DelegateCommand(GoLastPage, CanNextPageExcute).ObservesProperty(() => CurrentPage);
            ZoomInCommand = new DelegateCommand(ZoomIn, CanZoomIn).ObservesProperty(() => CurrentZoom);
            ZoomOutCommand = new DelegateCommand(ZoomOut, CanZoomOut).ObservesProperty(() => CurrentZoom);
            SetViewModeCommand = new DelegateCommand(SetModeView);
            PageTextKeyDownCommand = new DelegateCommand<object>(PageNumText_KeyDown);
            PageTextPreviewKeyDownCommand = new DelegateCommand<object>(PageNumText_PreviewKeyDown);
            SelectionChangedCommand = new DelegateCommand<object>(SelectionChangedEvent);
            ShowViewModularCommand = new DelegateCommand<object>(ShowViewModularEvent);

            PreViewCommand = new DelegateCommand(undo);

            NextViewCommnad = new DelegateCommand(redo);
        }

        private void undo()
        {
            RedoStack.Push(PDFViewer.CurrentIndex);
            IsNextEnable = true;

            int index = UndoStack.Pop();
            PDFViewer.GoToPage(index);
            if (UndoStack.Count <= 0)
            {
                IsPreEnable = false;
            }
            isFromMethod = true;
        }

        private void redo()
        {
            App.Current.Dispatcher.Invoke(() =>
            {
                UndoStack.Push(PDFViewer.CurrentIndex);
                IsPreEnable = true;

                int index = RedoStack.Pop();
                PDFViewer.GoToPage(index);
                if (RedoStack.Count <= 0)
                {
                    IsNextEnable = false;
                }
            });
            isFromMethod = true;
        }

        private void ShowViewModularEvent(object obj)
        {
            if (ViewContentViewModel.IsPropertyOpen == false)
            {
                ViewContentViewModel.IsPropertyOpen = true;

                NavigationParameters param = new NavigationParameters();
                param.Add(ParameterNames.PDFViewer, PDFViewer);
                param.Add(ParameterNames.BottomToolContentViewModel, this);
                region.RequestNavigate(RegionNames.PropertyRegionName, "ViewModularContent", param);

                if (region.Regions.ContainsRegionWithName(ViewContentViewModel.PropertyRegionName))
                {
                    var views = region.Regions[ViewContentViewModel.PropertyRegionName].Views;
                    foreach (var item in views)
                    {
                        if (item is LinkAnnotProperty linkAnnotProperty)
                        {
                            var contentRegion = region.Regions[ViewContentViewModel.PropertyRegionName];
                            contentRegion.Remove(item);
                            break;
                        }
                    }
                }
            }
            else
            {
                ViewContentViewModel.IsPropertyOpen = false;
            }
            IsShowViewModular = ViewContentViewModel.IsPropertyOpen;
        }

        private void SelectionChangedEvent(object e)
        {
            var args = e as SelectionChangedEventArgs;
            if (args != null)
            {
                if (SelectedIndex <= 2)
                {
                    switch (SelectedIndex)
                    {
                        case 0:
                            PDFViewer.ChangeFitMode(FitMode.FitSize);
                            OpenFileInfo.LastFitMode = FitMode.FitSize;
                            break;

                        case 1:
                            PDFViewer.ChangeFitMode(FitMode.FitWidth);
                            OpenFileInfo.LastFitMode = FitMode.FitWidth;
                            break;

                        case 2:
                            PDFViewer.ChangeFitMode(FitMode.FitHeight);
                            OpenFileInfo.LastFitMode = FitMode.FitHeight;
                            break;

                        default:
                            break;
                    }
                }
                else
                {
                    if (args.AddedItems[0] is ComboBoxItem)
                    {
                        if ((args.AddedItems[0] as ComboBoxItem).Tag != null)
                        {
                            PDFViewer.Zoom(Convert.ToDouble((args.AddedItems[0] as ComboBoxItem).Tag.ToString()) / 100.0);
                        }
                    }
                }
            }
        }

        private void PageNumText_PreviewKeyDown(object e)
        {
            var args = e as KeyEventArgs;
            if (args != null)
            {
                //显示文本框输入内容
                List<Key> NumberKeys = new List<Key>() { Key.D0,Key.D1,Key.D2,Key.D3,Key.D4,Key.D5,Key.D6,Key.D7,Key.D8,Key.D9,Key.NumPad0,Key.NumPad1,Key.NumPad2,
            Key.NumPad3,Key.NumPad4,Key.NumPad5,Key.NumPad6,Key.NumPad7,Key.NumPad8,Key.NumPad9,Key.Delete,Key.Back,Key.Enter,Key.Right,Key.Left};
                if (!NumberKeys.Contains(args.Key))
                {
                    args.Handled = true;
                }
            }
        }

        private void PageNumText_KeyDown(object e)
        {
            if (!(e is KeyEventArgs))
                return;
            //回车提交输入
            if ((e as KeyEventArgs).Key == System.Windows.Input.Key.Enter)
            {
                int pagenum = 0;
                string text = ((e as KeyEventArgs).OriginalSource as TextBox).Text.ToString();
                char[] chs = { ' ', '/', '\\' };//字符截取  拒止非法输入
                int i = text.LastIndexOfAny(chs);
                if (i > 0)
                    text = text.Substring(0, i - 1);

                if (!int.TryParse(text, out pagenum))
                {
                    CurrentPage = PDFViewer.Document.PageCount;
                    ((e as KeyEventArgs).OriginalSource as TextBox).Text = PDFViewer.Document.PageCount.ToString();
                    return;
                }
                if (pagenum < 1)
                    pagenum = 1;
                else if (pagenum > PDFViewer.Document.PageCount)
                    pagenum = PDFViewer.Document.PageCount;

                PDFViewer.GoToPage(pagenum - 1);
                CurrentPage = pagenum;
                ((e as KeyEventArgs).OriginalSource as TextBox).Text = pagenum.ToString();
            }
        }

        private void GoPrePage()
        {
            if (PDFViewer != null)
            {
                PDFViewer.GoToPage(PDFViewer.CurrentIndex - 1);
            }
        }

        private bool CanPrePageExcute()
        {
            if (PDFViewer != null)
            {
                if (PDFViewer.CurrentIndex <= 0)
                    return false;
                else
                    return true;
            }
            return false;
        }

        private void GoNextPage()
        {
            if (PDFViewer != null)
            {
                PDFViewer.GoToPage(PDFViewer.CurrentIndex + 1);
                //双页模式 一次性跳两页
                if (((int)PDFViewer.ModeView > 2))
                {
                    PDFViewer.GoToPage(PDFViewer.CurrentIndex + 2);
                }
            }
        }

        private bool CanNextPageExcute()
        {
            if (PDFViewer != null)
            {
                if (PDFViewer.CurrentIndex >= PDFViewer.Document.PageCount - 1)
                    return false;
                else
                    return true;
            }
            return false;
        }

        private void GoFirstPage()
        {
            if (PDFViewer != null)
            {
                PDFViewer.GoToPage(0);
            }
        }

        private void GoLastPage()
        {
            if (PDFViewer != null)
            {
                PDFViewer.GoToPage(PDFViewer.Document.PageCount - 1);
            }
        }

        private void ZoomIn()
        {
            double zoom = SetPageZoomFactor(true);
            PDFViewer.Zoom(zoom / 100);
        }

        private void ZoomOut()
        {
            double zoom = SetPageZoomFactor(false);
            PDFViewer.Zoom(zoom / 100);
        }

        private double SetPageZoomFactor(bool flag)
        {
            double zoom = PDFViewer.ZoomFactor * 100;
            if (flag)
            {
                if (zoom >= 25 && zoom <= 300)
                {
                    zoom = zoom + 25;
                }
                else if (zoom >= 301 && zoom <= 1000)
                {
                    zoom = zoom + 40;
                }
                else if (zoom >= 1001 && zoom <= 10000)
                {
                    zoom = zoom + 100;
                }
            }
            else
            {
                if (zoom >= 25 && zoom <= 300)
                {
                    zoom = zoom - 25;
                }
                else if (zoom >= 301 && zoom <= 1000)
                {
                    zoom = zoom - 40;
                }
                else if (zoom >= 1001 && zoom <= 10000)
                {
                    zoom = zoom - 100;
                }
            }

            if (zoom < 25)
            {
                zoom = 25;
            }
            if (zoom > 10000)
            {
                zoom = 10000;
            }
            return zoom;
        }

        private bool CanZoomIn()
        {
            if (PDFViewer != null)
            {
                if (PDFViewer.ZoomFactor * 100 >= 10000)
                    return false;
                else
                    return true;
            }
            return false;
        }

        private bool CanZoomOut()
        {
            if (PDFViewer != null)
            {
                if (PDFViewer.ZoomFactor * 100 <= 25)
                    return false;
                else
                    return true;
            }
            return false;
        }

        public void PDFViewer_InfoChanged(object sender, KeyValuePair<string, object> e)
        {
            if (e.Key == "PageNum")
            {
                RenderData renderData = e.Value as RenderData;
                if (renderData != null)
                {
                    CurrentPage = renderData.PageIndex;
                    PageCount = PDFViewer.Document.PageCount;
                    if (!renderData.IsMouseWheel && !isFromMethod)
                    {
                        UndoStack.Push(oldPageIndex);
                        RedoStack.Clear();
                        IsNextEnable = false;
                        IsPreEnable = true;
                    }
                    isFromMethod = false;
                }
                oldPageIndex = renderData.PageIndex - 1;
            }
            if (e.Key == "ViewMode")
            {
                GetModeView((ViewMode)e.Value);
            }
            if (e.Key == "Zoom")
            {
                CurrentZoom = (double)e.Value * 100;
                SelectedIndex = -1;
            }
            if (OpenFileInfo != null)
            {
                if (OpenFileInfo.LastFitMode != PDFViewer.ModeFit)
                {
                    OpenFileInfo.LastFitMode = PDFViewer.ModeFit;
                }

                if (PDFViewer.ModeFit == FitMode.FitFree)
                {
                    if (OpenFileInfo.LastZoom != PDFViewer.ZoomFactor)
                    {
                        OpenFileInfo.LastZoom = PDFViewer.ZoomFactor;
                    }
                }
                if (OpenFileInfo.LastPageIndex != PDFViewer.CurrentIndex)
                {
                    OpenFileInfo.LastPageIndex = PDFViewer.CurrentIndex;
                }
                SettingHelper.SetFileInfo(OpenFileInfo);
            }
        }

        private void ViewContentViewModel_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
        {
            if (e.PropertyName == "OCRContentVisible")
            {
                if (ViewContentViewModel.OCRContentVisible == Visibility.Visible)
                {
                    RightPanelEnable = false;
                }
                else
                {
                    RightPanelEnable = true;
                }
            }
        }

        private void GetModeView(ViewMode mode)
        {
            if ((int)mode % 2 == 0)
            {
                if (!IsContinue)
                {
                    IsContinue = true;
                }
            }
            else
            {
                if (IsContinue)
                {
                    IsContinue = false;
                }
            }

            if ((int)mode <= 2)
            {
                if (!isSingleView)
                {
                    IsSingleView = true;
                }
            }
            else if ((int)mode <= 4)
            {
                if (!isDoubleView)
                {
                    IsDoubleView = true;
                }
            }
            else
            {
                if (!isBookMode)
                {
                    IsBookMode = true;
                }
            }
        }

        public void SetModeView()
        {
            if (PDFViewer != null)
            {
                if (IsContinue)
                {
                    if (IsSingleView)
                    {
                        PDFViewer.ChangeViewMode(ViewMode.SingleContinuous);
                    }
                    else if (IsDoubleView)
                    {
                        PDFViewer.ChangeViewMode(ViewMode.DoubleContinuous);
                    }
                    else
                    {
                        PDFViewer.ChangeViewMode(ViewMode.BookContinuous);
                    }
                }
                else
                {
                    if (IsSingleView)
                    {
                        PDFViewer.ChangeViewMode(ViewMode.Single);
                    }
                    else if (IsDoubleView)
                    {
                        PDFViewer.ChangeViewMode(ViewMode.Double);
                    }
                    else
                    {
                        PDFViewer.ChangeViewMode(ViewMode.Book);
                    }
                }
            }
            SaveMode(PDFViewer.ModeView);
        }

        private void SaveMode(object modeView)
        {
            OpenFileInfo fileInfo = SettingHelper.GetFileInfo(PDFViewer.Document.FilePath);
            if (fileInfo != null)
            {
                if (modeView is SplitMode)
                {
                    fileInfo.LastSplitMode = PDFViewer.Mode;
                }
                else if (modeView is ViewMode)
                {
                    fileInfo.LastViewMode = PDFViewer.ModeView;
                }
                else if (modeView is bool)
                {
                    fileInfo.LastPageSpace = (bool)modeView;
                }
                SettingHelper.SetFileInfo(fileInfo);
            }
        }

        #region Navigation

        public void OnNavigatedTo(NavigationContext navigationContext)
        {
            var viewContentViewModel = navigationContext.Parameters[ParameterNames.ViewContentViewModel] as ViewContentViewModel;
            if (viewContentViewModel != null)
            {
                this.ViewContentViewModel = viewContentViewModel;
                IsShowViewModular = viewContentViewModel.IsPropertyOpen;
                viewContentViewModel.PropertyChanged -= ViewContentViewModel_PropertyChanged;
                viewContentViewModel.PropertyChanged += ViewContentViewModel_PropertyChanged;
            }

            var pdfview = navigationContext.Parameters[ParameterNames.PDFViewer] as CPDFViewer;
            if (pdfview != null)
            {
                if (ViewContentViewModel.OpenFileInfo != null)
                {
                    OpenFileInfo = ViewContentViewModel.OpenFileInfo;
                }

                //获取页面设置等信息
                PDFViewer = pdfview;
                oldPageIndex = pdfview.CurrentIndex;
                PageCount = PDFViewer.Document.PageCount;
                GetModeView(PDFViewer.ModeView);
                CurrentPage = PDFViewer.CurrentIndex + 1;
                CurrentZoom = PDFViewer.ZoomFactor * 100;
                PDFViewer.InfoChanged += PDFViewer_InfoChanged;
            }
        }

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

        public void OnNavigatedFrom(NavigationContext navigationContext)
        {
        }

        #endregion Navigation
    }
}