Пример #1
0
        /// <summary>
        /// Exports the page.
        /// </summary>
        /// <param name="state">The state.</param>
        /// <param name="doc">The document.</param>
        /// <param name="page">The page.</param>
        void ExportPage(ExporterState state, PdfDocument doc, GcPageBlock page)
        {
            PdfPage page2 = doc.Pages.AddNewPage(this.context.GetDot((float)page.Width), this.context.GetDot((float)page.Height));

            if (this.settings.PageDuration >= 0)
            {
                page2.PageDuration = this.settings.PageDuration;
            }
            if (this.settings.PageTransition != PageTransitionType.Default)
            {
                page2.PageTransition.TransitionType = this.settings.PageTransition;
            }
            state.CurrentPage = page2;
            PdfContent content = page2.AddNewContent();

            content.Filters.Enqueue(PdfFilter.FlateFilter);
            PdfGraphics pdfGraphics = content.Graphics;
            Graphics    g           = new Graphics(this.context, this, pdfGraphics);

            if (state.BlackAndWhite)
            {
                g.GrayMode = true;
            }
            g.SaveState();
            g.Scale((double)this.context.GetForce(), (double)-this.context.GetForce());
            g.Translate(0.0, -page.Height);
            new GcPaintHelper().Paint(page, g, state);
            g.RestoreState();
        }
Пример #2
0
        /// <summary>
        /// Exports the empty page.
        /// </summary>
        /// <param name="state">The state.</param>
        /// <param name="doc">The document.</param>
        void ExportEmptyPage(ExporterState state, PdfDocument doc)
        {
            PdfPage page = doc.Pages.AddNewPage(this.context.GetDot((float)this.context.PageRects.PageRectangle.Width), this.context.GetDot((float)this.context.PageRects.PageRectangle.Height));

            state.CurrentPage = page;
            PdfContent content = page.AddNewContent();

            content.Filters.Enqueue(PdfFilter.FlateFilter);
            PdfGraphics pdfGraphics = content.Graphics;
            Graphics    g           = new Graphics(this.context, this, pdfGraphics);

            g.SaveState();
            g.Scale((double)this.context.GetForce(), (double)-this.context.GetForce());
            g.Translate(0.0, -this.context.PageRects.PageRectangle.Height);
            GcLabel label = new GcLabel((int)((this.context.PageRects.PageRectangle.Width / 2.0) - 220.0), (int)(this.context.PageRects.PageRectangle.Height / 3.0), 440, 100)
            {
                Text = "No Page can be print, please check the settings.",
                Font = new Font(this.context.DefaultFont.FontFamily.ToString(), 20.0)
            };

            label.Alignment.VerticalAlignment   = TextVerticalAlignment.Center;
            label.Alignment.HorizontalAlignment = TextHorizontalAlignment.Center;
            label.Alignment.WordWrap            = true;
            label.Foreground = FillEffects.Red;
            label.Background = new SolidColorBrush(Colors.Red);
            GcPaintHelper.PaintLabel(label.GetBlock(this.context), g, state);
            g.RestoreState();
        }
Пример #3
0
        /// <summary>
        /// Exports the inner.
        /// </summary>
        /// <param name="stream">The stream</param>
        /// <param name="doc">The doc.</param>
        /// <param name="saveAuto">if set to <c>true</c> [save auto].</param>
        /// <param name="checkEmpty">if set to <c>true</c> [check empty].</param>
        /// <param name="processSettings">if set to <c>true</c> [process settings].</param>
        /// <param name="otfu">The otfu.</param>
        /// <param name="frc">The FRC.</param>
        /// <param name="pageCount">The page count.</param>
        internal void ExportInner(Stream stream, PdfDocument doc, bool saveAuto, bool checkEmpty, bool processSettings, OpenTypeFontUtility otfu, GcReportContext frc, int pageCount)
        {
            bool flag2;

            doc             = doc ?? CreatePdfDocument();
            this.currentDoc = doc;
            if (processSettings)
            {
                this.settings.AppendTo(doc);
            }
            bool flag = false;

            if (otfu != null)
            {
                this.openTypeFontUtility     = otfu;
                this.openTypeFontUtility.Dpi = this.Dpi;
            }
            else
            {
                this.openTypeFontUtility = new OpenTypeFontUtility(GcReportContext.defaultFont, this.Dpi);
                flag = true;
                this.openTypeFontUtility.ExternalFont += this.ExternalFont;
            }
            if (frc != null)
            {
                this.context = frc;
            }
            else
            {
                GcReportContext context = new GcReportContext(this.report, this.Dpi, this.openTypeFontUtility)
                {
                    UnitsPerInch = 0x48
                };
                this.context = context;
                this.context.GeneratePageBlocks();
            }
            if (this.report.Watermark != null)
            {
                this.report.Watermark.Height = (int)this.context.PageRects.PageRectangle.Height;
                this.report.Watermark.Width  = (int)this.context.PageRects.PageRectangle.Width;
            }
            ExporterState state = new ExporterState(this.context)
            {
                BlackAndWhite = this.report.BlackAndWhite
            };
            int num = 0;

            foreach (List <GcPageBlock> list in this.context.Pages)
            {
                state.PageCount += list.Count;
                num              = Math.Max(list.Count, num);
            }
            if (pageCount >= 0)
            {
                state.PageCount = pageCount;
            }
            else
            {
                state.PageCount += this.report.FirstPageNumber - 1;
            }
            switch (this.context.Report.PageOrder)
            {
            case PrintPageOrder.Auto:
                flag2 = this.context.Pages.Count >= num;
                break;

            case PrintPageOrder.DownThenOver:
                flag2 = true;
                break;

            case PrintPageOrder.OverThenDown:
                flag2 = false;
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }
            List <PageState> list2 = new List <PageState>();

            if (flag2)
            {
                for (int i = 0; i < num; i++)
                {
                    state.CurrentHPageNumber++;
                    state.CurrentVPageNumber = 0;
                    foreach (List <GcPageBlock> list3 in this.context.Pages)
                    {
                        if (list3.Count > i)
                        {
                            state.CurrentPageNumber++;
                            state.CurrentVPageNumber++;
                            list2.Add(new PageState(state.CurrentHPageNumber, state.CurrentVPageNumber, state.CurrentPageNumber, list3[i]));
                        }
                    }
                }
            }
            else
            {
                foreach (List <GcPageBlock> list4 in this.context.Pages)
                {
                    state.CurrentVPageNumber++;
                    state.CurrentHPageNumber = 0;
                    foreach (GcPageBlock block in list4)
                    {
                        state.CurrentPageNumber++;
                        state.CurrentHPageNumber++;
                        list2.Add(new PageState(state.CurrentHPageNumber, state.CurrentVPageNumber, state.CurrentPageNumber, block));
                    }
                }
            }
            if (list2.Count > 0)
            {
                if (string.IsNullOrEmpty(this.report.PageRange))
                {
                    foreach (PageState state2 in list2)
                    {
                        state.CurrentHPageNumber = state2.HPageIndex;
                        state.CurrentVPageNumber = state2.VPageIndex;
                        state.CurrentPageNumber  = (state2.PageIndex + this.report.FirstPageNumber) - 1;
                        this.ExportPage(state, doc, state2.PageBlock);
                    }
                }
                else
                {
                    foreach (int num3 in Utilities.GetPageRange(this.report.PageRange, list2.Count))
                    {
                        PageState state3 = list2[num3 - 1];
                        state.CurrentHPageNumber = state3.HPageIndex;
                        state.CurrentVPageNumber = state3.VPageIndex;
                        state.CurrentPageNumber  = (state3.PageIndex + this.report.FirstPageNumber) - 1;
                        this.ExportPage(state, doc, state3.PageBlock);
                    }
                }
            }
            if (checkEmpty && (doc.Pages.PageCount <= 0))
            {
                this.ExportEmptyPage(state, doc);
            }
            if (state.Bookmarks.Count > 0)
            {
                PdfOutlineItem item;
                if (doc.Outlines.Items.Count > 0)
                {
                    item = doc.Outlines.Items[0];
                }
                else
                {
                    item = new PdfOutlineItem(this.report.Bookmark, state.FirstPage);
                    doc.Outlines.Items.Add(item);
                }
                Dictionary <Bookmark, List <PdfOutlineItem> > dictionary = new Dictionary <Bookmark, List <PdfOutlineItem> >();
                foreach (ExporterState.BookmarkState state4 in state.Bookmarks)
                {
                    PdfOutlineItem item2 = new PdfOutlineItem(state4.Bookmark.Text, new PdfXYZDestination(state4.Page, (float)state4.Location.X, (float)state4.Location.Y, 0f));
                    if (!dictionary.ContainsKey(state4.Bookmark))
                    {
                        dictionary.Add(state4.Bookmark, new List <PdfOutlineItem>());
                    }
                    dictionary[state4.Bookmark].Add(item2);
                }
                foreach (KeyValuePair <Bookmark, List <PdfOutlineItem> > pair in dictionary)
                {
                    Bookmark bookmark           = pair.Key;
                    List <PdfOutlineItem> list6 = pair.Value;
                    if ((bookmark.Parent == null) || !dictionary.ContainsKey(bookmark.Parent))
                    {
                        foreach (PdfOutlineItem item3 in list6)
                        {
                            item.ChildItems.Add(item3);
                        }
                    }
                    else
                    {
                        List <PdfOutlineItem> list7 = dictionary[bookmark.Parent];
                        foreach (PdfOutlineItem item4 in list6)
                        {
                            PdfOutlineItem item5 = list7[0];
                            if (list7.Count > 1)
                            {
                                foreach (PdfOutlineItem item6 in list7)
                                {
                                    if (item6.Dest.TargetPage == item4.Dest.TargetPage)
                                    {
                                        item5 = item6;
                                        break;
                                    }
                                }
                            }
                            item5.ChildItems.Add(item4);
                        }
                    }
                }
            }
            if (processSettings)
            {
                if ((this.settings.DestinationType != DestinationType.Auto) || (doc.Pages.PageCount > 0))
                {
                    PdfArray array = new PdfArray();
                    if ((this.settings.OpenPageNumber <= doc.Pages.PageCount) && (doc.Pages.PageCount > 0))
                    {
                        array.Add(doc.Pages.Kids[this.settings.OpenPageNumber - 1]);
                    }
                    else
                    {
                        array.Add(doc.Pages.Kids[0]);
                    }
                    switch (this.settings.DestinationType)
                    {
                    case DestinationType.Auto:
                        break;

                    case DestinationType.FitPage:
                        array.Add(PdfName.Fit);
                        break;

                    case DestinationType.FitWidth:
                        array.Add(PdfName.FitH);
                        break;

                    case DestinationType.FitHeight:
                        array.Add(PdfName.FitV);
                        array.Add(PdfNumber.Zero);
                        break;

                    case DestinationType.FitBox:
                        array.Add(PdfName.FitB);
                        break;

                    default:
                        throw new ArgumentOutOfRangeException();
                    }
                    doc.Add(PdfName.OpenAction, array);
                }
                if ((this.settings.DocumentAttachments.Count > 0) && (doc.Pages.PageCount > 0))
                {
                    PdfPage page = doc.Pages.Kids[doc.Pages.PageCount - 1] as PdfPage;
                    if (page != null)
                    {
                        foreach (DocumentAttachment attachment in this.settings.DocumentAttachments)
                        {
                            if ((!string.IsNullOrEmpty(attachment.Name) && (attachment.FileStreamInner != null)) && attachment.FileStreamInner.CanRead)
                            {
                                PdfFileAttachmentAnnotation annotation = new PdfFileAttachmentAnnotation {
                                    FileSpecification = { FileName = attachment.Name }
                                };
                                attachment.FileStreamInner.WriteTo((Stream)annotation.FileSpecification.FileStream.Data);
                                annotation.FileSpecification.FileStream.Size = attachment.FileStreamInner.Length;
                                annotation.FileSpecification.FileStream.MIME = attachment.ContentType;
                                annotation.ModifiedDate = DateTime.Now;
                                annotation.FileSpecification.FileStream.ModifyDate   = DateTime.Now;
                                annotation.FileSpecification.FileStream.CreationDate = DateTime.Now;
                                if (!string.IsNullOrEmpty(attachment.Description))
                                {
                                    annotation.Contents = attachment.Description;
                                }
                                if (attachment.Compress)
                                {
                                    annotation.FileSpecification.FileStream.Filters.Enqueue(PdfFilter.FlateFilter);
                                }
                                annotation.Flags     = PdfAnnotationBase.Flag.NoView | PdfAnnotationBase.Flag.Hidden | PdfAnnotationBase.Flag.Invisible;
                                annotation.Rectangle = new PdfRectangle(-100f, -100f, 1f, 1f);
                                page.Annotations.Add(annotation);
                            }
                        }
                    }
                }
            }
            if (saveAuto)
            {
                SavePdfDocment(doc, stream);
            }
            if (flag)
            {
                this.openTypeFontUtility.ExternalFont -= this.ExternalFont;
            }
        }