/** * Copies the output intent dictionary from other document to this one. * @param reader the other document * @param checkExistence <CODE>true</CODE> to just check for the existence of a valid output intent * dictionary, <CODE>false</CODE> to insert the dictionary if it exists * @throws IOException on error * @return <CODE>true</CODE> if the output intent dictionary exists, <CODE>false</CODE> * otherwise */ public override bool SetOutputIntents(PdfReader reader, bool checkExistence) { PdfDictionary catalog = reader.Catalog; PdfArray outs = catalog.GetAsArray(PdfName.OUTPUTINTENTS); if (outs == null) { return(false); } if (outs.Size == 0) { return(false); } PdfDictionary outa = outs.GetAsDict(0); PdfObject obj = PdfReader.GetPdfObject(outa.Get(PdfName.S)); if (obj == null || !PdfName.GTS_PDFA1.Equals(obj)) { return(false); } if (checkExistence) { return(true); } PRStream stream = (PRStream)PdfReader.GetPdfObject(outa.Get(PdfName.DESTOUTPUTPROFILE)); byte[] destProfile = null; if (stream != null) { destProfile = PdfReader.GetStreamBytes(stream); } SetOutputIntents(GetNameString(outa, PdfName.OUTPUTCONDITIONIDENTIFIER), GetNameString(outa, PdfName.OUTPUTCONDITION), GetNameString(outa, PdfName.REGISTRYNAME), GetNameString(outa, PdfName.INFO), destProfile); return(true); }
/// <summary> /// Updates the pagination in the footer. /// </summary> /// <param name="inputPdf">The pdf to modify.</param> /// <param name="outputPdf">The pdf created with updated pagination.</param> public static void UpdateFooterPagination(string inputPdf, string outputPdf) { PdfReader reader = new PdfReader(inputPdf); FileStream fs = new FileStream(outputPdf, FileMode.Create, FileAccess.Write); int n = reader.NumberOfPages; for (int i = 1; i <= n; i++) { PdfDictionary dict = reader.GetPageN(i); PdfObject obj = dict.GetDirectObject(PdfName.CONTENTS); if (obj.GetType() == typeof(PRStream)) { PRStream stream = (PRStream)obj; byte[] data = PdfReader.GetStreamBytes(stream); String oldStr = System.Text.Encoding.UTF8.GetString(data); //Get the string matching the pagination String pageString = CommonUtils.MatchRegex(oldStr, @"\[\(Seite \)\]TJ.*\[\("); //Regex replacement of page string with updated page number String updatedPageString = Regex.Replace(pageString, @"\[\(\d+\)\]", "[(" + i + ")]"); String newString = Regex.Replace(oldStr, @"\[\(Seite \)\]TJ.*\[\(", updatedPageString, RegexOptions.Singleline); stream.SetData(System.Text.Encoding.UTF8.GetBytes(newString)); } } PdfStamper stamper = new PdfStamper(reader, fs); stamper.Close(); reader.Close(); }
public static byte[] GetPictureFromPdf(Stream stream) { byte[] imageData = new byte[0]; string path = Path.Combine(Directory.GetParent(Directory.GetCurrentDirectory()).FullName, "wwwroot", "CV Parser", "Pictures"); using (PdfReader pdfReader = new PdfReader(stream)) { for (int i = 0; i < pdfReader.XrefSize; i++) { PdfObject po = pdfReader.GetPdfObject(i); if (po == null || !po.IsStream()) //object not found so continue { continue; } PRStream pst = (PRStream)po; PdfObject type = pst.Get(PdfName.SUBTYPE); //get the object type //check if the object is the image type object if (type != null && type.ToString().Equals(PdfName.IMAGE.ToString())) { PdfImageObject pio = new PdfImageObject(pst); int imageLength = pio.GetImageAsBytes().Length; if (imageLength != WatermarkSize && imageLength > imageData.Length) { imageData = pio.GetImageAsBytes(); } } } } return(imageData); }
/// <summary> /// Reemplaza las cadenas de texto que encuentre en el array de datos del PDF. /// </summary> /// <param name="obj"></param> private void ReplacePRStream(PdfObject obj) { PRStream prStream = (PRStream)obj; byte[] data = PdfReader.GetStreamBytes(prStream); prStream.SetData(ReplaceValues(data)); }
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(); } }
private static List <PdfObject> SearchAllStreams(PdfReader reader, PdfObject o) { List <PdfObject> results = new List <PdfObject>(); if (o.IsArray()) { var array = (o as PdfArray); // for (int i = 0; i < array.ArrayList; i++) foreach (var item in array.ArrayList) { results.AddRange(SearchAllStreams(reader, item)); } } else if (o.IsIndirect()) { var indirect = o as PdfIndirectReference; int num = indirect.Number; var child = reader.GetPdfObject(num); results.AddRange(SearchAllStreams(reader, child)); } else if (o.IsStream()) { PRStream stream = (PRStream)o; results.Add(stream); } return(results); }
private static void ExtractLines(PdfReader reader, StringBuilder sb, PdfObject content) { var ir = (PRIndirectReference)content; var value = reader.GetPdfObject(ir.Number); if (value.IsStream()) { PRStream stream = (PRStream)value; var streamBytes = PdfReader.GetStreamBytes(stream); var tokenizer = new PRTokeniser(new RandomAccessFileOrArray(streamBytes)); try { while (tokenizer.NextToken()) { if (tokenizer.TokenType == PRTokeniser.TK_STRING) { string str = tokenizer.StringValue; sb.Append(str); } } } finally { tokenizer.Close(); } } }
/// <summary> /// Uses the OCGParser on a page </summary> /// <param name="parser"> the OCGParser </param> /// <param name="page"> the page dictionary of the page that needs to be parsed. </param> /// <exception cref="IOException"> </exception> private void Parse(OCGParser parser, PdfDictionary page) { PRStream stream = (PRStream)page.GetAsStream(PdfName.CONTENTS); PdfDictionary resources = page.GetAsDict(PdfName.RESOURCES); parser.Parse(stream, resources); }
// --------------------------------------------------------------------------- /** * 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) ); } } }
/** * Gets OCSP responses from the Document Security Store. * @return a list of BasicOCSPResp objects * @throws IOException * @throws GeneralSecurityException */ virtual public List <BasicOcspResp> GetOCSPResponsesFromDSS() { List <BasicOcspResp> ocsps = new List <BasicOcspResp>(); if (dss == null) { return(ocsps); } PdfArray ocsparray = dss.GetAsArray(PdfName.OCSPS); if (ocsparray == null) { return(ocsps); } for (int i = 0; i < ocsparray.Size; i++) { PRStream stream = (PRStream)ocsparray.GetAsStream(i); OcspResp ocspResponse = new OcspResp(PdfReader.GetStreamBytes(stream)); if (ocspResponse.Status == 0) { try { ocsps.Add((BasicOcspResp)ocspResponse.GetResponseObject()); } catch (OcspException e) { throw new GeneralSecurityException(e.ToString()); } } } return(ocsps); }
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); }
private void PrepareImageObject() { if (imageObject != null) { return; } PRStream stream = (PRStream)PdfReader.GetPdfObject(refi); imageObject = new PdfImageObject(stream); }
public ImageInfo(PdfObject pdfObject, Matrix matrix, float pageUnits, int pageNumber, ImageRenderInfo renderInfo) { IsImage = false; ID = Guid.NewGuid(); PageNumber = pageNumber; _matrix = matrix; _pageUnits = pageUnits; _renderInfo = renderInfo; _imgObject = (PdfDictionary)PdfReader.GetPdfObject(pdfObject); PdfObject subType = _imgObject.Get(PdfName.SUBTYPE); if (subType == null) { return; } _stream = _imgObject as PRStream; _maskStream = (PRStream)_imgObject.GetAsStream(PdfName.MASK) ?? (PRStream)_imgObject.GetAsStream(PdfName.SMASK); IsMask = _maskStream != null; _fltr = _imgObject.Get(PdfName.FILTER); WidthPx = _imgObject.GetAsNumber(PdfName.WIDTH).IntValue; HeightPx = _imgObject.GetAsNumber(PdfName.HEIGHT).IntValue; BitsPerPixel = _imgObject.GetAsNumber(PdfName.BITSPERCOMPONENT).IntValue; PixelFormat = _DetectPixelFormat(); ImageFilter = _DetectImageFilter(); ImageFileType = _GetFileType(); ImageBytes = _GetImageBytes(); var ctmWidth = matrix[Matrix.I11]; var ctmHeight = matrix[Matrix.I22]; var ImgSize = new SizeF(WidthPx, HeightPx); var CtmSize = new SizeF(ctmWidth, ctmHeight); var ImgWidthScale = ImgSize.Width / CtmSize.Width; var ImgHeightScale = ImgSize.Height / CtmSize.Height; Dpix = ImgWidthScale * pageUnits; DpiY = ImgHeightScale * pageUnits; WidthMm = Utilities.PointsToMillimeters(ctmWidth); HeightMm = Utilities.PointsToMillimeters(ctmHeight); IsImage = true; }
private void Do_Form(PdfStream stream) { PdfDictionary resources = stream.GetAsDict(PdfName.RESOURCES); byte[] contentBytes = ContentByteUtils.GetContentBytesFromContentObject(stream); contentBytes = _modifier.Modify(contentBytes, resources); PRStream prStream = stream as PRStream; prStream.SetData(contentBytes); }
public virtual bool CompareStreams(PRStream outStream, PRStream cmpStream) { bool decodeStreams = PdfName.FLATEDECODE.Equals(outStream.Get(PdfName.FILTER)); byte[] outStreamBytes = PdfReader.GetStreamBytesRaw(outStream); byte[] cmpStreamBytes = PdfReader.GetStreamBytesRaw(cmpStream); if (decodeStreams) { outStreamBytes = PdfReader.DecodeBytes(outStreamBytes, outStream); cmpStreamBytes = PdfReader.DecodeBytes(cmpStreamBytes, cmpStream); } return(Util.ArraysAreEqual(outStreamBytes, cmpStreamBytes)); }
/** * Creates a PdfImage object. * @param stream a PRStream * @throws IOException */ public PdfImageObject(PRStream stream) { this.dictionary = stream; try { streamBytes = PdfReader.GetStreamBytes(stream); decoded = true; } catch { try { streamBytes = PdfReader.GetStreamBytesRaw(stream); } catch {} } }
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); }
public static void ReplaceStream(PRStream orig, PdfStream stream) { orig.Clear(); MemoryStream ms = new MemoryStream(); stream.WriteContent(ms); orig.SetData(ms.ToArray(), false); Console.WriteLine("Iterating keys"); foreach (System.Collections.Generic.KeyValuePair <PdfName, PdfObject> keyValuePair in stream) { orig.Put(keyValuePair.Key, stream.Get(keyValuePair.Key)); } }
private bool TryToReadImage(PRStream stream) { try { var pdfImage = new PdfImageObject(stream); picImage.Image = null; picImage.Image = pdfImage.GetDrawingImage(); tsMessage.Text = "Image Size = " + stream.Length; return(true); } catch (Exception e) { return(false); } }
private void PrepareImageObject() { if (imageObject != null) { return; } if (refi != null) { PRStream stream = (PRStream)PdfReader.GetPdfObject(refi); imageObject = new PdfImageObject(stream, colorSpaceDictionary); } else if (inlineImageInfo != null) { imageObject = new PdfImageObject(inlineImageInfo.ImageDictionary, inlineImageInfo.Samples, colorSpaceDictionary); } }
private void PrepareImageObject() { if (imageObject != null) { return; } if (refi != null) { PRStream stream = (PRStream)iTextSharp.text.pdf.PdfReader.GetPdfObject(refi); imageObject = new PdfImageObject(stream, colorSpaceDictionary); } else if (inlineImageInfo != null) { // 'iTextSharp.text.pdf.parser.PdfImageObject.PdfImageObject(iTextSharp.text.pdf.PdfDictionary, byte[], iTextSharp.text.pdf.PdfDictionary)' is inaccessible due to its protection level imageObject = new PdfImageObject(inlineImageInfo.ImageDictionary, inlineImageInfo.Samples, colorSpaceDictionary); } }
public List <DataTable> Load(MemoryStream stream) { var tables = new List <DataTable>(); var sb = new StringBuilder(); var reader = new PdfReader(stream); for (int page = 1; page <= reader.NumberOfPages; page++) { var cpage = reader.GetPageN(page); var content = cpage.Get(PdfName.CONTENTS); var ir = (PRIndirectReference)content; var value = reader.GetPdfObject(ir.Number); if (value.IsStream()) { PRStream prstream = (PRStream)value; var streamBytes = PdfReader.GetStreamBytes(prstream); var tokenizer = new PRTokeniser(new RandomAccessFileOrArray(streamBytes)); try { while (tokenizer.NextToken()) { if (tokenizer.TokenType == PRTokeniser.TK_STRING) { string str = tokenizer.StringValue; sb.AppendLine(str); } } } finally { tokenizer.Close(); } } } Console.WriteLine(sb.ToString()); return(tables); }
public static CMapToUnicode GetFontCMapToUnicode(PdfReader pdfReader, int pageNumber, string fontKey) { PdfDictionary resources = pdfReader.GetPageN(pageNumber).GetAsDict(PdfName.RESOURCES); var fontDict = FindFontDictionary(resources, fontKey); if (fontDict == null) { return(null); } PRStream toUnicodeIndirectReference = (PRStream)PdfReader.GetPdfObject(fontDict.Get(PdfName.TOUNICODE)); if (toUnicodeIndirectReference == null) { return(null); } string toUnicode = Encoding.UTF8.GetString(PdfReader.GetStreamBytes(toUnicodeIndirectReference)); return(CMapToUnicode.Parse(toUnicode)); }
/// <summary> /// Parses a stream object and removes OCGs. </summary> /// <param name="stream"> a stream object </param> /// <param name="resources"> the resources dictionary of that object (containing info about the OCGs) </param> public virtual void Parse(PRStream stream, PdfDictionary resources) { baos = new MemoryStream(); properties = resources.GetAsDict(PdfName.PROPERTIES); xobj = new HashSet2 <PdfName>(); PdfDictionary xobjects = resources.GetAsDict(PdfName.XOBJECT); if (xobjects != null) { // remove XObject (form or image) that belong to an OCG that needs to be removed foreach (PdfName name in xobjects.Keys) { PRStream xobject = (PRStream)xobjects.GetAsStream(name); PdfDictionary oc = xobject.GetAsDict(PdfName.OC); if (oc != null) { PdfString ocname = oc.GetAsString(PdfName.NAME); if (ocname != null && ocgs.Contains(ocname.ToString())) { xobj.Add(name); } } } foreach (PdfName name in xobj) { xobjects.Remove(name); } } // parse the content stream byte[] contentBytes = PdfReader.GetStreamBytes(stream); PRTokeniser tokeniser = new PRTokeniser(new RandomAccessFileOrArray(contentBytes)); PdfContentParser ps = new PdfContentParser(tokeniser); List <PdfObject> operands = new List <PdfObject>(); while (ps.Parse(operands).Count > 0) { PdfLiteral @operator = (PdfLiteral)operands[operands.Count - 1]; ProcessOperator(this, @operator, operands); } baos.Flush(); baos.Close(); stream.SetData(baos.GetBuffer()); }
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); } } } } }
private static void FixPageNumberOnStream(PRStream stream, string initialLabel, string newPageLabel) { if (stream == null) { throw new Exception("The stream is null"); } byte[] data = PdfReader.GetStreamBytes(stream); var utf8 = new UTF8Encoding(); string originalString = utf8.GetString(data); if (originalString.Contains($"({initialLabel})Tj")) { string newString = originalString .Replace($"({initialLabel})Tj", $"({newPageLabel})Tj") .Replace("/F2 1", "/F1 1"); byte[] newData = utf8.GetBytes(newString); stream.SetData(newData); } }
/** * Searches for a tag in a page. * * @param tag * the name of the tag * @param obj * an identifier to find the marked content * @param page * a page dictionary * @throws IOException */ public void ParseTag(String tag, PdfObject obj, PdfDictionary page) { PRStream stream = (PRStream)page.GetAsStream(PdfName.CONTENTS); // if the identifier is a number, we can extract the content right away if (obj is PdfNumber) { PdfNumber mcid = (PdfNumber)obj; RenderFilter filter = new MarkedContentRenderFilter(mcid.IntValue); ITextExtractionStrategy strategy = new SimpleTextExtractionStrategy(); FilteredTextRenderListener listener = new FilteredTextRenderListener(strategy, new RenderFilter[] { filter }); PdfContentStreamProcessor processor = new PdfContentStreamProcessor( listener); processor.ProcessContent(PdfReader.GetStreamBytes(stream), page .GetAsDict(PdfName.RESOURCES)); outp.Write(SimpleXMLParser.EscapeXML(listener.GetResultantText(), true)); } // if the identifier is an array, we call the parseTag method // recursively else if (obj is PdfArray) { PdfArray arr = (PdfArray)obj; int n = arr.Size; for (int i = 0; i < n; i++) { ParseTag(tag, arr[i], page); if (i < n - 1) { outp.WriteLine(); } } } // if the identifier is a dictionary, we get the resources from the // dictionary else if (obj is PdfDictionary) { PdfDictionary mcr = (PdfDictionary)obj; ParseTag(tag, mcr.GetDirectObject(PdfName.MCID), mcr .GetAsDict(PdfName.PG)); } }
static void Main(string[] args) { string pdfPath = "C:\\mypdf.pdf"; PdfReader reader = new PdfReader(pdfPath); StringBuilder sb = new StringBuilder(); for (int page = 1; page <= reader.NumberOfPages; page++) { var cpage = reader.GetPageN(page); var content = cpage.Get(PdfName.CONTENTS); var ir = (PRIndirectReference)content; var value = reader.GetPdfObject(ir.Number); if (value.IsStream()) { PRStream stream = (PRStream)value; var streamBytes = PdfReader.GetStreamBytes(stream); var tokenizer = new PRTokeniser(new RandomAccessFileOrArray(streamBytes)); try { while (tokenizer.NextToken()) { if (tokenizer.TokenType == PRTokeniser.TK_STRING) { string str = tokenizer.StringValue; sb.Append(str); } } } finally { tokenizer.Close(); } } } Console.Write("PDF Content:" + Environment.NewLine); Console.Write(sb.ToString()); Console.Write(Environment.NewLine + "--EOF--"); }
/** * Gets the content bytes from a content object, which may be a reference * a stream or an array. * @param contentObject the object to read bytes from * @return the content bytes * @throws IOException */ public static byte[] GetContentBytesFromContentObject(PdfObject contentObject) { byte[] result; switch (contentObject.Type) { case PdfObject.INDIRECT: PRIndirectReference refi = (PRIndirectReference)contentObject; PdfObject directObject = PdfReader.GetPdfObject(refi); result = GetContentBytesFromContentObject(directObject); break; case PdfObject.STREAM: PRStream stream = (PRStream)PdfReader.GetPdfObject(contentObject); result = PdfReader.GetStreamBytes(stream); break; case PdfObject.ARRAY: // Stitch together all content before calling ProcessContent(), because // ProcessContent() resets state. MemoryStream allBytes = new MemoryStream(); PdfArray contentArray = (PdfArray)contentObject; ListIterator <PdfObject> iter = contentArray.GetListIterator(); while (iter.HasNext()) { PdfObject element = iter.Next(); byte[] b; allBytes.Write(b = GetContentBytesFromContentObject(element), 0, b.Length); allBytes.WriteByte((byte)' '); } result = allBytes.ToArray(); break; default: String msg = "Unable to handle Content of type " + contentObject.GetType(); throw new InvalidOperationException(msg); } return(result); }
private string PdfObjectContents(PdfObject obj) { if (obj.IsStream()) { PRStream stream = (PRStream)obj; byte[] b; try { b = PdfReader.GetStreamBytes(stream); } catch (UnsupportedPdfException) { b = PdfReader.GetStreamBytesRaw(stream); } return(new string(b.ToCharArray())); } if (obj.IsDictionary()) { PdfDictionary dict = (PdfDictionary)obj; } return("yet unsupported:("); }
/** * Creates a PdfImage object. * @param stream a PRStream * @param colorSpaceDic a color space dictionary * @throws IOException */ public PdfImageObject(PRStream stream, PdfDictionary colorSpaceDic) : this(stream, PdfReader.GetStreamBytesRaw(stream), colorSpaceDic) { }
/** * Creates a PdfImage object. * @param stream a PRStream * @throws IOException */ public PdfImageObject(PRStream stream) : this(stream, PdfReader.GetStreamBytesRaw(stream), null) { }