PDFOffice_Windows_exe/PDF Office/ViewModels/MainContentViewModel.cs

using ComPDFKitViewer.PdfViewer;
using Microsoft.Win32;
using PDF_Master.CustomControl;
using PDF_Master.EventAggregators;
using PDF_Master.Views;
using Prism.Commands;
using Prism.Events;
using Prism.Ioc;
using Prism.Mvvm;
using Prism.Regions;
using Prism.Services.Dialogs;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using PDF_Master.Model;
using System.ComponentModel;
using PDF_Master.Helper;
using PDFSettings.Settings;
using System.Drawing;
using System.IO;
using System.Drawing.Imaging;
using ComPDFKit.PDFDocument;
using static PDF_Master.Model.Dialog.ToolsDialogs.SaftyDialogs.DeleteSafetySettintgsModel;
using PDF_Master.Model.Dialog.ToolsDialogs.SaftyDialogs;
using PDF_Master.Properties;
using WIA;

namespace PDF_Master.ViewModels
{
    public class MainContentViewModel : BindableBase, INavigationAware
    {
        #region 文案

        private string T_rename;

        public string T_Rename
        {
            get { return T_rename; }
            set
            {
                SetProperty(ref T_rename, value);
            }
        }

        private string T_floder;

        public string T_Floder
        {
            get { return T_floder; }
            set
            {
                SetProperty(ref T_floder, value);
            }
        }

        private string T_close;

        public string T_Close
        {
            get { return T_close; }
            set
            {
                SetProperty(ref T_close, value);
            }
        }

        private string T_closeAll;

        public string T_CloseAll
        {
            get { return T_closeAll; }
            set
            {
                SetProperty(ref T_closeAll, value);
            }
        }

        private void InitString()
        {
            FileName = App.MainPageLoader.GetString("MultipleTabs_Default");
            T_Rename = App.MainPageLoader.GetString("MultipleTabs_Rename");
            T_Floder = App.MainPageLoader.GetString("MultipleTabs_ Folder");
            T_Close = App.MainPageLoader.GetString("MultipleTabs_ Close");
            T_CloseAll = App.MainPageLoader.GetString("MultipleTabs_ CloseAll");
        }


        #endregion
        /// <summary>
        /// 是否处于阅读模式
        /// </summary>
        public bool IsBookMode = false;

        private string fileName = "Home";

        public string FileName
        {
            get { return fileName; }
            set
            {
                SetProperty(ref fileName, value);
                if (IsReNameTextShow == Visibility.Visible)
                {
                    dorenameFile();
                }
            }
        }

        private string filePath;

        public string FilePath
        {
            get { return filePath; }
            set
            {
                SetProperty(ref filePath, value);
                if (!string.IsNullOrEmpty(filePath))
                {
                    FileName = System.IO.Path.GetFileName(filePath);
                }
            }
        }

        private Visibility fileChanged = Visibility.Collapsed;

        public Visibility FileChanged
        {
            get { return fileChanged; }
            set { SetProperty(ref fileChanged, value); }
        }

        public CPDFViewer PDFViewer { get; set; }

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

        public DelegateCommand UnLoaded { get; set; }

        public DelegateCommand ShowInFolderCommand { get; set; }

        public DelegateCommand RenameCommand { get; set; }

        public ViewContentViewModel viewContentViewModel { get; set; }

        public MainWindowViewModel mainWindowViewModel { get; set; }

        public HomeContentViewModel homeContentViewModel { get; set; }

        private string regionName;

        public string MainContentRegionName
        {
            get { return regionName; }
            set { SetProperty(ref regionName, value); }
        }

        private bool isReNameEnable = false;

        /// <summary>
        /// 是否能够重命名
        /// </summary>
        public bool IsReNameEnable
        {
            get { return isReNameEnable; }
            set
            {
                SetProperty(ref isReNameEnable, value);
            }
        }

        private bool isShowInFolderEnable = false;

        /// <summary>
        /// 是否能够显示文件浏览器
        /// </summary>
        public bool IsShowInFolderEnable
        {
            get { return isShowInFolderEnable; }
            set
            {
                SetProperty(ref isShowInFolderEnable, value);
            }
        }

        private Visibility isRenameTextShow = Visibility.Collapsed;

        public Visibility IsReNameTextShow
        {
            get { return isRenameTextShow; }
            set
            {
                SetProperty(ref isRenameTextShow, value);
            }
        }



        private bool newFile = false;
        /// <summary>
        /// 是否是新建的文档
        /// </summary>
        public bool NewFile
        {
            get { return newFile; }
            set
            {
                SetProperty(ref newFile, value);
                if(!value)
                {
                    IsShowInFolderEnable = true;
                }
            }
        }


        public IRegionManager toolregion;

        public IEventAggregator eventer;

        public IContainerProvider container;

        public IDialogService dialogs;

        public MainContentViewModel(IRegionManager regionManager, IEventAggregator eventAggregator, IContainerProvider containerProvider, IDialogService dialogService)
        {
            toolregion = regionManager;
            eventer = eventAggregator;
            container = containerProvider;
            dialogs = dialogService;

            CloseTab = new DelegateCommand<object>(CloseTabItem);
            ShowInFolderCommand = new DelegateCommand(showInFolder);
            RenameCommand = new DelegateCommand(rename);
            UnLoaded = new DelegateCommand(unload);

            MainContentRegionName = Guid.NewGuid().ToString();

            InitString();
        }

        //关闭页签
        //清除文件记录，释放Document对象
        private void unload()
        {
            if (PDFViewer != null)
            {
                App.OpenedFileList.Remove(PDFViewer.Document?.FilePath);
                PDFViewer.CloseDocument();
            }
        }

        /// <summary>
        /// 执行重命名操作
        /// </summary>
        private void dorenameFile()
        {
            var folder = PDFViewer.Document.FilePath.Substring(0, PDFViewer.Document.FilePath.LastIndexOf("\\"));
            ////File.Replace(PDFViewer.Document.FilePath,Path.Combine(folder,FileName),Path.Combine(folder,"back.bak"),true);
            ///TODO:会被占用 无法操作
            IsReNameTextShow = Visibility.Collapsed;
        }

        /// <summary>
        /// 显示重命名文本框
        /// </summary>
        private void rename()
        {
            IsReNameTextShow = Visibility.Visible;
        }

        private void showInFolder()
        {
            if (!string.IsNullOrEmpty(PDFViewer.Document.FilePath))
            {
                CommonHelper.ShowFileBrowser(PDFViewer.Document.FilePath);
            }
        }

        private void CloseTabItem(object item)
        {
            if (item == null)
            {
                App.mainWindowViewModel?.CloseTabItem(mainWindowViewModel.SelectedItem);
            }
            else
            {
                App.mainWindowViewModel?.CloseTabItem(item);
                App.OpenedFileList.Remove(FilePath);
                if(NewFile)
                {
                    //新文档 关闭文档后 及时清空临时缓存
                    DirectoryInfo directory = new DirectoryInfo(CacheFilePath.Instance.CreatedFilePath);
                    FileInfo fileInfo = new FileInfo(FilePath);
                    if(directory.GetFiles().ToList().Contains(fileInfo))
                    {
                        File.Delete(FilePath);
                    }
                }
            }
        }

        /// <summary>
        /// 打开指定路径的PDF文件
        /// </summary>
        /// <param name="filePath"></param>
        public void OpenFile(string filePath, PasswordInfo passwordInfo = null)
        {
            var result = LoadFileFormPath(filePath);
            if (!result)
            {
                return;
            }
            FilePath = filePath;


            NavigateToViewContent();

            //检查是否是新文档
            OpenFileInfo isnew = SettingHelper.GetFileInfo(filePath);
            if (isnew == null)
            {
                if (App.OpenedFileList.Contains(filePath) == false)
                {
                    App.OpenedFileList.Add(filePath);
                }
            }
            //打开文件后，不管是新文件还是旧文件都需要更新排序
            SettingHelper.SortRecentOpenFiles(filePath);
        }

        /// <summary>
        /// 创建PDFviewer对象后导航到ViewContent
        /// </summary>
        private void NavigateToViewContent(PasswordInfo passwordInfo = null)
        {
            NavigationParameters parameters = new NavigationParameters {
                { ParameterNames.MainViewModel, this },
                { ParameterNames.PDFViewer,PDFViewer},
                { ParameterNames.PasswordInfo, passwordInfo}
            };

            toolregion.RequestNavigate(MainContentRegionName, "ViewContent", parameters);

            IsReNameEnable = true;
            if (!string.IsNullOrEmpty(PDFViewer.Document.FilePath)&&!NewFile)
            {
                IsShowInFolderEnable = true;
            }
        }

        /// <summary>
        /// 从文件路径创建PDFViewer对象，已包含文档解密逻辑
        /// </summary>
        /// <param name="path"></param>
        /// <returns></returns>
        private bool LoadFileFormPath(string path)
        {
            PDFViewer = new CPDFViewer();
            PDFViewer.InitDocument(path);
            PDFViewer.UndoManager.PropertyChanged += UndoManager_PropertyChanged;
            if (PDFViewer.Document == null)
            {
                //MessageBoxEx.Show(App.MainPageLoader.GetString("Main_OpenFileFailedWarning"));
                return false;
            }
            else
            {
                //解密逻辑调整到显示阅读页后，测试确认没问题后，删除下面的注释部分代码
                //VerifyPasswordResult result = SecurityHelper.VerifyPasswordByPasswordKind(PDFViewer.Document, EnumPasswordKind.StatusOpenPassword, dialogs);
                //if (result.IsDiscryptied)
                //{
                //    if (result.Password != null)
                //    {
                //        string filePath = PDFViewer.Document.FilePath;
                //        PDFViewer.Document.UnlockWithPassword(result.Password);
                //        PDFViewer.Tag = result.Password;
                //    }
                //    ///TODO:
                //    ///此处填入需要执行的代码
                //}

                //if (result.IsDiscryptied == false)
                //{
                //    //未成功解密文档时，释放Document对象，返回
                //    PDFViewer.Document.Release();
                //    return false;
                //}
            }

            //PDFViewer.Load();
            //PDFViewer.SetFormFieldHighlight(Settings.Default.AppProperties.InitialVIew.HighlightLink);
            //PDFViewer.SetBackgroundBrush(new System.Windows.Media.SolidColorBrush(Settings.Default.AppProperties.InitialVIew.BackGround));

            if (App.mainWindowViewModel != null)
            {
                App.mainWindowViewModel.CurrentPDFViewer = PDFViewer;
            }
            return true;
        }







        /// <summary>
        /// 创建文件，路径为空时表示创建空白文档
        /// 否则表示从图片路径创建PDf
        /// </summary>
        /// <param name="imagePath"></param>
        /// <returns></returns>
        public bool CreateFile(string imagePath = null)
        {
            PDFViewer = new CPDFViewer();
            PDFViewer.CreateDocument();

            PDFViewer.UndoManager.PropertyChanged += UndoManager_PropertyChanged;
            if (PDFViewer.Document == null)
            {
                AlertsMessage alertsMessage = new AlertsMessage();
                alertsMessage.ShowDialog("", "创建文件失败.", "OK");
                return false;
            }

            if (string.IsNullOrEmpty(imagePath))
            {
                FileName = "Blank Page.pdf";
                //默认插入595*842 大小的页面
                PDFViewer.Document.InsertPage(0, 595, 842, null);
            }
            else
            {
                FileName = imagePath.Substring(imagePath.LastIndexOf("\\") + 1, imagePath.LastIndexOf(".") - imagePath.LastIndexOf("\\") - 1) + ".pdf";
                Bitmap pic = new Bitmap(imagePath);
                int width = pic.Size.Width;
                int height = pic.Size.Height;

                string ex = System.IO.Path.GetExtension(imagePath);
                //其他格式或者名称中含空格的图片 在本地先转存一下
                if ((ex != ".jpg" && ex != ".jpeg") || !Uri.IsWellFormedUriString(imagePath, UriKind.Absolute))
                {
                    //将其他格式图片转换成jpg
                    string folderPath = Path.GetTempPath();
                    if (File.Exists(folderPath))
                    {
                        File.Delete(folderPath);
                    }
                    DirectoryInfo tempfolder = new DirectoryInfo(folderPath);
                    if (!tempfolder.Exists)
                    {
                        tempfolder.Create();
                    }
                    string targetPath = System.IO.Path.Combine(folderPath, Guid.NewGuid().ToString());
                    imagePath = targetPath;
                    pic.Save(targetPath, ImageFormat.Jpeg);
                }
                pic.Dispose();

                var result = PDFViewer.Document.InsertPage(0, width, height, imagePath);
                if (!result)
                {
                    AlertsMessage alertsMessage = new AlertsMessage();
                    alertsMessage.ShowDialog("", "创建文件失败.", "OK");
                    return false;
                }
            }

            SaveToTempFile();
       

            PDFViewer.UndoManager.CanSave = true;
            FileChanged = Visibility.Visible;

            NavigateToViewContent();
            return true;
        }

        /// <summary>
        /// 从office文件转换成PDF
        /// </summary>
        /// <param name="sourcepath"></param>
        /// <returns></returns>
        public async Task<bool> CreateFileFromOffice(string sourcepath, Microsoft.Office.Interop.Word.WdPaperSize paperSize = Microsoft.Office.Interop.Word.WdPaperSize.wdPaperA4, double margin = 0)
        {
            try
            {
                //生成存放临时pdf的临时文件夹
                string folderPath = Path.GetTempPath();
                if (File.Exists(folderPath))
                {
                    File.Delete(folderPath);
                }
                DirectoryInfo tempfolder = new DirectoryInfo(folderPath);
                if (!tempfolder.Exists)
                {
                    tempfolder.Create();
                }
                string targetPath = System.IO.Path.Combine(folderPath, Guid.NewGuid().ToString() + ".pdf");

                string ex = System.IO.Path.GetExtension(sourcepath).ToLower();

                await Task.Delay(10);
                switch (ex)
                {
                    case ".doc":
                    case ".docx":
                    case "docm":
                    case ".dot":
                    case ".dotx":
                    case ".dotm":
                    case ".txt":
                    case ".html":
                        await Task.Run(() =>
                        {
                            Microsoft.Office.Interop.Word.Application word = new Microsoft.Office.Interop.Word.Application();
                            Microsoft.Office.Interop.Word.Document document = null;

                            word.Visible = false;
                            word.ShowWindowsInTaskbar = true;
                            document = word.Documents.Open(sourcepath);
                            var page = document.PageSetup;
                            page.PaperSize = paperSize;
                            if (margin > 0)
                            {
                                page.LeftMargin = page.TopMargin = page.RightMargin = page.BottomMargin = (float)margin;
                            }
                            document?.ExportAsFixedFormat(targetPath, Microsoft.Office.Interop.Word.WdExportFormat.wdExportFormatPDF);
                            document?.Close(false);
                            if (word != null)
                            {
                                word.NormalTemplate.Saved = true;
                                word.Quit();
                            }
                        });
                        break;

                    case ".xls":
                    case ".xlsx":
                    case ".xlsm":
                    case ".xlsb":
                    case ".xlam":
                    case ".xltx":
                    case ".xlt":
                        await Task.Run(() =>
                        {
                            Microsoft.Office.Interop.Excel.Application excele = new Microsoft.Office.Interop.Excel.Application();
                            Microsoft.Office.Interop.Excel.Workbook workbook = null;

                            excele.Visible = false;
                            try
                            {
                                workbook = excele.Workbooks.Open(sourcepath);
                            }
                            catch (Exception e)
                            {
                                workbook = excele.Workbooks.Open(sourcepath, 0, true, 5, "", "", true, Microsoft.Office.Interop.Excel.XlPlatform.xlWindows, "t", false, false, 0, true, 1, Microsoft.Office.Interop.Excel.XlCorruptLoad.xlRepairFile);
                            }

                            workbook?.ExportAsFixedFormat(Microsoft.Office.Interop.Excel.XlFixedFormatType.xlTypePDF, targetPath);
                            workbook?.Close();
                            excele?.Quit();
                        });
                        break;

                    case ".ppt":
                    case ".pptx":
                    case ".pptm":
                    case ".pptsx":
                    case ".pps":
                    case ".pptsm":
                    case ".pot":
                    case ".potm":
                        await Task.Run(() =>
                        {
                            Microsoft.Office.Interop.PowerPoint.Application ppt = new Microsoft.Office.Interop.PowerPoint.Application();
                            Microsoft.Office.Interop.PowerPoint.Presentation presentation = null;

                            ppt.Visible = Microsoft.Office.Core.MsoTriState.msoCTrue;
                            presentation = ppt.Presentations.Open(sourcepath);

                            presentation.ExportAsFixedFormat(targetPath, Microsoft.Office.Interop.PowerPoint.PpFixedFormatType.ppFixedFormatTypePDF);
                            presentation?.Close();
                            ppt?.Quit();
                        });
                        break;
                }

                PDFViewer = new CPDFViewer();
                PDFViewer.CreateDocument();

                if (PDFViewer.Document == null)
                {
                    AlertsMessage alertsMessage = new AlertsMessage();
                    alertsMessage.ShowDialog("", "创建PDF失败", "OK");
                    return false;
                }

                FileName = sourcepath.Substring(sourcepath.LastIndexOf("\\") + 1, sourcepath.LastIndexOf(".") - sourcepath.LastIndexOf("\\") - 1) + ".pdf";

                var tempdoc = CPDFDocument.InitWithFilePath(targetPath);
                if (tempdoc == null)
                {
                    AlertsMessage alertsMessage = new AlertsMessage();
                    alertsMessage.ShowDialog("", "创建PDF失败", "OK");
                    return false;
                }

                PDFViewer.Document.ImportPages(tempdoc, "");

                SaveToTempFile();

                PDFViewer.UndoManager.CanSave = true;
                FileChanged = Visibility.Visible;

                await System.Windows.Application.Current.Dispatcher.BeginInvoke(System.Windows.Threading.DispatcherPriority.Send, new Action(() =>
                {
                    NavigateToViewContent();
                }));

                return true;
            }
            catch (Exception ex)
            {
                string str = "没有安装";
                //判断是否有安装office软件
                var officeType = Type.GetTypeFromProgID("Word.Application");
                if (officeType == null)
                {
                    str += "Word;";
                }

                officeType = Type.GetTypeFromProgID("Excel.Application");
                if (officeType == null)
                {
                    str += "Excel;";
                }

                officeType = Type.GetTypeFromProgID("Powerpoint.Application");
                if (officeType == null)
                {
                    str += "Excel;";
                }

                AlertsMessage alertsMessage = new AlertsMessage();
                if (str != "没有安装")
                {
                    alertsMessage.ShowDialog("", "没有安装Office", "OK");
                }
                else
                {
                    alertsMessage.ShowDialog("", "创建PDF失败", "OK");
                }
                return false;
            }
        }

        /// <summary>
        /// 新建的文档 保存至临时文件 解决新建文档没有路径的问题
        /// </summary>
        private void SaveToTempFile()
        {
            if(PDFViewer!=null)
            {
                string tempfile = CacheFilePath.Instance.CreatedFilePath;
                string file = CommonHelper.CreateFilePath(Path.Combine(tempfile,"Untitle.pdf"));
                PDFViewer.Document.WriteToFilePath(file);

                PDFViewer.CloseDocument();
                PDFViewer.InitDocument(file);
                FilePath = file;
                //在viewcontent里打开是 会重新load 因此这里不需要load 避免重复
                FileName = PDFViewer.Document.FileName;
                NewFile = true;
            }
        }


        private void UndoManager_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            if (e.PropertyName == "CanSave")
            {
                if (PDFViewer.UndoManager.CanSave)
                {
                    FileChanged = Visibility.Visible;
                }
                else
                {
                    FileChanged = Visibility.Collapsed;
                }

                if (!string.IsNullOrEmpty(PDFViewer.Document.FileName))
                {
                    FileName = PDFViewer.Document.FileName;
                }
            }
        }

        #region Navigation

        public async void OnNavigatedTo(NavigationContext navigationContext)
        {
            mainWindowViewModel = App.mainWindowViewModel;

            //因为是异步打开多个文件，需要先显示Home界面
            NavigationParameters parameters = new NavigationParameters();
            parameters.Add(ParameterNames.MainViewModel, this);
            if (toolregion.Regions.ContainsRegionWithName(MainContentRegionName))
            {
                toolregion.RequestNavigate(MainContentRegionName, "HomeContent", parameters);
            }
            //常规加载首页的情况
            if (navigationContext.Parameters.Count <= 0)
            {
                return;
            }

            //一次打开多个文件的情况
            var filepath = navigationContext.Parameters[ParameterNames.FilePath].ToString();
            if (filepath != null)
            {
                bool result = true;
                if (System.IO.Path.GetExtension(filepath.ToString()).ToLower() == ".pdf")
                {
                    OpenFile(filepath.ToString());
                }
                else if (Properties.Resources.imageex.Contains(System.IO.Path.GetExtension(filepath).ToLower()))
                {
                    //图片转PDF
                    result = CreateFile(filepath);
                }
                else
                {
                    result = await CreateFileFromOffice(filepath);
                }

                if (!result)
                {
                    mainWindowViewModel.CloseTabItem(mainWindowViewModel.SelectedItem);
                    return;
                }

                if (!App.OpenedFileList.Contains(filepath))
                {
                    //更新已打开的文件记录
                    App.OpenedFileList.Add(filepath);
                }
            }
        }

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

        public void OnNavigatedFrom(NavigationContext navigationContext)
        {
        }

        #endregion Navigation
    }
}