PDFOffice_Windows_exe/PDF Office/ViewModels/Dialog/HomePageToolsDialogs/HomePagePrinter/HomePagePrinterDocumentContentViewModel.cs

using ComPDFKit.PDFPage;
using ComPDFKitViewer.PdfViewer;
using ImageMagick.Formats;
using ImTools;
using Microsoft.Office.Core;
using PDF_Office.EventAggregators;
using PDF_Office.Helper;
using PDF_Office.Model;
using PDF_Office.Model.Dialog.HomePageToolsDialogs.HomePagePrinter;
using Prism.Commands;
using Prism.Events;
using Prism.Mvvm;
using Prism.Regions;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.Drawing.Printing;
using System.IO;
using System.Linq;
using System.Printing;
using System.Reflection;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Annotations;
using System.Windows.Controls;
using System.Windows.Forms;
using System.Windows.Media.Imaging;
using System.Windows.Shell;
using static Dropbox.Api.TeamLog.PaperDownloadFormat;
using static PDF_Office.ViewModels.Dialog.HomePageToolsDialogs.HomePagePrinter.HomePagePrinterDocumentContentViewModel;

namespace PDF_Office.ViewModels.Dialog.HomePageToolsDialogs.HomePagePrinter
{
    public class HomePagePrinterDocumentContentViewModel : BindableBase, INavigationAware
    {
        private CPDFViewer PDFViewer;
        private PrintQueue documentPrintQueue;
        private PrintDocument printDocument = new PrintDocument();

        public PrintSettingsInfo PrintSettingsInfo;
        public IEventAggregator printDocumentEvent;
        private string Unicode = null;
        #region 海报模式，一些参数需要在函数外定义
        /// <summary>
        /// 海报模式：打印纸
        /// </summary>
        int posterPrintPaperIndex = 0;

        /// <summary>
        /// 海报模式，水平纸张数
        /// </summary>
        public int HorizonPaperCount = 0;
        /// <summary>
        /// 海报模式，垂直纸张数
        /// </summary>
        public int VerticalPaperCount = 0;
        /// <summary>
        /// 海报模式，单页总纸张数
        /// </summary>
        public int WholeCountSinglePage = 0;
        ///<summary>
        ///海报模式当前水平纸
        /// </summary>
        public int HorizonPaperIndex = 0;
        ///<summary>
        ///海报模式当前垂直纸
        /// </summary>
        public int VerticalPaperIndex = 0;

        /// <summary>
        /// 海报模式，总打印纸张数
        /// </summary>
        public int WholePaperCountModPoster = 0;

        /// <summary>
        /// 海报模式渲染出来的纸张，只有第一次进入和每次翻页才重新渲染，减少渲染次数
        /// </summary>
        public Bitmap PosterCurrentBitmap = null;

        /// <summary>
        /// 同理，海报模式实际被拆分的纸张，更改过比例，添加了白边
        /// </summary>
        public Bitmap DisplayBitmap = null;

        public double PosterRatio = 0;
        #endregion
        /// <summary>
        /// 转存防卡顿
        /// </summary>

        public class DocumentSettingsInfo
        {
            public int DocumentWidth = 0;
            public int DocumentHeight = 0;
            public Margins margins = new Margins();
            public Rectangle DocumentBounds = new Rectangle();
            public bool DocumentLandscape = false;
            public bool DocumentColor = false;
        }

        public DocumentSettingsInfo documentSettingsInfo = new DocumentSettingsInfo();

        /// <summary>
        /// 用于判断是否需要跳转第一页
        /// </summary>
        int PreviousPrintedPageCount = 0;


        public int PrintIndex;
        ///<summary>
        ///打印纸dpi100, PDF dpi 72,需要缩放
        /// </summary>
        public double PDFToMediaDpiRatio = 100.0 / 72.0;
        public double mmToDpiRatio = 100 / 25.4;
        Bitmap blankPageBitmap;
        Bitmap blankPageBitmapForPrint;

        private string _paperWidth;
        public string PaperWidth
        {
            get => _paperWidth;
            set => SetProperty(ref _paperWidth, value);
        }

        private string _paperHeight;
        public string PaperHeight
        {
            get => _paperHeight;
            set => SetProperty(ref _paperHeight, value);
        }

        private string _viewBoxWidth;
        public string ViewBoxWidth
        {
            get => _viewBoxWidth;
            set => SetProperty(ref _viewBoxWidth, value);
        }

        private string _viewBoxHeight;
        public string ViewBoxHeight
        {
            get => _viewBoxHeight;
            set => SetProperty(ref _viewBoxHeight, value);
        }

        private BitmapSource _bitmapSource;
        /// <summary>
        /// 渲染后的图
        /// </summary>
        public BitmapSource BitmapSource
        {
            get { return _bitmapSource; }
            set { SetProperty(ref _bitmapSource, value); }
        }

        private int _targetPaperIndex = 1;
        public int TargetPaperIndex
        {
            get => _targetPaperIndex;
            set
            {
                SetProperty(ref _targetPaperIndex, value);
                JumpToSelectedPage();
            }
        }
        /// <summary>
        /// 目标纸张
        /// TargetPaper[纸张编号]=正确的纸张
        /// </summary>
        public List<int> TargetPaperList = new List<int>();

        /// <summary>
        /// 打印的总页数
        /// </summary>
        private int _printedPageCount;
        public int PrintedPageCount
        {
            get => _printedPageCount;
            set => SetProperty(ref _printedPageCount, value);
        }

        private Visibility _errorPageTxtVisibility = Visibility.Collapsed;
        public Visibility ErrorPageTxtVisibility
        {
            get => _errorPageTxtVisibility;
            set => SetProperty(ref _errorPageTxtVisibility, value);
        }

        /// <summary>
        /// 手动双面打印
        /// </summary>
        public bool IsManualDuplex = false;

        public DelegateCommand<object> TurnPageCommand { get; set; }
        public DelegateCommand<object> JumpPageCommand { get; set; }

        public HomePagePrinterDocumentContentViewModel(IEventAggregator eventAggregator)
        {
            this.printDocumentEvent = eventAggregator;
            printDocumentEvent.GetEvent<SendPrintSettingsInfoEvent>().Subscribe(RecvPrintSettingsInfo, e => e.Unicode == Unicode);
            printDocumentEvent.GetEvent<SendPrintQueueEvent>().Subscribe(RecvPrintQueue, e => e.Unicode == Unicode);
            printDocumentEvent.GetEvent<SendLabelEvent>().Subscribe(RecvLabel, e => e.Unicode == Unicode);
            TurnPageCommand = new DelegateCommand<object>(TurnPage);
            JumpPageCommand = new DelegateCommand<object>(JumpPage);
        }

        public void TurnPage(object e)
        {
            var btn = e as System.Windows.Controls.Button;
            if (btn != null)
            {
                if (btn.Name == "PrePageBtn")
                {
                    if (TargetPaperIndex >= 2)
                    {
                        TargetPaperIndex--;
                    }
                }
                else
                {
                    if (TargetPaperIndex < PrintedPageCount)
                    {
                        TargetPaperIndex++;
                    }
                }
            }
        }

        public void RecvPrintQueue(PrintQueueWithUnicode printQueueWithUnicode)
        {
            if (printQueueWithUnicode.printQueue != null)
            {
                PrintIndex = 0;
                this.documentPrintQueue = printQueueWithUnicode.printQueue;
                var printDocument = new PrintDocument();
                var printTicket = new PrintTicket();
                printDocument.PrinterSettings.PrinterName = printQueueWithUnicode.printQueue.Name;

                if (PrintSettingsInfo.EnumPrintOrientation == EnumPrintOrientation.StatusPortrait)
                {
                    printDocument.DefaultPageSettings.Landscape = false;
                }
                else if (PrintSettingsInfo.EnumPrintOrientation == EnumPrintOrientation.StatusLandscape)
                {
                    printDocument.DefaultPageSettings.Landscape = true;
                }

                if (!PrintSettingsInfo.IsGrayscale && printQueueWithUnicode.printQueue.GetPrintCapabilities().OutputColorCapability.Contains(OutputColor.Color))
                {
                    printDocument.DefaultPageSettings.Color = true;
                }
                else
                {
                    printDocument.DefaultPageSettings.Color = false;
                }
                if (PrintSettingsInfo.PrintModInfo.EnumDuplexPrintMod == EnumDuplexPrintMod.StatusFlipLongEdge || PrintSettingsInfo.PrintModInfo.EnumDuplexPrintMod == EnumDuplexPrintMod.StatusFlipShortEdge || PrintSettingsInfo.PrintModInfo.EnumPrintMod == EnumPrintMod.StatusBooklet)
                {
                    ///无阶段，自动双面打印
                    ///已在起始时验证
                    if (printQueueWithUnicode.EnumBothSidesStage == EnumBothSidesStage.StatusNone)
                    {
                        if (PrintSettingsInfo.PrintModInfo.EnumDuplexPrintMod == EnumDuplexPrintMod.StatusFlipLongEdge)
                        {
                            ///Fix 13346: Duplex.Vertical, 这个是长边翻页
                            printDocument.PrinterSettings.Duplex = Duplex.Vertical;
                        }
                        else
                        {
                            ///Fix 13346: Duplex.Horizontal, 这个是短边翻页
                            printDocument.PrinterSettings.Duplex = Duplex.Horizontal;
                        }
                    }
                    else
                    {
                        printDocument.PrinterSettings.Duplex = Duplex.Simplex;
                        IsManualDuplex = true;
                        //TODO 手动双面打印，先印单数页再印双数页
                        if (printQueueWithUnicode.EnumBothSidesStage == EnumBothSidesStage.StatusFrontSide)
                        {
                            PrintIndex = 0;
                        }
                        else
                        {
                            PrintIndex = 1;
                        }
                    }
                }
                //海报模式，预设单面打印
                else
                {
                    printDocument.PrinterSettings.Duplex = Duplex.Simplex;
                }

                printQueueWithUnicode.printQueue.DefaultPrintTicket = printTicket;
                printDocument.DefaultPageSettings.PaperSize = PrintSettingsInfo.PrintDocument.DefaultPageSettings.PaperSize;
                PaperSource pkSource;
                List<PaperSource> paperSources = new List<PaperSource>();
                paperSources.Clear();
                for (int i = 0; i < printDocument.PrinterSettings.PaperSources.Count; i++)
                {
                    pkSource = printDocument.PrinterSettings.PaperSources[i];
                    paperSources.Add(pkSource);
                }
                ///纸盒不为空，实体打印机默认设置纸盒序号0（主纸盒）
                if (paperSources.Count != 0)
                {
                    printDocument.DefaultPageSettings.PaperSource = paperSources[0];
                }

                if (PrintSettingsInfo.Copies <= printQueueWithUnicode.printQueue.GetPrintCapabilities().MaxCopyCount && PrintSettingsInfo.Copies > 0)
                {
                    printDocument.PrinterSettings.Copies = (short)PrintSettingsInfo.Copies;
                }
                else if (PrintSettingsInfo.Copies > printQueueWithUnicode.printQueue.GetPrintCapabilities().MaxCopyCount)
                {
                    PrintSettingsInfo.Copies = (int)printQueueWithUnicode.printQueue.GetPrintCapabilities().MaxCopyCount;
                }
                else
                {
                    PrintSettingsInfo.Copies = 1;
                }
                posterPrintPaperIndex = 0;
                printDocument.PrintPage += PrintDocumentByCurrentSettings;
                printDocument.Print();
            }
        }

        private void RecvLabel(LabelWithUnicode labelWithUnicode)
        {


            if (PrintSettingsInfo.PrintModInfo.EnumPrintMod == EnumPrintMod.StatusPoster)
            {
                var posterInfo = (PosterInfo)PrintSettingsInfo.PrintModInfo;
                posterInfo.Label = labelWithUnicode.Label.ToString();
                PrintSettingsInfo.PrintModInfo = posterInfo;
            }
        }

        private Bitmap Crop(Bitmap src, Rectangle rectangle)
        {
            Bitmap targetBitmap = new Bitmap(rectangle.Width, rectangle.Height);

            using (Graphics g = Graphics.FromImage(targetBitmap))
            {
                g.DrawImage(src, new Rectangle(0, 0, targetBitmap.Width, targetBitmap.Height), rectangle, GraphicsUnit.Pixel);
            }
            return targetBitmap;
        }

        #region 打印各个模式
        private void PrintDocumentModSize(PrintPageEventArgs e)
        {
            ///Fix 13337 : 
            ///打印的宽度和高度是1/100英寸
            ///图片的宽度和高度是像素
            ///假如打印机DPI宽高600，图片宽高600px
            ///那么用DrawImage打印图片的时候,  就会把图片600像素的宽,理解为了600百分之一英寸(6英寸),数值没变,只是单位的理解不一样
            ///于是打印6英寸宽,需要跨度6*600DPI=3600像素,  但是图片本身只有600像素,于是就把图片的宽放大到3600像素,同理高也是这样,需要放大.
            ///放大以后的位图就会出现锯齿
            ///所以如果要打印6英寸的一条线,DPI为600的情况下,  需要准备6 * 600 = 3600像素的线条,然后告诉打印机要打印的宽度是600(百分之一英寸)  , 打印图像的3600像素,  元素图像的单位是像素.
            ///关键代码 e.Graphics.DrawImage(printBitmap, realBound, new Rectangle(0, 0, printBitmap.Width, printBitmap.Height), GraphicsUnit.Pixel);
            ///其他三个模式也一样                     
            int widthDpiRatio = (int)e.Graphics.DpiX / 100;
            int heightDpiRatio = (int)e.Graphics.DpiY / 100;
            SizeInfo sizeInfo = (SizeInfo)PrintSettingsInfo.PrintModInfo;
            CPDFPage cPDFPage = PDFViewer.Document.PageAtIndex(PrintSettingsInfo.PageRangeList[PrintIndex]);
            Rectangle realBound = new Rectangle(documentSettingsInfo.margins.Left * widthDpiRatio,
                        documentSettingsInfo.margins.Top * heightDpiRatio,
                        e.PageBounds.Width - documentSettingsInfo.margins.Left - documentSettingsInfo.margins.Right,
                        e.PageBounds.Height - documentSettingsInfo.margins.Top - documentSettingsInfo.margins.Bottom);
            System.Drawing.Point startPoint = new System.Drawing.Point(0, 0);
            blankPageBitmapForPrint = new Bitmap((int)documentSettingsInfo.DocumentWidth * widthDpiRatio, (int)documentSettingsInfo.DocumentHeight * heightDpiRatio);
            /////听说有效
            ////e.Graphics.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.NearestNeighbor;
            ////e.Graphics.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
            ////e.Graphics.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.Half;
            if (cPDFPage != null)
            {
                Bitmap printBitmap = new Bitmap((int)(float.Parse(PaperWidth)) * widthDpiRatio, (int)float.Parse(PaperHeight) * heightDpiRatio);
                Bitmap bitmap = ToolMethod.RenderPageBitmapNoWait(PDFViewer.Document, (int)(cPDFPage.PageSize.Width * PDFToMediaDpiRatio * widthDpiRatio), (int)(cPDFPage.PageSize.Height * PDFToMediaDpiRatio * heightDpiRatio), PrintSettingsInfo.PageRangeList[PrintIndex], PrintSettingsInfo.IsPrintWithAnnot, PrintSettingsInfo.IsPrintWithForm);

                if (PrintSettingsInfo.IsGrayscale)
                {
                    bitmap = ToGray(bitmap, 0);
                }
                ///< summary >
                /// 自适应模式
                ///</ summary >
                if (sizeInfo.EnumSizeType == EnumSizeType.StatusAdaptive)
                {

                    int resizedHeight = 0;
                    int resizedWidth = 0;
                    ///重设大小
                    if ((float)bitmap.Height / (float)bitmap.Width >= (float.Parse(PaperHeight) / float.Parse(PaperWidth)))
                    {
                        resizedHeight = (int)(float.Parse(PaperHeight) * mmToDpiRatio) * widthDpiRatio;
                        resizedWidth = (int)((float.Parse(PaperHeight) / bitmap.Height * bitmap.Width) * mmToDpiRatio) * heightDpiRatio;
                    }
                    else
                    {
                        resizedWidth = (int)(float.Parse(PaperWidth) * mmToDpiRatio) * widthDpiRatio;
                        resizedHeight = (int)((float.Parse(PaperWidth) / bitmap.Width * bitmap.Height) * mmToDpiRatio) * heightDpiRatio;
                    }
                    ///直接调整bitmap会引起内存问题,所以先这样处理....
                    Bitmap resizedBitmap = new Bitmap(bitmap, resizedWidth, resizedHeight);

                    startPoint.X = (blankPageBitmapForPrint.Width - resizedWidth) / 2;
                    startPoint.Y = (blankPageBitmapForPrint.Height - resizedHeight) / 2;
                    printBitmap = CombineBitmap(blankPageBitmapForPrint, resizedBitmap, startPoint);
                    resizedBitmap.Dispose();

                    if (IsManualDuplex && PrintIndex % 2 == 1 && sizeInfo.EnumDuplexPrintMod == EnumDuplexPrintMod.StatusFlipShortEdge)
                    {
                        printBitmap.RotateFlip(RotateFlipType.Rotate180FlipNone);
                    }
                    e.Graphics.DrawImage(printBitmap, realBound, new Rectangle(0, 0, printBitmap.Width, printBitmap.Height), GraphicsUnit.Pixel);
                }
                else if (sizeInfo.EnumSizeType == EnumSizeType.StatusActural)
                {
                    startPoint.X = (blankPageBitmapForPrint.Width - bitmap.Width) / 2;
                    startPoint.Y = (blankPageBitmapForPrint.Height - bitmap.Height) / 2;
                    printBitmap = CombineBitmap(blankPageBitmapForPrint, bitmap, startPoint);
                    if (IsManualDuplex && PrintIndex % 2 == 1 && sizeInfo.EnumDuplexPrintMod == EnumDuplexPrintMod.StatusFlipShortEdge)
                    {
                        printBitmap.RotateFlip(RotateFlipType.Rotate180FlipNone);
                    }
                    e.Graphics.DrawImage(printBitmap, realBound, new Rectangle(0, 0, printBitmap.Width, printBitmap.Height), GraphicsUnit.Pixel);
                }
                else if (sizeInfo.EnumSizeType == EnumSizeType.StatusCustomized)
                {
                    bitmap = Resize(bitmap, (int)(bitmap.Width * (sizeInfo.DisplayRatio / 100.0)), (int)(bitmap.Height * (sizeInfo.DisplayRatio / 100.0)));
                    startPoint.X = (blankPageBitmapForPrint.Width - bitmap.Width) / 2;
                    startPoint.Y = (blankPageBitmapForPrint.Height - bitmap.Height) / 2;
                    printBitmap = CombineBitmap(blankPageBitmapForPrint, bitmap, startPoint);
                    if (IsManualDuplex && PrintIndex % 2 == 1 && sizeInfo.EnumDuplexPrintMod == EnumDuplexPrintMod.StatusFlipShortEdge)
                    {
                        printBitmap.RotateFlip(RotateFlipType.Rotate180FlipNone);
                    }
                    e.Graphics.DrawImage(printBitmap, realBound, new Rectangle(0, 0, printBitmap.Width, printBitmap.Height), GraphicsUnit.Pixel);

                }
                bitmap.Dispose();
                printBitmap.Dispose();
                blankPageBitmapForPrint.Dispose();
                GC.Collect();

                //手动双面打印,且页码不为1
                if (IsManualDuplex && PrintSettingsInfo.PageRangeList.Count != 1)
                {
                    if (PrintIndex < PrintedPageCount - 2)
                    {
                        PrintIndex += 2;
                        e.HasMorePages = true;
                    }
                    else
                    {
                        e.HasMorePages = false;
                    }
                }
                //单面打印
                else
                {
                    if (PrintIndex < PrintedPageCount - 1)
                    {
                        PrintIndex++;
                        e.HasMorePages = true;
                    }
                    else
                    {
                        e.HasMorePages = false;
                    }
                }
            }
        }

        ///无论是拆分还是平铺，页面缩放比例都会在预览中完成
        ///先渲染整图
        ///得到effective域大小
        ///根据effective的量和重叠量计算开始的bitmap
        ///加字和标记
        ///字加在顶部，标记加在四角
        ///结束后翻页
        ///对于Tile页数不定，但是比例相等
        ///对于split页数固定，但是比例变化

        ///平铺模式：
        ///从第一页开始，先计算当前页总纸张数
        ///根据纸张数打印
        ///打印到位时页数进一
        ///页数到顶，纸数到顶打印结束

        ///当一页只有一张纸的时候，注意特殊处理
        ///

        ///内存问题：
        ///1、只有每次翻页才重新取整张图。
        ///取到的图片先不急着放大。
        ///根据原图大小取得图片，并进行处理后，进行放大
        ///再绘制到打印纸上
        private void PrintDocumentModPoster(PrintPageEventArgs e)
        {
            PosterInfo posterInfo = (PosterInfo)PrintSettingsInfo.PrintModInfo;
            var pageBound = documentSettingsInfo.DocumentBounds;

            int widthDpiRatio = (int)e.Graphics.DpiX / 100;
            int heightDpiRatio = (int)e.Graphics.DpiY / 100;


            double effectiveHeight;
            double effectiveWidth;
            ///计算有效打印区域
            if (PrintSettingsInfo.EnumPrintOrientation == EnumPrintOrientation.StatusPortrait)
            {
                effectiveHeight = documentSettingsInfo.DocumentHeight;
                effectiveWidth = documentSettingsInfo.DocumentWidth;
            }
            else
            {
                effectiveHeight = documentSettingsInfo.DocumentWidth;
                effectiveWidth = documentSettingsInfo.DocumentHeight;
            }

            effectiveHeight -= 2 * posterInfo.OverLap * mmToDpiRatio;
            effectiveWidth -= 2 * posterInfo.OverLap * mmToDpiRatio;
            if (posterInfo.HasLabel || posterInfo.HasCutMarks)
            {
                effectiveHeight -= 40;
                effectiveWidth -= 40;
            }
            effectiveHeight *= heightDpiRatio;
            effectiveWidth *= widthDpiRatio;

            ///平铺模式下：
            if (posterInfo.EnumPosterMod == EnumPosterMod.StatusTile)
            {
                CPDFPage cPDFPage = PDFViewer.Document.PageAtIndex(PrintSettingsInfo.PageRangeList[posterPrintPaperIndex]);
                if (cPDFPage != null)
                {
                    System.Drawing.Point startPoint = new System.Drawing.Point(0, 0);
                    double PreviewWidth;
                    double PreviewHeight;
                    ///仅当每一页第一张纸时打印时，进行一次渲染,，更换打印底图
                    if (HorizonPaperIndex == 0 && VerticalPaperIndex == 0)
                    {
                        {
                            PosterCurrentBitmap = ToolMethod.RenderPageBitmapNoWait(PDFViewer.Document, (int)(cPDFPage.PageSize.Width * PDFToMediaDpiRatio * (posterInfo.TileRatio / 100.0) * widthDpiRatio), (int)(cPDFPage.PageSize.Height * PDFToMediaDpiRatio * (posterInfo.TileRatio / 100.0) * heightDpiRatio), PrintSettingsInfo.PageRangeList[posterPrintPaperIndex], PrintSettingsInfo.IsPrintWithAnnot, PrintSettingsInfo.IsPrintWithForm);
                            if (PrintSettingsInfo.IsGrayscale)
                            {
                                PosterCurrentBitmap = ToGray(PosterCurrentBitmap, 0);
                            }
                            HorizonPaperCount = (int)Math.Ceiling((double)PosterCurrentBitmap.Width / effectiveWidth);
                            VerticalPaperCount = (int)Math.Ceiling(((double)PosterCurrentBitmap.Height / effectiveHeight));
                            WholeCountSinglePage = HorizonPaperCount * VerticalPaperCount;//每一轮的总页数
                            if (WholeCountSinglePage != 0)
                            {
                                PreviewWidth = (double)(effectiveWidth * HorizonPaperCount);
                                PreviewHeight = (double)(effectiveHeight * VerticalPaperCount);
                                DisplayBitmap = new Bitmap((int)PreviewWidth, (int)PreviewHeight);

                            }
                            else
                            {
                                PreviewWidth = effectiveWidth;
                                PreviewHeight = effectiveHeight;
                                DisplayBitmap = new Bitmap((int)effectiveWidth, (int)effectiveHeight);
                            }
                            //取到和渲染一样的Bitmap
                            startPoint.X = (int)((PreviewWidth - PosterCurrentBitmap.Width) / 2);
                            startPoint.Y = (int)((PreviewHeight - PosterCurrentBitmap.Height) / 2);
                            DisplayBitmap = CombineBitmap(DisplayBitmap, PosterCurrentBitmap, startPoint);
                            PosterCurrentBitmap.Dispose();
                        }

                    }


                    ///当前页未打印完
                    if (HorizonPaperIndex * VerticalPaperIndex < WholeCountSinglePage - 1)
                    {
                        ///取有效尺寸和重叠，边沿合并
                        ///有效尺寸+重叠边
                        Rectangle rectangle = new Rectangle((int)(HorizonPaperIndex * effectiveWidth), (int)(VerticalPaperIndex * effectiveHeight), (int)effectiveWidth, (int)effectiveHeight);
                        ///左重叠
                        if (HorizonPaperIndex != 0)
                        {
                            rectangle.Location = new System.Drawing.Point((int)(rectangle.Location.X - posterInfo.OverLap * mmToDpiRatio * widthDpiRatio), rectangle.Location.Y);
                        }

                        ///上重叠
                        if (VerticalPaperIndex != 0)
                        {
                            rectangle.Size = new System.Drawing.Size(rectangle.Size.Width, (int)(rectangle.Size.Height + posterInfo.OverLap * mmToDpiRatio * heightDpiRatio));
                        }

                        ///右重叠
                        if (HorizonPaperIndex != HorizonPaperCount)
                        {
                            rectangle.Size = new System.Drawing.Size((int)(rectangle.Size.Width + posterInfo.OverLap * mmToDpiRatio * widthDpiRatio), rectangle.Size.Height);
                        }

                        ///下重叠
                        if (VerticalPaperIndex != VerticalPaperCount)
                        {
                            rectangle.Location = new System.Drawing.Point(rectangle.Location.X, (int)(rectangle.Location.Y - posterInfo.OverLap * mmToDpiRatio * heightDpiRatio));
                        }

                        Bitmap currentPrintBitmap = Crop(DisplayBitmap, rectangle);
                        currentPrintBitmap = Resize(currentPrintBitmap, currentPrintBitmap.Width, currentPrintBitmap.Height);
                        ///当存在边沿时
                        int margin = 0;

                        ///Label和CutMarks
                        ///
                        if (posterInfo.HasLabel || posterInfo.HasCutMarks)
                        {
                            margin = 20;
                        }

                        if (posterInfo.HasLabel)
                        {
                            string sign = null;
                            if (posterInfo.Label == null || posterInfo.Label == "")
                            {
                                sign = string.Format("({0},{1}){2}.pdf {3} {4}", HorizonPaperIndex + 1, VerticalPaperIndex + 1, PrintIndex + 1, System.DateTime.Today.ToString("yyyy-MM-dd"), System.DateTime.Now.ToString("HH:mm:ss"));
                            }
                            else
                            {
                                sign = posterInfo.Label;
                            }
                            e.Graphics.DrawString(sign, new Font("Helvetica", 10.0f), System.Drawing.Brushes.Black, margin + 5, 0);
                        }

                        if (PrintSettingsInfo.EnumPrintOrientation == EnumPrintOrientation.StatusPortrait)
                        {
                            if (posterInfo.HasCutMarks)
                            {
                                System.Drawing.Pen pen = new System.Drawing.Pen(System.Drawing.Color.Black, 2);
                                //除了四角之外都要添加裁切标记

                                if (!(HorizonPaperIndex == 0 && VerticalPaperIndex == 0))
                                {
                                    e.Graphics.DrawRectangle(pen, new Rectangle(-margin, -margin, 2 * margin, 2 * margin));
                                }
                                if (!(HorizonPaperIndex == HorizonPaperCount - 1 && VerticalPaperIndex == 0))
                                {
                                    e.Graphics.DrawRectangle(pen, new Rectangle(pageBound.Width * widthDpiRatio - margin, -margin, margin * 2, margin * 2));
                                }
                                if (!(HorizonPaperIndex == 0 && VerticalPaperIndex == VerticalPaperCount - 1))
                                {
                                    e.Graphics.DrawRectangle(pen, new Rectangle(-margin, (int)pageBound.Height * heightDpiRatio - margin, margin * 2, margin * 2));
                                }
                                if (!(HorizonPaperIndex == HorizonPaperCount - 1 && VerticalPaperIndex == VerticalPaperCount - 1))
                                {
                                    e.Graphics.DrawRectangle(pen, new Rectangle(pageBound.Width * widthDpiRatio - margin, (int)pageBound.Height * heightDpiRatio - margin, margin * 2, margin * 2));
                                }
                                pen.Dispose();
                            }
                            e.Graphics.DrawImage(currentPrintBitmap, new Rectangle(margin, margin, pageBound.Width - 2 * margin, pageBound.Height - margin), new Rectangle(0, 0, currentPrintBitmap.Width, currentPrintBitmap.Height), GraphicsUnit.Pixel);
                            currentPrintBitmap.Dispose();
                        }
                        ///TODO：横向纵向仅Height Width相反，应该可以减少代码
                        else
                        {
                            if (posterInfo.HasCutMarks)
                            {
                                System.Drawing.Pen pen = new System.Drawing.Pen(System.Drawing.Color.Black, 2);
                                //除了四角之外都要添加裁切标记

                                if (!(HorizonPaperIndex == 0 && VerticalPaperIndex == 0))
                                {
                                    e.Graphics.DrawRectangle(pen, new Rectangle(-margin, -margin, 2 * margin, 2 * margin));
                                }
                                if (!(HorizonPaperIndex == HorizonPaperCount - 1 && VerticalPaperIndex == 0))
                                {
                                    e.Graphics.DrawRectangle(pen, new Rectangle(pageBound.Width * widthDpiRatio - margin, -margin, margin * 2, margin * 2));
                                }
                                if (!(HorizonPaperIndex == 0 && VerticalPaperIndex == VerticalPaperCount - 1))
                                {
                                    e.Graphics.DrawRectangle(pen, new Rectangle(-margin, (int)pageBound.Height * heightDpiRatio - margin, margin * 2, margin * 2));
                                }
                                if (!(HorizonPaperIndex == HorizonPaperCount - 1 && VerticalPaperIndex == VerticalPaperCount - 1))
                                {
                                    e.Graphics.DrawRectangle(pen, new Rectangle(pageBound.Width * widthDpiRatio - margin, (int)pageBound.Height * heightDpiRatio - margin, margin * 2, margin * 2));
                                }
                            }
                            e.Graphics.DrawImage(currentPrintBitmap, new Rectangle(margin, margin, pageBound.Width - 2 * margin, pageBound.Height - margin), new Rectangle(0, 0, currentPrintBitmap.Width, currentPrintBitmap.Height), GraphicsUnit.Pixel);
                            currentPrintBitmap.Dispose();
                        }
                        ///三种进位：当前列，当前行，当前页
                        if (HorizonPaperIndex < HorizonPaperCount - 1)
                        {
                            HorizonPaperIndex++;
                            e.HasMorePages = true;
                        }
                        else if (VerticalPaperIndex < VerticalPaperCount - 1)
                        {
                            HorizonPaperIndex = 0;
                            VerticalPaperIndex++;
                            e.HasMorePages = true;
                        }
                        else if (posterPrintPaperIndex < PrintedPageCount - 1)
                        {
                            ///当前总文件未打印完
                            posterPrintPaperIndex++;
                            DisplayBitmap.Dispose();
                            HorizonPaperIndex = 0;
                            VerticalPaperIndex = 0;
                            e.HasMorePages = true;
                            GC.Collect();
                        }
                        else
                        {
                            e.HasMorePages = false;
                        }
                    }

                    //当一页只有一张打印纸的时候
                    else if (WholeCountSinglePage == 1)
                    {
                        if (PrintSettingsInfo.IsGrayscale)
                        {
                            PosterCurrentBitmap = ToGray(PosterCurrentBitmap, 0);
                        }
                        e.Graphics.DrawImage(DisplayBitmap, e.PageBounds);
                        if (posterPrintPaperIndex < PrintedPageCount - 1)
                        {
                            ///当前总文件未打印完
                            posterPrintPaperIndex++;
                            DisplayBitmap.Dispose();
                            HorizonPaperIndex = 0;
                            VerticalPaperIndex = 0;
                            e.HasMorePages = true;
                            GC.Collect();
                        }
                        else
                        {
                            e.HasMorePages = false;
                        }
                    }
                }
            }
            ///拆分模式
            ///该模式下
            ///渲染图片到指定大小
            ///直接计算所有需要打印的纸张数
            ///计算单页打印的纸张数
            ///进位
            ///根据当前水平垂直序号裁切图片
            ///继续打印表征：当前纸张序号小于总计纸张序号
            //else
            //{
            //    int wholeCountSinglePage = posterInfo.HorizontalSheetNumber * posterInfo.VerticalSheetNumber;//每一轮的总页数
            //    WholePaperCountModPoster = wholeCountSinglePage * PrintedPageCount;//总计打印纸数
            //    int PrintPageIndex = PrintIndex / wholeCountSinglePage;//当前打印纸张所在海报页  从0开始
            //    int PrintIndexInCurrentPage = PrintIndex % wholeCountSinglePage;//当前海报页中，打印纸的序号  从0开始

            //    HorizonPaperIndex = PrintIndexInCurrentPage % HorizonPaperCount;//行中的第几个
            //    VerticalPaperIndex = PrintIndexInCurrentPage / HorizonPaperCount;//第几行

            //    CPDFPage cPDFPage = PDFViewer.Document.PageAtIndex(PrintSettingsInfo.PageRangeList[PrintPageIndex]);//取得当前海报页
            //    PreviewWidth = (double)(effectiveWidth * HorizonPaperCount);
            //    PreviewHeight = (double)(effectiveHeight * VerticalPaperCount);
            //    DisplayBitmap = new Bitmap((int)PreviewWidth, (int)PreviewHeight);
            //    double resizedHeight = 0;
            //    double resizedWidth = 0;
            //    if ((cPDFPage.PageSize.Height / cPDFPage.PageSize.Width) >= PreviewHeight / PreviewWidth)
            //    {
            //        resizedHeight = PreviewHeight;
            //        resizedWidth = PreviewHeight / cPDFPage.PageSize.Height * cPDFPage.PageSize.Width;
            //    }
            //    else
            //    {
            //        resizedWidth = PreviewWidth;
            //        resizedHeight = PreviewWidth / cPDFPage.PageSize.Width * cPDFPage.PageSize.Height;
            //    }
            //    bitmap = ToolMethod.RenderPageBitmapNoWait(PDFViewer.Document, (int)resizedWidth, (int)resizedHeight, PrintSettingsInfo.PageRangeList[PrintPageIndex], PrintSettingsInfo.IsPrintWithAnnot, PrintSettingsInfo.IsPrintWithForm);
            //    startPoint.X = (int)((PreviewWidth - bitmap.Width) / 2);
            //    startPoint.Y = (int)((PreviewHeight - bitmap.Height) / 2);
            //    if (PrintSettingsInfo.IsGrayscale)
            //    {
            //        bitmap = ToGray(bitmap, 0);
            //    }
            //    DisplayBitmap = CombineBitmap(DisplayBitmap, bitmap, startPoint);
            //    DisplayBitmap = CombineBitmap(DisplayBitmap, bitmap, startPoint);

            //    ///取有效尺寸和重叠，边沿合并
            //    ///有效尺寸+重叠边
            //    Rectangle rectangle = new Rectangle((int)(HorizonPaperIndex * effectiveWidth), (int)(VerticalPaperIndex * effectiveHeight), (int)effectiveWidth, (int)effectiveHeight);
            //    ///左重叠
            //    if (HorizonPaperIndex != 0)
            //    {
            //        rectangle.Location = new System.Drawing.Point((int)(rectangle.Location.X - posterInfo.OverLap * 100 / 24.5), rectangle.Location.Y);
            //    }

            //    ///上重叠
            //    if (VerticalPaperIndex != 0)
            //    {
            //        rectangle.Size = new System.Drawing.Size(rectangle.Size.Width, (int)(rectangle.Size.Height + posterInfo.OverLap * 100 / 24.5));
            //    }

            //    ///右重叠
            //    if (HorizonPaperIndex != HorizonPaperCount)
            //    {
            //        rectangle.Size = new System.Drawing.Size((int)(rectangle.Size.Width + posterInfo.OverLap * 100 / 24.5), rectangle.Size.Height);
            //    }

            //    ///下重叠
            //    if (VerticalPaperIndex != VerticalPaperCount)
            //    {
            //        rectangle.Location = new System.Drawing.Point(rectangle.Location.X, (int)(rectangle.Location.Y - posterInfo.OverLap * 100 / 24.5));
            //    }

            //    ///当存在边沿时
            //    int margin = 0;

            //    ///Label和CutMarks
            //    ///
            //    if (posterInfo.HasLabel || posterInfo.HasCutMarks)
            //    {
            //        margin = 20;
            //    }

            //    if (posterInfo.HasLabel)
            //    {
            //        string sign = null;
            //        if (posterInfo.Label == null || posterInfo.Label == "")
            //        {
            //            ///Fix 13366: (行、列）文件名 时间 日期)
            //            sign = string.Format("({0},{1}){2}.pdf {3} {4}", HorizonPaperIndex + 1, VerticalPaperIndex + 1, PDFViewer.Document.FileName, System.DateTime.Today.ToString("yyyy-MM-dd"), System.DateTime.Now.ToString("HH:mm:ss"));
            //        }
            //        else
            //        {
            //            sign = posterInfo.Label;
            //        }
            //        e.Graphics.DrawString(sign, new Font("Helvetica", 10.0f), System.Drawing.Brushes.Black, margin + 5, 0);
            //    }

            //    if (posterInfo.HasCutMarks)
            //    {
            //        System.Drawing.Pen pen = new System.Drawing.Pen(System.Drawing.Color.Black, 2);
            //        //除了四角之外都要添加裁切标记

            //        if (!(HorizonPaperIndex == 0 && VerticalPaperIndex == 0))
            //        {
            //            e.Graphics.DrawRectangle(pen, new Rectangle(-margin, -margin, 2 * margin, 2 * margin));
            //        }
            //        if (!(HorizonPaperIndex == HorizonPaperCount - 1 && VerticalPaperIndex == 0))
            //        {
            //            e.Graphics.DrawRectangle(pen, new Rectangle(pageBound.Height - margin, -margin, margin * 2, margin * 2));
            //        }
            //        if (!(HorizonPaperIndex == 0 && VerticalPaperIndex == VerticalPaperCount - 1))
            //        {
            //            e.Graphics.DrawRectangle(pen, new Rectangle(-margin, (int)pageBound.Width - margin, margin * 2, margin * 2));
            //        }
            //        if (!(HorizonPaperIndex == HorizonPaperCount - 1 && VerticalPaperIndex == VerticalPaperCount - 1))
            //        {
            //            e.Graphics.DrawRectangle(pen, new Rectangle(pageBound.Height - margin, (int)pageBound.Width - margin, margin * 2, margin * 2));
            //        }
            //    }

            //    Bitmap currentPrintbitmap = Crop(DisplayBitmap, rectangle);

            //    e.Graphics.DrawImage(currentPrintbitmap, new Rectangle(margin, margin, (int)pageBound.Height - margin * 2, (int)pageBound.Width - margin * 2));
            //    currentPrintbitmap.Dispose();
            //    if (PrintIndex < WholePaperCountModPoster - 1)
            //    {
            //        PrintIndex++;
            //        e.HasMorePages = true;
            //    }
            //    else
            //    {
            //        e.HasMorePages = false;
            //    }
            //}

        }

        private void PrintDocumentModMultiple(PrintPageEventArgs e)
        {
            MultipleInfo multipleInfo = (MultipleInfo)PrintSettingsInfo.PrintModInfo;
            int widthDpiRatio = (int)e.Graphics.DpiX / 100;
            int heightDpiRatio = (int)e.Graphics.DpiY / 100;
            int singlePageHeight;
            int singlePageWidth;
            Bitmap printBitmap;
            int currentPage = 0;
            Rectangle realBound = new Rectangle(documentSettingsInfo.margins.Left,
                       documentSettingsInfo.margins.Top,
                       e.PageBounds.Width - documentSettingsInfo.margins.Left - documentSettingsInfo.margins.Right,
                       e.PageBounds.Height - documentSettingsInfo.margins.Top - documentSettingsInfo.margins.Bottom);

            if (PrintSettingsInfo.EnumPrintOrientation == EnumPrintOrientation.StatusPortrait)
            {
                singlePageHeight = (int)(documentSettingsInfo.DocumentHeight / multipleInfo.VerticalPageNumber);
                singlePageWidth = (int)(documentSettingsInfo.DocumentWidth / multipleInfo.HorizontalPageNumber);
                printBitmap = new Bitmap((int)documentSettingsInfo.DocumentWidth, (int)documentSettingsInfo.DocumentHeight);
            }
            else
            {
                singlePageHeight = (int)(documentSettingsInfo.DocumentWidth / multipleInfo.VerticalPageNumber);
                singlePageWidth = (int)(documentSettingsInfo.DocumentHeight / multipleInfo.HorizontalPageNumber);
                printBitmap = new Bitmap((int)documentSettingsInfo.DocumentHeight, (int)documentSettingsInfo.DocumentWidth);
            }
            System.Drawing.Point startPoint = new System.Drawing.Point(0, 0);

            int startPage = PrintSettingsInfo.PageRangeList[PrintIndex * (multipleInfo.VerticalPageNumber) * (multipleInfo.HorizontalPageNumber)];
            int resizedHeight = 0;
            int resizedWidth = 0;
            bool isNoSrcPage = false;
            Bitmap pageBitmap;
            ///水平：横向排列，先横后纵，纵轴不变横轴翻转
            if (multipleInfo.EnumPageOrder == EnumPageOrder.StatusHorizontalOrder || multipleInfo.EnumPageOrder == EnumPageOrder.StatusHorizontalReverseOrder)
            {
                for (int tempVerticalIndex = 0; tempVerticalIndex < multipleInfo.VerticalPageNumber; tempVerticalIndex++)
                {
                    startPoint.Y = tempVerticalIndex * singlePageHeight;
                    for (int tempHorizontalIndex = 0; tempHorizontalIndex < multipleInfo.HorizontalPageNumber; tempHorizontalIndex++)
                    {
                        try
                        {
                            currentPage =
      PrintSettingsInfo.PageRangeList[PrintIndex *
      (multipleInfo.VerticalPageNumber) *
      (multipleInfo.HorizontalPageNumber) +
      (tempVerticalIndex * multipleInfo.HorizontalPageNumber) +
      tempHorizontalIndex];
                        }
                        catch
                        {
                            break;
                        }

                        //横向
                        if (multipleInfo.EnumPageOrder == EnumPageOrder.StatusHorizontalOrder)
                        {
                            startPoint.X = tempHorizontalIndex * singlePageWidth;
                        }
                        //横向倒序
                        else
                        {
                            startPoint.X = (multipleInfo.HorizontalPageNumber - tempHorizontalIndex - 1) * singlePageWidth;
                        }
                        CPDFPage cPDFPage = PDFViewer.Document.PageAtIndex(currentPage);
                        if (cPDFPage == null)
                        {
                            isNoSrcPage = true;
                            break;
                        }
                        pageBitmap = ToolMethod.RenderPageBitmapNoWait(PDFViewer.Document, (int)(cPDFPage.PageSize.Width), (int)(cPDFPage.PageSize.Height), currentPage, PrintSettingsInfo.IsPrintWithAnnot, PrintSettingsInfo.IsPrintWithForm);

                        if (multipleInfo.IsAutoRotate)
                        {
                            if ((cPDFPage.PageSize.Height / cPDFPage.PageSize.Width > 1 && (double)singlePageHeight / singlePageWidth < 1) ||
    (cPDFPage.PageSize.Height / cPDFPage.PageSize.Width < 1 && (double)singlePageHeight / singlePageWidth > 1))
                            {
                                pageBitmap = ToolMethod.RenderPageBitmapNoWait(PDFViewer.Document, (int)(cPDFPage.PageSize.Width), (int)(cPDFPage.PageSize.Height), currentPage, PrintSettingsInfo.IsPrintWithAnnot, PrintSettingsInfo.IsPrintWithForm);
                                pageBitmap.RotateFlip(RotateFlipType.Rotate270FlipNone);
                            }
                        }
                        ///重设大小
                        if ((float)pageBitmap.Height / (float)pageBitmap.Width >= ((float)singlePageHeight / (float)singlePageWidth))
                        {
                            resizedHeight = (int)(singlePageHeight * 0.96);
                            resizedWidth = (int)((float)singlePageHeight / pageBitmap.Height * pageBitmap.Width * 0.96);
                        }
                        else
                        {
                            resizedWidth = (int)(singlePageWidth * 0.96);
                            resizedHeight = (int)((float)singlePageWidth / pageBitmap.Width * pageBitmap.Height * 0.96);
                        }
                        pageBitmap = Resize(pageBitmap, (int)resizedWidth, (int)resizedHeight);


                        startPoint.X += (singlePageWidth - resizedWidth) / 2;
                        startPoint.Y += (singlePageHeight - resizedHeight) / 2;
                        if (PrintSettingsInfo.IsGrayscale)
                        {
                            pageBitmap = ToGray(pageBitmap, 0);
                        }
                        printBitmap = CombineBitmap(printBitmap, pageBitmap, startPoint);
                        //绘制边界
                        if (PrintSettingsInfo.IsPrintPageBorde)
                        {
                            using (Pen pen = new Pen(Color.Black, 4))
                            {
                                Graphics g = Graphics.FromImage(printBitmap);
                                g.DrawRectangle(pen, new Rectangle(startPoint.X, startPoint.Y, resizedWidth, resizedHeight));
                                g.Dispose();
                            }
                        }
                        startPoint.Y -= (singlePageHeight - resizedHeight) / 2;
                    }
                    if (isNoSrcPage)
                    {
                        isNoSrcPage = false;
                        break;
                    }
                }
            }
            //垂直：纵向排列，先纵后横，纵轴不变横轴翻转
            else
            {
                for (int tempHorizontalIndex = 0; tempHorizontalIndex < multipleInfo.HorizontalPageNumber; tempHorizontalIndex++)
                {
                    //纵向，垂直排列时先移位
                    if (multipleInfo.EnumPageOrder == EnumPageOrder.StatusVerticalOrder)
                    {
                        startPoint.X = tempHorizontalIndex * singlePageWidth;
                    }
                    //纵向倒序
                    else
                    {
                        startPoint.X = (multipleInfo.HorizontalPageNumber - tempHorizontalIndex - 1) * singlePageWidth;
                    }
                    for (int tempVerticalIndex = 0; tempVerticalIndex < multipleInfo.VerticalPageNumber; tempVerticalIndex++)
                    {
                        startPoint.Y = tempVerticalIndex * singlePageHeight;
                        try
                        {
                            currentPage = PrintSettingsInfo.PageRangeList[PrintIndex *
                          (multipleInfo.VerticalPageNumber) *
                          (multipleInfo.HorizontalPageNumber) +
                          (tempHorizontalIndex * multipleInfo.VerticalPageNumber) +
                          tempVerticalIndex];
                        }
                        catch
                        {
                            break;
                        }

                        CPDFPage cPDFPage = PDFViewer.Document.PageAtIndex(currentPage);
                        if (cPDFPage == null)
                        {
                            isNoSrcPage = true;
                            break;
                        }
                        pageBitmap = ToolMethod.RenderPageBitmapNoWait(PDFViewer.Document, (int)(cPDFPage.PageSize.Width), (int)(cPDFPage.PageSize.Height), currentPage, PrintSettingsInfo.IsPrintWithAnnot, PrintSettingsInfo.IsPrintWithForm);
                        if (multipleInfo.IsAutoRotate)
                        {
                            if ((cPDFPage.PageSize.Height / cPDFPage.PageSize.Width > 1 && (double)singlePageHeight / singlePageWidth < 1) ||
    (cPDFPage.PageSize.Height / cPDFPage.PageSize.Width < 1 && (double)singlePageHeight / singlePageWidth > 1))
                            {
                                pageBitmap = ToolMethod.RenderPageBitmapNoWait(PDFViewer.Document, (int)(cPDFPage.PageSize.Width), (int)(cPDFPage.PageSize.Height), currentPage, PrintSettingsInfo.IsPrintWithAnnot, PrintSettingsInfo.IsPrintWithForm);
                                pageBitmap.RotateFlip(RotateFlipType.Rotate270FlipNone);
                            }
                        }
                        Graphics graphics = Graphics.FromImage(pageBitmap);
                        ///重设大小
                        if ((float)pageBitmap.Height / (float)pageBitmap.Width >= ((float)singlePageHeight / (float)singlePageWidth))
                        {
                            resizedHeight = (int)(singlePageHeight * 0.96);
                            resizedWidth = (int)((float)singlePageHeight / pageBitmap.Height * pageBitmap.Width * 0.96);
                        }
                        else
                        {
                            resizedWidth = (int)(singlePageWidth * 0.96);
                            resizedHeight = (int)((float)singlePageWidth / pageBitmap.Width * pageBitmap.Height * 0.96);
                        }
                        pageBitmap = Resize(pageBitmap, (int)resizedWidth, (int)resizedHeight);

                        graphics.Dispose();
                        startPoint.X += (singlePageWidth - resizedWidth) / 2;
                        startPoint.Y += (singlePageHeight - resizedHeight) / 2;
                        if (PrintSettingsInfo.IsGrayscale)
                        {
                            pageBitmap = ToGray(pageBitmap, 0);
                        }
                        printBitmap = CombineBitmap(printBitmap, pageBitmap, startPoint);

                        //绘制边界
                        if (PrintSettingsInfo.IsPrintPageBorde)
                        {
                            using (Pen pen = new Pen(Color.Black, 4))
                            {
                                Graphics g = Graphics.FromImage(printBitmap);
                                g.DrawRectangle(pen, new Rectangle(startPoint.X, startPoint.Y, resizedWidth, resizedHeight));
                                g.Dispose();
                            }
                        }
                        startPoint.X -= (singlePageWidth - resizedWidth) / 2;
                    }
                    if (isNoSrcPage)
                    {
                        isNoSrcPage = false;
                        break;
                    }
                }
            }
            if (IsManualDuplex && PrintIndex % 2 == 1 && multipleInfo.EnumDuplexPrintMod == EnumDuplexPrintMod.StatusFlipShortEdge)
            {
                printBitmap.RotateFlip(RotateFlipType.Rotate180FlipNone);
            }
            e.Graphics.DrawImage(printBitmap, realBound);
            if (IsManualDuplex)
            {
                if (PrintIndex < PrintedPageCount - 2)
                {
                    PrintIndex += 2;
                    e.HasMorePages = true;
                }
                else
                {
                    e.HasMorePages = false;
                }
            }
            //单面打印
            else
            {
                if (PrintIndex < PrintedPageCount - 1)
                {
                    PrintIndex++;
                    e.HasMorePages = true;
                }
                else
                {
                    e.HasMorePages = false;
                }
            }
        }

        private void PrintDocumentModBooklet(PrintPageEventArgs e)
        {
            BookletInfo bookletInfo = (BookletInfo)PrintSettingsInfo.PrintModInfo;
            ///空白画布
            Bitmap printBitmap;
            double singlePageHeight = 0;
            double singlePageWidth = 0;
            Rectangle realBound = new Rectangle(documentSettingsInfo.margins.Left,
                        documentSettingsInfo.margins.Top,
                      e.PageBounds.Width - documentSettingsInfo.margins.Left - documentSettingsInfo.margins.Right,
                      e.PageBounds.Height - documentSettingsInfo.margins.Top - documentSettingsInfo.margins.Bottom);

            if (PrintSettingsInfo.EnumPrintOrientation == EnumPrintOrientation.StatusPortrait)
            {
                printBitmap = new Bitmap((int)documentSettingsInfo.DocumentWidth, (int)documentSettingsInfo.DocumentHeight);
                singlePageHeight = (double)documentSettingsInfo.DocumentHeight;
                singlePageWidth = (double)(documentSettingsInfo.DocumentWidth / 2);
            }
            else
            {
                printBitmap = new Bitmap((int)documentSettingsInfo.DocumentHeight, (int)documentSettingsInfo.DocumentWidth);
                singlePageHeight = (double)documentSettingsInfo.DocumentWidth;
                singlePageWidth = (double)(documentSettingsInfo.DocumentHeight / 2);
            }
            System.Drawing.Point startPoint = new System.Drawing.Point(0, 0);
            int maxPaperNumber = (PDFViewer.Document.PageCount % 4 == 0) ? (PDFViewer.Document.PageCount / 4) : (PDFViewer.Document.PageCount / 4 + 1);
            Bitmap leftBitmap = null;
            Bitmap rightBitmap = null;
            double resizedHeight = 0;
            double resizedWidth = 0;
            CPDFPage leftPage = null;
            CPDFPage rightPage = null;
            int leftPageIndex = 0;
            int rightPageIndex = 0;

            ///<summary>
            ///左装订与右装订顺序相反
            ///左装订:
            /// </summary>
            if (bookletInfo.EnumBookletBinding == EnumBookletBinding.StatusLeft)
            {
                ///奇数页：
                ///右面为页面序号
                ///左面为[（总打印纸数*4）+1-打印页右侧页序号]
                if ((TargetPaperList[PrintIndex + 1] + 1) % 2 == 1)
                {
                    try
                    {
                        leftPageIndex = PrintSettingsInfo.PageRangeList[maxPaperNumber * 4 - TargetPaperList[PrintIndex + 1] - 1];
                        leftPage = PDFViewer.Document.PageAtIndex(leftPageIndex);
                    }
                    catch
                    {
                        leftPage = null;
                    }
                    rightPageIndex = PrintSettingsInfo.PageRangeList[TargetPaperList[PrintIndex + 1]];
                    //左面
                    if (leftPage != null)
                    {
                        leftBitmap = ToolMethod.RenderPageBitmapNoWait(PDFViewer.Document, (int)leftPage.PageSize.Width, (int)leftPage.PageSize.Height, leftPageIndex, PrintSettingsInfo.IsPrintWithAnnot, PrintSettingsInfo.IsPrintWithForm);
                        if (bookletInfo.IsAutoRotate)
                        {
                            if ((leftPage.PageSize.Height / leftPage.PageSize.Width > 1 && (double)singlePageHeight / singlePageWidth < 1) ||
    (leftPage.PageSize.Height / leftPage.PageSize.Width < 1 && (double)singlePageHeight / singlePageWidth > 1))
                            {
                                leftBitmap.RotateFlip(RotateFlipType.Rotate270FlipNone);
                            }
                        }
                        ///重设大小
                        if ((leftBitmap.Height / leftBitmap.Width) >= singlePageHeight / singlePageWidth)
                        {
                            resizedHeight = singlePageHeight * 0.96;
                            resizedWidth = singlePageHeight / leftBitmap.Height * leftBitmap.Width * 0.96;
                        }
                        else
                        {
                            resizedWidth = singlePageWidth * 0.96;
                            resizedHeight = singlePageWidth / leftBitmap.Width * leftBitmap.Height * 0.96;
                        }
                        leftBitmap = Resize(leftBitmap, (int)(resizedWidth), (int)(resizedHeight));
                        startPoint.X = (int)(singlePageWidth - resizedWidth) / 2;
                        startPoint.Y = (int)(singlePageHeight - resizedHeight) / 2;
                        if (PrintSettingsInfo.IsGrayscale)
                        {
                            leftBitmap = ToGray(leftBitmap, 0);
                        }
                        printBitmap = CombineBitmap(printBitmap, leftBitmap, startPoint);
                        if (PrintSettingsInfo.IsPrintPageBorde)
                        {
                            using (Pen pen = new Pen(Color.Black, 4))
                            {
                                Graphics g = Graphics.FromImage(printBitmap);
                                g.DrawRectangle(pen, new Rectangle(startPoint.X, startPoint.Y, (int)resizedWidth, (int)resizedHeight));
                                g.Dispose();
                            }
                        }
                    }
                    //右面
                    rightPage = PDFViewer.Document.PageAtIndex(rightPageIndex);
                    startPoint.X = (int)singlePageWidth;
                    if (rightPage != null)
                    {
                        rightBitmap = ToolMethod.RenderPageBitmapNoWait(PDFViewer.Document, (int)rightPage.PageSize.Width, (int)rightPage.PageSize.Height, rightPageIndex, PrintSettingsInfo.IsPrintWithAnnot, PrintSettingsInfo.IsPrintWithForm);
                        if (bookletInfo.IsAutoRotate)
                        {
                            if ((rightPage.PageSize.Height / rightPage.PageSize.Width > 1 && (double)singlePageHeight / singlePageWidth < 1) ||
    (rightPage.PageSize.Height / rightPage.PageSize.Width < 1 && (double)singlePageHeight / singlePageWidth > 1))
                            {
                                rightBitmap.RotateFlip(RotateFlipType.Rotate270FlipNone);
                            }
                        }
                        ///重设大小
                        if ((rightBitmap.Height / rightBitmap.Width) >= singlePageHeight / singlePageWidth)
                        {
                            resizedHeight = singlePageHeight * 0.96;
                            resizedWidth = singlePageHeight / rightBitmap.Height * rightBitmap.Width * 0.96;
                        }
                        else
                        {
                            resizedWidth = singlePageWidth * 0.96;
                            resizedHeight = singlePageWidth / rightBitmap.Width * rightBitmap.Height * 0.96;
                        }
                        rightBitmap = Resize(rightBitmap, (int)(resizedWidth), (int)(resizedHeight));
                        startPoint.X += (int)(singlePageWidth - resizedWidth) / 2;
                        startPoint.Y = (int)(singlePageHeight - resizedHeight) / 2;
                        if (PrintSettingsInfo.IsGrayscale)
                        {
                            rightBitmap = ToGray(rightBitmap, 0);
                        }
                        printBitmap = CombineBitmap(printBitmap, rightBitmap, startPoint);
                        if (PrintSettingsInfo.IsPrintPageBorde)
                        {
                            using (Pen pen = new Pen(Color.Black, 4))
                            {
                                Graphics g = Graphics.FromImage(printBitmap);
                                g.DrawRectangle(pen, new Rectangle(startPoint.X, startPoint.Y, (int)resizedWidth, (int)resizedHeight));
                                g.Dispose();
                            }
                        }
                    }
                }
                /// 偶数页：
                /// 左面为页面序号
                /// 右面为[（总打印纸数*4）+1-打印页右侧页序号]
                else
                {
                    leftPageIndex = PrintSettingsInfo.PageRangeList[TargetPaperList[PrintIndex + 1]];
                    //左面
                    leftPage = PDFViewer.Document.PageAtIndex(leftPageIndex);
                    if (leftPage != null)
                    {
                        leftBitmap = ToolMethod.RenderPageBitmapNoWait(PDFViewer.Document, (int)leftPage.PageSize.Width, (int)leftPage.PageSize.Height, leftPageIndex, PrintSettingsInfo.IsPrintWithAnnot, PrintSettingsInfo.IsPrintWithForm);
                        if (bookletInfo.IsAutoRotate)
                        {
                            if ((leftPage.PageSize.Height / leftPage.PageSize.Width > 1 && (double)singlePageHeight / singlePageWidth < 1) ||
    (leftPage.PageSize.Height / leftPage.PageSize.Width < 1 && (double)singlePageHeight / singlePageWidth > 1))
                            {
                                leftBitmap.RotateFlip(RotateFlipType.Rotate270FlipNone);
                            }
                        }
                        ///重设大小
                        if ((leftBitmap.Height / leftBitmap.Width) >= singlePageHeight / singlePageWidth)
                        {
                            resizedHeight = singlePageHeight * 0.96;
                            resizedWidth = singlePageHeight / leftBitmap.Height * leftBitmap.Width * 0.96;
                        }
                        else
                        {
                            resizedWidth = singlePageWidth * 0.96;
                            resizedHeight = singlePageWidth / leftBitmap.Width * leftBitmap.Height * 0.96;
                        }
                        leftBitmap = Resize(leftBitmap, (int)(resizedWidth), (int)(resizedHeight));
                        startPoint.X = (int)(singlePageWidth - resizedWidth) / 2;
                        startPoint.Y = (int)(singlePageHeight - resizedHeight) / 2;
                        if (PrintSettingsInfo.IsGrayscale)
                        {
                            leftBitmap = ToGray(leftBitmap, 0);
                        }
                        printBitmap = CombineBitmap(printBitmap, leftBitmap, startPoint);
                        if (PrintSettingsInfo.IsPrintPageBorde)
                        {
                            using (Pen pen = new Pen(Color.Black, 4))
                            {
                                Graphics g = Graphics.FromImage(printBitmap);
                                g.DrawRectangle(pen, new Rectangle(startPoint.X, startPoint.Y, (int)resizedWidth, (int)resizedHeight));
                                g.Dispose();
                            }
                        }
                    }
                    //右面
                    try
                    {
                        rightPageIndex = PrintSettingsInfo.PageRangeList[maxPaperNumber * 4 - 1 - TargetPaperList[PrintIndex + 1]];
                        rightPage = PDFViewer.Document.PageAtIndex(rightPageIndex);
                    }
                    catch
                    {
                        rightPage = null;
                    }
                    startPoint.X = (int)singlePageWidth;
                    if (rightPage != null)
                    {
                        rightBitmap = ToolMethod.RenderPageBitmapNoWait(PDFViewer.Document, (int)rightPage.PageSize.Width, (int)rightPage.PageSize.Height, rightPageIndex, PrintSettingsInfo.IsPrintWithAnnot, PrintSettingsInfo.IsPrintWithForm);
                        if (bookletInfo.IsAutoRotate)
                        {
                            if ((rightPage.PageSize.Height / rightPage.PageSize.Width > 1 && (double)singlePageHeight / singlePageWidth < 1) ||
    (rightPage.PageSize.Height / rightPage.PageSize.Width < 1 && (double)singlePageHeight / singlePageWidth > 1))
                            {
                                rightBitmap.RotateFlip(RotateFlipType.Rotate270FlipNone);
                            }
                        }
                        ///重设大小
                        if ((rightBitmap.Height / rightBitmap.Width) >= singlePageHeight / singlePageWidth)
                        {
                            resizedHeight = singlePageHeight * 0.96;
                            resizedWidth = singlePageHeight / rightBitmap.Height * rightBitmap.Width * 0.96;
                        }
                        else
                        {
                            resizedWidth = singlePageWidth * 0.96;
                            resizedHeight = singlePageWidth / rightBitmap.Width * rightBitmap.Height * 0.96;
                        }
                        rightBitmap = Resize(rightBitmap, (int)(resizedWidth), (int)(resizedHeight));
                        startPoint.X += (int)(singlePageWidth - resizedWidth) / 2;
                        startPoint.Y = (int)(singlePageHeight - resizedHeight) / 2;
                        if (PrintSettingsInfo.IsGrayscale)
                        {
                            rightBitmap = ToGray(rightBitmap, 0);
                        }
                        printBitmap = CombineBitmap(printBitmap, rightBitmap, startPoint);
                        if (PrintSettingsInfo.IsPrintPageBorde)
                        {
                            using (Pen pen = new Pen(Color.Black, 4))
                            {
                                Graphics g = Graphics.FromImage(printBitmap);
                                g.DrawRectangle(pen, new Rectangle(startPoint.X, startPoint.Y, (int)resizedWidth, (int)resizedHeight));
                                g.Dispose();
                            }
                        }
                    }
                }
            }
            ///<summary>
            ///右装订打印
            /// </summary>
            if (bookletInfo.EnumBookletBinding == EnumBookletBinding.StatusRight)
            {
                ///奇数页：
                ///右面为页面序号
                ///左面为[（总打印纸数*4）+1-打印页右侧页序号]
                if ((TargetPaperList[PrintIndex + 1] + 1) % 2 == 0)
                {
                    try
                    {
                        leftPageIndex = PrintSettingsInfo.PageRangeList[maxPaperNumber * 4 - TargetPaperList[PrintIndex + 1] - 1];
                        leftPage = PDFViewer.Document.PageAtIndex(leftPageIndex);
                    }
                    catch
                    {
                        leftPage = null;
                    }
                    rightPageIndex = PrintSettingsInfo.PageRangeList[TargetPaperList[PrintIndex + 1]];
                    //左面
                    if (leftPage != null)
                    {
                        ///重设大小
                        leftBitmap = ToolMethod.RenderPageBitmapNoWait(PDFViewer.Document, (int)leftPage.PageSize.Width, (int)leftPage.PageSize.Height, leftPageIndex, PrintSettingsInfo.IsPrintWithAnnot, PrintSettingsInfo.IsPrintWithForm);
                        if (bookletInfo.IsAutoRotate)
                        {
                            if ((leftPage.PageSize.Height / leftPage.PageSize.Width > 1 && (double)singlePageHeight / singlePageWidth < 1) ||
    (leftPage.PageSize.Height / leftPage.PageSize.Width < 1 && (double)singlePageHeight / singlePageWidth > 1))
                            {
                                leftBitmap.RotateFlip(RotateFlipType.Rotate270FlipNone);
                            }
                        }
                        ///重设大小
                        if ((leftBitmap.Height / leftBitmap.Width) >= singlePageHeight / singlePageWidth)
                        {
                            resizedHeight = singlePageHeight * 0.96;
                            resizedWidth = singlePageHeight / leftBitmap.Height * leftBitmap.Width * 0.96;
                        }
                        else
                        {
                            resizedWidth = singlePageWidth * 0.96;
                            resizedHeight = singlePageWidth / leftBitmap.Width * leftBitmap.Height * 0.96;
                        }
                        leftBitmap = Resize(leftBitmap, (int)(resizedWidth), (int)(resizedHeight));
                        startPoint.X = (int)(singlePageWidth - resizedWidth) / 2;
                        startPoint.Y = (int)(singlePageHeight - resizedHeight) / 2;
                        if (PrintSettingsInfo.IsGrayscale)
                        {
                            leftBitmap = ToGray(leftBitmap, 0);
                        }

                        printBitmap = CombineBitmap(printBitmap, leftBitmap, startPoint);
                        if (PrintSettingsInfo.IsPrintPageBorde)
                        {
                            using (Pen pen = new Pen(Color.Black, 4))
                            {
                                Graphics g = Graphics.FromImage(printBitmap);
                                g.DrawRectangle(pen, new Rectangle(startPoint.X, startPoint.Y, (int)resizedWidth, (int)resizedHeight));
                                g.Dispose();
                            }
                        }
                    }
                    //右面
                    rightPage = PDFViewer.Document.PageAtIndex(rightPageIndex);
                    startPoint.X = (int)singlePageWidth;
                    if (rightPage != null)
                    {
                        ///重设大小
                        rightBitmap = ToolMethod.RenderPageBitmapNoWait(PDFViewer.Document, (int)rightPage.PageSize.Width, (int)rightPage.PageSize.Height, rightPageIndex, PrintSettingsInfo.IsPrintWithAnnot, PrintSettingsInfo.IsPrintWithForm);
                        if (bookletInfo.IsAutoRotate)
                        {
                            if ((rightPage.PageSize.Height / rightPage.PageSize.Width > 1 && (double)singlePageHeight / singlePageWidth < 1) ||
    (rightPage.PageSize.Height / rightPage.PageSize.Width < 1 && (double)singlePageHeight / singlePageWidth > 1))
                            {
                                rightBitmap.RotateFlip(RotateFlipType.Rotate270FlipNone);
                            }
                        }
                        ///重设大小
                        if ((rightBitmap.Height / rightBitmap.Width) >= singlePageHeight / singlePageWidth)
                        {
                            resizedHeight = singlePageHeight * 0.96;
                            resizedWidth = singlePageHeight / rightBitmap.Height * rightBitmap.Width * 0.96;
                        }
                        else
                        {
                            resizedWidth = singlePageWidth * 0.96;
                            resizedHeight = singlePageWidth / rightBitmap.Width * rightBitmap.Height * 0.96;
                        }
                        rightBitmap = Resize(rightBitmap, (int)(resizedWidth), (int)(resizedHeight));
                        startPoint.Y = (int)(singlePageHeight - resizedHeight) / 2;
                        if (PrintSettingsInfo.IsGrayscale)
                        {
                            rightBitmap = ToGray(rightBitmap, 0);
                        }
                        printBitmap = CombineBitmap(printBitmap, rightBitmap, startPoint);
                        if (PrintSettingsInfo.IsPrintPageBorde)
                        {
                            using (Pen pen = new Pen(Color.Black, 4))
                            {
                                Graphics g = Graphics.FromImage(printBitmap);
                                g.DrawRectangle(pen, new Rectangle(startPoint.X, startPoint.Y, (int)resizedWidth, (int)resizedHeight));
                                g.Dispose();
                            }
                        }
                    }
                }
                /// 偶数页：
                /// 左面为页面序号
                /// 右面为[（总打印纸数*4）+1-打印页右侧页序号]
                else
                {
                    leftPageIndex = PrintSettingsInfo.PageRangeList[TargetPaperList[PrintIndex + 1]];
                    //左面
                    leftPage = PDFViewer.Document.PageAtIndex(leftPageIndex);
                    if (leftPage != null)
                    {
                        ///重设大小
                        leftBitmap = ToolMethod.RenderPageBitmapNoWait(PDFViewer.Document, (int)leftPage.PageSize.Width, (int)leftPage.PageSize.Height, leftPageIndex, PrintSettingsInfo.IsPrintWithAnnot, PrintSettingsInfo.IsPrintWithForm);
                        if (bookletInfo.IsAutoRotate)
                        {
                            if ((leftPage.PageSize.Height / leftPage.PageSize.Width > 1 && (double)singlePageHeight / singlePageWidth < 1) ||
    (leftPage.PageSize.Height / leftPage.PageSize.Width < 1 && (double)singlePageHeight / singlePageWidth > 1))
                            {
                                leftBitmap.RotateFlip(RotateFlipType.Rotate270FlipNone);
                            }
                        }
                        ///重设大小
                        if ((leftBitmap.Height / leftBitmap.Width) >= singlePageHeight / singlePageWidth)
                        {
                            resizedHeight = singlePageHeight * 0.96;
                            resizedWidth = singlePageHeight / leftBitmap.Height * leftBitmap.Width * 0.96;
                        }
                        else
                        {
                            resizedWidth = singlePageWidth * 0.96;
                            resizedHeight = singlePageWidth / leftBitmap.Width * leftBitmap.Height * 0.96;
                        }
                        leftBitmap = Resize(leftBitmap, (int)(resizedWidth), (int)(resizedHeight));
                        startPoint.X = (int)(singlePageWidth - resizedWidth) / 2;
                        startPoint.Y = (int)(singlePageHeight - resizedHeight) / 2;
                        if (PrintSettingsInfo.IsGrayscale)
                        {
                            leftBitmap = ToGray(leftBitmap, 0);
                        }
                        printBitmap = CombineBitmap(printBitmap, leftBitmap, startPoint);
                        startPoint.X = (int)(singlePageWidth - resizedWidth) / 2;
                        startPoint.Y = (int)(singlePageHeight - resizedHeight) / 2;
                        if (PrintSettingsInfo.IsGrayscale)
                        {
                            leftBitmap = ToGray(leftBitmap, 0);
                        }
                        printBitmap = CombineBitmap(printBitmap, leftBitmap, startPoint);
                        if (PrintSettingsInfo.IsPrintPageBorde)
                        {
                            using (Pen pen = new Pen(Color.Black, 4))
                            {
                                Graphics g = Graphics.FromImage(printBitmap);
                                g.DrawRectangle(pen, new Rectangle(startPoint.X, startPoint.Y, (int)resizedWidth, (int)resizedHeight));
                                g.Dispose();
                            }
                        }
                    }
                    //右面
                    try
                    {
                        rightPageIndex = PrintSettingsInfo.PageRangeList[maxPaperNumber * 4 - 1 - TargetPaperList[PrintIndex + 1]];
                        rightPage = PDFViewer.Document.PageAtIndex(rightPageIndex);
                    }
                    catch
                    {
                        rightPage = null;
                    }
                    startPoint.X = (int)singlePageWidth;
                    if (rightPage != null)
                    {
                        rightBitmap = ToolMethod.RenderPageBitmapNoWait(PDFViewer.Document, (int)rightPage.PageSize.Width, (int)rightPage.PageSize.Height, rightPageIndex, PrintSettingsInfo.IsPrintWithAnnot, PrintSettingsInfo.IsPrintWithForm);
                        if (bookletInfo.IsAutoRotate)
                        {
                            if ((rightPage.PageSize.Height / rightPage.PageSize.Width > 1 && (double)singlePageHeight / singlePageWidth < 1) ||
    (rightPage.PageSize.Height / rightPage.PageSize.Width < 1 && (double)singlePageHeight / singlePageWidth > 1))
                            {
                                rightBitmap.RotateFlip(RotateFlipType.Rotate270FlipNone);
                            }
                        }
                        ///重设大小
                        if ((rightBitmap.Height / rightBitmap.Width) >= singlePageHeight / singlePageWidth)
                        {
                            resizedHeight = singlePageHeight * 0.96;
                            resizedWidth = singlePageHeight / rightBitmap.Height * rightBitmap.Width * 0.96;
                        }
                        else
                        {
                            resizedWidth = singlePageWidth * 0.96;
                            resizedHeight = singlePageWidth / rightBitmap.Width * rightBitmap.Height * 0.96;
                        }
                        rightBitmap = Resize(rightBitmap, (int)(resizedWidth), (int)(resizedHeight));
                        startPoint.X += (int)(singlePageWidth - resizedWidth) / 2;
                        startPoint.Y = (int)(singlePageHeight - resizedHeight) / 2;
                        if (PrintSettingsInfo.IsGrayscale)
                        {
                            rightBitmap = ToGray(rightBitmap, 0);
                        }
                        printBitmap = CombineBitmap(printBitmap, rightBitmap, startPoint);
                        if (PrintSettingsInfo.IsPrintPageBorde)
                        {
                            using (Pen pen = new Pen(Color.Black, 4))
                            {
                                Graphics g = Graphics.FromImage(printBitmap);
                                g.DrawRectangle(pen, new Rectangle(startPoint.X, startPoint.Y, (int)resizedWidth, (int)resizedHeight));
                                g.Dispose();
                            }
                        }
                    }
                }
            }
            e.Graphics.DrawImage(printBitmap, realBound);
            if (IsManualDuplex)
            {
                if (PrintIndex < PrintedPageCount - 2)
                {
                    PrintIndex += 2;
                    e.HasMorePages = true;
                }
                else
                {
                    e.HasMorePages = false;
                }
            }
            //单面打印
            else
            {
                if (PrintIndex < PrintedPageCount - 1)
                {
                    PrintIndex++;
                    e.HasMorePages = true;
                }
                else
                {
                    e.HasMorePages = false;
                }
            }
        }
        #endregion
        private void PrintDocumentByCurrentSettings(object sender, PrintPageEventArgs e)
        {
            switch (PrintSettingsInfo.PrintModInfo.EnumPrintMod)
            {

                case EnumPrintMod.StatusPoster:
                    PrintDocumentModPoster(e);
                    break;
                case EnumPrintMod.StatusMultiple:
                    PrintDocumentModMultiple(e);
                    break;
                case EnumPrintMod.StatusBooklet:
                    PrintDocumentModBooklet(e);
                    break;
                case EnumPrintMod.StatusSize:
                default:
                    PrintDocumentModSize(e);
                    break;
            }
        }

        //跳转指定页
        public void JumpToSelectedPage()
        {
            if (TargetPaperIndex >= 1 && TargetPaperIndex <= PrintedPageCount)
            {
                PaintPageByCurrentPreviewIndex(TargetPaperIndex);
                ErrorPageTxtVisibility = Visibility.Collapsed;
            }
            else
            {
                ErrorPageTxtVisibility = Visibility.Visible;
            }
        }

        //跳转指定页
        public void JumpPage(object e)
        {
            var txt = e as System.Windows.Controls.TextBox;
            if (txt.Text != null)
            {
                try
                {
                    TargetPaperIndex = Convert.ToInt32(txt.Text);
                }
                catch
                {
                    TargetPaperIndex = 1;
                }
            }
            if (TargetPaperIndex >= 1 && TargetPaperIndex <= PrintedPageCount)
            {
                PaintPageByCurrentPreviewIndex(TargetPaperIndex);
            }
        }

        public void RecvPrintSettingsInfo(PrintSettingsInfoWithUnicode printSettingsInfoWIthUnicode)
        {
            if (PDFViewer != null && printSettingsInfoWIthUnicode.printSettingsInfo != null)
            {
                documentSettingsInfo.DocumentWidth = PrintSettingsInfo.PrintDocument.DefaultPageSettings.PaperSize.Width;
                documentSettingsInfo.DocumentHeight = PrintSettingsInfo.PrintDocument.DefaultPageSettings.PaperSize.Height;
                documentSettingsInfo.margins = PrintSettingsInfo.PrintDocument.DefaultPageSettings.Margins;
                documentSettingsInfo.DocumentBounds = PrintSettingsInfo.PrintDocument.DefaultPageSettings.Bounds;
                CaculatePrintedPageCount();
                SetPaperCollection();
                if (PrintedPageCount != PreviousPrintedPageCount)
                {
                    TargetPaperIndex = 1;
                    PreviousPrintedPageCount = PrintedPageCount;
                }
                PaintPageByCurrentPreviewIndex(TargetPaperIndex);

            }
        }

        public void SetViewBox(double height, double width)
        {
            if (height / width >= (248.0 / 180.0))
            {
                ViewBoxHeight = "248.0";
                ViewBoxWidth = (width / height * 248.0).ToString();
            }
            else
            {
                ViewBoxWidth = "180.0";
                ViewBoxHeight = (height / width * 180.0).ToString();
            }
        }

        /// <summary>
        /// bitmap->bitmapsource转换器，用于显示到image控件
        /// </summary>
        /// <param name="bmp">
        /// Bitmap格式图片资源
        /// </param>
        /// <returns></returns>
        public static BitmapSource ToBitmapSource(System.Drawing.Bitmap bmp)
        {
            IntPtr ptr = bmp.GetHbitmap();//obtain the Hbitmap
            BitmapSource bmpsrc = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap
            (
                ptr,
                IntPtr.Zero,
                new Int32Rect(0, 0, bmp.Width, bmp.Height),
                System.Windows.Media.Imaging.BitmapSizeOptions.FromEmptyOptions()
            );
            return bmpsrc;
        }

        /// <summary>
        /// 创建空白底图
        /// </summary>
        private Bitmap CreateBlankBitmap()
        {
            if (PrintSettingsInfo.EnumPrintOrientation == EnumPrintOrientation.StatusPortrait)
            {
                blankPageBitmap = new Bitmap((int)documentSettingsInfo.DocumentWidth, (int)documentSettingsInfo.DocumentHeight);
            }
            else
            {
                blankPageBitmap = new Bitmap((int)documentSettingsInfo.DocumentHeight, (int)documentSettingsInfo.DocumentWidth);
            }
            return blankPageBitmap;
        }

        /// <summary>
        /// 设置预览(除海报)
        /// </summary>
        public void SetPreviewExceptPoster()
        {
            if (PrintSettingsInfo.PrintModInfo.EnumPrintMod != EnumPrintMod.StatusPoster)
            {
                if (PrintSettingsInfo.EnumPrintOrientation == EnumPrintOrientation.StatusPortrait)
                {
                    PaperWidth = String.Format("{0:F1}", (documentSettingsInfo.DocumentWidth) / 100.0 * 25.4);
                    PaperHeight = String.Format("{0:F1}", (documentSettingsInfo.DocumentHeight) / 100.0 * 25.4);
                }
                else
                {
                    PaperHeight = String.Format("{0:F1}", (documentSettingsInfo.DocumentWidth) / 100.0 * 25.4);
                    PaperWidth = String.Format("{0:F1}", (documentSettingsInfo.DocumentHeight) / 100.0 * 25.4);
                }
                SetViewBox(double.Parse(PaperHeight), double.Parse(PaperWidth));
            }
            blankPageBitmap = CreateBlankBitmap();
        }

        public System.Drawing.Image ResizeImage(System.Drawing.Image image, System.Drawing.Size size)
        {
            //获取图片宽度
            int sourceWidth = image.Width;
            //获取图片高度
            int sourceHeight = image.Height;

            float nPercent = 0;
            float nPercentW = 0;
            float nPercentH = 0;
            //计算宽度的缩放比例
            //nPercentW = ((float)size.Width * (float)GetDpiByGraphics()/120/ (float)sourceWidth);
            ////计算高度的缩放比例
            //nPercentH = ((float)size.Height*(float)GetDpiByGraphics() / 120 / (float)sourceHeight);
            nPercentW = ((float)size.Width / (float)sourceWidth);
            //计算高度的缩放比例
            nPercentH = ((float)size.Height / (float)sourceHeight);

            if (nPercentH < nPercentW)
                nPercent = nPercentH;
            else
                nPercent = nPercentW;
            //期望的宽度
            int destWidth = (int)(sourceWidth * nPercent);
            //期望的高度
            int destHeight = (int)(sourceHeight * nPercent);

            System.Drawing.Bitmap b = new System.Drawing.Bitmap(destWidth, destHeight);
            Graphics g = Graphics.FromImage((System.Drawing.Image)b);
            //g.InterpolationMode = InterpolationMode.HighQualityBicubic;
            g.SmoothingMode = SmoothingMode.None; //抗锯齿
            g.InterpolationMode = InterpolationMode.HighQualityBicubic; //高质量的双三次插值
            g.CompositingQuality = CompositingQuality.HighQuality; //高质量、低速度复合
            //绘制图像
            g.DrawImage(image, 0, 0, destWidth, destHeight);
            g.Dispose();
            return (System.Drawing.Image)b;
        }

        /// <summary>
        /// 直接Resize到给定大小
        /// </summary>
        /// <param name="input"></param>
        /// <param name="targetWidth"></param>
        /// <param name="targetHeight"></param>
        /// <returns></returns>
        public Bitmap Resize(Bitmap input, int targetWidth, int targetHeight)
        {
            try
            {
                var actualBitmap = new Bitmap(targetWidth, targetHeight);

                var g = Graphics.FromImage(actualBitmap);
                g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic; //设定插值方式

                g.DrawImage(input,
                    new Rectangle(0, 0, targetWidth, targetHeight),
                    new Rectangle(0, 0, input.Width, input.Height),
                    GraphicsUnit.Pixel);
                g.Dispose();
                return actualBitmap;
            }
            catch (Exception ex)
            {
                return null;
            }
        }

        /// <summary>
        /// 计算页数
        /// </summary>
        public void CaculatePrintedPageCount()
        {
            PrintedPageCount = PrintSettingsInfo.PageRangeList.Count;
            if (PrintSettingsInfo.PrintModInfo.EnumPrintMod == EnumPrintMod.StatusMultiple)
            {
                MultipleInfo multipleInfo = (MultipleInfo)PrintSettingsInfo.PrintModInfo;
                if (PrintedPageCount % (multipleInfo.HorizontalPageNumber * multipleInfo.VerticalPageNumber) != 0)
                {
                    PrintedPageCount = PrintedPageCount / (multipleInfo.HorizontalPageNumber * multipleInfo.VerticalPageNumber) + 1;
                }
                else
                {
                    PrintedPageCount = PrintedPageCount / (multipleInfo.HorizontalPageNumber * multipleInfo.VerticalPageNumber);
                }
            }
            else if (PrintSettingsInfo.PrintModInfo.EnumPrintMod == EnumPrintMod.StatusBooklet)
            {
                BookletInfo bookletInfo = (BookletInfo)PrintSettingsInfo.PrintModInfo;
                if (PrintedPageCount == 1)
                {
                    PrintedPageCount = 1;
                }
                else
                {
                    PrintedPageCount = (bookletInfo.EndPaperIndex - bookletInfo.BeginPaperIndex + 1) * 2;
                    if (bookletInfo.EnumBookletSubset == EnumBookletSubset.StatusFrontSideOnly ||
                        bookletInfo.EnumBookletSubset == EnumBookletSubset.StatusBackSideOnly)
                    {
                        PrintedPageCount /= 2;
                    }
                }
            }
        }

        /// <summary>
        /// 转灰度
        /// </summary>
        /// <param name="bmp"></param>
        /// <param name="mode"></param>
        /// <returns></returns>
        private Bitmap ToGray(Bitmap bmp, int mode)
        {
            if (bmp == null)
            {
                return null;
            }

            int w = bmp.Width;
            int h = bmp.Height;
            try
            {
                byte newColor = 0;
                BitmapData srcData = bmp.LockBits(new Rectangle(0, 0, w, h), ImageLockMode.ReadWrite, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
                unsafe
                {
                    byte* p = (byte*)srcData.Scan0.ToPointer();
                    for (int y = 0; y < h; y++)
                    {
                        for (int x = 0; x < w; x++)
                        {

                            if (mode == 0) // 加权平均
                            {
                                newColor = (byte)((float)p[0] * 0.114f + (float)p[1] * 0.587f + (float)p[2] * 0.299f);
                            }
                            else    // 算数平均
                            {
                                newColor = (byte)((float)(p[0] + p[1] + p[2]) / 3.0f);
                            }
                            p[0] = newColor;
                            p[1] = newColor;
                            p[2] = newColor;

                            p += 3;
                        }
                        p += srcData.Stride - w * 3;
                    }
                    bmp.UnlockBits(srcData);
                    return bmp;
                }
            }
            catch
            {
                return null;
            }
        }

        /// <summary>
        /// 合并底图和前景
        /// </summary>
        /// <param name="background"></param>
        /// <param name="foreground"></param>
        /// <param name="point"></param>
        /// <returns></returns>
        public Bitmap CombineBitmap(Bitmap background, Bitmap foreground, System.Drawing.Point point)
        {
            if (background == null)
            {
                return null;
            }
            int bgWidth = background.Width;
            int bgHeight = background.Height;
            int fgWidth = foreground.Width;
            int fgHeight = foreground.Height;
            Bitmap newMap = new Bitmap(bgWidth, bgHeight);
            Graphics graphics = Graphics.FromImage(newMap);
            graphics.DrawImage(background, new System.Drawing.Point(0, 0));
            graphics.DrawImage(foreground, point);
            graphics.Dispose();
            return newMap;
        }

        /// <summary>
        /// size模式
        /// </summary>
        /// <param name="paperIndex"></param>
        private async void PreviewModSize(int paperIndex)
        {
            SizeInfo sizeInfo = (SizeInfo)PrintSettingsInfo.PrintModInfo;
            CPDFPage cPDFPage = PDFViewer.Document.PageAtIndex(PrintSettingsInfo.PageRangeList[paperIndex]);
            System.Drawing.Point startPoint = new System.Drawing.Point(0, 0);
            if (cPDFPage != null)
            {
                Bitmap printBitmap = new Bitmap((int)(float.Parse(PaperWidth)), (int)float.Parse(PaperHeight));
                Bitmap bitmap = await ToolMethod.RenderPageBitmap(PDFViewer.Document, (int)(cPDFPage.PageSize.Width * PDFToMediaDpiRatio), (int)(cPDFPage.PageSize.Height * PDFToMediaDpiRatio), PrintSettingsInfo.PageRangeList[paperIndex], PrintSettingsInfo.IsPrintWithAnnot, PrintSettingsInfo.IsPrintWithForm);
                if (PrintSettingsInfo.IsGrayscale)
                {
                    bitmap = ToGray(bitmap, 0);
                }
                ///<summary>
                ///自适应模式
                /// </summary>
                if (sizeInfo.EnumSizeType == EnumSizeType.StatusAdaptive)
                {
                    int resizedHeight = 0;
                    int resizedWidth = 0;
                    ///重设大小
                    if ((float)bitmap.Height / (float)bitmap.Width >= (float.Parse(PaperHeight) / float.Parse(PaperWidth)))
                    {
                        resizedHeight = (int)(float.Parse(PaperHeight) * mmToDpiRatio);
                        resizedWidth = (int)((float.Parse(PaperHeight) / bitmap.Height * bitmap.Width) * mmToDpiRatio);
                    }
                    else
                    {
                        resizedWidth = (int)(float.Parse(PaperWidth) * mmToDpiRatio);
                        resizedHeight = (int)((float.Parse(PaperWidth) / bitmap.Width * bitmap.Height) * mmToDpiRatio);
                    }
                    bitmap = Resize(bitmap, resizedWidth, resizedHeight);
                    startPoint.X = (blankPageBitmap.Width - resizedWidth) / 2;
                    startPoint.Y = (blankPageBitmap.Height - resizedHeight) / 2;
                    printBitmap = CombineBitmap(blankPageBitmap, bitmap, startPoint);
                    BitmapSource = ToBitmapSource(printBitmap);
                }
                else if (sizeInfo.EnumSizeType == EnumSizeType.StatusActural)
                {
                    startPoint.X = (blankPageBitmap.Width - bitmap.Width) / 2;
                    startPoint.Y = (blankPageBitmap.Height - bitmap.Height) / 2;
                    printBitmap = CombineBitmap(blankPageBitmap, bitmap, startPoint);
                    BitmapSource = ToBitmapSource(printBitmap);
                }
                else if (sizeInfo.EnumSizeType == EnumSizeType.StatusCustomized)
                {
                    bitmap = Resize(bitmap, (int)(bitmap.Width * (sizeInfo.DisplayRatio / 100.0)), (int)(bitmap.Height * (sizeInfo.DisplayRatio / 100.0)));
                    startPoint.X = (blankPageBitmap.Width - bitmap.Width) / 2;
                    startPoint.Y = (blankPageBitmap.Height - bitmap.Height) / 2;
                    printBitmap = CombineBitmap(blankPageBitmap, bitmap, startPoint);
                    BitmapSource = ToBitmapSource(printBitmap);
                }
                bitmap.Dispose();
                printBitmap.Dispose();
            }
        }

        /// <summary>
        /// 海报模式
        /// </summary>
        /// <param name="paperIndex"></param>
        private async void PreviewModPoster(int paperIndex)
        {
            PosterInfo posterInfo = (PosterInfo)PrintSettingsInfo.PrintModInfo;
            CPDFPage cPDFPage = PDFViewer.Document.PageAtIndex(PrintSettingsInfo.PageRangeList[paperIndex]);
            double PreviewHeight = 0;
            double PreviewWidth = 0;
            System.Drawing.Point startPoint = new System.Drawing.Point(0, 0);
            Bitmap displayBitmap = null;
            double effectiveHeight;
            double effectiveWidth;
            //计算有效打印区域
            if (PrintSettingsInfo.EnumPrintOrientation == EnumPrintOrientation.StatusPortrait)
            {
                effectiveHeight = documentSettingsInfo.DocumentHeight;
                effectiveWidth = documentSettingsInfo.DocumentWidth;
            }
            else
            {
                effectiveHeight = documentSettingsInfo.DocumentWidth;
                effectiveWidth = documentSettingsInfo.DocumentHeight;
            }

            //重叠
            effectiveHeight = effectiveHeight - 2 * posterInfo.OverLap * 100 / 25.4;
            effectiveWidth = effectiveWidth - 2 * posterInfo.OverLap * 100 / 25.4;
            if (posterInfo.HasCutMarks || posterInfo.HasLabel)
            {
                ///如果边距小于预留尺寸
                effectiveHeight = effectiveHeight - 40;
                effectiveWidth = effectiveWidth - 40;
            }

            if (cPDFPage != null)
            {
                //平铺模式
                //根据页面大小，按最大有效打印区域划分为多块
                //最大有效区域
                //纸张大小-标记标签-重叠
                if (posterInfo.EnumPosterMod == EnumPosterMod.StatusTile)
                {
                    Bitmap bitmap;
                    //TODO 放大倍数过高引起超限
                    try
                    {
                        bitmap = await ToolMethod.RenderPageBitmap(PDFViewer.Document, (int)(cPDFPage.PageSize.Width * PDFToMediaDpiRatio * (posterInfo.TileRatio / 100.0)), (int)(cPDFPage.PageSize.Height * PDFToMediaDpiRatio * (posterInfo.TileRatio / 100.0)), PrintSettingsInfo.PageRangeList[paperIndex], PrintSettingsInfo.IsPrintWithAnnot, PrintSettingsInfo.IsPrintWithForm);
                    }
                    catch
                    {
                        bitmap = await ToolMethod.RenderPageBitmap(PDFViewer.Document, (int)(cPDFPage.PageSize.Width * PDFToMediaDpiRatio), (int)(cPDFPage.PageSize.Height * PDFToMediaDpiRatio), PrintSettingsInfo.PageRangeList[paperIndex], PrintSettingsInfo.IsPrintWithAnnot, PrintSettingsInfo.IsPrintWithForm);
                    }
                    HorizonPaperCount = (int)Math.Ceiling((double)bitmap.Width / effectiveWidth);
                    VerticalPaperCount = (int)Math.Ceiling(((double)bitmap.Height / effectiveHeight));
                    PreviewWidth = (double)(effectiveWidth * HorizonPaperCount);
                    PreviewHeight = (double)(effectiveHeight * VerticalPaperCount);
                    //铺放纸张
                    SetViewBox(PreviewHeight, PreviewWidth);
                    //创建空白图像，大小等于纸张铺放后
                    displayBitmap = new Bitmap((int)PreviewWidth, (int)PreviewHeight);
                    //居中合并
                    startPoint.X = (int)((PreviewWidth - bitmap.Width) / 2);
                    startPoint.Y = (int)((PreviewHeight - bitmap.Height) / 2);
                    if (PrintSettingsInfo.IsGrayscale)
                    {
                        bitmap = ToGray(bitmap, 0);
                    }
                    displayBitmap = CombineBitmap(displayBitmap, bitmap, startPoint);
                    //画线
                    Graphics g = Graphics.FromImage(displayBitmap);
                    if (HorizonPaperCount > 1)
                    {
                        for (int tempX = 1; tempX < HorizonPaperCount; tempX++)
                        {
                            int horizonLocate = (int)(tempX * displayBitmap.Width / HorizonPaperCount);
                            g.DrawLine(new Pen(Color.Gray, HorizonPaperCount * 2), new System.Drawing.Point(horizonLocate, 0), new System.Drawing.Point(horizonLocate, (int)PreviewHeight));

                        }
                    }
                    if (VerticalPaperCount > 1)
                    {
                        for (int tempY = 1; tempY < VerticalPaperCount; tempY++)
                        {
                            int verticalLocate = (int)(tempY * displayBitmap.Height / VerticalPaperCount);

                            g.DrawLine(new Pen(Color.Gray, VerticalPaperCount * 2), new System.Drawing.Point(0, verticalLocate), new System.Drawing.Point((int)PreviewWidth, verticalLocate));
                        }
                    }
                    g.Dispose();
                    bitmap.Dispose();
                    PosterRatio = posterInfo.TileRatio / 100.0;
                }
                //拆分模式
                else if (posterInfo.EnumPosterMod == EnumPosterMod.StatusSplit)
                {
                    HorizonPaperCount = posterInfo.HorizontalSheetNumber;
                    VerticalPaperCount = posterInfo.VerticalSheetNumber;
                    PreviewWidth = (double)(documentSettingsInfo.DocumentWidth * HorizonPaperCount);
                    PreviewHeight = (double)(documentSettingsInfo.DocumentHeight * VerticalPaperCount);
                    //铺放纸张
                    SetViewBox(PreviewHeight, PreviewWidth);
                    //创建空白图像，大小等于纸张铺放后
                    displayBitmap = new Bitmap((int)PreviewWidth, (int)PreviewHeight);
                    //文件根据有效范围缩放
                    double wholeEffectiveHeight = effectiveHeight * VerticalPaperCount;
                    double wholeEffectiveWidth = effectiveWidth * HorizonPaperCount;
                    double resizedHeight = 0;
                    double resizedWidth = 0;
                    if ((cPDFPage.PageSize.Height / cPDFPage.PageSize.Width) >= wholeEffectiveHeight / wholeEffectiveWidth)
                    {
                        resizedHeight = wholeEffectiveHeight;
                        resizedWidth = wholeEffectiveHeight / cPDFPage.PageSize.Height * cPDFPage.PageSize.Width;
                    }
                    else
                    {
                        resizedWidth = wholeEffectiveWidth;
                        resizedHeight = wholeEffectiveWidth / cPDFPage.PageSize.Width * cPDFPage.PageSize.Height;
                    }
                    PosterRatio = resizedWidth / cPDFPage.PageSize.Width;
                    Bitmap bitmap = await ToolMethod.RenderPageBitmap(PDFViewer.Document, (int)resizedWidth, (int)resizedHeight, PrintSettingsInfo.PageRangeList[paperIndex], PrintSettingsInfo.IsPrintWithAnnot, PrintSettingsInfo.IsPrintWithForm);
                    startPoint.X = (int)((PreviewWidth - bitmap.Width) / 2);
                    startPoint.Y = (int)((PreviewHeight - bitmap.Height) / 2);
                    if (PrintSettingsInfo.IsGrayscale)
                    {
                        bitmap = ToGray(bitmap, 0);
                    }
                    displayBitmap = CombineBitmap(displayBitmap, bitmap, startPoint);
                    //画线
                    Graphics g = Graphics.FromImage(displayBitmap);
                    if (HorizonPaperCount > 1)
                    {
                        for (int tempX = 1; tempX < HorizonPaperCount; tempX++)
                        {
                            int horizonLocate = (int)(tempX * displayBitmap.Width / HorizonPaperCount);
                            g.DrawLine(new Pen(Color.Gray, HorizonPaperCount * 2), new System.Drawing.Point(horizonLocate, 0), new System.Drawing.Point(horizonLocate, (int)PreviewHeight));
                        }
                    }
                    if (VerticalPaperCount > 1)
                    {
                        for (int tempY = 1; tempY < VerticalPaperCount; tempY++)
                        {
                            int verticalLocate = (int)(tempY * displayBitmap.Height / VerticalPaperCount);
                            g.DrawLine(new Pen(Color.Gray, VerticalPaperCount * 2), new System.Drawing.Point(0, verticalLocate), new System.Drawing.Point((int)PreviewWidth, verticalLocate));
                        }
                    }
                    g.Dispose();
                    bitmap.Dispose();
                }
            }
            BitmapSource = ToBitmapSource(displayBitmap);
            displayBitmap.Dispose();
        }

        /// <summary>
        /// 多页
        /// </summary>
        /// <param name="paperIndex"></param>
        private async void PreviewModMultiple(int paperIndex)
        {
            MultipleInfo multipleInfo = (MultipleInfo)PrintSettingsInfo.PrintModInfo;
            int singlePageHeight;
            int singlePageWidth;
            Bitmap printBitmap;
            int currentPage = 0;
            if (PrintSettingsInfo.EnumPrintOrientation == EnumPrintOrientation.StatusPortrait)
            {
                singlePageHeight = (int)(documentSettingsInfo.DocumentHeight / multipleInfo.VerticalPageNumber);
                singlePageWidth = (int)(documentSettingsInfo.DocumentWidth / multipleInfo.HorizontalPageNumber);
                printBitmap = new Bitmap((int)documentSettingsInfo.DocumentWidth, (int)documentSettingsInfo.DocumentHeight);
            }
            else
            {
                singlePageHeight = (int)(documentSettingsInfo.DocumentWidth / multipleInfo.VerticalPageNumber);
                singlePageWidth = (int)(documentSettingsInfo.DocumentHeight / multipleInfo.HorizontalPageNumber);
                printBitmap = new Bitmap((int)documentSettingsInfo.DocumentHeight, (int)documentSettingsInfo.DocumentWidth);
            }
            System.Drawing.Point startPoint = new System.Drawing.Point(0, 0);

            int startPage = PrintSettingsInfo.PageRangeList[paperIndex * (multipleInfo.VerticalPageNumber) * (multipleInfo.HorizontalPageNumber)];
            int resizedHeight = 0;
            int resizedWidth = 0;
            bool isNoSrcPage = false;
            Bitmap pageBitmap;
            ///水平：横向排列，先横后纵，纵轴不变横轴翻转
            if (multipleInfo.EnumPageOrder == EnumPageOrder.StatusHorizontalOrder || multipleInfo.EnumPageOrder == EnumPageOrder.StatusHorizontalReverseOrder)
            {
                for (int tempVerticalIndex = 0; tempVerticalIndex < multipleInfo.VerticalPageNumber; tempVerticalIndex++)
                {
                    startPoint.Y = tempVerticalIndex * singlePageHeight;
                    for (int tempHorizontalIndex = 0; tempHorizontalIndex < multipleInfo.HorizontalPageNumber; tempHorizontalIndex++)
                    {
                        try
                        {
                            currentPage =
      PrintSettingsInfo.PageRangeList[paperIndex *
      (multipleInfo.VerticalPageNumber) *
      (multipleInfo.HorizontalPageNumber) +
      (tempVerticalIndex * multipleInfo.HorizontalPageNumber) +
      tempHorizontalIndex];
                        }
                        catch
                        {
                            break;
                        }

                        //横向
                        if (multipleInfo.EnumPageOrder == EnumPageOrder.StatusHorizontalOrder)
                        {
                            startPoint.X = tempHorizontalIndex * singlePageWidth;
                        }
                        //横向倒序
                        else
                        {
                            startPoint.X = (multipleInfo.HorizontalPageNumber - tempHorizontalIndex - 1) * singlePageWidth;
                        }
                        CPDFPage cPDFPage = PDFViewer.Document.PageAtIndex(currentPage);
                        if (cPDFPage == null)
                        {
                            isNoSrcPage = true;
                            break;
                        }
                        pageBitmap = await ToolMethod.RenderPageBitmap(PDFViewer.Document, (int)(cPDFPage.PageSize.Width), (int)(cPDFPage.PageSize.Height), currentPage, PrintSettingsInfo.IsPrintWithAnnot, PrintSettingsInfo.IsPrintWithForm);
                        if (multipleInfo.IsAutoRotate)
                        {
                            if ((cPDFPage.PageSize.Height / cPDFPage.PageSize.Width > 1 && (double)singlePageHeight / singlePageWidth < 1) ||
    (cPDFPage.PageSize.Height / cPDFPage.PageSize.Width < 1 && (double)singlePageHeight / singlePageWidth > 1))
                            {
                                pageBitmap = ToolMethod.RenderPageBitmapNoWait(PDFViewer.Document, (int)(cPDFPage.PageSize.Width), (int)(cPDFPage.PageSize.Height), currentPage, PrintSettingsInfo.IsPrintWithAnnot, PrintSettingsInfo.IsPrintWithForm);
                                pageBitmap.RotateFlip(RotateFlipType.Rotate270FlipNone);
                            }
                        }
                        ///重设大小
                        if ((float)pageBitmap.Height / (float)pageBitmap.Width >= ((float)singlePageHeight / (float)singlePageWidth))
                        {
                            resizedHeight = (int)(singlePageHeight * 0.96);
                            resizedWidth = (int)((float)singlePageHeight / pageBitmap.Height * pageBitmap.Width * 0.96);
                        }
                        else
                        {
                            resizedWidth = (int)(singlePageWidth * 0.96);
                            resizedHeight = (int)((float)singlePageWidth / pageBitmap.Width * pageBitmap.Height * 0.96);
                        }
                        pageBitmap = Resize(pageBitmap, (int)resizedWidth, (int)resizedHeight);


                        startPoint.X += (singlePageWidth - resizedWidth) / 2;
                        startPoint.Y += (singlePageHeight - resizedHeight) / 2;
                        if (PrintSettingsInfo.IsGrayscale)
                        {
                            pageBitmap = ToGray(pageBitmap, 0);
                        }
                        printBitmap = CombineBitmap(printBitmap, pageBitmap, startPoint);
                        //绘制边界
                        if (PrintSettingsInfo.IsPrintPageBorde)
                        {
                            using (Pen pen = new Pen(Color.Black, 4))
                            {
                                Graphics g = Graphics.FromImage(printBitmap);
                                g.DrawRectangle(pen, new Rectangle(startPoint.X, startPoint.Y, resizedWidth, resizedHeight));
                                g.Dispose();
                            }
                        }
                        startPoint.Y -= (singlePageHeight - resizedHeight) / 2;
                    }
                    if (isNoSrcPage)
                    {
                        isNoSrcPage = false;
                        break;
                    }
                }
            }
            //垂直：纵向排列，先纵后横，纵轴不变横轴翻转
            else
            {
                for (int tempHorizontalIndex = 0; tempHorizontalIndex < multipleInfo.HorizontalPageNumber; tempHorizontalIndex++)
                {
                    //纵向，垂直排列时先移位
                    if (multipleInfo.EnumPageOrder == EnumPageOrder.StatusVerticalOrder)
                    {
                        startPoint.X = tempHorizontalIndex * singlePageWidth;
                    }
                    //纵向倒序
                    else
                    {
                        startPoint.X = (multipleInfo.HorizontalPageNumber - tempHorizontalIndex - 1) * singlePageWidth;
                    }
                    for (int tempVerticalIndex = 0; tempVerticalIndex < multipleInfo.VerticalPageNumber; tempVerticalIndex++)
                    {
                        startPoint.Y = tempVerticalIndex * singlePageHeight;
                        try
                        {
                            currentPage = PrintSettingsInfo.PageRangeList[paperIndex *
                          (multipleInfo.VerticalPageNumber) *
                          (multipleInfo.HorizontalPageNumber) +
                          (tempHorizontalIndex * multipleInfo.VerticalPageNumber) +
                          tempVerticalIndex];
                        }
                        catch
                        {
                            break;
                        }

                        CPDFPage cPDFPage = PDFViewer.Document.PageAtIndex(currentPage);
                        if (cPDFPage == null)
                        {
                            isNoSrcPage = true;
                            break;
                        }
                        pageBitmap = await ToolMethod.RenderPageBitmap(PDFViewer.Document, (int)(cPDFPage.PageSize.Width), (int)(cPDFPage.PageSize.Height), currentPage, PrintSettingsInfo.IsPrintWithAnnot, PrintSettingsInfo.IsPrintWithForm);
                        if (multipleInfo.IsAutoRotate)
                        {
                            if ((cPDFPage.PageSize.Height / cPDFPage.PageSize.Width > 1 && (double)singlePageHeight / singlePageWidth < 1) ||
    (cPDFPage.PageSize.Height / cPDFPage.PageSize.Width < 1 && (double)singlePageHeight / singlePageWidth > 1))
                            {
                                pageBitmap.RotateFlip(RotateFlipType.Rotate270FlipNone);
                            }
                        }
                        Graphics graphics = Graphics.FromImage(pageBitmap);
                        ///重设大小
                        if ((float)pageBitmap.Height / (float)pageBitmap.Width >= ((float)singlePageHeight / (float)singlePageWidth))
                        {
                            resizedHeight = (int)(singlePageHeight * 0.96);
                            resizedWidth = (int)((float)singlePageHeight / pageBitmap.Height * pageBitmap.Width * 0.96);
                        }
                        else
                        {
                            resizedWidth = (int)(singlePageWidth * 0.96);
                            resizedHeight = (int)((float)singlePageWidth / pageBitmap.Width * pageBitmap.Height * 0.96);
                        }
                        pageBitmap = Resize(pageBitmap, (int)resizedWidth, (int)resizedHeight);

                        graphics.Dispose();
                        startPoint.X += (singlePageWidth - resizedWidth) / 2;
                        startPoint.Y += (singlePageHeight - resizedHeight) / 2;
                        if (PrintSettingsInfo.IsGrayscale)
                        {
                            pageBitmap = ToGray(pageBitmap, 0);
                        }
                        printBitmap = CombineBitmap(printBitmap, pageBitmap, startPoint);

                        //绘制边界
                        if (PrintSettingsInfo.IsPrintPageBorde)
                        {
                            using (Pen pen = new Pen(Color.Black, 4))
                            {
                                Graphics g = Graphics.FromImage(printBitmap);
                                g.DrawRectangle(pen, new Rectangle(startPoint.X, startPoint.Y, resizedWidth, resizedHeight));
                                g.Dispose();
                            }
                        }
                        startPoint.X -= (singlePageWidth - resizedWidth) / 2;
                    }
                    if (isNoSrcPage)
                    {
                        isNoSrcPage = false;
                        break;
                    }
                }
            }
            WholePaperCountModPoster = PrintedPageCount * HorizonPaperCount * VerticalPaperCount;
            BitmapSource = ToBitmapSource(printBitmap);
        }

        /// <summary>
        /// 小册子模式
        /// </summary>
        /// <param name="paperIndex"></param>
        private async void PreviewModBooklet(int paperIndex)
        {
            BookletInfo bookletInfo = (BookletInfo)PrintSettingsInfo.PrintModInfo;
            ///空白画布
            Bitmap printBitmap;
            double singlePageHeight = 0;
            double singlePageWidth = 0;
            if (PrintSettingsInfo.EnumPrintOrientation == EnumPrintOrientation.StatusPortrait)
            {
                printBitmap = new Bitmap((int)documentSettingsInfo.DocumentWidth, (int)documentSettingsInfo.DocumentHeight);
                singlePageHeight = (double)documentSettingsInfo.DocumentHeight;
                singlePageWidth = (double)(documentSettingsInfo.DocumentWidth / 2);
            }
            else
            {
                printBitmap = new Bitmap((int)documentSettingsInfo.DocumentHeight, (int)documentSettingsInfo.DocumentWidth);
                singlePageHeight = (double)documentSettingsInfo.DocumentWidth;
                singlePageWidth = (double)(documentSettingsInfo.DocumentHeight / 2);
            }
            System.Drawing.Point startPoint = new System.Drawing.Point(0, 0);
            int maxPaperNumber = (PDFViewer.Document.PageCount % 4 == 0) ? (PDFViewer.Document.PageCount / 4) : (PDFViewer.Document.PageCount / 4 + 1);
            Bitmap leftBitmap = null;
            Bitmap rightBitmap = null;
            double resizedHeight = 0;
            double resizedWidth = 0;
            CPDFPage leftPage = null;
            CPDFPage rightPage = null;
            int leftPageIndex = 0;
            int rightPageIndex = 0;

            ///<summary>
            ///左装订与右装订顺序相反
            /// </summary>
            if (bookletInfo.EnumBookletBinding == EnumBookletBinding.StatusLeft)
            {
                ///奇数页：
                ///右面为页面序号
                ///左面为[（总打印纸数*4）+1-打印页右侧页序号]
                if ((paperIndex + 1) % 2 == 1)
                {
                    try
                    {
                        leftPageIndex = PrintSettingsInfo.PageRangeList[maxPaperNumber * 4 - paperIndex - 1];
                        leftPage = PDFViewer.Document.PageAtIndex(leftPageIndex);
                    }
                    catch
                    {
                        leftPage = null;
                    }
                    rightPageIndex = PrintSettingsInfo.PageRangeList[paperIndex];
                    //左面
                    if (leftPage != null)
                    {
                        leftBitmap = await ToolMethod.RenderPageBitmap(PDFViewer.Document, (int)leftPage.PageSize.Width, (int)leftPage.PageSize.Height, leftPageIndex, PrintSettingsInfo.IsPrintWithAnnot, PrintSettingsInfo.IsPrintWithForm);
                        if (bookletInfo.IsAutoRotate)
                        {
                            if ((leftPage.PageSize.Height / leftPage.PageSize.Width > 1 && (double)singlePageHeight / singlePageWidth < 1) ||
    (leftPage.PageSize.Height / leftPage.PageSize.Width < 1 && (double)singlePageHeight / singlePageWidth > 1))
                            {
                                leftBitmap.RotateFlip(RotateFlipType.Rotate270FlipNone);
                            }
                        }
                        ///重设大小
                        if ((leftBitmap.Height / leftBitmap.Width) >= singlePageHeight / singlePageWidth)
                        {
                            resizedHeight = singlePageHeight * 0.96;
                            resizedWidth = singlePageHeight / leftBitmap.Height * leftBitmap.Width * 0.96;
                        }
                        else
                        {
                            resizedWidth = singlePageWidth * 0.96;
                            resizedHeight = singlePageWidth / leftBitmap.Width * leftBitmap.Height * 0.96;
                        }
                        leftBitmap = Resize(leftBitmap, (int)(resizedWidth), (int)(resizedHeight));
                        startPoint.X = (int)(singlePageWidth - resizedWidth) / 2;
                        startPoint.Y = (int)(singlePageHeight - resizedHeight) / 2;
                        if (PrintSettingsInfo.IsGrayscale)
                        {
                            leftBitmap = ToGray(leftBitmap, 0);
                        }
                        printBitmap = CombineBitmap(printBitmap, leftBitmap, startPoint);
                    }
                    //右面
                    rightPage = PDFViewer.Document.PageAtIndex(rightPageIndex);
                    startPoint.X = (int)singlePageWidth;
                    if (rightPage != null)
                    {
                        rightBitmap = await ToolMethod.RenderPageBitmap(PDFViewer.Document, (int)rightPage.PageSize.Width, (int)rightPage.PageSize.Height, rightPageIndex, PrintSettingsInfo.IsPrintWithAnnot, PrintSettingsInfo.IsPrintWithForm);
                        if (bookletInfo.IsAutoRotate)
                        {
                            if ((rightPage.PageSize.Height / rightPage.PageSize.Width > 1 && (double)singlePageHeight / singlePageWidth < 1) ||
    (rightPage.PageSize.Height / rightPage.PageSize.Width < 1 && (double)singlePageHeight / singlePageWidth > 1))
                            {
                                rightBitmap.RotateFlip(RotateFlipType.Rotate270FlipNone);
                            }
                        }
                        ///重设大小
                        if ((rightBitmap.Height / rightBitmap.Width) >= singlePageHeight / singlePageWidth)
                        {
                            resizedHeight = singlePageHeight * 0.96;
                            resizedWidth = singlePageHeight / rightBitmap.Height * rightBitmap.Width * 0.96;
                        }
                        else
                        {
                            resizedWidth = singlePageWidth * 0.96;
                            resizedHeight = singlePageWidth / rightBitmap.Width * rightBitmap.Height * 0.96;
                        }
                        rightBitmap = Resize(rightBitmap, (int)(resizedWidth), (int)(resizedHeight));
                        startPoint.X += (int)(singlePageWidth - resizedWidth) / 2;
                        startPoint.Y = (int)(singlePageHeight - resizedHeight) / 2;
                        if (PrintSettingsInfo.IsGrayscale)
                        {
                            rightBitmap = ToGray(rightBitmap, 0);
                        }
                        printBitmap = CombineBitmap(printBitmap, rightBitmap, startPoint);
                        if (PrintSettingsInfo.IsPrintPageBorde)
                        {
                            using (Pen pen = new Pen(Color.Black, 4))
                            {
                                Graphics g = Graphics.FromImage(printBitmap);
                                g.DrawRectangle(pen, new Rectangle(startPoint.X, startPoint.Y, (int)resizedWidth, (int)resizedHeight));
                                g.Dispose();
                            }
                        }
                    }
                }
                /// 偶数页：
                /// 左面为页面序号
                /// 右面为[（总打印纸数*4）+1-打印页右侧页序号]
                else
                {
                    try
                    {
                        leftPageIndex = PrintSettingsInfo.PageRangeList[paperIndex];
                        leftPage = PDFViewer.Document.PageAtIndex(leftPageIndex);

                    }
                    catch
                    {
                        leftPage = null;
                    }
                    //左面
                    if (leftPage != null)
                    {
                        leftBitmap = await ToolMethod.RenderPageBitmap(PDFViewer.Document, (int)leftPage.PageSize.Width, (int)leftPage.PageSize.Height, leftPageIndex, PrintSettingsInfo.IsPrintWithAnnot, PrintSettingsInfo.IsPrintWithForm);
                        if (bookletInfo.IsAutoRotate)
                        {
                            if ((leftPage.PageSize.Height / leftPage.PageSize.Width > 1 && (double)singlePageHeight / singlePageWidth < 1) ||
    (leftPage.PageSize.Height / leftPage.PageSize.Width < 1 && (double)singlePageHeight / singlePageWidth > 1))
                            {
                                leftBitmap.RotateFlip(RotateFlipType.Rotate270FlipNone);
                            }
                        }
                        ///重设大小
                        if ((leftBitmap.Height / leftBitmap.Width) >= singlePageHeight / singlePageWidth)
                        {
                            resizedHeight = singlePageHeight * 0.96;
                            resizedWidth = singlePageHeight / leftBitmap.Height * leftBitmap.Width * 0.96;
                        }
                        else
                        {
                            resizedWidth = singlePageWidth * 0.96;
                            resizedHeight = singlePageWidth / leftBitmap.Width * leftBitmap.Height * 0.96;
                        }
                        leftBitmap = Resize(leftBitmap, (int)(resizedWidth), (int)(resizedHeight));
                        startPoint.X = (int)(singlePageWidth - resizedWidth) / 2;
                        startPoint.Y = (int)(singlePageHeight - resizedHeight) / 2;
                        if (PrintSettingsInfo.IsGrayscale)
                        {
                            leftBitmap = ToGray(leftBitmap, 0);
                        }
                        printBitmap = CombineBitmap(printBitmap, leftBitmap, startPoint);
                        if (PrintSettingsInfo.IsPrintPageBorde)
                        {
                            using (Pen pen = new Pen(Color.Black, 4))
                            {
                                Graphics g = Graphics.FromImage(printBitmap);
                                g.DrawRectangle(pen, new Rectangle(startPoint.X, startPoint.Y, (int)resizedWidth, (int)resizedHeight));
                                g.Dispose();
                            }
                        }
                    }
                    //右面
                    try
                    {
                        rightPageIndex = PrintSettingsInfo.PageRangeList[maxPaperNumber * 4 - 1 - paperIndex];
                        rightPage = PDFViewer.Document.PageAtIndex(rightPageIndex);
                    }
                    catch
                    {
                        rightPage = null;
                    }
                    startPoint.X = (int)singlePageWidth;
                    if (rightPage != null)
                    {
                        ///重设大小
                        rightBitmap = await ToolMethod.RenderPageBitmap(PDFViewer.Document, (int)rightPage.PageSize.Width, (int)rightPage.PageSize.Height, rightPageIndex, PrintSettingsInfo.IsPrintWithAnnot, PrintSettingsInfo.IsPrintWithForm);
                        if (bookletInfo.IsAutoRotate)
                        {
                            if ((rightPage.PageSize.Height / rightPage.PageSize.Width > 1 && (double)singlePageHeight / singlePageWidth < 1) ||
    (rightPage.PageSize.Height / rightPage.PageSize.Width < 1 && (double)singlePageHeight / singlePageWidth > 1))
                            {
                                rightBitmap.RotateFlip(RotateFlipType.Rotate270FlipNone);
                            }
                        }
                        ///重设大小
                        if ((rightBitmap.Height / rightBitmap.Width) >= singlePageHeight / singlePageWidth)
                        {
                            resizedHeight = singlePageHeight * 0.96;
                            resizedWidth = singlePageHeight / rightBitmap.Height * rightBitmap.Width * 0.96;
                        }
                        else
                        {
                            resizedWidth = singlePageWidth * 0.96;
                            resizedHeight = singlePageWidth / rightBitmap.Width * rightBitmap.Height * 0.96;
                        }
                        rightBitmap = Resize(rightBitmap, (int)(resizedWidth), (int)(resizedHeight));
                        startPoint.X += (int)(singlePageWidth - resizedWidth) / 2;
                        startPoint.Y = (int)(singlePageHeight - resizedHeight) / 2;
                        if (PrintSettingsInfo.IsGrayscale)
                        {
                            rightBitmap = ToGray(rightBitmap, 0);
                        }
                        printBitmap = CombineBitmap(printBitmap, rightBitmap, startPoint);
                        if (PrintSettingsInfo.IsPrintPageBorde)
                        {
                            using (Pen pen = new Pen(Color.Black, 4))
                            {
                                Graphics g = Graphics.FromImage(printBitmap);
                                g.DrawRectangle(pen, new Rectangle(startPoint.X, startPoint.Y, (int)resizedWidth, (int)resizedHeight));
                                g.Dispose();
                            }
                        }
                    }
                }
            }
            ///<summary>
            ///右装订打印
            /// </summary>
            if (bookletInfo.EnumBookletBinding == EnumBookletBinding.StatusRight)
            {
                ///奇数页：
                ///右面为页面序号
                ///左面为[（总打印纸数*4）+1-打印页右侧页序号]
                if ((paperIndex + 1) % 2 == 0)
                {
                    try
                    {
                        leftPageIndex = PrintSettingsInfo.PageRangeList[maxPaperNumber * 4 - paperIndex - 1];
                        leftPage = PDFViewer.Document.PageAtIndex(leftPageIndex);
                    }
                    catch
                    {
                        leftPage = null;
                    }
                    rightPageIndex = PrintSettingsInfo.PageRangeList[paperIndex];
                    //左面
                    if (leftPage != null)
                    {
                        leftBitmap = await ToolMethod.RenderPageBitmap(PDFViewer.Document, (int)leftPage.PageSize.Width, (int)leftPage.PageSize.Height, leftPageIndex, PrintSettingsInfo.IsPrintWithAnnot, PrintSettingsInfo.IsPrintWithForm);
                        if (bookletInfo.IsAutoRotate)
                        {
                            if ((leftPage.PageSize.Height / leftPage.PageSize.Width > 1 && (double)singlePageHeight / singlePageWidth < 1) ||
    (leftPage.PageSize.Height / leftPage.PageSize.Width < 1 && (double)singlePageHeight / singlePageWidth > 1))
                            {
                                leftBitmap.RotateFlip(RotateFlipType.Rotate270FlipNone);
                            }
                        }
                        ///重设大小
                        if ((leftBitmap.Height / leftBitmap.Width) >= singlePageHeight / singlePageWidth)
                        {
                            resizedHeight = singlePageHeight * 0.96;
                            resizedWidth = singlePageHeight / leftBitmap.Height * leftBitmap.Width * 0.96;
                        }
                        else
                        {
                            resizedWidth = singlePageWidth;
                            resizedHeight = singlePageWidth / leftBitmap.Width * leftBitmap.Height;
                        }
                        leftBitmap = Resize(leftBitmap, (int)(resizedWidth), (int)(resizedHeight));
                        startPoint.X = (int)(singlePageWidth - resizedWidth) / 2;
                        startPoint.Y = (int)(singlePageHeight - resizedHeight) / 2;
                        if (PrintSettingsInfo.IsGrayscale)
                        {
                            leftBitmap = ToGray(leftBitmap, 0);
                        }

                        printBitmap = CombineBitmap(printBitmap, leftBitmap, startPoint);
                        if (PrintSettingsInfo.IsPrintPageBorde)
                        {
                            using (Pen pen = new Pen(Color.Black, 4))
                            {
                                Graphics g = Graphics.FromImage(printBitmap);
                                g.DrawRectangle(pen, new Rectangle(startPoint.X, startPoint.Y, (int)resizedWidth, (int)resizedHeight));
                                g.Dispose();
                            }
                        }
                    }
                    //右面
                    rightPage = PDFViewer.Document.PageAtIndex(rightPageIndex);
                    startPoint.X = (int)singlePageWidth;
                    if (rightPage != null)
                    {
                        ///重设大小
                        rightBitmap = await ToolMethod.RenderPageBitmap(PDFViewer.Document, (int)rightPage.PageSize.Width, (int)rightPage.PageSize.Height, rightPageIndex, PrintSettingsInfo.IsPrintWithAnnot, PrintSettingsInfo.IsPrintWithForm);
                        if (bookletInfo.IsAutoRotate)
                        {
                            if ((rightPage.PageSize.Height / rightPage.PageSize.Width > 1 && (double)singlePageHeight / singlePageWidth < 1) ||
    (rightPage.PageSize.Height / rightPage.PageSize.Width < 1 && (double)singlePageHeight / singlePageWidth > 1))
                            {
                                rightBitmap.RotateFlip(RotateFlipType.Rotate270FlipNone);
                            }
                        }
                        ///重设大小
                        if ((rightBitmap.Height / rightBitmap.Width) >= singlePageHeight / singlePageWidth)
                        {
                            resizedHeight = singlePageHeight * 0.96;
                            resizedWidth = singlePageHeight / rightBitmap.Height * rightBitmap.Width * 0.96;
                        }
                        else
                        {
                            resizedWidth = singlePageWidth * 0.96;
                            resizedHeight = singlePageWidth / rightBitmap.Width * rightBitmap.Height * 0.96;
                        }
                        rightBitmap = Resize(rightBitmap, (int)(resizedWidth), (int)(resizedHeight));
                        startPoint.X += (int)(singlePageWidth - resizedWidth) / 2;
                        startPoint.Y = (int)(singlePageHeight - resizedHeight) / 2;
                        if (PrintSettingsInfo.IsGrayscale)
                        {
                            rightBitmap = ToGray(rightBitmap, 0);
                        }
                        printBitmap = CombineBitmap(printBitmap, rightBitmap, startPoint);
                        if (PrintSettingsInfo.IsPrintPageBorde)
                        {
                            using (Pen pen = new Pen(Color.Black, 4))
                            {
                                Graphics g = Graphics.FromImage(printBitmap);
                                g.DrawRectangle(pen, new Rectangle(startPoint.X, startPoint.Y, (int)resizedWidth, (int)resizedHeight));
                                g.Dispose();
                            }
                        }
                    }
                }
                /// 偶数页：
                /// 左面为页面序号
                /// 右面为[（总打印纸数*4）+1-打印页右侧页序号]
                else
                {
                    leftPageIndex = PrintSettingsInfo.PageRangeList[paperIndex];
                    //左面
                    leftPage = PDFViewer.Document.PageAtIndex(leftPageIndex);
                    if (leftPage != null)
                    {
                        ///重设大小
                        leftBitmap = await ToolMethod.RenderPageBitmap(PDFViewer.Document, (int)leftPage.PageSize.Width, (int)leftPage.PageSize.Height, leftPageIndex, PrintSettingsInfo.IsPrintWithAnnot, PrintSettingsInfo.IsPrintWithForm);
                        if (bookletInfo.IsAutoRotate)
                        {
                            if ((leftPage.PageSize.Height / leftPage.PageSize.Width > 1 && (double)singlePageHeight / singlePageWidth < 1) ||
    (leftPage.PageSize.Height / leftPage.PageSize.Width < 1 && (double)singlePageHeight / singlePageWidth > 1))
                            {
                                leftBitmap.RotateFlip(RotateFlipType.Rotate270FlipNone);
                            }
                        }
                        ///重设大小
                        if ((leftBitmap.Height / leftBitmap.Width) >= singlePageHeight / singlePageWidth)
                        {
                            resizedHeight = singlePageHeight * 0.96;
                            resizedWidth = singlePageHeight / leftBitmap.Height * leftBitmap.Width * 0.96;
                        }
                        else
                        {
                            resizedWidth = singlePageWidth * 0.96;
                            resizedHeight = singlePageWidth / leftBitmap.Width * leftBitmap.Height * 0.96;
                        }
                        leftBitmap = Resize(leftBitmap, (int)(resizedWidth), (int)(resizedHeight)); startPoint.X = (int)(singlePageWidth - resizedWidth) / 2;
                        startPoint.Y = (int)(singlePageHeight - resizedHeight) / 2;
                        if (PrintSettingsInfo.IsGrayscale)
                        {
                            leftBitmap = ToGray(leftBitmap, 0);
                        }
                        printBitmap = CombineBitmap(printBitmap, leftBitmap, startPoint);
                        if (PrintSettingsInfo.IsPrintPageBorde)
                        {
                            using (Pen pen = new Pen(Color.Black, 4))
                            {
                                Graphics g = Graphics.FromImage(printBitmap);
                                g.DrawRectangle(pen, new Rectangle(startPoint.X, startPoint.Y, (int)resizedWidth, (int)resizedHeight));
                                g.Dispose();
                            }
                        }
                    }
                    //右面
                    try
                    {
                        rightPageIndex = PrintSettingsInfo.PageRangeList[maxPaperNumber * 4 - 1 - paperIndex];
                        rightPage = PDFViewer.Document.PageAtIndex(rightPageIndex);
                    }
                    catch
                    {
                        rightPage = null;
                    }
                    startPoint.X = (int)singlePageWidth;
                    if (rightPage != null)
                    {
                        ///重设大小
                        rightBitmap = await ToolMethod.RenderPageBitmap(PDFViewer.Document, (int)rightPage.PageSize.Width, (int)rightPage.PageSize.Height, rightPageIndex, PrintSettingsInfo.IsPrintWithAnnot, PrintSettingsInfo.IsPrintWithForm);
                        if (bookletInfo.IsAutoRotate)
                        {
                            if ((rightPage.PageSize.Height / rightPage.PageSize.Width > 1 && (double)singlePageHeight / singlePageWidth < 1) ||
    (rightPage.PageSize.Height / rightPage.PageSize.Width < 1 && (double)singlePageHeight / singlePageWidth > 1))
                            {
                                rightBitmap.RotateFlip(RotateFlipType.Rotate270FlipNone);
                            }
                        }
                        ///重设大小
                        if ((rightBitmap.Height / rightBitmap.Width) >= singlePageHeight / singlePageWidth)
                        {
                            resizedHeight = singlePageHeight * 0.96;
                            resizedWidth = singlePageHeight / rightBitmap.Height * rightBitmap.Width * 0.96;
                        }
                        else
                        {
                            resizedWidth = singlePageWidth * 0.96;
                            resizedHeight = singlePageWidth / rightBitmap.Width * rightBitmap.Height * 0.96;
                        }
                        rightBitmap = Resize(rightBitmap, (int)(resizedWidth), (int)(resizedHeight)); startPoint.X += (int)(singlePageWidth - resizedWidth) / 2;
                        startPoint.Y = (int)(singlePageHeight - resizedHeight) / 2;
                        if (PrintSettingsInfo.IsGrayscale)
                        {
                            rightBitmap = ToGray(rightBitmap, 0);
                        }
                        printBitmap = CombineBitmap(printBitmap, rightBitmap, startPoint);
                        if (PrintSettingsInfo.IsPrintPageBorde)
                        {
                            using (Pen pen = new Pen(Color.Black, 4))
                            {
                                Graphics g = Graphics.FromImage(printBitmap);
                                g.DrawRectangle(pen, new Rectangle(startPoint.X, startPoint.Y, (int)resizedWidth, (int)resizedHeight));
                                g.Dispose();
                            }
                        }
                    }
                }
            }
            BitmapSource = ToBitmapSource(printBitmap);
        }

        /// <summary>
        /// 按照模式绘制指定纸张
        /// </summary>
        /// <param name="TargetPageIndex"></param>
        private void PaintPageByCurrentPreviewIndex(int TargetPaperIndex)
        {
            lock (this)
            {
                if (PrintSettingsInfo.PrintModInfo.EnumPrintMod == EnumPrintMod.StatusSize)
                {
                    SetPreviewExceptPoster();
                    PreviewModSize(TargetPaperList[TargetPaperIndex]);
                }
                else if (PrintSettingsInfo.PrintModInfo.EnumPrintMod == EnumPrintMod.StatusPoster)
                {
                    PreviewModPoster(TargetPaperList[TargetPaperIndex]);
                }
                else if (PrintSettingsInfo.PrintModInfo.EnumPrintMod == EnumPrintMod.StatusMultiple)
                {
                    SetPreviewExceptPoster();
                    PreviewModMultiple(TargetPaperList[TargetPaperIndex]);
                }
                else if (PrintSettingsInfo.PrintModInfo.EnumPrintMod == EnumPrintMod.StatusBooklet)
                {
                    SetPreviewExceptPoster();
                    PreviewModBooklet(TargetPaperList[TargetPaperIndex]);
                }
            }
        }

        /// <summary>
        /// 设置纸张集合
        /// 大小模式：目标纸张和目标纸张页一致
        /// 海报模式：一致
        /// 多页模式: 一致
        /// 小册子模式：不一致
        /// 第a页-第b页：从第1页开始数，a页=（a-1）*2, b页=（b-1）*2
        /// 面向：奇数页：paper%2 = 1
        /// 背向：偶数页：Paper%2 = 0;
        /// </summary>
        public void SetPaperCollection()
        {
            if (PrintSettingsInfo.PrintModInfo.EnumPrintMod == EnumPrintMod.StatusSize ||
               PrintSettingsInfo.PrintModInfo.EnumPrintMod == EnumPrintMod.StatusPoster ||
               PrintSettingsInfo.PrintModInfo.EnumPrintMod == EnumPrintMod.StatusMultiple)
            {
                TargetPaperList.Clear();
                TargetPaperList.Add(0);

                for (int temp = 0; temp < PrintSettingsInfo.PageRangeList.Count; temp++)
                {
                    TargetPaperList.Add(temp);
                }
            }
            else
            {

                BookletInfo bookletInfo = (BookletInfo)PrintSettingsInfo.PrintModInfo;
                if (bookletInfo.EnumBookletSubset == EnumBookletSubset.StatusBothSides)
                {
                    TargetPaperList.Clear();
                    TargetPaperList.Add(0);
                    for (int temp = bookletInfo.BeginPaperIndex * 2 - 2; temp < bookletInfo.EndPaperIndex * 2; temp++)
                    {

                        TargetPaperList.Add(temp);
                    }
                }
                else if (bookletInfo.EnumBookletSubset == EnumBookletSubset.StatusFrontSideOnly)
                {
                    TargetPaperList.Clear();
                    TargetPaperList.Add(0);
                    for (int temp = bookletInfo.BeginPaperIndex * 2 - 2; temp < bookletInfo.EndPaperIndex * 2; temp += 2)
                    {
                        TargetPaperList.Add(temp);
                    }
                }
                else
                {
                    TargetPaperList.Clear();
                    TargetPaperList.Add(0);
                    for (int temp = bookletInfo.BeginPaperIndex * 2 - 1; temp < bookletInfo.EndPaperIndex * 2; temp += 2)
                    {
                        TargetPaperList.Add(temp);
                    }
                }
            }
        }

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

        public void OnNavigatedFrom(NavigationContext navigationContext)
        {
            this.printDocument.Dispose();
        }

        public void OnNavigatedTo(NavigationContext navigationContext)
        {
            navigationContext.Parameters.TryGetValue<CPDFViewer>(ParameterNames.PDFViewer, out PDFViewer);
            navigationContext.Parameters.TryGetValue<PrintSettingsInfo>(ParameterNames.PrintSettingsInfo, out PrintSettingsInfo);
            navigationContext.Parameters.TryGetValue<string>("Unicode", out Unicode);
            if (PDFViewer != null && PrintSettingsInfo != null)
            {
                documentSettingsInfo.DocumentWidth = PrintSettingsInfo.PrintDocument.DefaultPageSettings.PaperSize.Width;
                documentSettingsInfo.DocumentHeight = PrintSettingsInfo.PrintDocument.DefaultPageSettings.PaperSize.Height;
                documentSettingsInfo.margins = PrintSettingsInfo.PrintDocument.DefaultPageSettings.Margins;
                documentSettingsInfo.DocumentBounds = PrintSettingsInfo.PrintDocument.DefaultPageSettings.Bounds;
                SetPreviewExceptPoster();
                CaculatePrintedPageCount();
                SetPaperCollection();
                PaintPageByCurrentPreviewIndex(1);
            }
        }
    }
}