//
        // methods
        //


        public virtual PDFObjectRef OutputToPDF(PDFRenderContext context, PDFWriter writer)
        {
            if (this.IsEmpty())
            {
                if (context.ShouldLogMessage)
                {
                    context.TraceLog.Add(TraceLevel.Message, "Viewer Preferences", "No values set on the document viewer preferences so not outputting");
                }
                return(null);
            }
            else
            {
                PDFObjectRef oref = writer.BeginObject();
                writer.BeginDictionary();
                this.WriteOptionalFlag("CenterWindow", _centrewindow, context, writer);
                this.WriteOptionalFlag("FitWindow", _fitwindow, context, writer);
                this.WriteOptionalFlag("HideWindowUI", _hidewindowui, context, writer);
                this.WriteOptionalFlag("HideToolbar", _hidetoolbar, context, writer);
                this.WriteOptionalFlag("HideMenubar", _hidemenubar, context, writer);
                if (this.NonFullScreenPageDisplay != PageDisplayMode.Undefined)
                {
                    this.WriteOptionalName("NonFullScreenPageMode", this.NonFullScreenPageDisplay.ToString(), context, writer);
                }
                writer.EndDictionary();
                writer.EndObject();

                return(oref);
            }
        }
Exemplo n.º 2
0
        //
        // methods
        //

        #region public virtual PDFObjectRef OutputToPDF(PDFRenderContext context, PDFWriter writer) + Support methods

        /// <summary>
        /// Outputs this Info to the current writer
        /// </summary>
        /// <param name="context"></param>
        /// <param name="writer"></param>
        /// <returns></returns>
        public virtual PDFObjectRef OutputToPDF(PDFRenderContext context, PDFWriter writer)
        {
            PDFObjectRef inforef = writer.BeginObject("Info");

            writer.BeginDictionary();
            OutputInfoEntry("Title", this.Title, writer);
            OutputInfoEntry("Subject", this.Subject, writer);
            OutputInfoEntry("Author", this.Author, writer);
            OutputInfoEntry("Keywords", this.Keywords, writer);
            OutputInfoEntry("Producer", this.Producer, writer);
            OutputInfoEntry("Creator", this.Creator, writer);
            OutputInfoEntry("CreationDate", this.CreationDate, writer);
            OutputInfoEntry("ModDate", this.ModifiedDate, writer);

            if (this.HasTrapping)
            {
                writer.WriteDictionaryNameEntry("Trapped", this.Trapped.ToString());
            }

            if (this.HasExtras)
            {
                foreach (PDFDocumentInfoExtra extra in this.Extras)
                {
                    OutputInfoEntry(extra.Name, extra.Value, writer);
                }
            }
            writer.EndDictionary();
            writer.EndObject();

            return(inforef);
        }
        public PDFObjectRef OutputToPDF(PDFRenderContext context, PDFWriter writer)
        {
            if (this.Fields.Count > 0)
            {
                PDFObjectRef parent = writer.BeginObject();

                List <PDFObjectRef> children = new List <PDFObjectRef>();
                foreach (var fld in this.Fields)
                {
                    var child = fld.OutputToPDF(context, writer);
                    if (null != child)
                    {
                        children.Add(child);
                    }
                }

                writer.BeginDictionary();
                writer.WriteDictionaryStringEntry("T", this.Name);
                writer.BeginDictionaryEntry("Kids");
                writer.WriteArrayRefEntries(true, children.ToArray());
                writer.EndDictionaryEntry();
                writer.EndDictionary();
                writer.EndObject();
                return(parent);
            }
            return(null);
        }
        /// <summary>
        /// Outputs the first Page tree Component and calls Output on each of the layout pages.
        /// </summary>
        /// <param name="context">The current context</param>
        /// <param name="writer">The current writer</param>
        /// <returns>A reference to the current page tree root Component</returns>
        protected virtual PDFObjectRef OutputPageTree(PDFRenderContext context, PDFWriter writer)
        {
            //Begin the Pages object and dictionary
            PDFObjectRef pgs = writer.BeginObject(Const.PageTreeName);

            writer.BeginDictionary();
            writer.WriteDictionaryNameEntry("Type", "Pages");

            List <PDFObjectRef> pagerefs = OutputAllPages(pgs, context, writer);

            //write the kids array entry in the dictionary
            writer.BeginDictionaryEntry("Kids");
            writer.BeginArray();
            foreach (PDFObjectRef kid in pagerefs)
            {
                writer.BeginArrayEntry();
                writer.WriteFileObject(kid);
                writer.EndArrayEntry();
            }
            writer.EndArray();
            //Write the total number of pages to the dictionary
            writer.EndDictionaryEntry();
            writer.BeginDictionaryEntry("Count");
            writer.WriteNumber(pagerefs.Count);
            writer.EndDictionaryEntry();

            //close the ditionary and the object
            writer.EndDictionary();

            writer.EndObject();

            return(pgs);
        }
Exemplo n.º 5
0
        public PDFObjectRef OutputToPDF(PDFRenderContext context, PDFWriter writer)
        {
            if (context.ShouldLogDebug)
            {
                context.TraceLog.Begin(TraceLevel.Verbose, "Annotation Collection", "Outputting the doument annotations to the writer");
            }

            PDFObjectRef        annot   = writer.BeginObject();
            List <PDFObjectRef> entries = new List <PDFObjectRef>();

            //TODO:Render annotations
            foreach (PDFAnnotationEntry entry in this._annots)
            {
                PDFObjectRef oref = entry.OutputToPDF(context, writer);
                if (oref != null)
                {
                    entries.Add(oref);
                }
            }

            writer.WriteArrayRefEntries(entries.ToArray());
            writer.EndObject();

            if (context.ShouldLogDebug)
            {
                context.TraceLog.End(TraceLevel.Verbose, "Annotation Collection", "Completed the output of " + entries.Count + " annotations on the writer");
            }


            return(annot);
        }
Exemplo n.º 6
0
        /// <summary>
        /// Renders the widths to the output writer
        /// </summary>
        /// <param name="context"></param>
        /// <param name="writer"></param>
        /// <returns></returns>
        public PDFObjectRef RenderToPDF(PDFContextBase context, PDFWriter writer)
        {
            PDFObjectRef oref = writer.BeginObject();

            this.RenderWidthsArrayToPDF(context, writer);
            writer.EndObject();
            return(oref);
        }
        internal override PDFObjectRef WriteTo(PDFWriter writer)
        {
            PDFObjectRef oref = writer.BeginObject("StandardEncryption");

            writer.BeginDictionary();
            writer.WriteDictionaryNameEntry("Filter", "Standard");
            this.WriteStandardSecurityEntries(writer);
            writer.EndDictionary();
            writer.EndObject();
            return(oref);
        }
Exemplo n.º 8
0
        /// <summary>
        /// Overrides the default method to write a 4 element array
        /// </summary>
        /// <param name="writer"></param>
        protected override void  RenderCustomColorSpace(PDFWriter writer)
        {
            writer.BeginDictionaryEntry("ColorSpace");


            if (null == this.Pallette || this.Pallette.Length == 0)
            {
                throw new NullReferenceException("Palette");
            }
            else
            {
                PDFObjectRef index = writer.BeginObject();
                writer.BeginArray();
                writer.BeginArrayEntry();
                writer.WriteName("Indexed");
                writer.EndArrayEntry();

                writer.BeginArrayEntry();
                ColorSpace cs = this.Pallette[0].ColorSpace;

                if (cs == ColorSpace.RGB)
                {
                    writer.WriteName("DeviceRGB");
                }
                else if (cs == ColorSpace.G)
                {
                    writer.WriteName("DeviceG");
                }
                else
                {
                    throw new ArgumentOutOfRangeException("Palette[0].ColorSpace");
                }
                writer.EndArrayEntry();

                writer.BeginArrayEntry();
                writer.WriteNumber(this.Pallette.Length - 1);//maximum value not number of entries
                writer.EndArrayEntry();
                //check the stored instance
                if (null == _bytestreamdata)
                {
                    _bytestreamdata = GetPaletteString(cs);
                }

                writer.BeginArrayEntry();
                writer.WriteByteString(_bytestreamdata);
                writer.EndArrayEntry();
                writer.EndArray();
                writer.EndObject();
                writer.WriteObjectRef(index);
            }
            writer.EndDictionaryEntry();
        }
        /// <summary>
        /// Outputs the document catalog (usually the first Component) and then calls output on each of the documents
        /// </summary>
        /// <param name="context"></param>
        /// <param name="writer"></param>
        /// <returns></returns>
        protected virtual PDFObjectRef WriteCatalog(PDFRenderContext context, PDFWriter writer)
        {
            PDFObjectRef catalog = writer.BeginObject("Catalog");

            writer.BeginDictionary();
            writer.WriteDictionaryNameEntry("Type", "Catalog");

            WriteCatalogEntries(context, writer);

            writer.EndDictionary();
            writer.EndObject();

            return(catalog);
        }
Exemplo n.º 10
0
        public PDFObjectRef OutputToPDF(PDFRenderContext context, PDFWriter writer)
        {
            if (this.Roots.Count > 0)
            {
                if (context.ShouldLogDebug)
                {
                    context.TraceLog.Begin(TraceLevel.Verbose, "Outline Stack", "Starting to render the outline tree");
                }

                PDFObjectRef outlines = writer.BeginObject();
                writer.BeginDictionary();
                writer.WriteDictionaryNameEntry("Type", "Outlines");
                PDFObjectRef first, last;
                int          count;

                this.RenderOutlineCollection(this.Roots, outlines, context, writer, out first, out last, out count);

                if (null != first)
                {
                    writer.WriteDictionaryObjectRefEntry("First", first);
                }
                if (null != last)
                {
                    writer.WriteDictionaryObjectRefEntry("Last", last);
                }
                if (count > 0)
                {
                    writer.WriteDictionaryNumberEntry("Count", count);
                }

                writer.EndDictionary();
                writer.EndObject();//outlines

                if (context.ShouldLogDebug)
                {
                    context.TraceLog.End(TraceLevel.Verbose, "Outline Stack", "Finished rendering the outline tree");
                }
                else if (context.ShouldLogVerbose)
                {
                    context.TraceLog.Add(TraceLevel.Verbose, "Outline Stack", "Rendered the outline tree to indirect object " + outlines + " with first " + first + ", last " + last + " and count " + count);
                }

                return(outlines);
            }
            else
            {
                return(null);
            }
        }
Exemplo n.º 11
0
        protected override PDFObjectRef DoRenderToPDF(PDFContextBase context, PDFWriter writer)
        {
            PDFObjectRef oref = writer.BeginObject();

            writer.BeginDictionaryS();
            writer.WriteDictionaryNameEntry("Type", "ExtGState");
            foreach (PDFName name in this.States.Keys)
            {
                writer.BeginDictionaryEntry(name);
                this.States[name].WriteData(writer);
                writer.EndDictionaryEntry();
            }
            writer.EndDictionary();
            writer.EndObject();
            return(oref);
        }
Exemplo n.º 12
0
        private PDFObjectRef RenderAlpaImageData(PDFContextBase context, PDFWriter writer)
        {
            context.TraceLog.Add(TraceLevel.Debug, "IMAGE", "Rendering image alpha mask");
            PDFObjectRef mask = writer.BeginObject();

            writer.BeginDictionary();
            writer.WriteDictionaryNameEntry("Type", "XObject");
            writer.WriteDictionaryNameEntry("Subtype", "Image");
            writer.WriteDictionaryNumberEntry("Width", this.PixelWidth);
            writer.WriteDictionaryNumberEntry("Height", this.PixelHeight);
            //writer.WriteDictionaryNumberEntry("Length", this.AlphaData.LongLength);
            writer.WriteDictionaryNameEntry("ColorSpace", "DeviceGray");
            writer.WriteDictionaryNumberEntry("BitsPerComponent", 8);
            this.WriteFilterNames(context, writer);

            //writer.EndDictionary();
            writer.BeginStream(mask);

            byte[] data;
            if (this.HasFilter && this.ShouldApplyFilters(context))
            {
                data = this.GetAlphaFilteredData(this.Filters, context);
                if (null == data)
                {
                    data = this.ApplyFiltersToData(this.AlphaData, context);
                    this.SetAlphaFilteredData(this.Filters, data, context);
                }
            }
            else
            {
                data = this.AlphaData;
            }

            writer.WriteRaw(data, 0, data.Length);

            writer.EndStream();

            //inserted 15/01/15 - Write the filtered length, not the actua image data length to the dictionary.
            writer.WriteDictionaryNumberEntry("Length", data.Length);
            writer.EndDictionary();
            //end of insert

            writer.EndObject();

            return(mask);
        }
Exemplo n.º 13
0
        internal PDFObjectRef Render(PDFName name, PDFContextBase context, PDFWriter writer)
        {
            if (context.ShouldLogDebug)
            {
                context.TraceLog.Begin(TraceLevel.Message, "Image Data", "Rendering image data for '" + name.ToString() + "'");
            }

            PDFObjectRef renderref = writer.BeginObject(name.Value);

            writer.BeginDictionaryS();
            writer.WriteDictionaryNameEntry("Name", name.Value);
            writer.WriteDictionaryNameEntry("Type", "XObject");
            writer.WriteDictionaryNameEntry("Subtype", "Image");

            RenderImageInformation(context, writer);

            //writer.EndDictionary(); //- commented for data length fix

            writer.BeginStream(renderref);

            int length = this.RenderImageStreamData(context, writer);

            writer.EndStream();

            //Added for Data Length fix HRB 15/01/2015
            writer.WriteDictionaryNumberEntry("Length", length);
            writer.EndDictionary();
            //End of add

            writer.EndObject();

            if (context.ShouldLogDebug)
            {
                context.TraceLog.End(TraceLevel.Message, "Image Data", "Completed render of the image data for '" + name + "' with source " + this.SourcePath);
            }
            else
            {
                context.TraceLog.Add(TraceLevel.Message, "Image Data", "Rendered the image data for '" + name.ToString() + "' with source " + this.SourcePath);
            }


            return(renderref);
        }
Exemplo n.º 14
0
        protected override PDFObjectRef DoRenderToPDF(PDFContextBase context, PDFWriter writer)
        {
            PDFObjectRef oref = writer.BeginObject(this.Name.Value);

            writer.BeginDictionary();
            writer.WriteDictionaryNameEntry("Type", "Pattern");
            writer.WriteDictionaryNumberEntry("PatternType", (int)this.PatternType);
            //Actual shading dictionary
            var shading = this.RenderShadingDictionary(context, writer);

            if (null != shading)
            {
                writer.WriteDictionaryObjectRefEntry("Shading", shading);
            }

            writer.EndDictionary();
            writer.EndObject();

            return(oref);
        }
        public PDFObjectRef OutputToPDF(PDFRenderContext context, PDFWriter writer)
        {
            if (this.Fields.Count > 0)
            {
                PDFObjectRef fields = writer.BeginObject();
                writer.BeginDictionary();

                OutputFields(context, writer);
                //OutputDefaultResources(context, writer);

                writer.EndDictionary();
                writer.EndObject();

                return(fields);
            }
            else
            {
                return(null);
            }
        }
        /// <summary>
        /// Outputs all the names within this dictionary to a new PDFObject in output writer and returns a reference to the dictionary
        /// </summary>
        /// <param name="context"></param>
        /// <param name="writer"></param>
        /// <returns></returns>
        public PDFObjectRef OutputToPDF(PDFRenderContext context, PDFWriter writer)
        {
            PDFObjectRef names = writer.BeginObject();

            writer.BeginDictionary();

            if (_dests.Count > 0)
            {
                List <string> all = new List <string>(_dests.Keys);

                all.Sort();
                PDFObjectRef dests = WriteDestinationNames(context, writer, all);

                writer.WriteDictionaryObjectRefEntry("Dests", dests);
            }
            writer.EndDictionary();

            writer.EndObject();

            return(names);
        }
        /// <summary>
        /// Writes the collection of page labels and returns a reference to this collection
        /// </summary>
        /// <param name="context"></param>
        /// <param name="writer"></param>
        /// <returns></returns>
        private PDFObjectRef WritePageLabels(PDFRenderContext context, PDFWriter writer)
        {
            PDFPageNumbers nums   = this.Numbers;
            PDFObjectRef   labels = writer.BeginObject("PageLabels");

            writer.BeginDictionary();
            writer.BeginDictionaryEntry("Nums");
            writer.BeginArrayS();

            //PDFPageNumberRegistration def = this.Numbers.;
            //this.WriteAPageLabel(context, writer, def);

            foreach (PDFPageNumberRegistration entry in this.Numbers.Registrations)
            {
                WriteAPageLabel(context, writer, entry);
            }
            writer.EndArray();
            writer.EndDictionaryEntry();
            writer.EndDictionary();
            writer.EndObject();
            return(labels);
        }
Exemplo n.º 18
0
        /// <summary>
        /// Outputs the entire contents of this name dictionary to the specified writer
        /// </summary>
        /// <param name="context"></param>
        /// <param name="writer"></param>
        /// <returns></returns>
        public PDFObjectRef OutputToPDF(PDFRenderContext context, PDFWriter writer)
        {
            PDFObjectRef names = null;

            if (this.InnerDictionary.Count > 0)
            {
                names = writer.BeginObject();
                writer.BeginDictionary();

                foreach (KeyValuePair <string, PDFCategorisedNameTree> kvp in this.InnerDictionary)
                {
                    PDFObjectRef oref = kvp.Value.OutputToPDF(writer, context);
                    if (null != oref)
                    {
                        writer.WriteDictionaryObjectRefEntry(kvp.Key, oref);
                    }
                }

                writer.EndDictionary();
                writer.EndObject();
            }
            return(names);
        }
Exemplo n.º 19
0
        /// <summary>
        /// This will render the actual content of the XObject graphical content in a new object reference.
        /// This can then be referred to.
        /// </summary>
        /// <param name="context"></param>
        /// <param name="writer"></param>
        /// <returns></returns>
        private PDFObjectRef OutputContent(PDFRenderContext context, PDFWriter writer)
        {
            PDFObjectRef xObject = writer.BeginObject();

            IStreamFilter[] filters = (context.Compression == OutputCompressionType.FlateDecode) ? this._page.PageCompressionFilters : null;

            writer.BeginStream(xObject, filters);

            this.Location = context.Offset.Offset(0, this.Line.OffsetY);
            PDFSize     origSpace    = context.Space.Clone();
            PDFGraphics prevGraphics = context.Graphics;

            using (PDFGraphics g = this.CreateGraphics(writer, context.StyleStack, context))
            {
                context.Graphics = g;
                g.SaveGraphicsState();
                g.RestoreGraphicsState();

                context.Offset = Drawing.PDFPoint.Empty;

                this._childContainer.OutputToPDF(context, writer);
            }
            context.Offset   = this.Location;
            context.Space    = origSpace;
            context.Graphics = prevGraphics;

            long len = writer.EndStream();

            writer.BeginDictionary();

            this.WriteXObjectDictionaryContent(context, writer, len, filters);

            writer.EndDictionary();
            writer.EndObject();

            return(xObject);
        }
        internal PDFObjectRef Render(PDFName name, PDFContextBase context, PDFWriter writer)
        {
            if (context.ShouldLogDebug)
            {
                context.TraceLog.Begin(TraceLevel.Message, "Path Data", "Rendering path data for '" + name.ToString() + "'");
            }

            PDFObjectRef renderref = writer.BeginObject(name.Value);

            writer.BeginDictionaryS();
            writer.WriteDictionaryNameEntry("Name", name.Value);
            writer.WriteDictionaryNameEntry("Type", "XObject");
            writer.WriteDictionaryNameEntry("Subtype", "Image");

            RenderPathInformation(context, writer, renderref);

            int length = this.RenderPathData(context, writer, renderref);

            writer.WriteDictionaryNumberEntry("Length", length);
            writer.EndDictionary();
            //End of add

            writer.EndObject();

            if (context.ShouldLogDebug)
            {
                context.TraceLog.End(TraceLevel.Message, "Path Data", "Completed render of the path data for '" + name.ToString());
            }
            else
            {
                context.TraceLog.Add(TraceLevel.Message, "Path Data", "Rendered the path data for '" + name.ToString());
            }


            return(renderref);
        }
Exemplo n.º 21
0
        public PDFObjectRef WriteResourceList(PDFContextBase context, PDFWriter writer)
        {
            PDFObjectRef oref = writer.BeginObject();

            writer.BeginDictionary();

            if (this._includeProcSet)
            {
                writer.BeginDictionaryEntry("ProcSet");
                writer.WriteArrayNameEntries(ProcSets);
                writer.EndDictionaryEntry();
            }
            foreach (PDFResourceItemList list in this.types)
            {
                writer.BeginDictionaryEntry(list.Type);
                writer.BeginDictionary();
                foreach (PDFResource rsrc in list)
                {
                    PDFObjectRef rref = rsrc.EnsureRendered(context, writer);
                    if (rref != null)
                    {
                        writer.BeginDictionaryEntry(rsrc.Name);
                        writer.WriteObjectRef(rref);
                        writer.EndDictionaryEntry();
                    }
                }
                writer.EndDictionary();
                writer.EndDictionaryEntry();
            }


            writer.EndDictionary();
            writer.EndObject();

            return(oref);
        }
        /// <summary>
        /// Writes all the destinations to the current PDF Object
        /// </summary>
        /// <param name="context"></param>
        /// <param name="writer"></param>
        /// <param name="all"></param>
        /// <returns></returns>
        private PDFObjectRef WriteDestinationNames(PDFRenderContext context, PDFWriter writer, IEnumerable <string> all)
        {
            PDFObjectRef dests = writer.BeginObject();

            writer.BeginDictionary();

            //Write the names array
            writer.BeginDictionaryEntry("Names");
            writer.BeginArray();

            string firstname = string.Empty;
            string lastname  = string.Empty;

            foreach (string name in all)
            {
                if (WriteDestination(context, writer, name))
                {
                    if (string.IsNullOrEmpty(firstname))
                    {
                        firstname = name;
                    }
                    lastname = name;
                }
            }
            writer.EndArray();
            writer.EndDictionaryEntry();

            //Write limits
            writer.BeginDictionaryEntry("Limits");
            writer.WriteArrayStringEntries(firstname, lastname);
            writer.EndDictionaryEntry();

            writer.EndDictionary();
            writer.EndObject();
            return(dests);
        }
Exemplo n.º 23
0
        private PDFObjectRef RenderOutlineItem(PDFOutlineRef outlineref, PDFObjectRef parent, PDFObjectRef prev, PDFRenderContext context, PDFWriter writer, out int count)
        {
            PDFOutline outline = outlineref.Outline;

            Scryber.Drawing.PDFColor  c  = outlineref.GetColor();
            Scryber.Drawing.FontStyle fs = outlineref.GetFontStyle();
            bool isopen = outlineref.GetIsOpen();

            count = 1;//this one
            PDFObjectRef item = writer.BeginObject();

            writer.BeginDictionary();
            writer.WriteDictionaryObjectRefEntry("Parent", parent);
            writer.WriteDictionaryStringEntry("Title", outline.Title);
            writer.WriteDictionaryStringEntry("Dest", outline.DestinationName);
            if (null != c)
            {
                writer.BeginDictionaryEntry("C");
                writer.BeginArray();
                writer.WriteRealS(c.Red.Value, c.Green.Value, c.Blue.Value);
                writer.EndArray();
                writer.EndDictionaryEntry();
            }

            if (fs != Scryber.Drawing.FontStyle.Regular)
            {
                int f = 0;
                if ((fs & Scryber.Drawing.FontStyle.Bold) > 0)
                {
                    f = 2;
                }
                if ((fs & Scryber.Drawing.FontStyle.Italic) > 0)
                {
                    f += 1;
                }
                writer.WriteDictionaryNumberEntry("F", f);
            }

            if (null != prev)
            {
                writer.WriteDictionaryObjectRefEntry("Prev", prev);
            }

            if (context.ShouldLogVerbose)
            {
                context.TraceLog.Add(TraceLevel.Verbose, "Outline Stack", "Rendered outline item " + item + " with title '" + outline.Title + " and destination name " + outline.DestinationName);
            }

            if (outlineref.HasInnerItems)
            {
                if (context.ShouldLogDebug)
                {
                    context.TraceLog.Begin(TraceLevel.Debug, "Outline Stack", "Started rendering inner outline items");
                }


                int          opencount;
                PDFObjectRef childfirst, childlast;
                this.RenderOutlineCollection(outlineref.InnerItems, item, context, writer, out childfirst, out childlast, out opencount);

                writer.WriteDictionaryObjectRefEntry("First", childfirst);
                writer.WriteDictionaryObjectRefEntry("Last", childlast);
                if (opencount > 0)
                {
                    if (isopen)
                    {
                        writer.WriteDictionaryNumberEntry("Count", opencount);
                        count += opencount;
                    }
                    else
                    {
                        writer.WriteDictionaryNumberEntry("Count", -opencount);
                    }
                }

                if (context.ShouldLogDebug)
                {
                    context.TraceLog.End(TraceLevel.Debug, "Outlines", " Finished rendering inner outline items");
                }
            }

            //we don't close the dictionary here as we need the next entry written
            //It should be closed in the calling method

            return(item);
        }
Exemplo n.º 24
0
        public PDFObjectRef RenderToPDF(string fullname, PDFContextBase context, PDFWriter writer)
        {
            if (context.ShouldLogDebug)
            {
                context.TraceLog.Add(TraceLevel.Debug, "Font Descriptor", "Rendering the font descriptor information");
            }

            PDFObjectRef oref = writer.BeginObject();

            writer.BeginDictionary();
            writer.WriteDictionaryNameEntry("Type", "FontDescriptor");
            writer.WriteDictionaryNameEntry("FontName", fullname);

            if (this.FontFamily != String.Empty)
            {
                writer.WriteDictionaryStringEntry("FontFamily", this.FontFamily);
            }

            if (this.BoundingBox != null && this.BoundingBox.Length > 0)
            {
                writer.BeginDictionaryEntry("FontBBox");
                writer.WriteArrayNumberEntries(this.BoundingBox);
                writer.EndDictionaryEntry();
            }

            if (this.FontStretch != FontStretch.Normal)
            {
                writer.WriteDictionaryStringEntry("FontStretch", this.FontStretch.ToString());
            }

            if (this.Weight != 400)
            {
                writer.WriteDictionaryNumberEntry("FontWeight", this.Weight);
            }

            writer.WriteDictionaryNumberEntry("FontWeight", 700);
            writer.WriteDictionaryNumberEntry("Flags", (int)this.Flags);
            writer.WriteDictionaryNumberEntry("Ascent", (int)(this.Ascent * 0.6));
            writer.WriteDictionaryNumberEntry("Descent", this.Descent);

            //if (this.Leading != 0.0)
            //    writer.WriteDictionaryNumberEntry("Leading", this.Leading);

            if (this.CapHeight != 0.0)
            {
                writer.WriteDictionaryNumberEntry("CapHeight", this.CapHeight);
            }

            if (this.XHeight != 0.0)
            {
                writer.WriteDictionaryNumberEntry("XHeight", this.XHeight);
            }

            writer.WriteDictionaryNumberEntry("StemV", this.StemV);

            writer.WriteDictionaryNumberEntry("ItalicAngle", this.ItalicAngle);

            if (this.StemH != 0.0)
            {
                writer.WriteDictionaryNumberEntry("StemH", this.StemH);
            }

            if (this.AvgWidth != 0.0)
            {
                writer.WriteDictionaryNumberEntry("AvgWidth", this.AvgWidth);
            }

            if (this.MaxWidth != 0.0)
            {
                writer.WriteDictionaryNumberEntry("MaxWidth", this.MaxWidth);
            }

            if (this.MissingWidth != 0.0)
            {
                writer.WriteDictionaryNumberEntry("MissingWidth", this.MissingWidth);
            }

            if (this.FontFile != null)
            {
                if (context.ShouldLogDebug)
                {
                    context.TraceLog.Add(TraceLevel.Debug, "Font Descriptor", "Rendering the font descriptor font file");
                }

                byte[] outputdata = this.FontFile;
                string filter     = null;
                if (context.Compression == OutputCompressionType.FlateDecode)
                {
                    if (context.ShouldLogDebug)
                    {
                        context.TraceLog.Add(TraceLevel.Debug, "Font Descriptor", "Ensuring the font data is compressed");
                    }

                    outputdata = this.FilteredFontFile;
                    filter     = this.FilterName;
                }

                PDFObjectRef fileref = writer.BeginObject();
                writer.BeginDictionary();
                writer.WriteDictionaryNumberEntry("Length", outputdata.Length);
                if (this.FontType == FontType.TrueType)
                {
                    writer.WriteDictionaryNumberEntry("Length1", this.FontFile.Length);
                }
                else
                {
                    throw new ArgumentOutOfRangeException("FontType");
                }

                if (!string.IsNullOrEmpty(filter))
                {
                    writer.WriteDictionaryNameEntry("Filter", this.FilterName);
                }

                writer.EndDictionary();
                writer.BeginStream(fileref);

                writer.WriteRaw(outputdata, 0, outputdata.Length);
                writer.EndStream();
                writer.EndObject();

                //We know this is a true type font program from above
                writer.WriteDictionaryObjectRefEntry("FontFile2", fileref);
            }
            writer.EndDictionary();
            writer.EndObject();

            if (context.ShouldLogDebug)
            {
                context.TraceLog.Add(TraceLevel.Debug, "Font Descriptor", "Completed font descriptor");
            }
            return(oref);
        }
Exemplo n.º 25
0
        protected override PDFObjectRef DoOutputToPDF(PDFRenderContext context, PDFWriter writer)
        {
            List <PDFObjectRef> all = new List <PDFObjectRef>();

            if (context.ShouldLogDebug)
            {
                context.TraceLog.Begin(TraceLevel.Debug, "Link Annotation", "Outputting all required link annotations for component " + this.Component.UniqueID);
            }

            int pageindex = context.PageIndex;
            PDFComponentArrangement arrange = this.Component.GetFirstArrangement();
            int index = 1;

            while (null != arrange && arrange.PageIndex == pageindex)
            {
                PDFObjectRef annotref = writer.BeginObject();
                writer.BeginDictionary();
                writer.WriteDictionaryNameEntry("Type", "Annot");
                writer.WriteDictionaryNameEntry("Subtype", "Link");
                if (!string.IsNullOrEmpty(this.AlternateText))
                {
                    writer.WriteDictionaryStringEntry("Contents", this.AlternateText);
                }
                PDFRect bounds = arrange.RenderBounds;
                if (bounds != PDFRect.Empty && bounds.Size != PDFSize.Empty)
                {
                    if (context.DrawingOrigin == DrawingOrigin.TopLeft)
                    {
                        //PDFs have origin at bottom so need to convert.
                        PDFReal value = context.Graphics.GetXPosition(bounds.X.RealValue);
                        bounds.X      = new PDFUnit(value.Value, PageUnits.Points);
                        value         = context.Graphics.GetYPosition(bounds.Y.RealValue);
                        bounds.Y      = new PDFUnit(value.Value, PageUnits.Points);
                        bounds.Width  = bounds.X + bounds.Width;
                        bounds.Height = bounds.Y - bounds.Height;
                    }
                    else
                    {
                        bounds.Width  = bounds.X + bounds.Width;
                        bounds.Height = bounds.Y + bounds.Height;
                    }

                    writer.BeginDictionaryEntry("Rect");
                    writer.WriteArrayRealEntries(bounds.X.Value, bounds.Y.Value, bounds.Width.Value, bounds.Height.Value);
                    writer.EndDictionaryEntry();
                }
                string name = this.Component.UniqueID + "_" + index.ToString();
                writer.WriteDictionaryStringEntry("NM", name);

                //Draw the border
                StyleValue <LineType> lstyle;

                /* if (this.AnnotationStyle != null && this.AnnotationStyle.TryGetValue(StyleKeys.BorderStyleKey, out lstyle) && lstyle != null && lstyle.Value != LineType.None)
                 * {
                 *  PDFUnit corner = this.AnnotationStyle.GetValue(StyleKeys.BorderCornerRadiusKey, (PDFUnit)0);
                 *  PDFUnit width = this.AnnotationStyle.GetValue(StyleKeys.BorderWidthKey, (PDFUnit)1);
                 *  PDFColor c = this.AnnotationStyle.GetValue(StyleKeys.BorderColorKey, PDFColors.Transparent);
                 *
                 *  if (c != null && width > 0)
                 *  {
                 *      writer.BeginDictionaryEntry("Border");
                 *      writer.WriteArrayRealEntries(corner.PointsValue, corner.PointsValue, width.PointsValue);
                 *      writer.EndDictionaryEntry();
                 *
                 *      writer.BeginDictionaryEntry("C");
                 *      if (c.ColorSpace == ColorSpace.G)
                 *          writer.WriteArrayRealEntries(c.Gray.Value);
                 *      else if (c.ColorSpace == ColorSpace.RGB)
                 *          writer.WriteArrayRealEntries(c.Red.Value, c.Green.Value, c.Blue.Value);
                 *      else if (context.Conformance == ParserConformanceMode.Strict)
                 *          RecordAndRaise.ArgumentOutOfRange("c", Errors.ColorValueIsNotCurrentlySupported, c.ColorSpace);
                 *      else
                 *          context.TraceLog.Add(TraceLevel.Error, "Link Annotation", string.Format(Errors.ColorValueIsNotCurrentlySupported, c.ColorSpace));
                 *
                 *      writer.EndDictionaryEntry();
                 *  }
                 *
                 * }
                 * else
                 * {   */

                writer.BeginDictionaryEntry("Border");
                //writer.WriteArrayRealEntries(1.0, 1.0, 1.0);
                writer.WriteArrayRealEntries(0.0, 0.0, 0.0);
                writer.EndDictionaryEntry();
                //}

                if (null != this.Action)
                {
                    writer.BeginDictionaryEntry("A");
                    PDFObjectRef actionref = this.Action.OutputToPDF(context, writer);
                    if (null != actionref)
                    {
                        writer.WriteObjectRefS(actionref);
                    }
                    writer.EndDictionaryEntry();
                }
                writer.EndDictionary();
                writer.EndObject();

                if (context.ShouldLogDebug)
                {
                    context.TraceLog.Add(TraceLevel.Debug, "Link Annotation", "Annotation added " + name + " for bounds " + bounds + " on page " + context.PageIndex);
                }

                all.Add(annotref);

                //If we have more than one arrangement on the object then move to the next one
                if (arrange is PDFComponentMultiArrangement)
                {
                    arrange = ((PDFComponentMultiArrangement)arrange).NextArrangement;
                }
                index++;
            }



            if (all.Count == 0)
            {
                if (context.ShouldLogDebug)
                {
                    context.TraceLog.End(TraceLevel.Debug, "Link Annotation", "No required link annotations for component " + this.Component.UniqueID);
                }

                return(null);
            }
            else if (all.Count == 1)
            {
                return(all[0]);
            }
            else
            {
                if (context.ShouldLogDebug)
                {
                    context.TraceLog.End(TraceLevel.Debug, "Link Annotation", "All " + all.Count + " link annotations for component " + this.Component.UniqueID + " were output");
                }
                PDFObjectRef array = writer.BeginObject();
                writer.WriteArrayRefEntries(all.ToArray());
                writer.EndObject();
                return(array);
            }
        }
        public Native.PDFObjectRef OutputToPDF(PDFWriter writer, PDFRenderContext context)
        {
            List <ICategorisedArtefactNamesEntry> entries = new List <ICategorisedArtefactNamesEntry>();

            Native.PDFObjectRef oref = null;
            if (this.InnerEntries.Count == 0)
            {
                return(oref);
            }
            if (this.NameType == PDFCategorisedNameDictionary.DestinationsName)
            {
                oref = writer.BeginObject();
                writer.BeginDictionary();
                writer.BeginDictionaryEntry("Names");


                string first = null;
                string last  = null;
                writer.BeginArray();
                foreach (KeyValuePair <string, IArtefactEntry> kvp in this.InnerEntries)
                {
                    if (string.IsNullOrEmpty(first))
                    {
                        first = kvp.Key;
                    }
                    else
                    {
                        last = kvp.Key;
                    }

                    writer.BeginArrayEntry();
                    writer.WriteStringLiteral(kvp.Key);
                    writer.EndArrayEntry();

                    writer.BeginArrayEntry();
                    ((PDFDestination)kvp.Value).OutputToPDF(context, writer);
                    writer.EndArrayEntry();
                    writer.WriteLine();
                }

                writer.EndArray();
                writer.EndDictionaryEntry();

                if (!string.IsNullOrEmpty(first) && !string.IsNullOrEmpty(last))
                {
                    writer.BeginDictionaryEntry("Limits");
                    writer.WriteArrayStringEntries(true, first, last);
                    writer.EndDictionaryEntry();
                }

                writer.EndDictionary();
                writer.EndObject();
            }
            else //we contain ICategorizedArtefactNameEntry(s)
            {
                oref = writer.BeginObject();
                writer.BeginDictionary();
                writer.BeginDictionaryEntry("Names");


                //string first = null;
                //string last = null;

                writer.BeginArray();
                foreach (KeyValuePair <string, IArtefactEntry> kvp in this.InnerEntries)
                {
                    //if (string.IsNullOrEmpty(first))
                    //    first = kvp.Key;
                    //else
                    //    last = kvp.Key;

                    writer.BeginArrayEntry();
                    writer.WriteStringLiteral(kvp.Key);
                    writer.EndArrayEntry();

                    writer.BeginArrayEntry();
                    ICategorisedArtefactNamesEntry entry = (ICategorisedArtefactNamesEntry)kvp.Value;

                    Native.PDFObjectRef entryOref = entry.OutputToPDF(context, writer);
                    if (null != entryOref)
                    {
                        writer.WriteObjectRef(entryOref);
                    }

                    writer.EndArrayEntry();
                    writer.WriteLine();
                }

                writer.EndArray();
                writer.EndDictionaryEntry();

                //Limits only required on Intermediate and Leaf nodes of a tree, not the root
                //if (!string.IsNullOrEmpty(first) && !string.IsNullOrEmpty(last))
                //{
                //    writer.BeginDictionaryEntry("Limits");
                //    writer.WriteArrayStringEntries(true, first, last);
                //    writer.EndDictionaryEntry();

                //}

                writer.EndDictionary();
                writer.EndObject();
            }

            return(oref);
        }
        //
        // methods
        //

        #region protected override PDFObjectRef DoRenderToPDF(PDFContextBase context, PDFWriter writer)

        /// <summary>
        /// Renders the tiling image
        /// </summary>
        /// <param name="context"></param>
        /// <param name="writer"></param>
        /// <returns></returns>
        protected override PDFObjectRef DoRenderToPDF(PDFContextBase context, PDFWriter writer)
        {
            IStreamFilter[] filters = writer.DefaultStreamFilters;
            PDFObjectRef    pattern = writer.BeginObject();

            writer.BeginDictionary();
            writer.WriteDictionaryNameEntry("Type", "Pattern");
            writer.WriteDictionaryNumberEntry("PatternType", (int)this.PatternType);
            writer.WriteDictionaryNumberEntry("PaintType", (int)this.PaintType);
            writer.WriteDictionaryNumberEntry("TilingType", (int)this.TilingType);
            writer.BeginDictionaryEntry("BBox");

            PDFPoint offset = new PDFPoint(this.Start.X, this.Start.Y - this.ImageSize.Height);// this.Start;
            PDFSize  size   = this.ImageSize;

            PDFSize graphicsSize = new PDFSize(size.Width + offset.X, size.Height + offset.Y);

            writer.WriteArrayRealEntries(true, offset.X.PointsValue,
                                         offset.Y.PointsValue,
                                         offset.X.PointsValue + size.Width.PointsValue,
                                         offset.Y.PointsValue + size.Height.PointsValue);

            writer.EndDictionaryEntry();

            writer.WriteDictionaryRealEntry("XStep", this.Step.Width.PointsValue);
            writer.WriteDictionaryRealEntry("YStep", this.Step.Height.PointsValue);

            PDFObjectRef all = this.Resources.WriteResourceList(context, writer);

            writer.WriteDictionaryObjectRefEntry("Resources", all);

            writer.BeginStream(pattern);

            using (PDFGraphics g = PDFGraphics.Create(writer, false, this, DrawingOrigin.TopLeft,
                                                      graphicsSize, context))
            {
                offset = new PDFPoint(offset.X, 0.0);
                g.PaintImageRef(this.Image, size, offset);
            }
            long len = writer.EndStream();

            if (null != filters && filters.Length > 0)
            {
                writer.BeginDictionaryEntry("Length");
                writer.WriteNumberS(len);
                writer.EndDictionaryEntry();
                writer.BeginDictionaryEntry("Filter");
                writer.BeginArray();
                foreach (IStreamFilter filter in filters)
                {
                    writer.BeginArrayEntry();
                    writer.WriteName(filter.FilterName);
                    writer.EndArrayEntry();
                }
                writer.EndArray();
                writer.EndDictionaryEntry();
            }
            else
            {
                writer.BeginDictionaryEntry("Length");
                writer.WriteNumberS(len);
                writer.EndDictionaryEntry();
            }

            writer.EndDictionary();
            writer.EndObject();

            return(pattern);
        }
Exemplo n.º 28
0
        protected virtual PDFObjectRef OutputContent(PDFRenderContext context, PDFWriter writer)
        {
            PDFObjectRef oref = writer.BeginObject();


            IStreamFilter[] filters = (context.Compression == OutputCompressionType.FlateDecode) ? this.PageCompressionFilters : null;
            writer.BeginStream(oref, filters);


            PDFPoint pt = context.Offset.Clone();
            PDFSize  sz = context.Space.Clone();

            using (PDFGraphics g = this.CreateGraphics(writer, context.StyleStack, context))
            {
                context.Graphics = g;

                if (null != this.HeaderBlock)
                {
                    this.HeaderBlock.OutputToPDF(context, writer);
                }

                this.ContentBlock.OutputToPDF(context, writer);

                if (null != this.FooterBlock)
                {
                    this.FooterBlock.OutputToPDF(context, writer);
                }

                if (_outputbadge)
                {
                    this.PaintBadgeXObj(context, writer);
                }
            }
            context.Offset = pt;
            context.Space  = sz;

            long len = writer.EndStream();

            writer.BeginDictionary();


            if (null != filters && filters.Length > 0)
            {
                writer.BeginDictionaryEntry("Length");
                writer.WriteNumberS(len);
                writer.EndDictionaryEntry();
                writer.BeginDictionaryEntry("Filter");
                writer.BeginArray();

                foreach (IStreamFilter filter in filters)
                {
                    writer.BeginArrayEntry();
                    writer.WriteName(filter.FilterName);
                    writer.EndArrayEntry();
                }
                writer.EndArray();
                writer.EndDictionaryEntry();
            }
            else
            {
                writer.BeginDictionaryEntry("Length");
                writer.WriteNumberS(len);
                writer.EndDictionaryEntry();
            }

            writer.EndDictionary();
            writer.EndObject();
            return(oref);
        }
Exemplo n.º 29
0
        protected override PDFObjectRef DoOutputToPDF(PDFRenderContext context, PDFWriter writer)
        {
            //Get the default font and size required for the DA (default Appearance value)
            var xObject = this._states[FormFieldAppearanceState.Normal];

            if (null == xObject)
            {
                return(null);
            }

            PDFObjectRef root = writer.BeginObject();

            var    font = this._style.CreateFont();
            var    rsrc = xObject.Document.GetResource(Scryber.Resources.PDFResource.FontDefnResourceType, font.FullName, true);
            string da   = rsrc.Name.ToString() + " " + font.Size.ToPoints().Value.ToString() + " Tf";

            writer.BeginDictionary();
            writer.WriteDictionaryNameEntry("Subtype", "Widget");
            writer.WriteDictionaryStringEntry("T", this.Name);

            if (!string.IsNullOrEmpty(this.Value))
            {
                writer.WriteDictionaryStringEntry("V", this.Value);
            }

            if (!string.IsNullOrEmpty(this.DefaultValue))
            {
                writer.WriteDictionaryStringEntry("DV", this.DefaultValue);
            }

            writer.WriteDictionaryNumberEntry("Ff", (int)this.FieldOptions + (int)this.FieldType);
            writer.WriteDictionaryStringEntry("DA", da);
            writer.WriteDictionaryNameEntry("FT", GetFieldTypeName(this.FieldType));
            if (null != this._page && null != this._page.PageObjectRef)
            {
                writer.WriteDictionaryObjectRefEntry("P", this._page.PageObjectRef);
            }

            //MK - appearance dictionary
            writer.BeginDictionaryEntry("MK");
            writer.BeginDictionary();

            if (this._style.IsValueDefined(Styles.StyleKeys.BorderColorKey))
            {
                WriteInputColor(context, writer, "BC", this._style.Border.Color);
            }
            if (this._style.IsValueDefined(Styles.StyleKeys.BgColorKey))
            {
                WriteInputColor(context, writer, "BG", this._style.Background.Color);
            }
            writer.EndDictionary();
            writer.EndDictionaryEntry();

            if (this._states.Count > 0)
            {
                _location = context.Offset;

                Drawing.PDFRect bounds = Drawing.PDFRect.Empty;
                writer.BeginDictionaryEntry("AP");
                writer.BeginDictionary();
                foreach (var kvp in _states)
                {
                    xObject = kvp.Value;
                    FormFieldAppearanceState state = kvp.Key;

                    PDFObjectRef oref = xObject.OutputToPDF(context, writer);

                    if (null != oref)
                    {
                        PDFSize sz = new Drawing.PDFSize(xObject.Width, xObject.Height);
                        if (_size == PDFSize.Empty)
                        {
                            _size = sz;
                        }
                        else
                        {
                            if (_size.Width < sz.Width)
                            {
                                _size.Width = sz.Width;
                            }
                            if (_size.Height < sz.Height)
                            {
                                _size.Height = sz.Height;
                            }
                        }
                        var name = GetFieldStateName(kvp.Key);
                        writer.WriteDictionaryObjectRefEntry(name, oref);

                        //We should have all states starting at the same location no matter what.
                        this._location = xObject.Location;
                    }
                }
                writer.EndDictionary();
                writer.EndDictionaryEntry();

                PDFReal left   = context.Graphics.GetXPosition(_location.X);
                PDFReal top    = context.Graphics.GetYPosition(_location.Y);
                PDFReal right  = left + context.Graphics.GetXOffset(_size.Width);
                PDFReal bottom = top + context.Graphics.GetYOffset(_size.Height);

                writer.BeginDictionaryEntry("Rect");
                writer.WriteArrayRealEntries(true, left.Value, bottom.Value, right.Value, top.Value);
                writer.EndDictionaryEntry();
            }
            writer.EndDictionary();
            writer.EndObject();
            //context.Offset = new PDFPoint(context.Offset.X, context.Offset.Y + _size.Height);
            return(root);
        }