/**
* <summary>Gets the object equivalent to the given value.</summary>
*/
public static PdfDirectObject Get(
object value
)
{
if (value == null)
{
return(null);
}
if (value is int)
{
return(PdfInteger.Get((int)value));
}
if (value is double || value is float)
{
return(PdfReal.Get(value));
}
if (value is string)
{
return(PdfTextString.Get((string)value));
}
if (value is DateTime)
{
return(PdfDate.Get((DateTime)value));
}
if (value is bool)
{
return(PdfBoolean.Get((bool)value));
}
throw new NotImplementedException();
}
public override bool MoveNext(
)
{
bool moved;
while (moved = base.MoveNext())
{
TokenTypeEnum tokenType = TokenType;
if (tokenType == TokenTypeEnum.Comment)
{
continue; // Comments are ignored.
}
if (tokenType == TokenTypeEnum.Literal)
{
string literalToken = (string)Token;
if (literalToken.StartsWith(Keyword.DatePrefix)) // Date.
{
/*
* NOTE: Dates are a weak extension to the PostScript language.
*/
try
{ Token = PdfDate.ToDate(literalToken); }
catch (ParseException)
{ /* NOOP: gently degrade to a common literal. */ }
}
}
break;
}
return(moved);
}
public void ParseDateString_WithNoOffset()
{
var pdfDate = new PdfDate("D:19981223195200Z");
var expectedDateWithOffset = new DateTimeOffset(new DateTime(1998, 12, 23, 19, 52, 0), new TimeSpan(0, 0, 0));
pdfDate.Value.ToUniversalTime().Should().Be(expectedDateWithOffset.UtcDateTime);
}
/// <summary>Sets the value of the collection item.</summary>
/// <param name="d"/>
public virtual void AddItem(String key, PdfDate d)
{
PdfCollectionField field = schema.GetField(key);
if (field.subType == PdfCollectionField.DATE)
{
GetPdfObject().Put(new PdfName(key), d.GetPdfObject());
}
}
/**
* Sets the value of the collection item.
* @param value
*/
virtual public void AddItem(String key, PdfDate d)
{
PdfName fieldname = new PdfName(key);
PdfCollectionField field = (PdfCollectionField)schema.Get(fieldname);
if (field.fieldType == PdfCollectionField.DATE)
{
Put(fieldname, d);
}
}
/// <summary>
/// Sets the value of the collection item.
/// </summary>
public void AddItem(string key, PdfDate d)
{
var fieldname = new PdfName(key);
var field = (PdfCollectionField)Schema.Get(fieldname);
if (field.FieldType == PdfCollectionField.DATE)
{
Put(fieldname, d);
}
}
private static DateTime?ToDate(PdfString pdfstr)
{
string strRet = null;
if (pdfstr != null)
{
strRet = pdfstr.ToUnicodeString();
return(PdfDate.Decode(strRet));
}
return(null);
}
///// <summary>
///// Fonts in file
///// </summary>
//internal List<Font> Fonts { get; set; }
public override string ToString()
=> new StringBuilder($"PDF description:")
.Append($"\r\n - Title: {Title}")
.Append($"\r\n - Author: {Author}")
.Append($"\r\n - Subject: {Subject}")
.Append($"\r\n - Keywords: {Keywords}")
.Append($"\r\n - Creator: {Creator}")
.Append($"\r\n - Producer: {Producer}")
.Append($"\r\n - Version: {Version}")
.Append($"\r\n - Creatioan date: " +
$"{(string.IsNullOrEmpty(CreationDate) ? string.Empty : PdfDate.Decode(CreationDate).ToString())}")
.Append($"\r\n - Modification date: " +
$"{(string.IsNullOrEmpty(ModificationDate) ? string.Empty : PdfDate.Decode(ModificationDate).ToString())}")
.ToString();
virtual public void AddDocInfoProperty(Object key, String value)
{
if (key is String)
{
key = new PdfName((String)key);
}
if (PdfName.TITLE.Equals(key))
{
xmpMeta.SetLocalizedText(XmpConst.NS_DC, DublinCoreProperties.TITLE, XmpConst.X_DEFAULT,
XmpConst.X_DEFAULT, value);
}
else if (PdfName.AUTHOR.Equals(key))
{
xmpMeta.AppendArrayItem(XmpConst.NS_DC, DublinCoreProperties.CREATOR,
new PropertyOptions(PropertyOptions.ARRAY_ORDERED), value, null);
}
else if (PdfName.SUBJECT.Equals(key))
{
xmpMeta.SetLocalizedText(XmpConst.NS_DC, DublinCoreProperties.DESCRIPTION, XmpConst.X_DEFAULT,
XmpConst.X_DEFAULT, value);
}
else if (PdfName.KEYWORDS.Equals(key))
{
foreach (String v in value.Split(',', ';'))
{
if (v.Trim().Length > 0)
{
xmpMeta.AppendArrayItem(XmpConst.NS_DC, DublinCoreProperties.SUBJECT, new PropertyOptions(PropertyOptions.ARRAY), v.Trim(), null);
}
}
xmpMeta.SetProperty(XmpConst.NS_PDF, PdfProperties.KEYWORDS, value);
}
else if (PdfName.PRODUCER.Equals(key))
{
xmpMeta.SetProperty(XmpConst.NS_PDF, PdfProperties.PRODUCER, value);
}
else if (PdfName.CREATOR.Equals(key))
{
xmpMeta.SetProperty(XmpConst.NS_XMP, XmpBasicProperties.CREATORTOOL, value);
}
else if (PdfName.CREATIONDATE.Equals(key))
{
xmpMeta.SetProperty(XmpConst.NS_XMP, XmpBasicProperties.CREATEDATE, PdfDate.GetW3CDate(value));
}
else if (PdfName.MODDATE.Equals(key))
{
xmpMeta.SetProperty(XmpConst.NS_XMP, XmpBasicProperties.MODIFYDATE, PdfDate.GetW3CDate(value));
}
}
/// <summary>
/// Prepares an
/// <see cref="PdfPKCS7"/>
/// instance for the given signature.
/// This method handles signature parsing and might throw an exception if
/// signature is malformed.
/// <p>
/// The returned
/// <see cref="PdfPKCS7"/>
/// can be used to fetch additional info about the signature
/// and also to perform integrity check of data signed by the given signature field.
/// </p>
/// Prepared
/// <see cref="PdfPKCS7"/>
/// instance calculates digest based on signature's /ByteRange entry.
/// In order to check that /ByteRange is properly defined and given signature indeed covers the current PDF document
/// revision please use
/// <see cref="SignatureCoversWholeDocument(System.String)"/>
/// method.
/// </summary>
/// <param name="signatureFieldName">the signature field name</param>
/// <param name="securityProvider">the security provider or null for the default provider</param>
/// <returns>
/// a
/// <see cref="PdfPKCS7"/>
/// instance which can be used to fetch additional info about the signature
/// and also to perform integrity check of data signed by the given signature field.
/// </returns>
public virtual PdfPKCS7 ReadSignatureData(String signatureFieldName)
{
PdfSignature signature = GetSignature(signatureFieldName);
if (signature == null)
{
return(null);
}
try {
PdfName sub = signature.GetSubFilter();
PdfString contents = signature.GetContents();
PdfPKCS7 pk = null;
if (sub.Equals(PdfName.Adbe_x509_rsa_sha1))
{
PdfString cert = signature.GetPdfObject().GetAsString(PdfName.Cert);
if (cert == null)
{
cert = signature.GetPdfObject().GetAsArray(PdfName.Cert).GetAsString(0);
}
pk = new PdfPKCS7(PdfEncodings.ConvertToBytes(contents.GetValue(), null), cert.GetValueBytes());
}
else
{
pk = new PdfPKCS7(PdfEncodings.ConvertToBytes(contents.GetValue(), null), sub);
}
UpdateByteRange(pk, signature);
PdfString date = signature.GetDate();
if (date != null)
{
pk.SetSignDate(PdfDate.Decode(date.ToString()));
}
String signName = signature.GetName();
pk.SetSignName(signName);
String reason = signature.GetReason();
if (reason != null)
{
pk.SetReason(reason);
}
String location = signature.GetLocation();
if (location != null)
{
pk.SetLocation(location);
}
return(pk);
}
catch (Exception e) {
throw new PdfException(e);
}
}
/**
* Returns a PdfObject that can be used as the value of a Collection Item.
* @param String value the value that has to be changed into a PdfObject (PdfString, PdfDate or PdfNumber)
*/
virtual public PdfObject GetValue(String v)
{
switch (fieldType)
{
case TEXT:
return(new PdfString(v, PdfObject.TEXT_UNICODE));
case DATE:
return(new PdfDate(PdfDate.Decode(v)));
case NUMBER:
return(new PdfNumber(v));
}
throw new InvalidOperationException(MessageLocalization.GetComposedMessage("1.is.not.an.acceptable.value.for.the.field.2", v, Get(PdfName.N).ToString()));
}
/// <summary>
/// Returns a PdfObject that can be used as the value of a Collection Item.
/// </summary>
public PdfObject GetValue(string v)
{
switch (FieldType)
{
case TEXT:
return(new PdfString(v, TEXT_UNICODE));
case DATE:
return(new PdfDate(PdfDate.Decode(v)));
case NUMBER:
return(new PdfNumber(v));
}
throw new InvalidOperationException($"{v} is not an acceptable value for the field {Get(PdfName.N)}");
}
public virtual void DontAddDateItemToAnotherSubTypeFieldTest()
{
String fieldName = "fieldName";
String timeValueAsString = "D:19860426012347+04'00'";
PdfDictionary pdfObject = new PdfDictionary();
pdfObject.Put(PdfName.Subtype, PdfName.F);
PdfCollectionField field = new PdfCollectionField(pdfObject);
PdfCollectionSchema schema = new PdfCollectionSchema();
schema.AddField(fieldName, field);
PdfCollectionItem item = new PdfCollectionItem(schema);
item.AddItem(fieldName, new PdfDate(PdfDate.Decode(timeValueAsString)));
NUnit.Framework.Assert.IsNull(item.GetPdfObject().GetAsString(new PdfName(fieldName)));
}
public virtual void AddDateItemTest()
{
String fieldName = "fieldName";
String timeValueAsString = "D:19860426012347+04'00'";
PdfDictionary pdfObject = new PdfDictionary();
pdfObject.Put(PdfName.Subtype, PdfName.D);
PdfCollectionField field = new PdfCollectionField(pdfObject);
PdfCollectionSchema schema = new PdfCollectionSchema();
schema.AddField(fieldName, field);
PdfCollectionItem item = new PdfCollectionItem(schema);
item.AddItem(fieldName, new PdfDate(PdfDate.Decode(timeValueAsString)));
NUnit.Framework.Assert.IsTrue(((PdfString)field.GetValue(timeValueAsString)).GetValue().StartsWith("D:1986"
));
}
private string GetModifyDatePdf(string fullPath)
{
try
{
using (PdfReader reader = new PdfReader(fullPath))
{
if (reader.Info.ContainsKey("ModDate"))
{
return(PdfDate.Decode(reader.Info["ModDate"]).ToString());
}
return(blank);
}
}
catch
{
return(cannotOpen);
}
}
public virtual PdfObject GetValue(String value)
{
switch (subType)
{
case TEXT: {
return(new PdfString(value));
}
case DATE: {
return(new PdfDate(PdfDate.Decode(value)).GetPdfObject());
}
case NUMBER: {
return(new PdfNumber(System.Double.Parse(value.Trim(), System.Globalization.CultureInfo.InvariantCulture)));
}
}
throw new PdfException(PdfException._1IsNotAnAcceptableValueForTheField2).SetMessageParams(value, GetPdfObject
().GetAsName(PdfName.N).GetValue());
}
public string Pdf_get_metadata(string path)
{
PdfDocument pdfDoc = new PdfDocument(new PdfReader(path));
Document doc = new Document(pdfDoc);
PdfFont pdfFont;
pdfFont = null;
PdfDictionary infoDictionary = pdfDoc.GetTrailer().GetAsDictionary(PdfName.Info);
string metadatastring = $"Metadata: {Environment.NewLine}";
foreach (PdfName key in infoDictionary.KeySet())
{
string keytext = infoDictionary.GetAsString(key).ToUnicodeString();
if (key == PdfName.CreationDate | key == PdfName.ModDate)
{
DateTime date = PdfDate.Decode(keytext);
keytext = date.ToString("dd/MM/yyyy HH:mm:ss");
}
string cleankey = ($"{ key }").Replace("/", "");
metadatastring += $"{cleankey}: {keytext}{Environment.NewLine}{Environment.NewLine}";
}
metadatastring += $"-----------------{Environment.NewLine}";
HashSet <string> fontinfo = Find_fonts(path);
if (fontinfo != null && fontinfo.Count > 0)
{
metadatastring += $"OCR present because pdf has {fontinfo.Count} fonts.{Environment.NewLine}-----------------{Environment.NewLine}";
}
else
{
metadatastring += $"OCR NOT present because pdf has no fonts.{Environment.NewLine}-----------------{Environment.NewLine}";
}
metadatastring += $"Pages: {pdfDoc.GetNumberOfPages().ToString()}" + Environment.NewLine;
return(metadatastring);
}
/// <summary>The date and time when the trap network was most recently modified.</summary>
/// <remarks>
/// The date and time when the trap network was most recently modified.
/// <para />
/// This entry is required if /Version (
/// <see cref="GetVersion()"/>
/// ) and /AnnotStates (
/// <see cref="GetAnnotStates()"/>
/// )
/// entries are absent; shall be absent if /Version and /AnnotStates entries are present.
/// </remarks>
/// <param name="lastModified">
/// a
/// <see cref="iText.Kernel.Pdf.PdfDate"/>
/// wrapper with the specified date.
/// </param>
/// <returns>
/// this
/// <see cref="PdfTrapNetworkAnnotation"/>
/// instance.
/// </returns>
public virtual iText.Kernel.Pdf.Annot.PdfTrapNetworkAnnotation SetLastModified(PdfDate lastModified)
{
return((iText.Kernel.Pdf.Annot.PdfTrapNetworkAnnotation)Put(PdfName.LastModified, lastModified.GetPdfObject
()));
}
public static DateTime ToDateTime(this string str)
{
return(PdfDate.Decode(str));
}
/**
* @param os
* @param info
* @throws IOException
*/
public XmpWriter(Stream os, Hashtable info) : this(os) {
if (info != null)
{
DublinCoreSchema dc = new DublinCoreSchema();
PdfSchema p = new PdfSchema();
XmpBasicSchema basic = new XmpBasicSchema();
String value;
foreach (String key in info.Keys)
{
value = (String)info[key];
if (value == null)
{
continue;
}
if ("Title".Equals(key))
{
dc.AddTitle(value);
}
if ("Author".Equals(key))
{
dc.AddAuthor(value);
}
if ("Subject".Equals(key))
{
dc.AddSubject(value);
}
if ("Keywords".Equals(key))
{
p.AddKeywords(value);
}
if ("Creator".Equals(key))
{
basic.AddCreatorTool(value);
}
if ("Producer".Equals(key))
{
p.AddProducer(value);
}
if ("CreationDate".Equals(key))
{
basic.AddCreateDate(PdfDate.GetW3CDate(value));
}
if ("ModDate".Equals(key))
{
basic.AddModDate(PdfDate.GetW3CDate(value));
}
}
if (dc.Count > 0)
{
AddRdfDescription(dc);
}
if (p.Count > 0)
{
AddRdfDescription(p);
}
if (basic.Count > 0)
{
AddRdfDescription(basic);
}
}
}
public static void CheckForXMPMetadataUpdateStrings(string file, Metadata metadata, OutputFormat format, bool encryption, string ownerPassword)
{
if (encryption)
{
file = GetDecryptedFile(file, ownerPassword);
}
var content = File.ReadAllText(file);
var regex = new Regex(@"(<.xpacket begin=[\s\S]*?<.xpacket end=.+>)");
var matches = regex.Matches(content);
string xmlString;
Assert.DoesNotThrow(() => { xmlString = matches[matches.Count - 1].ToString(); },
"Missing XMP Metadata starting and ending with \'<?xpacket\'.");
xmlString = matches[matches.Count - 1].ToString();
//Check if xmp structure is valid
var doc = new XmlDocument();
doc.LoadXml(xmlString); //Throws XmlException
doc.Schemas = new XmlSchemaSet();
var reader = new PdfReader(file);
var nsmgr = new XmlNamespaceManager(doc.NameTable);
nsmgr.AddNamespace("pdfaid", "http://www.aiim.org/pdfa/ns/id/");
nsmgr.AddNamespace("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#");
nsmgr.AddNamespace("dc", "http://purl.org/dc/elements/1.1/");
nsmgr.AddNamespace("xmp", "http://ns.adobe.com/xap/1.0/");
nsmgr.AddNamespace("xmpMM", "http://ns.adobe.com/xap/1.0/mm/");
nsmgr.AddNamespace("pdf", "http://ns.adobe.com/pdf/1.3/");
var node = doc.SelectSingleNode("//pdfaid:part", nsmgr);
Assert.NotNull(node, "PDF/A id part is not set.");
var part = format == OutputFormat.PdfA1B ? "1" : "2";
Assert.AreEqual(part, node.InnerText.Trim(), "PDF/A id part is not set properly.");
node = doc.SelectSingleNode("//pdfaid:conformance", nsmgr);
Assert.NotNull(node, "PDF/A id conformance is not set.");
Assert.AreEqual("B", node.InnerText.Trim(), "PDF/A id conformance is not set properly.");
node = doc.SelectSingleNode("//xmp:CreateDate", nsmgr);
Assert.NotNull(node, "Creation date is not set.");
var expectedDate = PdfDate.Decode(reader.Info["CreationDate"]);
var creationDate = DateTime.Parse(node.InnerText.Trim());
Assert.AreEqual(expectedDate, creationDate, "Creation date is wrong.");
node = doc.SelectSingleNode("//xmp:ModifyDate", nsmgr);
Assert.NotNull(node, "Modify date is not set.");
Assert.IsTrue(Regex.IsMatch(node.InnerText.Trim(), @"[1-2][0-9]{3}-[0-1][0-9]-[0-3][0-9]T[0-2][0-9]:[0-5][0-9]:[0-5][0-9]([\+\-Z][0-2][0-9]:[0-5][0-9]){0,1}"), "Modify date in wrong format.");
//same as creation date???
node = doc.SelectSingleNode("//dc:title/rdf:Alt/rdf:li", nsmgr);
Assert.NotNull(node, "Title is not set.");
Assert.AreEqual(metadata.Title, node.InnerText.Trim(), "Title is not set properly.");
node = doc.SelectSingleNode("//dc:description/rdf:Alt/rdf:li", nsmgr);
Assert.NotNull(node, "Description is not set.");
Assert.AreEqual(metadata.Subject, node.InnerText.Trim(), "Description (Subject) is not set properly.");
node = doc.SelectSingleNode("//dc:creator/rdf:Seq/rdf:li", nsmgr);
Assert.NotNull(node, "Creator is not set.");
Assert.AreEqual(metadata.Author, node.InnerText.Trim(), "Creator (Author) is not set properly.");
node = doc.SelectSingleNode("//pdf:Producer", nsmgr);
Assert.NotNull(node, "PDF producer is not set.");
Assert.IsTrue(Regex.IsMatch(node.InnerText.Trim(), "PDFCreator [0-9].[0-9].[0-9].[0-9].*"), "PDF producer is not PDFCreator X.X.X.X.");
node = doc.SelectSingleNode("//pdf:Keywords", nsmgr);
Assert.NotNull(node, "PDF Keywords are not set.");
Assert.AreEqual(metadata.Keywords, node.InnerText.Trim(), "Keywords are not set properly.");
/*
* node = doc.SelectSingleNode("//xmpMM:DocumentID", nsmgr);
* Assert.NotNull(node, "Document ID is not set.");
* Assert.IsTrue(Regex.IsMatch(node.InnerText.Trim(), @"uuid:[0-9A-Za-z\-]{32,}"), "Document ID in wrong format.");
* //*/
}
static void Main(string[] args)
{
Document document = new Document(PageSize.LETTER, 0f, 0f, 0f, 0f);
string inputFile = "Heroes Unlimited RPG - 2E.pdf";
string destinationFile = "OUT" + inputFile;
PdfWriter writer = PdfWriter.GetInstance(document, new FileStream(destinationFile, FileMode.Create));
writer.SetFullCompression();
PdfDate st = new PdfDate(DateTime.Today);
document.Open();
PdfContentByte cb = writer.DirectContent;
PdfImportedPage page;
int rotation;
int iPageNo = 1;
PdfReader reader = new PdfReader(inputFile);
int n = reader.NumberOfPages;
int i = 1;
while (i <= n)
{
document.NewPage();
PdfDictionary pg = reader.GetPageN(i);
// recursively search pages, forms and groups for images.
PdfObject obj = FindImageInPDFDictionary(pg);
if (obj != null)
{
int XrefIndex =
Convert.ToInt32(((PRIndirectReference)obj).Number.ToString(System.Globalization.CultureInfo
.InvariantCulture));
PdfObject pdfObj = reader.GetPdfObject(XrefIndex);
PdfStream pdfStrem = (PdfStream)pdfObj;
byte[] bytes = PdfReader.GetStreamBytesRaw((PRStream)pdfStrem);
if ((bytes != null))
{
using (System.IO.MemoryStream memStream = new System.IO.MemoryStream(bytes))
{
memStream.Position = 0;
System.Drawing.Image img = i == 1 || i == n?System.Drawing.Image.FromStream(memStream) ://let the first and last page stay the same size.
BitmapToGrayscale(ImageHelper.ResizeImage(System.Drawing.Image.FromStream(memStream), .35M));
ImageFormat format = img.PixelFormat == PixelFormat.Format1bppIndexed ||
img.PixelFormat == PixelFormat.Format4bppIndexed ||
img.PixelFormat == PixelFormat.Format8bppIndexed
? ImageFormat.Tiff
: ImageFormat.Jpeg;
var pdfImage = iTextSharp.text.Image.GetInstance(img, format);
pdfImage.Alignment = Element.ALIGN_CENTER;
pdfImage.ScaleToFit(document.PageSize.Width - 10, document.PageSize.Height - 10);
pdfImage.ColorTransform = 1;
//page = writer.GetImportedPage(reader, i);
document.Add(pdfImage);
}
}
}
i++;
Console.SetCursorPosition(0, 0);
Console.Write($"{((i*100)/(n)).ToString().PadLeft(3)}%");
}
Console.WriteLine("Complete");
document.Close();
// ExtractImagesFromPDF(inputFile, ".\\");
}
/// <summary>Sets the /M value.</summary>
/// <remarks>Sets the /M value. Should only be used if the time of signing is not available in the signature.</remarks>
/// <param name="date">time of signing</param>
public virtual void SetDate(PdfDate date)
{
Put(PdfName.M, date.GetPdfObject());
}
/**
* <summary>Parses the current PDF object [PDF:1.6:3.2].</summary>
*/
public virtual PdfDataObject ParsePdfObject(
)
{
switch (TokenType)
{
case TokenTypeEnum.Integer:
return(PdfInteger.Get((int)Token));
case TokenTypeEnum.Name:
return(new PdfName((string)Token, true));
case TokenTypeEnum.DictionaryBegin:
{
PdfDictionary dictionary = new PdfDictionary();
dictionary.Updateable = false;
while (true)
{
// Key.
MoveNext(); if (TokenType == TokenTypeEnum.DictionaryEnd)
{
break;
}
PdfName key = (PdfName)ParsePdfObject();
// Value.
MoveNext();
PdfDirectObject value = (PdfDirectObject)ParsePdfObject();
// Add the current entry to the dictionary!
dictionary[key] = value;
}
dictionary.Updateable = true;
return(dictionary);
}
case TokenTypeEnum.ArrayBegin:
{
PdfArray array = new PdfArray();
array.Updateable = false;
while (true)
{
// Value.
MoveNext(); if (TokenType == TokenTypeEnum.ArrayEnd)
{
break;
}
// Add the current item to the array!
array.Add((PdfDirectObject)ParsePdfObject());
}
array.Updateable = true;
return(array);
}
case TokenTypeEnum.Literal:
if (Token is DateTime)
{
return(PdfDate.Get((DateTime)Token));
}
else
{
return(new PdfTextString(
Encoding.Pdf.Encode((string)Token)
));
}
case TokenTypeEnum.Hex:
return(new PdfTextString(
(string)Token,
PdfString.SerializationModeEnum.Hex
));
case TokenTypeEnum.Real:
return(PdfReal.Get((double)Token));
case TokenTypeEnum.Boolean:
return(PdfBoolean.Get((bool)Token));
case TokenTypeEnum.Null:
return(null);
default:
throw new PostScriptParseException(String.Format("Unknown type beginning: '{0}'", Token), this);
}
}
/**
* <summary>Parse the next token [PDF:1.6:3.1].</summary>
* <remarks>
* Contract:
* <list type="bullet">
* <li>Preconditions:
* <list type="number">
* <item>To properly parse the current token, the pointer MUST be just before its starting (leading whitespaces are ignored).</item>
* </list>
* </item>
* <item>Postconditions:
* <list type="number">
* <item id="moveNext_contract_post[0]">When this method terminates, the pointer IS at the last byte of the current token.</item>
* </list>
* </item>
* <item>Invariants:
* <list type="number">
* <item>The byte-level position of the pointer IS anytime (during token parsing) at the end of the current token (whereas the 'current token' represents the token-level position of the pointer).</item>
* </list>
* </item>
* <item>Side-effects:
* <list type="number">
* <item>See <see href="#moveNext_contract_post[0]">Postconditions</see>.</item>
* </list>
* </item>
* </list>
* </remarks>
* <returns>Whether a new token was found.</returns>
*/
public bool MoveNext(
)
{
if (stream == null)
{
return(false);
}
/*
* NOTE: It'd be interesting to evaluate an alternative regular-expression-based
* implementation...
*/
int c = 0;
// Skip white-space characters [PDF:1.6:3.1.1].
while (true)
{
c = stream.ReadByte();
if (c == -1)
{
/* NOTE: Current stream has finished. */
// Move to the next stream!
MoveNextStream();
// No more streams?
if (stream == null)
{
return(false);
}
}
else if (!IsWhitespace(c)) // Keep goin' till there's a white-space character...
{
break;
}
}
StringBuilder buffer = null;
token = null;
// Which character is it?
switch (c)
{
case '/': // Name.
tokenType = TokenTypeEnum.Name;
buffer = new StringBuilder();
while ((c = stream.ReadByte()) != -1)
{
if (IsDelimiter(c) || IsWhitespace(c))
{
break;
}
// Is it an hexadecimal code [PDF:1.6:3.2.4]?
if (c == '#')
{
try
{ c = (GetHex(stream.ReadByte()) << 4) + GetHex(stream.ReadByte()); }
catch
{ throw new FileFormatException("Unexpected EOF (malformed hexadecimal code in name object).", stream.Position); }
}
buffer.Append((char)c);
}
stream.Skip(-1); // Recover the first byte after the current token.
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case '.':
case '-':
case '+': // Number [PDF:1.6:3.2.2] | Indirect reference.
switch (c)
{
case '.': // Decimal point.
tokenType = TokenTypeEnum.Real;
break;
default: // Digit or signum.
tokenType = TokenTypeEnum.Integer; // By default (it may be real).
break;
}
// Building the number...
buffer = new StringBuilder();
do
{
buffer.Append((char)c);
c = stream.ReadByte();
if (c == -1)
{
break;
}
if (c == '.')
{
tokenType = TokenTypeEnum.Real;
}
else if (c < '0' || c > '9')
{
break;
}
} while(true);
stream.Skip(-1); // Recover the first byte after the current token.
break;
case '[': // Array (begin).
tokenType = TokenTypeEnum.ArrayBegin;
break;
case ']': // Array (end).
tokenType = TokenTypeEnum.ArrayEnd;
break;
case '<': // Dictionary (begin) | Hexadecimal string.
c = stream.ReadByte();
if (c == -1)
{
throw new FileFormatException("Unexpected EOF (isolated opening angle-bracket character).", stream.Position);
}
// Is it a dictionary (2nd angle bracket [PDF:1.6:3.2.6])?
if (c == '<')
{
tokenType = TokenTypeEnum.DictionaryBegin;
break;
}
// Hexadecimal string (single angle bracket [PDF:1.6:3.2.3]).
tokenType = TokenTypeEnum.Hex;
// [FIX:0.0.4:4] It skipped after the first hexadecimal character, missing it.
buffer = new StringBuilder();
while (c != '>') // NOT string end.
{
buffer.Append((char)c);
c = stream.ReadByte();
if (c == -1)
{
throw new FileFormatException("Unexpected EOF (malformed hex string).", stream.Position);
}
}
break;
case '>': // Dictionary (end).
c = stream.ReadByte();
if (c != '>')
{
throw new FileFormatException("Malformed dictionary.", stream.Position);
}
tokenType = TokenTypeEnum.DictionaryEnd;
break;
case '(': // Literal string.
tokenType = TokenTypeEnum.Literal;
buffer = new StringBuilder();
int level = 0;
while (true)
{
c = stream.ReadByte();
if (c == -1)
{
break;
}
if (c == '(')
{
level++;
}
else if (c == ')')
{
level--;
}
else if (c == '\\')
{
bool lineBreak = false;
c = stream.ReadByte();
switch (c)
{
case 'n':
c = '\n';
break;
case 'r':
c = '\r';
break;
case 't':
c = '\t';
break;
case 'b':
c = '\b';
break;
case 'f':
c = '\f';
break;
case '(':
case ')':
case '\\':
break;
case '\r':
lineBreak = true;
c = stream.ReadByte();
if (c != '\n')
{
stream.Skip(-1);
}
break;
case '\n':
lineBreak = true;
break;
default:
{
// Is it outside the octal encoding?
if (c < '0' || c > '7')
{
break;
}
// Octal [PDF:1.6:3.2.3].
int octal = c - '0';
c = stream.ReadByte();
// Octal end?
if (c < '0' || c > '7')
{
c = octal; stream.Skip(-1); break;
}
octal = (octal << 3) + c - '0';
c = stream.ReadByte();
// Octal end?
if (c < '0' || c > '7')
{
c = octal; stream.Skip(-1); break;
}
octal = (octal << 3) + c - '0';
c = octal & 0xff;
break;
}
}
if (lineBreak)
{
continue;
}
if (c == -1)
{
break;
}
}
else if (c == '\r')
{
c = stream.ReadByte();
if (c == -1)
{
break;
}
if (c != '\n')
{
c = '\n'; stream.Skip(-1);
}
}
if (level == -1)
{
break;
}
buffer.Append((char)c);
}
if (c == -1)
{
throw new FileFormatException("Malformed literal string.", stream.Position);
}
break;
case '%': // Comment.
tokenType = TokenTypeEnum.Comment;
buffer = new StringBuilder();
while (true)
{
c = stream.ReadByte();
if (c == -1 ||
IsEOL(c))
{
break;
}
buffer.Append((char)c);
}
break;
default: // Keyword.
tokenType = TokenTypeEnum.Keyword;
buffer = new StringBuilder();
do
{
buffer.Append((char)c);
c = stream.ReadByte();
if (c == -1)
{
break;
}
} while(!IsDelimiter(c) && !IsWhitespace(c));
stream.Skip(-1); // Recover the first byte after the current token.
break;
}
if (buffer != null)
{
/*
* Here we prepare the current token state.
*/
// Wich token type?
switch (tokenType)
{
case TokenTypeEnum.Keyword:
token = buffer.ToString();
// Late recognition.
switch ((string)token)
{
case Keyword.False:
case Keyword.True: // Boolean.
tokenType = TokenTypeEnum.Boolean;
token = bool.Parse((string)token);
break;
case Keyword.Null: // Null.
tokenType = TokenTypeEnum.Null;
token = null;
break;
}
break;
case TokenTypeEnum.Comment:
case TokenTypeEnum.Hex:
case TokenTypeEnum.Name:
token = buffer.ToString();
break;
case TokenTypeEnum.Literal:
token = buffer.ToString();
// Late recognition.
if (((string)token).StartsWith("D:")) // Date.
{
tokenType = TokenTypeEnum.Date;
token = PdfDate.ToDate((string)token);
}
break;
case TokenTypeEnum.Integer:
token = Int32.Parse(
buffer.ToString(),
NumberStyles.Integer,
StandardNumberFormatInfo
);
break;
case TokenTypeEnum.Real:
// [FIX:1668410] Parsing of float numbers was buggy (localized default number format).
token = Single.Parse(
buffer.ToString(),
NumberStyles.Float,
StandardNumberFormatInfo
);
break;
}
}
return(true);
}
/// <summary>Verifies a signature.</summary>
/// <remarks>
/// Verifies a signature. Further verification can be done on the returned
/// <see cref="PdfPKCS7"/>
/// object.
/// </remarks>
/// <param name="name">the signature field name</param>
/// <param name="provider">the provider or null for the default provider</param>
/// <returns>PdfPKCS7 object to continue the verification</returns>
public virtual PdfPKCS7 VerifySignature(String name)
{
PdfDictionary v = GetSignatureDictionary(name);
if (v == null)
{
return(null);
}
try {
PdfName sub = v.GetAsName(PdfName.SubFilter);
PdfString contents = v.GetAsString(PdfName.Contents);
PdfPKCS7 pk = null;
if (sub.Equals(PdfName.Adbe_x509_rsa_sha1))
{
PdfString cert = v.GetAsString(PdfName.Cert);
if (cert == null)
{
cert = v.GetAsArray(PdfName.Cert).GetAsString(0);
}
pk = new PdfPKCS7(PdfEncodings.ConvertToBytes(contents.GetValue(), null), cert.GetValueBytes());
}
else
{
pk = new PdfPKCS7(PdfEncodings.ConvertToBytes(contents.GetValue(), null), sub);
}
UpdateByteRange(pk, v);
PdfString str = v.GetAsString(PdfName.M);
if (str != null)
{
pk.SetSignDate(PdfDate.Decode(str.ToString()));
}
PdfObject obj = v.Get(PdfName.Name);
if (obj != null)
{
if (obj.IsString())
{
pk.SetSignName(((PdfString)obj).ToUnicodeString());
}
else
{
if (obj.IsName())
{
pk.SetSignName(((PdfName)obj).GetValue());
}
}
}
str = v.GetAsString(PdfName.Reason);
if (str != null)
{
pk.SetReason(str.ToUnicodeString());
}
str = v.GetAsString(PdfName.Location);
if (str != null)
{
pk.SetLocation(str.ToUnicodeString());
}
return(pk);
}
catch (Exception e) {
throw new PdfException(e);
}
}
/// <summary>
/// @throws IOException
/// </summary>
/// <param name="os"></param>
/// <param name="info"></param>
public XmpWriter(Stream os, Hashtable info) : this(os)
{
if (info != null)
{
var dc = new DublinCoreSchema();
var p = new PdfSchema();
var basic = new XmpBasicSchema();
string value;
foreach (DictionaryEntry entry in info)
{
var key = (string)entry.Key;
value = (string)entry.Value;
if (value == null)
{
continue;
}
if ("Title".Equals(key))
{
dc.AddTitle(value);
}
if ("Author".Equals(key))
{
dc.AddAuthor(value);
}
if ("Subject".Equals(key))
{
dc.AddSubject(value);
dc.AddDescription(value);
}
if ("Keywords".Equals(key))
{
p.AddKeywords(value);
}
if ("Creator".Equals(key))
{
basic.AddCreatorTool(value);
}
if ("Producer".Equals(key))
{
p.AddProducer(value);
}
if ("CreationDate".Equals(key))
{
basic.AddCreateDate(PdfDate.GetW3CDate(value));
}
if ("ModDate".Equals(key))
{
basic.AddModDate(PdfDate.GetW3CDate(value));
}
}
if (dc.Count > 0)
{
AddRdfDescription(dc);
}
if (p.Count > 0)
{
AddRdfDescription(p);
}
if (basic.Count > 0)
{
AddRdfDescription(basic);
}
}
}
public static PDFFileInfo GetPDFMetaData(Stream pdfStream, string filePath, bool deepinfo)
{
var fileInfo = new PDFFileInfo();
fileInfo.FilePath = filePath;
fileInfo.FileName = System.IO.Path.GetFileName(filePath);
if (pdfStream.Length == 0)
{
fileInfo.ErrorMessages.Add("Zero length file");
return(fileInfo);
}
try
{
pdfStream.Position = 0; // Ensure that we are at the start
}
catch (NotSupportedException) { }
try
{
// Note: PdfReader Dispose closes the stream...
using (PdfReader reader = new PdfReader(pdfStream))
{
fileInfo.PDFVersion = reader.PdfVersion;
fileInfo.PageCount = reader.NumberOfPages;
fileInfo.FileSize = reader.FileLength;
if (reader.Info != null)
{
try
{
if (reader.Info.ContainsKey("CreationDate"))
{
fileInfo.CreationDate = PdfDate.Decode(reader.Info["CreationDate"]);
}
if (reader.Info.ContainsKey("ModDate"))
{
fileInfo.ModDate = PdfDate.Decode(reader.Info["ModDate"]);
}
}
catch (Exception ex)
{
fileInfo.ErrorMessages.Add($"PdfDate Decode {ex.Message.Replace(',',' ')}");
}
if (reader.Info.ContainsKey("Creator"))
{
fileInfo.Creator = reader.Info["Creator"];
}
if (reader.Info.ContainsKey("Producer"))
{
fileInfo.Producer = reader.Info["Producer"];
}
}
if (deepinfo)
{
var parser = new PdfReaderContentParser(reader);
ImageRenderListener listener = null;
for (var i = 1; i <= reader.NumberOfPages; i++)
{
var page = new PDFPageInfo();
try
{
parser.ProcessContent(i, (listener = new ImageRenderListener(fileInfo.ErrorMessages)));
}
catch (Exception ex)
{
fileInfo.ErrorMessages.Add($"Page {i} Image Processing Exception: {ex.Message.Replace(',', ' ')}");
}
try
{
var pageText = PdfTextExtractor.GetTextFromPage(reader, i, new SimpleTextExtractionStrategy());
page.TextCharacters += pageText.Length;
}
catch (System.ArgumentException ex)
{
fileInfo.ErrorMessages.Add($"Page {i} Text Extraction Exception {ex.Message.Replace(',', ' ')}");
}
page.PageNum = i;
page.ImageCount = listener.Images.Count;
page.Images = listener.Images;
for (int j = 0; j < page.ImageCount; j++)
{
page.Images[j].ImageNum = j + 1;
page.ImageBytes += page.Images[j].ImageBytes;
}
fileInfo.Pages.Add(page);
fileInfo.ImageCount += page.ImageCount;
fileInfo.ImageBytes += page.ImageBytes;
fileInfo.TextCharacters += page.TextCharacters;
}
}
}
}
catch (Exception ex)
{
fileInfo.ErrorMessages.Add(ex.Message);
}
return(fileInfo);
}
/**
* @param os
* @param info
* @throws IOException
*/
public XmpWriter(Stream os, IDictionary <string, string> info) : this(os) {
if (info != null)
{
DublinCoreSchema dc = new DublinCoreSchema();
PdfSchema p = new PdfSchema();
XmpBasicSchema basic = new XmpBasicSchema();
String value;
foreach (KeyValuePair <string, string> entry in info)
{
String key = entry.Key;
value = entry.Value;
if (value == null)
{
continue;
}
if ("Title".Equals(key))
{
dc.AddTitle(value);
}
if ("Author".Equals(key))
{
dc.AddAuthor(value);
}
if ("Subject".Equals(key))
{
dc.AddSubject(value);
dc.AddDescription(value);
}
if ("Keywords".Equals(key))
{
p.AddKeywords(value);
}
if ("Creator".Equals(key))
{
basic.AddCreatorTool(value);
}
if ("Producer".Equals(key))
{
p.AddProducer(value);
}
if ("CreationDate".Equals(key))
{
basic.AddCreateDate(PdfDate.GetW3CDate(value));
}
if ("ModDate".Equals(key))
{
basic.AddModDate(PdfDate.GetW3CDate(value));
}
}
if (dc.Count > 0)
{
AddRdfDescription(dc);
}
if (p.Count > 0)
{
AddRdfDescription(p);
}
if (basic.Count > 0)
{
AddRdfDescription(basic);
}
}
}
/**
* @param os
* @param info
* @throws IOException
*/
public XmpWriter(Stream os, PdfDictionary info, int PdfXConformance) : this(os) {
if (info != null)
{
DublinCoreSchema dc = new DublinCoreSchema();
PdfSchema p = new PdfSchema();
XmpBasicSchema basic = new XmpBasicSchema();
PdfObject obj;
String value;
foreach (PdfName key in info.Keys)
{
obj = info.Get(key);
if (obj == null)
{
continue;
}
value = ((PdfString)obj).ToUnicodeString();
if (PdfName.TITLE.Equals(key))
{
dc.AddTitle(value);
}
if (PdfName.AUTHOR.Equals(key))
{
dc.AddAuthor(value);
}
if (PdfName.SUBJECT.Equals(key))
{
dc.AddSubject(value);
dc.AddDescription(value);
}
if (PdfName.KEYWORDS.Equals(key))
{
p.AddKeywords(value);
}
if (PdfName.CREATOR.Equals(key))
{
basic.AddCreatorTool(value);
}
if (PdfName.PRODUCER.Equals(key))
{
p.AddProducer(value);
}
if (PdfName.CREATIONDATE.Equals(key))
{
basic.AddCreateDate(PdfDate.GetW3CDate(obj.ToString()));
}
if (PdfName.MODDATE.Equals(key))
{
basic.AddModDate(PdfDate.GetW3CDate(obj.ToString()));
}
}
if (dc.Count > 0)
{
AddRdfDescription(dc);
}
if (p.Count > 0)
{
AddRdfDescription(p);
}
if (basic.Count > 0)
{
AddRdfDescription(basic);
}
if (PdfXConformance == PdfWriter.PDFA1A || PdfXConformance == PdfWriter.PDFA1B)
{
PdfA1Schema a1 = new PdfA1Schema();
if (PdfXConformance == PdfWriter.PDFA1A)
{
a1.AddConformance("A");
}
else
{
a1.AddConformance("B");
}
AddRdfDescription(a1);
}
}
}
