PDFOffice_Windows_exe/PDF Office/ViewModels/ViewContentViewModel.cs

using Microsoft.Win32;
using Prism.Commands;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using ComPDFKitViewer.PdfViewer;
using Prism.Regions;
using Prism.Services.Dialogs;
using PDF_Office.CustomControl;
using PDF_Office.Model;
using System.Windows;
using System.Windows.Controls;
using System.IO;
using ComPDFKitViewer.AnnotEvent;
using PDF_Office.ViewModels.Tools;
using Prism.Events;
using PDF_Office.EventAggregators;
using PDF_Office.Helper;
using ComPDFKit.PDFDocument;
using PDFSettings.Settings;
using PDF_Office.Model.Dialog.ToolsDialogs.SaftyDialogs;
using static PDF_Office.Model.Dialog.ToolsDialogs.SaftyDialogs.SetPasswordDialogModel;
using PDF_Office.Model.Dialog.ToolsDialogs;
using DryIoc;
using PDF_Office.Model.Dialog.ConverterDialogs;
using static PDF_Office.Model.Dialog.ToolsDialogs.SaftyDialogs.DeleteSafetySettintgsModel;
using PDF_Office.Views.PropertyPanel.AnnotPanel;

namespace PDF_Office.ViewModels
{
    public class ViewContentViewModel : BindableBase, INavigationAware
    {
        #region 属性、变量

        public OpenFileInfo OpenFileInfo = null;
        public CPDFViewer PDFViewer { get; set; }

        public MainContentViewModel mainViewModel { get; set; }

        public IRegionManager region;

        public IDialogService dialogs;

        public IEventAggregator events;

        public bool IsRightMenuCreateLink { get => isCreateLink; set => isCreateLink = value; }

        public string ViwerRegionName { get; set; }

        /// <summary>
        /// 分屏视图的region名称
        /// </summary>
        public string SplitViewerRegionName { get; set; }

        /// <summary>
        /// OCR视图名称
        /// </summary>
        public string OCRViewerRegionName { get; set; }

        public string BOTARegionName { get; set; }

        public string PropertyRegionName { get; set; }

        public string ToolContentRegionName { get; set; }

        public string ToolsBarContentRegionName { get; set; }

        /// <summary>
        /// 顶部提示的Content
        /// </summary>
        public string TipContentRegionName { get; set; }

        public string LeftTipContentRegionName { get; set; }

        public string ReadModeRegionName { get; set; }

        public string ConverterBarContentRegionName { get; set; }

        public string TextEditContentRegionName { get; set; }

        public string BackgroundContentRegionName { get; set; }

        public List<Point> FillAndSign = new List<Point>();

        /// <summary>
        /// 文档的密码
        /// </summary>
        public string PassWord { get; set; }

        private Visibility tipVisible = Visibility.Collapsed;

        /// <summary>
        /// 顶部提示栏的显示状态
        /// </summary>
        public Visibility TipVisible
        {
            get { return tipVisible; }
            set
            {
                SetProperty(ref tipVisible, value);
            }
        }

        private Visibility leftTipVisible = Visibility.Collapsed;

        public Visibility LeftTipVisible
        {
            get { return leftTipVisible; }
            set
            {
                SetProperty(ref leftTipVisible, value);
            }
        }

        private Visibility readModelTip = Visibility.Collapsed;

        public Visibility ReadModelTip
        {
            get { return readModelTip; }
            set
            {
                SetProperty(ref readModelTip, value);
            }
        }

        /// <summary>
        /// 底部工具栏 RegionName
        /// </summary>
        public string BottomToolRegionName { get; set; }

        private bool _isInPageEdit = false;

        /// <summary>
        /// 是否处于页面编辑模式，用于执行undo redo 的具体操作
        /// </summary>
        public bool isInPageEdit
        {
            get { return _isInPageEdit; }
            set
            {
                _isInPageEdit = value;
                if (!value)
                {
                    CanRedo = PDFViewer.UndoManager.CanRedo;
                    CanUndo = PDFViewer.UndoManager.CanUndo;
                }
            }
        }

        public Action PageEditUndo { get; set; }

        public Action PageEditRedo { get; set; }

        /// <summary>
        ///工具条
        ///0：收起
        ///40：显示
        /// </summary>
        private int toolRowHeight = 40;

        public int ToolRowHeight
        {
            get { return toolRowHeight; }
            set
            {
                SetProperty(ref toolRowHeight, value);
            }
        }

        /// <summary>
        /// 水印，背景侧边栏宽度
        /// 0：收起
        /// 260：显示
        /// </summary>
        private int propertyColumnWidth = 0;

        public int PropertyColumnWidth
        {
            get { return propertyColumnWidth; }
            set
            {
                SetProperty(ref propertyColumnWidth, value);
            }
        }

        private int gridToolRow = 1;

        /// <summary>
        /// 控制ToolContent的Row
        /// </summary>
        public int GridToolRow
        {
            get { return gridToolRow; }
            set
            {
                SetProperty(ref gridToolRow, value);
            }
        }

        private int gridToolRowSpan = 3;

        /// <summary>
        /// 控制ToolContent的RowSpan
        /// </summary>
        public int GridToolRowSpan
        {
            get { return gridToolRowSpan; }
            set
            {
                SetProperty(ref gridToolRowSpan, value);
            }
        }

        private Visibility toolContentVisible = Visibility.Collapsed;

        /// <summary>
        /// 控制Content的显示 用于显示水印、贝茨码、密文等功能模块
        /// 留意：显示前需要先注入内容、设置好行和跨行数
        /// </summary>
        public Visibility ToolContentVisible
        {
            get { return toolContentVisible; }
            set
            {
                SetProperty(ref toolContentVisible, value);
            }
        }

        private Visibility gridVisibility = Visibility.Visible;

        /// <summary>
        /// 是否正在加载中
        /// </summary>
        public Visibility GridVisibility
        {
            get { return gridVisibility; }
            set
            {
                SetProperty(ref gridVisibility, value);
            }
        }

        private Visibility isLoading = Visibility.Collapsed;

        private Visibility ocrContentVisible = Visibility.Collapsed;

        public Visibility OCRContentVisible
        {
            get { return ocrContentVisible; }
            set
            {
                SetProperty(ref ocrContentVisible, value);
            }
        }

        /// <summary>
        /// 是否正在加载中
        /// </summary>
        public Visibility IsLoading
        {
            get { return isLoading; }
            set
            {
                SetProperty(ref isLoading, value);
            }
        }

        private Visibility converterBarContentVisible = Visibility.Collapsed;
        private Visibility toolsbarContentVisible = Visibility.Collapsed;

        /// <summary>
        /// 控制ToolsBarContent的显示
        /// 留意：显示前需要先注入内容、设置好行和跨行数
        /// </summary>
        public Visibility ConverterBarContentVisible
        {
            get { return converterBarContentVisible; }
            set
            {
                SetProperty(ref converterBarContentVisible, value);
            }
        }

        private Visibility toolsBarContentVisible = Visibility.Collapsed;

        /// <summary>
        /// 控制ToolsBarContent的显示
        /// 留意：显示前需要先注入内容、设置好行和跨行数
        /// </summary>
        public Visibility ToolsBarContentVisible
        {
            get { return toolsBarContentVisible; }
            set
            {
                SetProperty(ref toolsBarContentVisible, value);
            }
        }

        private Visibility textEditToolContentVisible = Visibility.Collapsed;

        /// <summary>
        /// 控制ToolsBarContent的显示
        /// 留意：显示前需要先注入内容、设置好行和跨行数
        /// </summary>
        public Visibility TextEditToolContentVisible
        {
            get { return textEditToolContentVisible; }
            set
            {
                SetProperty(ref textEditToolContentVisible, value);
            }
        }

        private bool isPorpertyOpen = false;

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

        private Visibility isReadMode = Visibility.Visible;

        /// <summary>
        ///是否为阅读模式
        /// </summary>
        public Visibility IsReadMode
        {
            get { return isReadMode; }
            set
            {
                SetProperty(ref isReadMode, value);
            }
        }

        private bool canSave;

        /// <summary>
        /// 是否可以保存
        /// </summary>
        public bool CanSave
        {
            get { return canSave; }
            set
            {
                SetProperty(ref canSave, value);
            }
        }

        private bool canUndo;

        /// <summary>
        /// 是否可以进行Undo
        /// </summary>
        public bool CanUndo
        {
            get { return canUndo; }
            set
            {
                SetProperty(ref canUndo, value);
            }
        }

        private bool canRedo;

        /// <summary>
        /// 是否可以进行Redo
        /// </summary>
        public bool CanRedo
        {
            get { return canRedo; }
            set
            {
                SetProperty(ref canRedo, value);
            }
        }

        private GridLength botaWidth = new GridLength(48);

        /// <summary>
        /// BOTA栏的宽度
        /// </summary>
        public GridLength BOTAWidth
        {
            get { return botaWidth; }
            set
            {
                SetProperty(ref botaWidth, value);
                if (botaWidth.Value <= 48)
                {
                    OpenBOTA = false;
                }
            }
        }

        private int selectedIndex;

        /// <summary>
        /// 工具栏选中项的索引
        /// </summary>
        public int TabSelectedIndex
        {
            get { return selectedIndex; }
            set
            {
                SetProperty(ref selectedIndex, value);
            }
        }

        private bool openBOTA = false;

        /// <summary>
        /// 是否展开BOTA
        /// </summary>
        public bool OpenBOTA
        {
            get { return openBOTA; }
            set
            {
                SetProperty(ref openBOTA, value);
                if (openBOTA && BOTAWidth.Value <= 48)
                {
                    BOTAWidth = new GridLength(260);
                }
                //关闭BOTA的逻辑在xaml.cs代码里控制，无法绑定后台
            }
        }

        public SecurityInfo SecurityInfo = new SecurityInfo();

        private Dictionary<string, string> regionNameByTabItem;

        private Dictionary<string, string> barContentByTabItem;

        private string previousBar = "";

        public string CurrentBar = "";

        public string unicode = null;

        /// <summary>
        /// 用来避免重复触发导航事件的标志符
        /// </summary>
        private bool isOpenFile = false;

        /// <summary>
        /// 鼠标滚轮缩放的缩放值
        /// </summary>
        private double[] zoomLevel = { 1.00f, 10, 25, 50, 75, 100, 125, 150, 200, 300, 400, 600, 800, 1000 };

        /// <summary>
        /// 注释-链接，提示语
        /// </summary>
        private Visibility linkAnnotTipVisibility = Visibility.Collapsed;

        public Visibility LinkAnnotTipVisibility
        {
            get { return linkAnnotTipVisibility; }
            set
            {
                SetProperty(ref linkAnnotTipVisibility, value);
            }
        }

        private string linkAnnotTipText = "Please use the scroll bar, thumbnail tool to locate the target page, click or box the area to select the target range";
        private bool isCreateLink = false;

        public string LinkAnnotTipText
        {
            get { return linkAnnotTipText; }
            set
            {
                SetProperty(ref linkAnnotTipText, value);
            }
        }

        #endregion 属性、变量

        #region 命令

        public DelegateCommand LoadFile { get; set; }

        public DelegateCommand Load { get; set; }

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

        public DelegateCommand SaveFile { get; set; }

        public DelegateCommand SaveAsFile { get; set; }

        public DelegateCommand SaveAsFlattenCommand { get; set; }

        public DelegateCommand UndoCommand { get; set; }

        public DelegateCommand RedoCommand { get; set; }
        public DelegateCommand<object> MenuEnterReadMode { get; set; }

        public DelegateCommand PrintCommand { get; set; }

        public DelegateCommand SettingsCommand { get; set; }

        public DelegateCommand ShareCommand { get; set; }

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

        public DelegateCommand PropertyCommand { get; set; }

        public DelegateCommand ShowInFolderCommand { get; set; }

        public DelegateCommand CompressCommand { get; set; }

        public DelegateCommand MergeFileCommand { get; set; }

        public DelegateCommand EncryptCommand { get; set; }

        public DelegateCommand DecryptCommand { get; set; }

        public DelegateCommand<string> ConvertCommand { get; set; }

        public DelegateCommand CloseWindowCommand { get; set; }

        #endregion 命令

        public ViewContentViewModel(IRegionManager regionManager, IDialogService dialogService, IEventAggregator eventAggregator)
        {
            region = regionManager;
            dialogs = dialogService;
            events = eventAggregator;
            unicode = App.mainWindowViewModel.SelectedItem.Unicode;
            LoadFile = new DelegateCommand(loadFile);
            Load = new DelegateCommand(LoadControl);
            SaveFile = new DelegateCommand(() => { saveFile(); }, CanSaveExcute).ObservesProperty(() => CanSave);
            SaveAsFlattenCommand = new DelegateCommand(saveAsFlatten);
            SaveAsFile = new DelegateCommand(() => { saveAsFile(); });
            UndoCommand = new DelegateCommand(Undo);
            RedoCommand = new DelegateCommand(Redo);
            ShareCommand = new DelegateCommand(share);
            PropertyCommand = new DelegateCommand(property);
            ShowInFolderCommand = new DelegateCommand(ShowInFolder);
            TabControlSelectionChangedCommand = new DelegateCommand<object>(TabControlSelectonChangedEvent);
            CompressCommand = new DelegateCommand(compress);
            MergeFileCommand = new DelegateCommand(mergeFile);
            EncryptCommand = new DelegateCommand(encrypt);
            DecryptCommand = new DelegateCommand(decrypt);
            ConvertCommand = new DelegateCommand<string>(convert);
            CloseWindowCommand = new DelegateCommand(closeWindow);

            ViwerRegionName = RegionNames.ViwerRegionName;
            SplitViewerRegionName = RegionNames.Viewer_SplitRegionName;
            BOTARegionName = RegionNames.BOTARegionName;
            PropertyRegionName = RegionNames.PropertyRegionName;
            BottomToolRegionName = RegionNames.BottomToolRegionName;
            ReadModeRegionName = RegionNames.ReadModeRegionName;
            MenuEnterReadMode = new DelegateCommand<object>(MenuEnterReadModeEvent);

            PrintCommand = new DelegateCommand(ShowPrintDialog);

            SettingsCommand = new DelegateCommand(SettingsEvent);
            CreateLinkCommand = new DelegateCommand<object>(CreateLinkEvent);

            //未显示时无法注册上Region名称
            ToolContentVisible = Visibility.Visible;
            ToolsBarContentVisible = Visibility.Visible;
            OCRContentVisible = Visibility.Visible;
            TipVisible = Visibility.Visible;
            TipContentRegionName = RegionNames.TipContentRegionName;
            LeftTipContentRegionName = RegionNames.LeftTipContentRegionName;
            OCRViewerRegionName = RegionNames.OCRViewerRegionName;
            ToolContentRegionName = Guid.NewGuid().ToString();
            ToolsBarContentRegionName = Guid.NewGuid().ToString();
            ConverterBarContentRegionName = Guid.NewGuid().ToString();
            TextEditContentRegionName = Guid.NewGuid().ToString();

            ToolContentVisible = Visibility.Collapsed;
            ToolsBarContentVisible = Visibility.Collapsed;
            OCRContentVisible = Visibility.Collapsed;
            TipVisible = Visibility.Collapsed;
            regionNameByTabItem = new Dictionary<string, string>();
            barContentByTabItem = new Dictionary<string, string>();
            InitialregionNameByTabItem(ref regionNameByTabItem);
            InitialbarContentByTabItem(ref barContentByTabItem);

            eventAggregator.GetEvent<EnterSelectedEditToolEvent>().Subscribe(EnterEditTools, e => e.Unicode == unicode);
            eventAggregator.GetEvent<CloseEditToolEvent>().Subscribe(CloseEditTool, e => e.Unicode == unicode);
            eventAggregator.GetEvent<ShowTipEvent>().Subscribe(ShowSelectedTip, e => e.Unicode == unicode);

            //TODO:根据缓存 选择用户上次选择的菜单
            EnterSelectedBar("TabItemAnnotation");
        }

        /// <summary>
        /// 关闭当前窗体
        /// </summary>
        private void closeWindow()
        {
            App.Current.MainWindow.Close();
        }

        /// <summary>
        /// 转档
        /// </summary>
        /// <param name="obj"></param>
        private void convert(string obj)
        {
            if (!string.IsNullOrEmpty(obj))
            {
                DialogParameters value = new DialogParameters();
                value.Add(ParameterNames.PDFViewer, PDFViewer);
                switch (obj)
                {
                    case "Word":
                        dialogs.ShowDialog(DialogNames.ConverterWordDialog, value, e =>
                        {
                            ConverterDialogsModel converterDialogsModel = new ConverterDialogsModel();
                            converterDialogsModel.OnOpened((DialogResult)e);
                        });
                        break;

                    case "Excel":
                        dialogs.ShowDialog(DialogNames.ConverterExcelDialog, value, e =>
                        {
                            ConverterDialogsModel converterDialogsModel = new ConverterDialogsModel();
                            converterDialogsModel.OnOpened((DialogResult)e);
                        });
                        break;

                    case "PPT":
                        dialogs.ShowDialog(DialogNames.ConverterPPTDialog, value, e =>
                        {
                            ConverterDialogsModel converterDialogsModel = new ConverterDialogsModel();
                            converterDialogsModel.OnOpened((DialogResult)e);
                        });
                        break;

                    case "RTF":
                        dialogs.ShowDialog(DialogNames.ConverterRTFDialog, value, e =>
                        {
                            ConverterDialogsModel converterDialogsModel = new ConverterDialogsModel();
                            converterDialogsModel.OnOpened((DialogResult)e);
                        });
                        break;

                    case "CSV":
                        dialogs.ShowDialog(DialogNames.ConverterCSVDialog, value, e =>
                        {
                            ConverterDialogsModel converterDialogsModel = new ConverterDialogsModel();
                            converterDialogsModel.OnOpened((DialogResult)e);
                        });
                        break;

                    case "HTML":
                        dialogs.ShowDialog(DialogNames.ConverterHTMLDialog, value, e =>
                        {
                            ConverterDialogsModel converterDialogsModel = new ConverterDialogsModel();
                            converterDialogsModel.OnOpened((DialogResult)e);
                        });
                        break;

                    case "Text":
                        dialogs.ShowDialog(DialogNames.ConverterTextDialog, value, e =>
                        {
                            ConverterDialogsModel converterDialogsModel = new ConverterDialogsModel();
                            converterDialogsModel.OnOpened((DialogResult)e);
                        });
                        break;

                    case "Image":
                        dialogs.ShowDialog(DialogNames.ConverterImgDialog, value, e =>
                        {
                            ConverterDialogsModel converterDialogsModel = new ConverterDialogsModel();
                            converterDialogsModel.OnOpened((DialogResult)e);
                        });
                        break;

                    default:
                        break;
                }
            }
        }

        /// <summary>
        /// 解密
        /// </summary>
        private void decrypt()
        {
            if (!PDFViewer.Document.IsEncrypted)
            {
                MessageBoxEx.Show("No security settings available ");
            }
            else
            {
                VerifyPasswordResult result = SecurityHelper.VerifyPasswordByPasswordKind(PDFViewer.Document, EnumPasswordKind.StatusPermissionsPassword, dialogs);
                if (result.IsDiscryptied)
                {
                    if (result.Password != null)
                    {
                        string filePath = PDFViewer.Document.FilePath;
                        PDFViewer.Document.Release();
                        PDFViewer.InitDocument(filePath);
                        PDFViewer.Document.UnlockWithPassword(result.Password);
                    }
                    DialogParameters value = new DialogParameters();
                    value.Add(ParameterNames.PDFDocument, PDFViewer.Document);
                    dialogs.ShowDialog(DialogNames.DeleteSafetySettingsDialog, value, e => { });
                }
            }
        }

        /// <summary>
        /// 加密
        /// </summary>
        private void encrypt()
        {
            if (!this.SecurityInfo.IsPasswordChanged)
            {
                VerifyPasswordResult result = SecurityHelper.VerifyPasswordByPasswordKind(PDFViewer.Document, EnumPasswordKind.StatusPermissionsPassword, dialogs);
                if (result.IsDiscryptied)
                {
                    if (result.Password != null)
                    {
                        string filePath = PDFViewer.Document.FilePath;
                        PDFViewer.Document.Release();
                        PDFViewer.InitDocument(filePath);
                        PDFViewer.Document.UnlockWithPassword(result.Password);
                    }
                }
            }

            DialogParameters value = new DialogParameters();
            value.Add(ParameterNames.PDFViewer, this.PDFViewer);
            value.Add(ParameterNames.ViewContentViewModel, this);
            dialogs.ShowDialog(DialogNames.SetPasswordDialog, value, e =>
            {
                if (e.Result == ButtonResult.OK)
                {
                    SecurityHelper.IsPasswordChanged = true;
                    if (this.SecurityInfo.IsPasswordChanged)
                    {
                        this.PDFViewer.UndoManager.CanSave = true;
                    }
                    this.events.GetEvent<ShowTipEvent>().Publish(new ShowTipEventArgs() { enumTipKind = EnumTipKind.StatusSetPasswordSuccessfully, Unicode = unicode });
                }
            });
        }

        /// <summary>
        /// 合并
        /// </summary>
        private void mergeFile()
        {
            DialogParameters value = new DialogParameters();
            value.Add(ParameterNames.PDFViewer, PDFViewer);
            dialogs.ShowDialog(DialogNames.MergeDialog, value, e => { });
        }

        /// <summary>
        /// 压缩
        /// </summary>
        private void compress()
        {
            DialogParameters value = new DialogParameters();
            value.Add(ParameterNames.PDFViewer, PDFViewer);
            dialogs.ShowDialog(DialogNames.CompressDialog, value, e =>
            {
                CompressDialogModel compressDialogModel = new CompressDialogModel();
                compressDialogModel.OnOpened((Prism.Services.Dialogs.DialogResult)e);
            });
        }

        /// <summary>
        /// 设置Tip状态栏的显示状态
        /// </summary>
        /// <param name="show">是否显示</param>
        public void ShowTip(bool show)
        {
            if (show)
            {
                TipVisible = Visibility.Visible;
            }
            else
            {
                TipVisible = Visibility.Collapsed;
            }
        }

        /// <summary>
        /// 设置LeftTip状态栏的显示状态
        /// </summary>
        /// <param name="show">是否显示</param>
        public void ShowLeftTip(bool show)
        {
            if (show)
            {
                LeftTipVisible = Visibility.Visible;
            }
            else
            {
                LeftTipVisible = Visibility.Collapsed;
            }
        }

        public void CheckHaveAllPermission()
        {
            if (!SecurityHelper.CheckHaveAllPermissions(PDFViewer.Document))
            {
                ShowLeftTip(true);
                NavigationParameters param = new NavigationParameters();
                param.Add(ParameterNames.PDFViewer, PDFViewer);
                region.RequestNavigate(LeftTipContentRegionName, "FileRestrictedTip", param);
            }
        }

        public void ShowSelectedTip(ShowTipEventArgs showTipEventArgs)
        {
            switch (showTipEventArgs.enumTipKind)
            {
                case EnumTipKind.StatusNone:
                    ShowLeftTip(false);
                    break;

                case EnumTipKind.StatusSetPasswordSuccessfully:
                    ShowLeftTip(true);
                    region.RequestNavigate(LeftTipContentRegionName, "SetPasswordSuccessfullyTip");
                    break;

                default: break;
            }
        }

        /// <summary>
        /// 右键菜单创建链接
        /// </summary>
        /// <param name="obj"></param>
        private void CreateLinkEvent(object obj)
        {
            if (obj is object[] objArry)
            {
                if (objArry[0] is AnnotToolContentViewModel toolContentViewModel && objArry[1] is AnnotCommandArgs annotCommand)
                {
                    LinkAnnotArgs linkArgs = new LinkAnnotArgs();
                    linkArgs.URI = string.Empty;
                    linkArgs.LinkType = LINK_TYPE.GOTO;
                    linkArgs.PageIndex = annotCommand.PageIndex;
                    //linkArgs.InvokeLinkSaveCalled(this, EventArgs.Empty);
                    this.IsRightMenuCreateLink = true;
                    List<AnnotHandlerEventArgs> lists = new List<AnnotHandlerEventArgs>();
                    lists.Add(linkArgs);
                    AnnotHandlerEventArgs annotArgs = toolContentViewModel.GetLink(lists);
                    PDFViewer.SetMouseMode(MouseModes.AnnotCreate);
                    PDFViewer.SetToolParam(annotArgs);
                    this.IsPropertyOpen = true;
                }
            }
        }

        /// <summary>
        /// 在文件资源管理器中显示
        /// </summary>
        private void ShowInFolder()
        {
            CommonHelper.ShowFileBrowser(PDFViewer.Document.FilePath);
        }

        private void property()
        {
            DialogParameters valuePairs = new DialogParameters();
            valuePairs.Add(ParameterNames.PDFDocument, PDFViewer.Document);
            dialogs.ShowDialog(DialogNames.PropertyDialog, valuePairs, null);
        }

        private void share()
        {
            try
            {
                var path = PDFViewer.Document.FilePath;
                string subject = "分享至" + " " + PDFViewer.Document.FileName;
                System.Diagnostics.Process.Start("outlook", "/a,\"" + path + "\"" + "/m \"" + "&subject=" + subject + "\"");
            }
            catch
            {
                AlertsMessage alertsMessage = new AlertsMessage();
                alertsMessage.ShowDialog("", "未检测到Ooutlook软件,请先安装Outlook", "OK");
            }
        }

        private void SettingsEvent()
        {
            dialogs.ShowDialog(DialogNames.SettingsDialog, null, null);
        }

        private bool CanSaveExcute()
        {
            return CanSave;
        }

        private void MenuEnterReadModeEvent(object obj)
        {
        }

        public void ShowPrintDialog()
        {
            DialogParameters printValue = new DialogParameters();
            printValue.Add(ParameterNames.PDFViewer, PDFViewer);
            printValue.Add(ParameterNames.FilePath, PDFViewer.Document.FileName);
            printValue.Add(ParameterNames.PrintCurrentPage, PDFViewer.CurrentIndex);
            dialogs.ShowDialog(DialogNames.HomePagePrinterDialog, printValue, e => { });
        }

        private void InitialregionNameByTabItem(ref Dictionary<string, string> dictionary)
        {
            dictionary.Add("TabItemPageEdit", ToolContentRegionName);
            dictionary.Add("TabItemTool", ToolsBarContentRegionName);
            //其他工具菜单栏共用一个ToolsBarContentRegionName
            dictionary.Add("TabItemAnnotation", ToolsBarContentRegionName);
            dictionary.Add("TabItemConvert", ConverterBarContentRegionName);
            dictionary.Add("TabItemScan", ToolsBarContentRegionName);
            dictionary.Add("TabItemEdit", TextEditContentRegionName);
            dictionary.Add("TabItemForm", ToolsBarContentRegionName);
            dictionary.Add("TabItemFill", ToolsBarContentRegionName);
        }

        private void InitialbarContentByTabItem(ref Dictionary<string, string> dictionary)
        {
            dictionary.Add("TabItemPageEdit", "PageEditContent");
            dictionary.Add("TabItemTool", "ToolsBarContent");
            dictionary.Add("TabItemAnnotation", "AnnotToolContent");
            dictionary.Add("TabItemConvert", "ConverterBarContent");
            dictionary.Add("TabItemScan", "ScanContent");
            dictionary.Add("TabItemEdit", "TextEditToolContent");
            dictionary.Add("TabItemForm", "FormsToolContent");
            dictionary.Add("TabItemFill", "FillAndSignContent");
        }

        private void UpdateShowContent(string currentBar)
        {
            ToolContentVisible = Visibility.Collapsed;
            ToolsBarContentVisible = Visibility.Collapsed;
            ConverterBarContentVisible = Visibility.Collapsed;
            TextEditToolContentVisible = Visibility.Collapsed;
            OCRContentVisible = Visibility.Collapsed;

            switch (currentBar)
            {
                case "TabItemAnnotation":

                case "TabItemTool":
                case "TabItemForm":
                case "TabItemFill":
                    ToolsBarContentVisible = Visibility.Visible;
                    break;

                case "TabItemScan":
                    ToolsBarContentVisible = Visibility.Visible;
                    OCRContentVisible = Visibility.Visible;
                    break;

                case "TabItemEdit":
                    TextEditToolContentVisible = Visibility.Visible;
                    break;

                case "TabItemConvert":
                    ConverterBarContentVisible = Visibility.Visible;
                    break;

                case "TabItemPageEdit":
                case "HeaderFooterContent":
                case "BatesContent":
                case "WatermarkContent":
                case "BackgroundContent":
                case "RedactionContent":
                    ToolContentVisible = Visibility.Visible;
                    break;

                default:
                    break;
            }

            PDFEditMode(currentBar);
            FormMode(currentBar);
        }

        private void PDFEditMode(string currentBar)
        {
            if (currentBar == "TabItemEdit")
            {
                if (PDFViewer != null)
                {
                    PDFViewer.SetMouseMode(MouseModes.PDFEdit);
                    //SelectedPrpoertyPanel("TextEditProperty", null);
                    //IsPropertyOpen = true;
                }
            }
            else
            {
                if (PDFViewer != null && PDFViewer.MouseMode == MouseModes.PDFEdit)
                {
                    IsPropertyOpen = false;
                    PDFViewer.SetMouseMode(MouseModes.PanTool);
                }
            }
        }

        private void FormMode(string currentBar)
        {
            if (currentBar == "TabItemForm")
            {
                if (PDFViewer != null)
                {
                    PDFViewer.SetMouseMode(MouseModes.FormEditTool);
                }
            }
            else
            {
                if (PDFViewer != null && PDFViewer.MouseMode == MouseModes.FormEditTool)
                {
                    PDFViewer.SetMouseMode(MouseModes.PanTool);
                }
            }
        }

        private void UndoManager_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
        {
            if (!isInPageEdit)
            {
                //不处于页面编辑模式下时，根据PDFVIewer的undo redo状态来更新按钮状态
                //页面编辑模式下，按钮状态根据页面编辑的undo redo来显示
                if (e.PropertyName == "CanUndo")
                {
                    CanUndo = PDFViewer.UndoManager.CanUndo;
                }
                if (e.PropertyName == "CanRedo")
                {
                    CanRedo = PDFViewer.UndoManager.CanRedo;
                }
            }
            if (e.PropertyName == "CanSave")
            {
                CanSave = PDFViewer.UndoManager.CanSave;
            }
        }

        /// <summary>
        /// 选项卡切换事件
        /// </summary>
        /// <param name="e"></param>
        private void TabControlSelectonChangedEvent(object e)
        {
            var args = e as SelectionChangedEventArgs;
            if (args != null)
            {
                var item = args.AddedItems[0] as TabItem;
                CurrentBar = item.Name;
                if (previousBar != CurrentBar)
                {
                    if (CurrentBar == "TabItemPageEdit")//如果是页面编辑则进入页面编辑模式
                    {
                        EnterToolMode(barContentByTabItem[CurrentBar]);
                        isInPageEdit = true;
                    }
                    else//其余情况直接导航至对应的工具栏即可，不需要清空之前的content,region里是单例模式
                    {
                        EnterSelectedBar(CurrentBar);
                        isInPageEdit = false;
                    }
                    previousBar = CurrentBar;
                }
            }
        }

        /// <summary>
        /// 阅读模式
        /// </summary>
        /// <param name="viewContent"></param>
        public async void RbtnReadMode()
        {
            App.mainWindowViewModel.SelectedItem.IsInReadctonMode = true;
            mainViewModel.IsBookMode = true;
            IsLoading = Visibility.Visible;
            await Task.Delay(1);
            PDFViewer.SetMouseMode(MouseModes.PanTool);
            NavigationParameters param = new NavigationParameters();
            param.Add(ParameterNames.PDFViewer, PDFViewer);
            param.Add(ParameterNames.ViewContentViewModel, this);
            region.RequestNavigate(ToolContentRegionName, "ReadViewContent", param);

            //ShowContent(CurrentBar, true);
            if (GridToolRow != 0)
            {
                GridToolRow = 0;
            }

            if (GridToolRowSpan != 4)
            {
                GridToolRowSpan = 4;
            }
            //isInPageEdit = true;
            UpdateShowContent("TabItemPageEdit");
            IsLoading = Visibility.Collapsed;
        }

        /// <summary>
        /// 退出阅读模式
        /// </summary>
        public async void UnReadModel()
        {
            App.mainWindowViewModel.SelectedItem.IsInReadctonMode = false;
            mainViewModel.IsBookMode = false;
            IsLoading = Visibility.Visible;
            await Task.Delay(1);
            //PDFViewer.MouseMode = MouseModes.None;

            if (region.Regions.ContainsRegionWithName(ViwerRegionName))
            {
                if (region.Regions[ViwerRegionName].Views.Contains(PDFViewer))
                {
                    var contentRegion = region.Regions[ViwerRegionName];
                    contentRegion.Remove(PDFViewer);
                }
                region.AddToRegion(ViwerRegionName, PDFViewer);
            }
            if (string.IsNullOrEmpty(CurrentBar) || CurrentBar.Equals("TabItemPageEdit", StringComparison.OrdinalIgnoreCase))
            {
                EnterSelectedBar("TabItemAnnotation");
            }
            else
            {
                EnterSelectedBar(CurrentBar);
            }
            bool isExist = false;
            if (region.Regions.ContainsRegionWithName(TipContentRegionName))
            {
                var views = region.Regions[TipContentRegionName].Views;
                foreach (var item in views)
                {
                    if (item is Views.TipContent.ReadModelTip readModelTip)
                    {
                        isExist = true;
                        break;
                    }
                }
            }
            if (isExist == false)
            {
                region.RequestNavigate(TipContentRegionName, "ReadModelTip");
            }

            IsLoading = Visibility.Collapsed;

            ShowTip(true);
            await Task.Delay(3000);
            //ReadModelTip = Visibility.Collapsed;
            TipVisible = Visibility.Collapsed;
        }

        #region PDFViewer鼠标滚轮缩放事件

        public void PdfViewer_MouseWheelZoomHandler(object sender, bool e)
        {
            double newZoom = CheckZoomLevel(PDFViewer.ZoomFactor + (e ? 0.01 : -0.01), e);
            PDFViewer.Zoom(newZoom);
        }

        public double CheckZoomLevel(double zoom, bool IsGrowth)
        {
            double standardZoom = 100;
            if (zoom <= 0.01)
            {
                return 0.01;
            }
            if (zoom >= 10)
            {
                return 10;
            }

            zoom *= 100;
            for (int i = 0; i < zoomLevel.Length - 1; i++)
            {
                if (zoom > zoomLevel[i] && zoom <= zoomLevel[i + 1] && IsGrowth)
                {
                    standardZoom = zoomLevel[i + 1];
                    break;
                }
                if (zoom >= zoomLevel[i] && zoom < zoomLevel[i + 1] && !IsGrowth)
                {
                    standardZoom = zoomLevel[i];
                    break;
                }
            }
            return standardZoom / 100;
        }

        #endregion PDFViewer鼠标滚轮缩放事件

        #region Navigate

        public void OnNavigatedTo(NavigationContext navigationContext)
        {
            if (isOpenFile)
                return;

            var mainVM = navigationContext.Parameters[ParameterNames.MainViewModel] as MainContentViewModel;
            if (mainVM != null)
            {
                mainViewModel = mainVM;
                mainViewModel.viewContentViewModel = this;
            }
            var pdfview = navigationContext.Parameters[ParameterNames.PDFViewer] as CPDFViewer;
            if (pdfview != null)
            {
                PDFViewer = pdfview;
                if (pdfview.Tag != null)
                {
                    //保存密码
                    PassWord = pdfview.Tag.ToString();
                }
                loadFile();
                CheckHaveAllPermission();
            }
            isOpenFile = true;
        }

        public bool IsNavigationTarget(NavigationContext navigationContext)
        {
            if (navigationContext != null)
            {
                //另存为打开导航进来时  不能新建一个实例
                return true;
            }
            else
            {
                //一次性打开多个文件时，需要新建实例
                return false;
            }
        }

        public void OnNavigatedFrom(NavigationContext navigationContext)
        {
        }

        #endregion Navigate

        #region 方法

        /// <summary>
        /// 视图面板  切换分屏模式
        /// </summary>
        /// <param name="mode"></param>
        public void EnterSplitMode(SplitMode mode)
        {
            ///通知UI层更改布局
            this.events.GetEvent<SplitEvent>().Publish(new SplitEventArgs() { Unicode = unicode, Mode = mode });
        }

        private void Undo()
        {
            if (isInPageEdit)
            {
                //执行页面编辑的Undo
                PageEditUndo?.Invoke();
            }
            else
            {
                PDFViewer.UndoManager.Undo();
            }
        }

        private void Redo()
        {
            if (isInPageEdit)
            {
                //执行页面编辑的Redo
                PageEditRedo?.Invoke();
            }
            else
            {
                PDFViewer.UndoManager.Redo();
            }
        }

        private void LoadControl()
        {
            //在构造函数中使用Region需要借助Dispatcher 确保UI已经加载完成,加载BOTA区域
            // 非必要情况不要使用该异步方法，可能会导致一次性加载多个文件时出现因异步引起的regionname 错乱问题
            //System.Windows.Application.Current.Dispatcher.BeginInvoke(System.Windows.Threading.DispatcherPriority.Send, new Action(() =>
            //      {
            NavigationParameters parameters = new NavigationParameters();
            parameters.Add(ParameterNames.PDFViewer, PDFViewer);
            parameters.Add(ParameterNames.ViewContentViewModel, this);

            region.RequestNavigate(BOTARegionName, "BOTAContent", parameters);
            region.RequestNavigate(BottomToolRegionName, "BottomToolContent", parameters);
            region.RequestNavigate(ReadModeRegionName, "ReadModeContent", parameters);
            region.RequestNavigate(SplitViewerRegionName, "SplitScreenContent", parameters);
            //TODO 根据上一次关闭记录的菜单，选中TabItem
            EnterSelectedBar("TabItemAnnotation");
            //}
            //));

            //if (App.IsBookMode)
            //{
            //    RbtnReadMode();
            //}
            //else
            //{
            //    UnReadModel();
            //}
        }

        /// <summary>
        /// 各个注释（选中和创建注释）导航到对应注释的属性面板
        /// </summary>
        /// <param name="Content"></param>
        /// <param name="annotPropertyPanel"></param>
        public void SelectedPrpoertyPanel(string Content, AnnotPropertyPanel annotPropertyPanel)
        {
            NavigationParameters parameters = new NavigationParameters();
            //传其他参数：文档类，空注释面板；
            parameters.Add(ParameterNames.PDFViewer, PDFViewer);
            parameters.Add(ParameterNames.PropertyPanelContentViewModel, annotPropertyPanel);
            parameters.Add(ParameterNames.ViewContentViewModel, this);
            region.RequestNavigate(PropertyRegionName, Content, parameters);
        }

        /// <summary>
        /// 将PDFViwer添加到Region
        /// </summary>
        private void loadFile()
        {
            PDFViewer.MouseWheelZoomHandler += PdfViewer_MouseWheelZoomHandler;
            PDFViewer.UndoManager.PropertyChanged += UndoManager_PropertyChanged;
            CanSave = PDFViewer.UndoManager.CanSave;
            CanUndo = PDFViewer.UndoManager.CanUndo;
            CanRedo = PDFViewer.UndoManager.CanRedo;
            region.Regions[ViwerRegionName].RemoveAll();

            //OpenFileInfo 内容赋值给PDFViewer
            GetOpenFileInfo();

            region.AddToRegion(ViwerRegionName, PDFViewer);
        }

        private void GetOpenFileInfo()
        {
            OpenFileInfo = SettingHelper.GetFileInfo(PDFViewer.Document.FilePath);
            if (OpenFileInfo != null)
            {
                if (OpenFileInfo.LastViewMode != PDFViewer.ModeView)
                {
                    PDFViewer.ChangeViewMode(OpenFileInfo.LastViewMode);
                }
                if (OpenFileInfo.LastFitMode != PDFViewer.ModeFit)
                {
                    PDFViewer.ChangeFitMode(OpenFileInfo.LastFitMode);
                }
                if (OpenFileInfo.LastFitMode == ComPDFKitViewer.FitMode.FitFree)
                {
                    PDFViewer.Zoom(OpenFileInfo.LastZoom);
                }
                if (OpenFileInfo.LastPageIndex != PDFViewer.CurrentIndex)
                {
                    PDFViewer.GoToPage(OpenFileInfo.LastPageIndex);
                }
                PDFViewer.SetSplitMode(OpenFileInfo.LastSplitMode);

                PDFViewer.SetShowLink(OpenFileInfo.ShowHighLightLink);

                if (OpenFileInfo.LastPageSpace)
                {
                    PDFViewer.SetPageSpacing(8);
                }
                else
                {
                    PDFViewer.SetPageSpacing(0);
                }

                if (OpenFileInfo.LastDrawMode == ComPDFKitViewer.DrawModes.Draw_Mode_Custom && OpenFileInfo.LastFillColor != 0)
                {
                    PDFViewer.SetDrawMode(OpenFileInfo.LastDrawMode, OpenFileInfo.LastFillColor);
                }
                else
                {
                    PDFViewer.SetDrawMode(OpenFileInfo.LastDrawMode);
                }
            }
        }

        /// <summary>
        /// 已有路径文档的保存逻辑
        /// </summary>
        public bool saveFile()
        {
            try
            {
                if (string.IsNullOrEmpty(PDFViewer.Document.FilePath))
                    return saveAsFile();

                //文档已被修复时 提示另存为
                if (PDFViewer.Document.HasRepaired)
                {
                    AlertsMessage alertsMessage = new AlertsMessage();
                    alertsMessage.ShowDialog("", "文件已被修复，建议另存为", "Cancel", "OK");
                    if (alertsMessage.result == ContentResult.Ok)
                        return saveAsFile();
                    else
                        return false;
                }

                //文件路径无法存在时
                if (!File.Exists(PDFViewer.Document.FilePath))
                {
                    AlertsMessage alertsMessage = new AlertsMessage();
                    alertsMessage.ShowDialog("", "文件路径不存在，需要另存为", "Cancel", "OK");
                    if (alertsMessage.result == ContentResult.Ok)
                        return saveAsFile();
                    else
                        return false;
                }

                //只读文件无法写入时，提示另存为
                FileInfo fileInfo = new FileInfo(PDFViewer.Document.FilePath);
                if (fileInfo.IsReadOnly)
                {
                    AlertsMessage alertsMessage = new AlertsMessage();
                    alertsMessage.ShowDialog("", "文件为只读文件，需要另存为", "Cancel", "OK");
                    if (alertsMessage.result == ContentResult.Ok)
                        return saveAsFile();
                    else
                        return false;
                }

                if (SecurityInfo.IsPasswordChanged)
                {
                    string currentFilePath = PDFViewer.Document.FilePath;
                    string tempFilePath = PDFViewer.Document.FilePath + ".temp.pdf";
                    string openPassword = null;
                    string permissionsPassword = null;
                    CPDFPermissionsInfo cPDFPermissionsInfo = CreateDefaultPermissionsInfo();
                    if (SecurityInfo.NeedOpenPassword)
                    {
                        openPassword = SecurityInfo.OpenPassword;
                    }

                    if (SecurityInfo.NeedPermissionsPassword)
                    {
                        permissionsPassword = SecurityInfo.PermissionsPassword;
                        cPDFPermissionsInfo = SecurityInfo.CPDFPermissionsInfo;
                    }
                    //方案一
                    if (true)
                    {
                        PDFViewer.Document.Encrypt(openPassword, permissionsPassword, cPDFPermissionsInfo);
                        AlertsMessage alertsMessage = new AlertsMessage();
                        alertsMessage.ShowDialog("", "文件安全设置已修改，需要另存为", "Cancel", "OK");
                        if (alertsMessage.result == ContentResult.Ok)
                            return saveAsFile();
                        else
                            return false;
                    }
                    else
                    {
                        //方案二
                        string currentPath = PDFViewer.Document.FilePath;
                        string tempPath = PDFViewer.Document.FilePath + ".temp.pdf";
                        PDFViewer.Document.Encrypt(openPassword, permissionsPassword, cPDFPermissionsInfo);
                        PDFViewer.Document.WriteToFilePath(tempPath);
                        PDFViewer.InitDocument(tempPath);
                        //PDFViewer.Document.UnlockWithPassword(permissionsPassword);
                        //PDFViewer.Document.Encrypt(openPassword, permissionsPassword, cPDFPermissionsInfo);
                        PDFViewer.Document.WriteToFilePath(currentPath);
                        System.IO.File.Delete(tempPath);
                        PDFViewer.CloseDocument();
                        PDFViewer.InitDocument(currentPath);
                        PDFViewer.Document.UnlockWithPassword(permissionsPassword);
                    }
                }

                bool result = PDFViewer.Document.WriteToLoadedPath();
                if (result)
                {
                    PDFViewer.UndoManager.CanSave = false;
                    App.Current.Dispatcher.Invoke(() =>
                                  {
                                      //保存时更新缩略图
                                      OpenFileInfo info = SettingHelper.GetFileInfo(PDFViewer.Document.FilePath);
                                      try
                                      {
                                          if (!string.IsNullOrEmpty(info.ThumbImgPath) && !PDFViewer.Document.IsEncrypted)//加密的文档不获取缩略图
                                          {
                                              var size = PDFViewer.Document.GetPageSize(0);
                                              System.Drawing.Bitmap bitmap = ToolMethod.RenderPageBitmapNoWait(PDFViewer.Document, (int)size.Width, (int)size.Height, 0, true, true);
                                              string folderPath = System.IO.Path.Combine(App.CurrentPath, "CoverImage");
                                              if (File.Exists(folderPath))
                                                  File.Delete(folderPath);
                                              DirectoryInfo folder = new DirectoryInfo(folderPath);
                                              if (!folder.Exists)
                                                  folder.Create();
                                              string imagePath = info.ThumbImgPath;
                                              if (!File.Exists(imagePath))//由加密文档变为非加密文档时 新建一个路径
                                              {
                                                  string imageName = Guid.NewGuid().ToString();
                                                  imagePath = System.IO.Path.Combine(folderPath, imageName);
                                                  using (FileStream stream = new FileStream(imagePath, FileMode.Create))
                                                  {
                                                      bitmap.Save(stream, System.Drawing.Imaging.ImageFormat.Png);
                                                  }
                                              }
                                              else
                                              {
                                                  using (FileStream stream = new FileStream(imagePath, FileMode.Open))
                                                  {
                                                      bitmap.Save(stream, System.Drawing.Imaging.ImageFormat.Png);
                                                  }
                                              }
                                              info.ThumbImgPath = imagePath;
                                              SettingHelper.SetFileInfo(info);
                                          }
                                      }
                                      catch
                                      {
                                          info.ThumbImgPath = null;
                                          SettingHelper.SetFileInfo(info);
                                      }
                                  });
                }
                else
                {
                    //文件被占用 保存失败时
                    AlertsMessage alertsMessage = new AlertsMessage();
                    alertsMessage.ShowDialog("", "文件被占用，需要另存为", "Cancel", "OK");
                    if (alertsMessage.result == ContentResult.Ok)
                        return saveAsFile();
                    else
                        return false;
                }

                return result;
            }
            catch { return false; }
        }

        /// <summary>
        /// 另存为或新文档保存逻辑
        /// </summary>
        public bool saveAsFile(Action RedactionAction = null)
        {
            var dlg = new Microsoft.Win32.SaveFileDialog();
            dlg.Filter = Properties.Resources.OpenDialogFilter;
            dlg.FileName = PDFViewer.Document.FileName;
            if (dlg.ShowDialog() == true && !string.IsNullOrEmpty(dlg.FileName))
            {
                bool result = false;
                if (RedactionAction != null)
                {
                    //保存前进行标记密文处理应用或擦除
                    RedactionAction.Invoke();
                }

                if (App.OpenedFileList.Contains(dlg.FileName))
                {
                    //提示文件已经被打开
                }
                else
                {
                    result = PDFViewer.Document.WriteToFilePath(dlg.FileName);
                    if (result)
                    {
                        DoAfterSaveAs(dlg.FileName);
                    }
                    else
                    {
                        //提示文件被其他软件占用 无法保存
                        //MessageBoxEx.Show(App.MainPageLoader.GetString("Main_TheFileOccupiedWarning"), "", Winform.MessageBoxButtons.OKCancel, new string[] { App.MainPageLoader.GetString("Main_SaveAs"), App.MainPageLoader.GetString("Main_Cancel") })
                    }
                ;
                }
                return result;
            }
            else
                return false;
        }

        /// <summary>
        /// 另存为Flatten
        /// </summary>
        private void saveAsFlatten()
        {
            var dlg = new SaveFileDialog();
            dlg.Filter = Properties.Resources.OpenDialogFilter;
            dlg.FileName = PDFViewer.Document.FileName.Substring(0, PDFViewer.Document.FileName.LastIndexOf(".")) + "_Flatten.pdf";

            if (dlg.ShowDialog() == true && !string.IsNullOrEmpty(dlg.FileName))
            {
                saveFile();
                CPDFDocument kmdoc = CPDFDocument.InitWithFilePath(PDFViewer.Document.FileName);
                if (kmdoc == null)
                    return;

                bool result = kmdoc.WriteFlattenToFilePath(dlg.FileName);
                if (result)
                    System.Diagnostics.Process.Start("explorer", "/select,\"" + dlg.FileName + "\"");
                kmdoc.Release();
            }
        }

        /// <summary>
        /// 另存为后进行的操作
        /// 重新打开新文档
        /// </summary>
        /// <param name="targetPath"></param>
        public void DoAfterSaveAs(string targetPath)
        {
            App.OpenedFileList.Remove(targetPath);
            string oldFilePath = targetPath;

            PDFViewer.UndoManager.CanSave = false;

            mainViewModel.OpenFile(targetPath);
            //TODO：通知各模块更新PDFview对象
            //var result = OpenFile(targetPath, true);

            //if (result)
            //{
            //    FileChanged.Invoke(this, null);
            //    Zoomer.PdfViewer = PdfViewer;
            //    PageSelector.PdfViewer = PdfViewer;
            //    ViewModeSelector.PdfViewer = PdfViewer;

            //    OpenFileInfo fileInfo = SettingHelper.GetFileInfo(oldFilePath);
            //    if (fileInfo != null)
            //    {
            //        PdfViewer.ChangeViewMode(fileInfo.LastViewMode);
            //        PdfViewer.ChangeFitMode(fileInfo.LastFitMode);
            //        if (fileInfo.LastFitMode == FitMode.FitFree)
            //            PdfViewer.Zoom(fileInfo.LastZoom);

            //        PdfViewer.GoToPage(fileInfo.LastPageIndex);
            //        if (fileInfo.LastDrawMode == DrawModes.Draw_Mode_Custom && fileInfo.LastFillColor != 0)
            //            PdfViewer.SetDrawMode(fileInfo.LastDrawMode, fileInfo.LastFillColor);
            //        else
            //            PdfViewer.SetDrawMode(fileInfo.LastDrawMode);
            //    }
            //}
        }

        /// <summary>
        /// 显示前添加内容到Region
        /// </summary>
        /// <param name="isPageEdit"></param>
        private void ShowContent(string currentBar, bool isToolMode = false)
        {
            GridVisibility = Visibility.Visible;
            //显示页面编辑或其他工具
            if (currentBar == "TabItemPageEdit" || isToolMode)
            {
                if (currentBar == "TabItemPageEdit")//进入页面编辑
                {
                    if (GridToolRow != 1)
                    {
                        GridToolRow = 1;
                    }

                    if (GridToolRowSpan != 3)
                    {
                        GridToolRowSpan = 3;
                    }
                }
                else//进入水印等其他工具模式
                {
                    GridVisibility = Visibility.Collapsed;
                    if (GridToolRow != 0)
                    {
                        GridToolRow = 0;
                    }

                    if (GridToolRowSpan != 4)
                    {
                        GridToolRowSpan = 4;
                    }
                }
                //ToolContent的visible跟toolsbarContent 的visible是互斥的
                UpdateShowContent(currentBar);
            }
            else
            {
                if (GridToolRow != 1)
                {
                    GridToolRow = 1;
                }
                UpdateShowContent(currentBar);
            }
        }

        /// <summary>
        /// 从二级工具栏进入需要修改界面布局的场景
        /// </summary>
        /// <param name="EditToolName"></param>
        private void EnterEditTools(StringWithUnicode EditToolName)
        {
            EnterSelectedEditTool(EditToolName);
        }

        private void CloseEditTool(EnumCloseModeUnicode enumCloseModeunicode)
        {
            EnumCloseMode enumCloseMode = enumCloseModeunicode.Status;
            if (enumCloseMode == EnumCloseMode.StatusConfirm)
            {
                PDFViewer.Document.ReleasePages();
                PDFViewer.ReloadDocument();
            }

            //如果是其他工具共用一个PDFview,退出工具模式后，需要重新添加到Region，否则不会显示
            if (!region.Regions[ViwerRegionName].Views.Contains(PDFViewer))
            {
                region.AddToRegion(ViwerRegionName, PDFViewer);
            }

            CurrentBar = "TabItemTool";
            EnterSelectedBar(CurrentBar);
        }

        /// <summary>
        /// 二级菜单指定目标处理
        /// </summary>
        /// <param name="e"></param>
        private void EnterSelectedEditTool(StringWithUnicode EditToolName)
        {
            CurrentBar = EditToolName.EditToolsContentName;
            EnterToolMode(CurrentBar);
        }

        /// <summary>
        /// 进入工具编辑(如页面编辑、水印、密文等)模式
        /// </summary>
        /// <param name="targetToolMode">要导航过去的控件名称</param>
        /// <param name="valuePairs">导航需要传送的参数，为空时，默认传送PDFView和ViewContentViewModel</param>
        private async void EnterToolMode(string targetToolMode, NavigationParameters valuePairs = null)
        {
            IsLoading = Visibility.Visible;
            await Task.Delay(3);
            NavigationParameters param = new NavigationParameters();
            if (valuePairs == null)
            {
                param.Add(ParameterNames.PDFViewer, PDFViewer);
                param.Add(ParameterNames.ViewContentViewModel, this);
            }
            else//有传入其他内容的参数时
            {
                param = valuePairs;
            }
            region.RequestNavigate(ToolContentRegionName, targetToolMode, param);
            ShowContent(CurrentBar, true);

            IsLoading = Visibility.Collapsed;
        }

        private void EnterSelectedBar(string currentBar)
        {
            NavigationParameters param = new NavigationParameters();
            param.Add(ParameterNames.PDFViewer, PDFViewer);
            param.Add(ParameterNames.ViewContentViewModel, this);
            region.RequestNavigate(regionNameByTabItem[currentBar], barContentByTabItem[currentBar], param);
            if (currentBar == "TabItemScan")
            {
                region.RequestNavigate(RegionNames.OCRViewerRegionName, "ScanViwer", param);
            }
            ShowContent(currentBar);
        }

        /// <summary>
        /// 退出工具(水印、密文等)编辑模式，隐藏ToolContent
        /// </summary>
        public void ExitToolMode()
        {
            ToolContentVisible = Visibility.Collapsed;
            if (isInPageEdit)
            {
                TabSelectedIndex = 0;
                isInPageEdit = false;
            }
        }

        #endregion 方法
    }
}