コード例 #1
0
        private static BaseFont FindFontInFontDict(PdfDictionary fontDict,
                                                   string sourceFieldFontName)
        {
            var fieldFontName = fontDict.Keys
                                .FirstOrDefault(f =>
                                                sourceFieldFontName.StartsWith(f.ToString()));
            var iRef = (PRIndirectReference)fontDict
                       .GetAsIndirectObject(fieldFontName);
            var font = iRef != null?BaseFont.CreateFont(iRef) : null;

            if (!string.IsNullOrWhiteSpace(font?.Encoding))
            {
                return(font);
            }
            foreach (var fontName in fontDict.Keys)
            {
                iRef = (PRIndirectReference)fontDict
                       .GetAsIndirectObject(fontName);
                font = iRef != null?BaseFont.CreateFont(iRef) : null;

                if (!string.IsNullOrWhiteSpace(font?.Encoding))
                {
                    return(font);
                }
            }
            return(null);
        }
コード例 #2
0
 /**
  * Creates a StructureObject for an OBJR dictionary.
  * @param structElem	the parent structure element
  * @param ref			the reference of the parent structure element
  * @param dict			the object reference dictionary
  */
 public StructureObject(PdfDictionary structElem, PdfIndirectReference refa, PdfDictionary dict) {
     this.structElem = structElem;
     this.refa = refa;
     this.obj = dict.GetDirectObject(PdfName.OBJ);
     this.objref = dict.GetAsIndirectObject(PdfName.OBJ);
     this.structParent = ((PdfDictionary) obj).GetAsNumber(PdfName.STRUCTPARENT).IntValue;
     PdfIndirectReference pg = dict.GetAsIndirectObject(PdfName.PG);
     if (pg == null)
         pg = structElem.GetAsIndirectObject(PdfName.PG);
     this.pageref = pg.Number;
 }
コード例 #3
0
        /**
         * Creates a StructureObject for an OBJR dictionary.
         * @param structElem	the parent structure element
         * @param ref			the reference of the parent structure element
         * @param dict			the object reference dictionary
         */
        public StructureObject(PdfDictionary structElem, PdfIndirectReference refa, PdfDictionary dict)
        {
            this.structElem   = structElem;
            this.refa         = refa;
            this.obj          = dict.GetDirectObject(PdfName.OBJ);
            this.objref       = dict.GetAsIndirectObject(PdfName.OBJ);
            this.structParent = ((PdfDictionary)obj).GetAsNumber(PdfName.STRUCTPARENT).IntValue;
            PdfIndirectReference pg = dict.GetAsIndirectObject(PdfName.PG);

            if (pg == null)
            {
                pg = structElem.GetAsIndirectObject(PdfName.PG);
            }
            this.pageref = pg.Number;
        }
コード例 #4
0
        private void TestFile(String filename, int page, String objectid)
        {
            PdfReader pdfReader = TestResourceUtils.GetResourceAsPdfReader(TEST_RESOURCES_PATH, filename);

            try
            {
                PdfDictionary        resources = pdfReader.GetPageResources(page);
                PdfDictionary        xobjects  = resources.GetAsDict(PdfName.XOBJECT);
                PdfIndirectReference objRef    = xobjects.GetAsIndirectObject(new PdfName(objectid));
                if (objRef == null)
                {
                    throw new NullReferenceException("Reference " + objectid + " not found - Available keys are " + xobjects.Keys);
                }
                PRStream      stream        = (PRStream)PdfReader.GetPdfObject(objRef);
                PdfDictionary colorSpaceDic = resources != null?resources.GetAsDict(PdfName.COLORSPACE) : null;

                PdfImageObject img    = new PdfImageObject(stream, colorSpaceDic);
                byte[]         result = img.GetImageAsBytes();
                Assert.NotNull(result);
                int zeroCount = 0;
                foreach (byte b in result)
                {
                    if (b == 0)
                    {
                        zeroCount++;
                    }
                }
                Assert.IsTrue(zeroCount > 0);
            }
            finally
            {
                pdfReader.Close();
            }
        }
コード例 #5
0
// ---------------------------------------------------------------------------

        /**
         * Extracts document level attachments
         * @param PDF from which document level attachments will be extracted
         * @param zip the ZipFile object to add the extracted images
         */
        public void ExtractDocLevelAttachments(byte[] pdf, ZipFile zip)
        {
            PdfReader     reader        = new PdfReader(pdf);
            PdfDictionary root          = reader.Catalog;
            PdfDictionary documentnames = root.GetAsDict(PdfName.NAMES);
            PdfDictionary embeddedfiles =
                documentnames.GetAsDict(PdfName.EMBEDDEDFILES);
            PdfArray filespecs = embeddedfiles.GetAsArray(PdfName.NAMES);

            for (int i = 0; i < filespecs.Size;)
            {
                filespecs.GetAsString(i++);
                PdfDictionary filespec = filespecs.GetAsDict(i++);
                PdfDictionary refs     = filespec.GetAsDict(PdfName.EF);
                foreach (PdfName key in refs.Keys)
                {
                    PRStream stream = (PRStream)PdfReader.GetPdfObject(
                        refs.GetAsIndirectObject(key)
                        );
                    zip.AddEntry(
                        filespec.GetAsString(key).ToString(),
                        PdfReader.GetStreamBytes(stream)
                        );
                }
            }
        }
コード例 #6
0
        public Boolean PDFPortfolio(byte[] pdf, string filename, Boolean weitergabe, SPFolder tempfolder, string tempuploadurl, string DocID)
        {
            Boolean portfolio;

            using (PdfReader reader = new PdfReader(pdf))
            {
                PdfReader.unethicalreading = true;
                PdfDictionary documentNames = null;
                PdfDictionary embeddedFiles = null;
                PdfDictionary fileArray     = null;
                PdfDictionary file          = null;
                PRStream      stream        = null;
                PdfDictionary catalog       = reader.Catalog;
                documentNames = (PdfDictionary)PdfReader.GetPdfObject(catalog.Get(PdfName.NAMES));
                if (documentNames != null)
                {
                    //Erster Check: Portfolio ist vorhanden
                    embeddedFiles = (PdfDictionary)PdfReader.GetPdfObject(documentNames.Get(PdfName.EMBEDDEDFILES));
                    if (embeddedFiles != null)
                    {
                        //Zweiter Check: Portfolio ist wirklich vorhanden
                        portfolio = true;
                        PdfArray filespecs = embeddedFiles.GetAsArray(PdfName.NAMES);
                        for (int i = 0; i < filespecs.Size; i++)
                        {
                            i++;
                            fileArray = filespecs.GetAsDict(i);
                            file      = fileArray.GetAsDict(PdfName.EF);
                            int filecount = 0;
                            foreach (PdfName key in file.Keys)
                            {
                                stream = (PRStream)PdfReader.GetPdfObject(file.GetAsIndirectObject(key));
                                //string attachedFileName = folderName + fileArray.GetAsString(key).ToString();
                                filecount++;
                                string     attachedFileName     = DocID + "_" + filename + "_ExportFromPortfolio_" + i + ".pdf";
                                byte[]     attachedFileBytes    = PdfReader.GetStreamBytes(stream);
                                SPFile     attachmentuploadfile = tempfolder.Files.Add(tempuploadurl + attachedFileName, attachedFileBytes, true);
                                SPListItem attachmentitem       = attachmentuploadfile.Item;
                                attachmentitem["Weitergabe"] = weitergabe;
                                attachmentitem.SystemUpdate();
                            }
                        }
                    }
                    else
                    {
                        //Zweiter Check: Doch kein Portfolio vorhanden
                        portfolio = false;
                    }
                }
                else
                {
                    //Erster check: Kein Portfolio vorhanden
                    portfolio = false;
                }
            }
            return(portfolio);
        }
コード例 #7
0
        /**
         * Creates a StructureObject for an OBJR dictionary.
         * @param structElem	the parent structure element
         * @param ref			the reference of the parent structure element
         * @param dict			the object reference dictionary
         */
        public StructureObject(PdfDictionary structElem, PdfIndirectReference refa, PdfDictionary dict)
        {
            this.structElem = structElem;
            this.refa       = refa;
            this.obj        = dict.GetDirectObject(PdfName.OBJ);
            this.objref     = dict.GetAsIndirectObject(PdfName.OBJ);
            PdfNumber sp = ((PdfDictionary)obj).GetAsNumber(PdfName.STRUCTPARENT);

            if (sp == null)
            {
                throw new InvalidPdfException("structparentid.not.found");
            }
            this.structParent = sp.IntValue;
            PdfIndirectReference pg = dict.GetAsIndirectObject(PdfName.PG);

            if (pg == null)
            {
                pg = structElem.GetAsIndirectObject(PdfName.PG);
            }
            this.pageref = pg.Number;
        }
コード例 #8
0
        /**
         * Processes the kids object of a StructElem dictionary.
         * This kids object can be a number (MCID), another StructElem dictionary,
         * an MCR dictionary, an OBJR dictionary, or an array of the above.
         * @param structElem	the StructElem dictionary
         * @param ref			the reference to the StructElem dictionary
         * @param object		the kids object
         */

        protected virtual void ProcessStructElemKids(PdfDictionary structElem, PdfIndirectReference refa, PdfObject objecta)
        {
            if (LOGGER.IsLogging(Level.INFO))
            {
                LOGGER.Info(String.Format("addStructureItem({0}, {1}, {2})", structElem, refa, objecta));
            }
            if (objecta == null)
            {
                return;
            }
            StructureItem item;

            switch (objecta.Type)
            {
            case PdfObject.NUMBER:
                item = new StructureMCID(structElem.GetAsIndirectObject(PdfName.PG), (PdfNumber)objecta);
                Add(item);
                LOGGER.Info("Added " + item);
                break;

            case PdfObject.ARRAY:
                PdfArray array = (PdfArray)objecta;
                for (int i = 0; i < array.Size; i++)
                {
                    ProcessStructElemKids(structElem, array.GetAsIndirectObject(i), array.GetDirectObject(i));
                }
                break;

            case PdfObject.DICTIONARY:
                PdfDictionary dict = (PdfDictionary)objecta;
                if (dict.CheckType(PdfName.MCR))
                {
                    item = new StructureMCID(dict);
                    Add(item);
                    LOGGER.Info("Added " + item);
                }
                else if (dict.CheckType(PdfName.OBJR))
                {
                    item = new StructureObject(structElem, refa, dict);
                    Add(item);
                    LOGGER.Info("Added " + item);
                }
                else
                {
                    ProcessStructElems(dict, refa);
                }
                break;
            }
        }
コード例 #9
0
        public static string ExtractEdiconData(string srcEdiconPdfFileName)
        {
            PdfReader reader = null;

            //
            try
            {
                reader = new PdfReader(srcEdiconPdfFileName);
                //
                PdfDictionary root          = reader.Catalog;
                PdfDictionary documentnames = root.GetAsDict(PdfName.NAMES);
                PdfDictionary embeddedfiles = documentnames.GetAsDict(PdfName.EMBEDDEDFILES);
                PdfArray      filespecs     = embeddedfiles.GetAsArray(PdfName.NAMES);
                //
                for (int i = 0; i < filespecs.Size;)
                {
                    filespecs.GetAsString(i++);
                    PdfDictionary filespec = filespecs.GetAsDict(i++);
                    PdfDictionary refs     = filespec.GetAsDict(PdfName.EF);
                    //
                    foreach (PdfName key in refs.Keys)
                    {
                        PRStream stream = (PRStream)PdfReader.GetPdfObject(refs.GetAsIndirectObject(key));
                        //
                        var outName = filespec.GetAsString(key).ToString();
                        //
                        if (outName.Equals(EDICON_EMBED_FILENAME, StringComparison.OrdinalIgnoreCase))
                        {
                            byte[] outByteArray = PdfReader.GetStreamBytes(stream);
                            string ediconData   = Encoding.UTF8.GetString(outByteArray);
                            return(ediconData);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                //Console.WriteLine("ExtractEdiconData error: " + ex.Message);
                throw new EdiconException("Soubor neobsahuje platnou přílohu Edicon");
            }
            finally
            {
                if (reader != null)
                {
                    reader.Close();
                }
            }
            return(null);
        }
コード例 #10
0
        internal void ExtractAttachments(string file_name, string folderName, PdfWriter write)
        {
            PdfDictionary documentNames = null;
            PdfDictionary embeddedFiles = null;
            PdfDictionary fileArray     = null;
            PdfDictionary file          = null;
            PRStream      stream        = null;

            PdfReader     reader  = new PdfReader(file_name);
            PdfDictionary catalog = reader.Catalog;

            documentNames = (PdfDictionary)PdfReader.GetPdfObject(catalog.Get(PdfName.NAMES));

            if (documentNames != null)
            {
                embeddedFiles = (PdfDictionary)PdfReader.GetPdfObject(documentNames.Get(PdfName.EMBEDDEDFILES));
                if (embeddedFiles != null)
                {
                    PdfArray filespecs = embeddedFiles.GetAsArray(PdfName.NAMES);

                    for (int i = 0; i < filespecs.Size; i++)
                    {
                        i++;
                        fileArray = filespecs.GetAsDict(i);
                        file      = fileArray.GetAsDict(PdfName.EF);

                        foreach (PdfName key in file.Keys)
                        {
                            stream = (PRStream)PdfReader.GetPdfObject(file.GetAsIndirectObject(key));
                            string attachedFileName  = folderName + fileArray.GetAsString(key).ToString();
                            byte[] attachedFileBytes = PdfReader.GetStreamBytes(stream);
                            //graba el anexo extraido
                            System.IO.File.WriteAllBytes(attachedFileName, attachedFileBytes);
                            //adjunta los anexos
                            PdfFileSpecification pfs = PdfFileSpecification.FileEmbedded(write, attachedFileName, fileArray.GetAsString(key).ToString(), null);
                            write.AddFileAttachment(pfs);
                            //borramos los archivos extraidos
                            System.IO.File.Delete(attachedFileName);
                        }
                    }
                }
            }
        }
コード例 #11
0
        public void ManipulatePdf(string src, string dest)
        {
            PdfReader reader = new PdfReader(src);
            // We assume that there's a single large picture on the first page
            PdfDictionary page      = reader.GetPageN(1);
            PdfDictionary resources = page.GetAsDict(PdfName.RESOURCES);
            PdfDictionary xobjects  = resources.GetAsDict(PdfName.XOBJECT);

            Dictionary <PdfName, PdfObject> .KeyCollection.Enumerator enumerator = xobjects.Keys.GetEnumerator();
            enumerator.MoveNext();
            PdfName imgName = enumerator.Current;
            Image   img     = Image.GetInstance((PRIndirectReference)xobjects.GetAsIndirectObject(imgName));

            img.SetAbsolutePosition(0, 0);
            img.ScaleAbsolute(reader.GetPageSize(1));
            PdfStamper stamper = new PdfStamper(reader, new FileStream(dest, FileMode.Create));

            stamper.GetOverContent(1).AddImage(img);
            stamper.Close();
            reader.Close();
        }
コード例 #12
0
        /**
         * Displays an XObject using the registered handler for this XObject's subtype
         * @param xobjectName the name of the XObject to retrieve from the resource dictionary
         */
        private void DisplayXObject(PdfName xobjectName)
        {
            PdfDictionary xobjects      = resources.GetAsDict(PdfName.XOBJECT);
            PdfObject     xobject       = xobjects.GetDirectObject(xobjectName);
            PdfStream     xobjectStream = (PdfStream)xobject;

            PdfName subType = xobjectStream.GetAsName(PdfName.SUBTYPE);

            if (xobject.IsStream())
            {
                IXObjectDoHandler handler;
                xobjectDoHandlers.TryGetValue(subType, out handler);
                if (handler == null)
                {
                    handler = xobjectDoHandlers[PdfName.DEFAULT];
                }
                handler.HandleXObject(this, xobjectStream, xobjects.GetAsIndirectObject(xobjectName));
            }
            else
            {
                throw new InvalidOperationException(MessageLocalization.GetComposedMessage("XObject.1.is.not.a.stream", xobjectName));
            }
        }
コード例 #13
0
        /**
         * Creates a list of StructuredItem objects.
         * @param reader the reader holding the PDF to examine
         */
        public StructureItems(PdfReader reader)
        {
            PdfDictionary catalog = reader.Catalog;

            structTreeRoot = catalog.GetAsDict(PdfName.STRUCTTREEROOT);
            if (structTreeRoot == null)
            {
                throw new DocumentException(MessageLocalization.GetComposedMessage("can.t.read.document.structure"));
            }
            // Storing the parent tree
            parentTree = PdfNumberTree.ReadTree(structTreeRoot.GetAsDict(PdfName.PARENTTREE));
            structTreeRoot.Remove(PdfName.STRUCTPARENTS);
            // Examining the StructTreeRoot
            PdfObject objecta = structTreeRoot.GetDirectObject(PdfName.K);

            if (objecta == null)
            {
                return;
            }
            switch (objecta.Type)
            {
            case PdfObject.DICTIONARY:
                LOGGER.Info("StructTreeRoot refers to dictionary");
                ProcessStructElems((PdfDictionary)objecta, structTreeRoot.GetAsIndirectObject(PdfName.K));
                break;

            case PdfObject.ARRAY:
                LOGGER.Info("StructTreeRoot refers to array");
                PdfArray array = (PdfArray)objecta;
                for (int i = 0; i < array.Size; i++)
                {
                    ProcessStructElems(array.GetAsDict(i), array.GetAsIndirectObject(i));
                }
                break;
            }
        }
コード例 #14
0
ファイル: StructureMCID.cs プロジェクト: zinkpad/itextsharp
 /**
  * Creates a StructurItem using an MCR dictionary.
  * @param dict	an MCR dictionary
  */
 public StructureMCID(PdfDictionary mcr)
 {
     mcid    = mcr.GetAsNumber(PdfName.MCID).IntValue;
     pageref = mcr.GetAsIndirectObject(PdfName.PG).Number;
 }
コード例 #15
0
ファイル: StructureMCID.cs プロジェクト: newlysoft/itextsharp
 /**
  * Creates a StructurItem using an MCR dictionary.
  * @param dict	an MCR dictionary
  */
 public StructureMCID(PdfDictionary mcr)
 {
     mcid = mcr.GetAsNumber(PdfName.MCID).IntValue;
     pageref = mcr.GetAsIndirectObject(PdfName.PG).Number;
 }
コード例 #16
0
 private String GetParentIndRefStr(PdfDictionary dict)
 {
     return(dict.GetAsIndirectObject(PdfName.PARENT).ToString());
 }
コード例 #17
0
ファイル: MCParser.cs プロジェクト: w16014936/itextsharp
        /**
         * Converts an annotation structure item to a Form XObject annotation.
         * @param item the structure item
         * @throws IOException
         */
        protected void ConvertToXObject(StructureObject item)
        {
            PdfDictionary structElem = item.GetStructElem();

            if (structElem == null)
            {
                return;
            }
            PdfDictionary dict = item.GetObjAsDict();

            if (dict == null || !dict.CheckType(PdfName.ANNOT))
            {
                return;
            }
            PdfDictionary ap = dict.GetAsDict(PdfName.AP);

            if (ap == null)
            {
                return;
            }
            PdfNumber structParent = dict.GetAsNumber(PdfName.STRUCTPARENT);

            if (structParent == null)
            {
                return;
            }
            PdfStream stream = ap.GetAsStream(PdfName.N);

            if (stream == null)
            {
                return;
            }
            stream.Put(PdfName.STRUCTPARENT, structParent);
            PdfIndirectReference xobjr = ap.GetAsIndirectObject(PdfName.N);

            if (xobjr == null)
            {
                return;
            }
            // remove the annotation from the page
            for (int i = 0; i < annots.Length; i++)
            {
                PdfIndirectReference annotref = annots.GetAsIndirectObject(i);
                if (item.GetObjRef().Number == annotref.Number)
                {
                    annots.Remove(i);
                    break;
                }
            }
            // replace the existing attributes by a PrintField attribute
            PdfDictionary attribute = new PdfDictionary();

            attribute.Put(PdfName.O, PdfName.PRINTFIELD);
            PdfString description = dict.GetAsString(PdfName.TU);

            if (description == null)
            {
                description = dict.GetAsString(PdfName.T);
            }
            if (PdfName.BTN.Equals(dict.Get(PdfName.FT)))
            {
                PdfNumber fflags = dict.GetAsNumber(PdfName.FF);
                if (fflags != null)
                {
                    int ff = fflags.IntValue;
                    if ((ff & PdfFormField.FF_PUSHBUTTON) != 0)
                    {
                        attribute.Put(PdfName.ROLE, PdfName.PB);
                    }
                    // I don't think the condition below will ever be true
                    if ((ff & PdfFormField.FF_RADIO) != 0)
                    {
                        attribute.Put(PdfName.ROLE, PdfName.rb);
                    }
                    else
                    {
                        attribute.Put(PdfName.ROLE, PdfName.CB);
                    }
                }
            }
            else
            {
                attribute.Put(PdfName.ROLE, PdfName.TV);
            }
            attribute.Put(PdfName.DESC, description);
            // Updating the values of the StructElem dictionary
            PdfString t = structElem.GetAsString(PdfName.T);

            if (t == null || t.ToString().Trim().Length == 0)
            {
                structElem.Put(PdfName.T, dict.GetAsString(PdfName.T));
            }
            structElem.Put(PdfName.A, attribute);
            structElem.Put(PdfName.S, PdfName.P);
            structElem.Put(PdfName.PG, pageref);
            // Defining a new MCID
            int mcid = items.ProcessMCID(structParents, item.GetRef());

            LOGGER.Info("Using MCID " + mcid);
            structElem.Put(PdfName.K, new PdfNumber(mcid));
            // removing the annotation from the parent tree
            items.RemoveFromParentTree(structParent);
            // Adding the XObject to the page
            PdfName xobj = new PdfName("XObj" + structParent.IntValue);

            LOGGER.Info("Creating XObject with name " + xobj);
            xobjects.Put(xobj, xobjr);
            PdfArray array = dict.GetAsArray(PdfName.RECT);
            // Getting the position of the annotation
            Rectangle rect = new Rectangle(
                array.GetAsNumber(0).FloatValue, array.GetAsNumber(1).FloatValue,
                array.GetAsNumber(2).FloatValue, array.GetAsNumber(3).FloatValue);

            rect.Normalize();
            // A Do operator is forbidden inside a text block
            if (inText && !btWrite)
            {
                LOGGER.Debug("Introducing extra ET");
                byte[] bytes = Encoding.ASCII.GetBytes("ET\n");
                baos.Write(bytes, 0, bytes.Length);
                etExtra = true;
            }
            // Writing the marked-content sequence with the Do operator
            // Note that the position assumes that the CTM wasn't changed in the graphics state
            // TODO: do the math if the CTM did change!
            ByteBuffer buf = new ByteBuffer();

            buf.Append("/P <</MCID ");
            buf.Append(mcid);
            buf.Append(">> BDC\n");
            buf.Append("q 1 0 0 1 ");
            buf.Append(rect.Left.ToString(CultureInfo.InvariantCulture));
            buf.Append(" ");
            buf.Append(rect.Bottom.ToString(CultureInfo.InvariantCulture));
            buf.Append(" cm ");
            buf.Append(xobj.GetBytes());
            buf.Append(" Do Q\n");
            buf.Append("EMC\n");
            buf.Flush();
            buf.WriteTo(baos);
            // if we were inside a text block, we've introduced an ET, so we'll need to write a BT
            if (inText)
            {
                btWrite = true;
            }
        }
コード例 #18
0
        public static List <Attachment> GetAttachments(Stream stream, string password = null)
        {
            PdfReader reader = null;

            if (!string.IsNullOrWhiteSpace(password))
            {
                reader = new PdfReader(stream, Encoding.ASCII.GetBytes(password));
            }
            else
            {
                reader = new PdfReader(stream);
            }

            #region Variables

            PdfDictionary catalog       = null;
            PdfDictionary documentNames = null;
            PdfDictionary embeddedFiles = null;
            PdfDictionary fileArray     = null;
            PdfDictionary file          = null;

            PRStream prstream = null;

            Attachment        fContent = null;
            List <Attachment> lstAtt   = null;

            #endregion Variables

            catalog = reader.Catalog;

            lstAtt = new List <Attachment>();

            documentNames = (PdfDictionary)PdfReader.GetPdfObject(catalog.Get(PdfName.NAMES));

            if (documentNames != null)
            {
                embeddedFiles = (PdfDictionary)PdfReader.GetPdfObject(documentNames.Get(PdfName.EMBEDDEDFILES));
                if (embeddedFiles != null)
                {
                    PdfArray filespecs = embeddedFiles.GetAsArray(PdfName.NAMES);

                    for (int i = 0; i < filespecs.Size; i++)
                    {
                        i++;
                        fileArray = filespecs.GetAsDict(i);

                        file = fileArray.GetAsDict(PdfName.EF);

                        foreach (PdfName key in file.Keys)
                        {
                            prstream = (PRStream)PdfReader.GetPdfObject(file.GetAsIndirectObject(key));

                            fContent      = new Attachment();
                            fContent.Name = fileArray.GetAsString(key).ToString();

                            fContent.Content = PdfReader.GetStreamBytes(prstream);
                            lstAtt.Add(fContent);
                        }
                    }
                }
            }

            return(lstAtt);
        }