|
public static GetPdfObject ( |
||
| obj | ||
| return | ||
//-------------------------------------------------------------------------
private bool ExtractImages(String PDFSourcePath, Audit sourceAudit, out Exception exception)
{
//List<System.Drawing.Image> ImgList = new List<System.Drawing.Image>();
exception = null;
iTextSharp.text.pdf.RandomAccessFileOrArray RAFObj = null;
iTextSharp.text.pdf.PdfReader PDFReaderObj = null;
iTextSharp.text.pdf.PdfObject PDFObj = null;
iTextSharp.text.pdf.PdfStream PDFStremObj = null;
int pageNumber = 0;
bool ok = false;
try
{
RAFObj = new iTextSharp.text.pdf.RandomAccessFileOrArray(PDFSourcePath);
PDFReaderObj = new iTextSharp.text.pdf.PdfReader(RAFObj, null);
for (int i = 0; i < PDFReaderObj.XrefSize; i++)
{
PDFObj = PDFReaderObj.GetPdfObject(i);
if ((PDFObj != null) && PDFObj.IsStream())
{
PDFStremObj = (iTextSharp.text.pdf.PdfStream)PDFObj;
iTextSharp.text.pdf.PdfObject subtype = PDFStremObj.Get(iTextSharp.text.pdf.PdfName.SUBTYPE);
if ((subtype != null) && subtype.ToString() == iTextSharp.text.pdf.PdfName.IMAGE.ToString())
{
try
{
iTextSharp.text.pdf.parser.PdfImageObject PdfImageObj =
new iTextSharp.text.pdf.parser.PdfImageObject((iTextSharp.text.pdf.PRStream)PDFStremObj);
System.Drawing.Image ImgPDF = PdfImageObj.GetDrawingImage();
pageNumber++;
if (pageNumber > PDFReaderObj.NumberOfPages)
return false;
}
catch (Exception)
{
}
}
}
}
pageNumber = 0;
PageCount = PDFReaderObj.NumberOfPages;
for (int i = 0; i < PDFReaderObj.XrefSize; i++)
{
PDFObj = PDFReaderObj.GetPdfObject(i);
if ((PDFObj != null) && PDFObj.IsStream())
{
PDFStremObj = (iTextSharp.text.pdf.PdfStream)PDFObj;
iTextSharp.text.pdf.PdfObject subtype = PDFStremObj.Get(iTextSharp.text.pdf.PdfName.SUBTYPE);
if ((subtype != null) && subtype.ToString() == iTextSharp.text.pdf.PdfName.IMAGE.ToString())
{
try
{
iTextSharp.text.pdf.parser.PdfImageObject PdfImageObj =
new iTextSharp.text.pdf.parser.PdfImageObject((iTextSharp.text.pdf.PRStream)PDFStremObj);
System.Drawing.Image ImgPDF = PdfImageObj.GetDrawingImage();
pageNumber++;
//using (Bitmap bmp = new Bitmap(ImgPDF))
//{
// SaveFrameFiles(PDFSourcePath, sourceAudit, bmp, pageNumber, PageCount);
try
{
SaveFrameFiles(PDFSourcePath, sourceAudit, (Bitmap)ImgPDF, pageNumber, PageCount);
}
catch (Exception)
{
ImgPDF.Dispose();
continue;
}
ImgPDF.Dispose();
ok = true;
//}
}
catch (Exception)
{ }
}
}
}
return ok;
}
catch (Exception)// ex
{
//log.LogMessage(PDFSourcePath + " Page" + pageNumber.ToString() + " ", ex);
return false;
}
finally
{
PDFReaderObj.Close();
PDFReaderObj.Dispose();
}
}
// ---------------------------------------------------------------------------
/**
* Manipulates a PDF file src
* @param src the original PDF
*/
public byte[] ManipulatePdf(byte[] src) {
PdfReader reader = new PdfReader(src);
PdfObject obj;
PdfDictionary action;
for (int i = 1; i < reader.XrefSize; i++) {
obj = reader.GetPdfObject(i);
if (obj is PdfDictionary) {
action = ((PdfDictionary)obj).GetAsDict(PdfName.A);
if (action == null) continue;
if (PdfName.LAUNCH.Equals(action.GetAsName(PdfName.S))) {
action.Remove(PdfName.F);
action.Remove(PdfName.WIN);
action.Put(PdfName.S, PdfName.JAVASCRIPT);
action.Put(PdfName.JS, new PdfString(
"app.alert('Launch Application Action removed by iText');\r"
));
}
}
}
using (MemoryStream ms = new MemoryStream()) {
using (PdfStamper stamper = new PdfStamper(reader, ms)) {
}
return ms.ToArray();
}
}
public static void ExtractImagesFromPDF(string password, string key, string docPath, string pagePath, PageCollection pages)
{
Page page = null;
// NOTE: This will only get the first image it finds per page.
PdfReader pdf = new PdfReader(Utility.Security.AES.DecryptFile(key, docPath));
//RandomAccessFileOrArray raf = new iTextSharp.text.pdf.RandomAccessFileOrArray(p);
try
{
for (int pageNumber = 1; pageNumber <= pdf.NumberOfPages; pageNumber++)
{
PdfDictionary pg = pdf.GetPageN(pageNumber);
// 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 = pdf.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 = System.Drawing.Image.FromStream(memStream);
// must save the file while stream is open.
page = new Page();
page.Order = pages.Count;
page.Save();
page.Token = Utility.Security.AES.GetToken(page.Id, password);
//string path = System.IO.Path.Combine(page.Filename, String.Format(@"{0}.jpg", pageNumber));
System.Drawing.Imaging.EncoderParameters parms = new System.Drawing.Imaging.EncoderParameters(1);
parms.Param[0] = new System.Drawing.Imaging.EncoderParameter(System.Drawing.Imaging.Encoder.Compression, 0);
System.Drawing.Imaging.ImageCodecInfo jpegEncoder = System.Drawing.Imaging.ImageCodecInfo.GetImageEncoders().FirstOrDefault(e => e.FormatDescription == "JPEG");
System.IO.MemoryStream ms = new System.IO.MemoryStream();
img.Save(ms, jpegEncoder, parms);
System.IO.File.WriteAllBytes(System.IO.Path.Combine(pagePath, page.Filename), SoftFluent.Samples.GED.Utility.Security.AES.EncryptStream(page.Token, ms.ToArray()).ToArray());
ms.Close();
pages.Add(page);
}
}
}
}
}
catch
{
throw;
}
finally
{
pdf.Close();
//raf.Close();
}
}
/// <summary>
/// Extract Image from PDF file and Store in Image Object
/// </summary>
/// <param name="pdfPath">Specify PDF Source Path</param>
/// <returns>elenco dei path relativi alle immagini estratte</returns>
public static List<string> ExtractImages(String pdfPath)
{
var pathTokens = pdfPath.Split(new char[] { '\\' });
var session = pathTokens[pathTokens.Length - 2];
var basePath = Path.GetDirectoryName(pdfPath);
var filename = Path.GetFileNameWithoutExtension(pdfPath);
List<string> urls = new List<string>();
RandomAccessFileOrArray RAFObj = null;
PdfReader PDFReaderObj = null;
PdfObject PDFObj = null;
PdfStream PDFStreamObj = null;
//try
//{
RAFObj = new RandomAccessFileOrArray(pdfPath);//(PDFSourcePath);
PDFReaderObj = new PdfReader(RAFObj, null);
var info = PDFReaderObj.Info;
var j = 0;
for (int i = 0; i <= PDFReaderObj.XrefSize - 1; i++)
{
PDFObj = PDFReaderObj.GetPdfObject(i);
if ((PDFObj != null) && PDFObj.IsStream())
{
PdfDictionary pd = (PdfDictionary)PDFObj;
PDFStreamObj = (iTextSharp.text.pdf.PdfStream)PDFObj;
iTextSharp.text.pdf.PdfObject subtype = PDFStreamObj.Get(iTextSharp.text.pdf.PdfName.SUBTYPE);
if ((subtype != null) && subtype.ToString() == iTextSharp.text.pdf.PdfName.IMAGE.ToString())
{
filename = filename + "_" + (++j).ToString();
byte[] bytes = PdfReader.GetStreamBytesRaw((iTextSharp.text.pdf.PRStream)PDFStreamObj);
Tiff tiff = Tiff.Open(Path.Combine(basePath, filename + ".tif"), "w");
tiff.SetField(TiffTag.IMAGEWIDTH, UInt32.Parse(pd.Get(PdfName.WIDTH).ToString()));
tiff.SetField(TiffTag.IMAGELENGTH, UInt32.Parse(pd.Get(PdfName.HEIGHT).ToString()));
tiff.SetField(TiffTag.COMPRESSION, Compression.CCITTFAX4);
tiff.SetField(TiffTag.BITSPERSAMPLE, UInt32.Parse(pd.Get(PdfName.BITSPERCOMPONENT).ToString()));
tiff.SetField(TiffTag.SAMPLESPERPIXEL, 1);
tiff.WriteRawStrip(0, bytes, bytes.Length);
tiff.Close();
var bmp = tiffToBitmap(Path.Combine(basePath, filename + ".tif"));
if (bmp != null)
{
bmp.Save(Path.Combine(basePath, filename + ".bmp"));
urls.Add( session + "/" + filename + ".bmp");
}
}
}
}
PDFReaderObj.Close();
return urls;
}
public List<System.Drawing.Image> GetImages(string path)
{
FileStream fs = File.OpenRead(path);
byte[] data = new byte[fs.Length];
fs.Read(data, 0, (int)fs.Length);
//List<double> match = new List<double>();
List<System.Drawing.Image> ImgList = new List<System.Drawing.Image>();
//iTextSharp.text.pdf.RandomAccessFileOrArray RAFObj = null;
PdfReader PDFReaderObj = null;
PdfObject PDFObj = null;
PdfStream PDFStremObj = null;
PdfDictionary dic;
//RAFObj = new RandomAccessFileOrArray(data);
PDFReaderObj = new PdfReader(path);
for (int i = 0; i <= PDFReaderObj.XrefSize - 1; i++)
{
PDFObj = PDFReaderObj.GetPdfObject(i);
string filter;
if ((PDFObj != null) && PDFObj.IsStream())
{
PDFStremObj = (PdfStream)PDFObj;
PdfObject subtype = PDFStremObj.Get(PdfName.SUBTYPE);
if ((subtype != null) && subtype.ToString() == PdfName.IMAGE.ToString())
{
byte[] bytes = PdfReader.GetStreamBytesRaw((PRStream)PDFStremObj);
if ((bytes != null))
{
dic = (PdfDictionary)PDFObj;
MemoryStream ms = new System.IO.MemoryStream(bytes);
filter = dic.Get(PdfName.FILTER).ToString();
if (filter.Equals("/DCTDecode"))
{
ms.Position = 0;
System.Drawing.Image ImgPDF = System.Drawing.Image.FromStream(ms);
ImgList.Add(ImgPDF);
}
}
}
}
}
PDFReaderObj.Close();
return ImgList;
}
public static void ExtractImagesFromPDF(string sourcePdf, string outputPath)
{
// NOTE: This will only get the first image it finds per page.
PdfReader pdf = new PdfReader(sourcePdf);
RandomAccessFileOrArray raf = new iTextSharp.text.pdf.RandomAccessFileOrArray(sourcePdf);
try
{
for (int pageNumber = 1; pageNumber <= pdf.NumberOfPages; pageNumber++)
{
PdfDictionary pg = pdf.GetPageN(pageNumber);
// 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 = pdf.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 = System.Drawing.Image.FromStream(memStream);
// must save the file while stream is open.
if (!Directory.Exists(outputPath))
Directory.CreateDirectory(outputPath);
string path = Path.Combine(outputPath, String.Format(@"{0}.jpg", pageNumber));
System.Drawing.Imaging.EncoderParameters parms = new System.Drawing.Imaging.EncoderParameters(1);
parms.Param[0] = new System.Drawing.Imaging.EncoderParameter(System.Drawing.Imaging.Encoder.Compression, 0);
System.Drawing.Imaging.ImageCodecInfo jpegEncoder = GetImageEncoder("JPEG");
img.Save(path, jpegEncoder, parms);
}
}
}
}
}
catch
{
throw;
}
finally
{
pdf.Close();
raf.Close();
}
}
// ---------------------------------------------------------------------------
/**
* Manipulates a PDF file src with the byte array as result
*/
public byte[] ManipulatePdf(byte[] pdf)
{
PdfName key = new PdfName("ITXT_SpecialId");
PdfName value = new PdfName("123456789");
// Read the file
PdfReader reader = new PdfReader(pdf);
int n = reader.XrefSize;
PdfObject pdfObject;
PRStream prStream;
// Look for image and manipulate image prStream
for (int i = 0; i < n; i++) {
pdfObject = reader.GetPdfObject(i);
if (pdfObject == null || !pdfObject.IsStream()) continue;
prStream = (PRStream) pdfObject;
byte[] imageBytes;
if (value.Equals(prStream.Get(key))) {
PdfImageObject image = new PdfImageObject(prStream);
using (System.Drawing.Image original = image.GetDrawingImage()) {
if (original == null) continue;
int width = (int)(original.Width * FACTOR);
int height = (int)(original.Height * FACTOR);
using (System.Drawing.Image thumb = new Bitmap(width, height) ) {
using ( Graphics graphic = Graphics.FromImage(thumb) ) {
graphic.DrawImage(original, 0, 0, width, height);
using (MemoryStream ms = new MemoryStream()) {
thumb.Save(ms, ImageFormat.Jpeg);
imageBytes = ms.ToArray();
}
}
}
prStream.Clear();
prStream.SetData(imageBytes, false, PRStream.NO_COMPRESSION);
prStream.Put(PdfName.TYPE, PdfName.XOBJECT);
prStream.Put(PdfName.SUBTYPE, PdfName.IMAGE);
prStream.Put(key, value);
prStream.Put(PdfName.FILTER, PdfName.DCTDECODE);
prStream.Put(PdfName.WIDTH, new PdfNumber(width));
prStream.Put(PdfName.HEIGHT, new PdfNumber(height));
prStream.Put(PdfName.BITSPERCOMPONENT, new PdfNumber(8));
prStream.Put(PdfName.COLORSPACE, PdfName.DEVICERGB);
}
}
}
// Save altered PDF
using (MemoryStream ms = new MemoryStream()) {
using (PdfStamper stamper = new PdfStamper(reader, ms)) {
}
return ms.ToArray();
}
}
private static List <System.Drawing.Image> ExtractImages(byte[] PDFSourcePath)
{
List <System.Drawing.Image> ImgList = new List <System.Drawing.Image>();
iTextSharp.text.pdf.PdfReader PDFReaderObj = null;
iTextSharp.text.pdf.PdfObject PDFObj = null;
iTextSharp.text.pdf.PdfStream PDFStremObj = null;
try
{
PDFReaderObj = new iTextSharp.text.pdf.PdfReader(PDFSourcePath, null);
for (int i = 0; i <= PDFReaderObj.XrefSize - 1; i++)
{
PDFObj = PDFReaderObj.GetPdfObject(i);
if ((PDFObj != null) && PDFObj.IsStream())
{
PDFStremObj = (iTextSharp.text.pdf.PdfStream)PDFObj;
iTextSharp.text.pdf.PdfObject subtype = PDFStremObj.Get(iTextSharp.text.pdf.PdfName.SUBTYPE);
if ((subtype != null) && subtype.ToString() == iTextSharp.text.pdf.PdfName.IMAGE.ToString())
{
try
{
iTextSharp.text.pdf.parser.PdfImageObject PdfImageObj =
new iTextSharp.text.pdf.parser.PdfImageObject((iTextSharp.text.pdf.PRStream)PDFStremObj);
System.Drawing.Image ImgPDF = PdfImageObj.GetDrawingImage();
ImgList.Add(ImgPDF);
}
catch (Exception)
{
}
}
}
}
PDFReaderObj.Close();
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
return(ImgList);
}
/**
* Removes the embedded font
*/
public void ManipulatePdf(String src, String dest)
{
CreatePdf(src);
// we create a reader instance
PdfReader reader = new PdfReader(src);
// we loop over all objects
PdfObject obj;
for (int i = 1; i < reader.XrefSize; i++)
{
obj = reader.GetPdfObject(i);
// we skip all objects that aren't a dictionary
if (obj == null || !obj.IsDictionary())
continue;
// we process all dictionaries
UnembedTTF((PdfDictionary) obj);
}
// removing unused objects will remove unused font file streams
reader.RemoveUnusedObjects();
// we persist the altered document
Stream os = new FileStream(dest, FileMode.Create);
PdfStamper stamper = new PdfStamper(reader, os);
stamper.Close();
}
// ---------------------------------------------------------------------------
/**
* Manipulates a PDF file src with the file dest as result
* @param src the original PDF
*/
public byte[] ManipulatePdf(byte[] src) {
// the font file
byte[] fontfile = null;
using (FileStream fs = new FileStream(
FONT, FileMode.Open, FileAccess.Read))
{
fontfile = new byte[fs.Length];
fs.Read(fontfile, 0, (int) fs.Length);
}
// create a new stream for the font file
PdfStream stream = new PdfStream(fontfile);
stream.FlateCompress();
stream.Put(PdfName.LENGTH1, new PdfNumber(fontfile.Length));
// create a reader object
PdfReader reader = new PdfReader(src);
int n = reader.XrefSize;
PdfDictionary font;
using (MemoryStream ms = new MemoryStream()) {
using (PdfStamper stamper = new PdfStamper(reader, ms)) {
PdfName fontname = new PdfName(FONTNAME);
for (int i = 0; i < n; i++) {
PdfObject objectPdf = reader.GetPdfObject(i);
if (objectPdf == null || !objectPdf.IsDictionary()) {
continue;
}
font = (PdfDictionary)objectPdf;
if (PdfName.FONTDESCRIPTOR.Equals(font.Get(PdfName.TYPE))
&& fontname.Equals(font.Get(PdfName.FONTNAME)))
{
PdfIndirectObject objref = stamper.Writer.AddToBody(stream);
font.Put(PdfName.FONTFILE2, objref.IndirectReference);
}
}
}
return ms.ToArray();
}
}
/// <summary>
/// Extracts the images from the given PDF file and save it into the given images folder
/// </summary>
/// <param name="sourcePdfFile"></param>
/// <param name="imagesFolderPath"></param>
public List<string> ExtractImages(string sourcePdfFile, string imagesFolderPath)
{
List<string> RetVal = new List<string>();
string ImageFileName = string.Empty;
RandomAccessFileOrArray raf = null;
PdfReader reader = null;
PdfObject pdfObj = null;
PdfStream pdfStream = null;
int ImageNo = 1;
try
{
raf = new RandomAccessFileOrArray(sourcePdfFile);
reader = new PdfReader(raf, null);
for (int i = 0; i < reader.XrefSize; i++)
{
pdfObj = reader.GetPdfObject(i);
if (pdfObj != null && pdfObj.IsStream())
{
pdfStream = (PdfStream)(pdfObj);
PdfObject subtype = pdfStream.Get(PdfName.SUBTYPE);
if (subtype != null && subtype.ToString() == PdfName.IMAGE.ToString())
{
Byte[] bytes = PdfReader.GetStreamBytesRaw((PRStream)(pdfStream));
if (bytes != null)
{
try
{
using (System.IO.MemoryStream memStream = new System.IO.MemoryStream(bytes))
{
memStream.Position = 0;
System.Drawing.Image img = System.Drawing.Image.FromStream(memStream);
ImageFileName = imagesFolderPath + "\\" + Path.GetFileNameWithoutExtension(sourcePdfFile) + "_" + ImageNo + ".png";
img.Save(ImageFileName);
RetVal.Add(imagesFolderPath + "\\" + Path.GetFileNameWithoutExtension(sourcePdfFile) + "_" + ImageNo + ".png");
ImageNo++;
}
}
catch (Exception ex)
{
//'Most likely the image is in an unsupported format
//'Do nothing
//'You can add your own code to handle this exception if you want to
}
}
}
}
}
reader.Close();
}
catch (Exception ex)
{
//ExceptionFacade.ThrowException(ex);
}
return RetVal;
}
/** Creates a new instance of DocumentFont */
internal DocumentFont(PRIndirectReference refFont)
{
this.refFont = refFont;
font = (PdfDictionary)PdfReader.GetPdfObject(refFont);
Init();
}
// public PdfObject GetPdfObject( int idx ) {
// return (PdfObject)arrayList[idx];
// }
public PdfObject GetDirectObject(int idx)
{
return(PdfReader.GetPdfObject(this[idx]));
}
//
// Event handler for extract images button
//
private void ExtractImageFromPdf1(string sourcePDF)
{
MemoryStream memStream;
byte[] bytes;
// Imagecount is used to allow a unique key to be generated for each image - the key will be the imagecount itsself
int imagecount = 0;
//
// Now we can start by loading the PDF document into our IText control
//
try
{
PdfReader rd = new PdfReader(sourcePDF);
for (int i = 0; i < rd.XrefSize; i++)
{
PdfObject pdfObj = rd.GetPdfObject(i);
if (pdfObj != null)
{
if (pdfObj.IsStream() == true)
{
PdfStream stream = (PdfStream)pdfObj;
PdfObject subtype = stream.Get(PdfName.SUBTYPE);
if (subtype != null)
{
if (subtype.ToString() == PdfName.IMAGE.ToString())
{
// Now we need to get the image stream
bytes = PdfReader.GetStreamBytesRaw((PRStream)stream);
if (bytes != null)
{
PdfDictionary dic = (PdfDictionary)pdfObj;
//
// Get the information about this image
//
String filter = dic.Get(PdfName.FILTER).ToString();
String width = dic.Get(PdfName.WIDTH).ToString();
String height = dic.Get(PdfName.HEIGHT).ToString();
String bpp = dic.Get(PdfName.BITSPERCOMPONENT).ToString();
String colorspace = dic.Get(PdfName.COLORSPACE).ToString();
try
{
BinaryWriter bw = null;
FileStream fs = null;
switch (filter)
{
case "/DCTDecode":
memStream = new MemoryStream(bytes);
memStream.Position = 0;
// Create the image from the stream
System.Drawing.Image img = System.Drawing.Image.FromStream(memStream);
// Save the image
img.Save(imagecount + ".jpg", ImageFormat.Jpeg);
break;
case "/JBIG2Decode":
// STANDARD HEADER NO PAGES, SEQUENTIAL ORDER
byte[] JBIGHeader = new byte[] { 0x97, 0x4a, 0x42, 0x32, 0x0d, 0x0a, 0x1a, 0x0a, 0x3 };
fs = new FileStream(imagecount + ".jb2", FileMode.Create, FileAccess.ReadWrite);
bw = new BinaryWriter(fs);
bw.Write(JBIGHeader);
bw.Write(bytes);
bw.Close();
break;
case "/FlateDecode":
PixelFormat pf = PixelFormat.Format24bppRgb;
string fileext = ".png";
ImageFormat imgformat = ImageFormat.Png;
int actualw = Int32.Parse(width);
int actualh = Int32.Parse(height);
switch (Int32.Parse(bpp))
{
case 1:
pf = PixelFormat.Format1bppIndexed;
imgformat = ImageFormat.Gif;
fileext = ".gif";
break;
case 8:
pf = PixelFormat.Format8bppIndexed;
imgformat = ImageFormat.Png;
fileext = ".png";
break;
case 24:
pf = PixelFormat.Format24bppRgb;
break;
default:
Debug.Write("Unknown Pixel Format: " + bpp);
break;
}
bytes = PdfReader.FlateDecode(bytes, true);
//Prepare a working image buffer to recreate the PDF image
Bitmap bmp = new Bitmap(actualw, actualh, pf);
BitmapData bmd = bmp.LockBits(new System.Drawing.Rectangle(0, 0, actualw, actualh), ImageLockMode.WriteOnly, pf);
//Now the complex part of working out how to process the byte stream
//We need the w,h,bpp, and component
//gray/rgb/cmyk
bmp.UnlockBits(bmd);
bmp.Save(imagecount + fileext, imgformat);
break;
default:
// Unhandled filter
break;
}
// Increase our image
imagecount++;
}
catch
{
// Unknown image type
Debug.Write("Image error");
//MessageBox.Show("Unknown image or something!");
}
}
}
}
}
}
}
}
catch
{
//MessageBox.Show("Error reading the PDF document.");
}
// Show how many we actually extracted
//MessageBox.Show("Processed " + imagecount + " images");
//// Should we show the output folder?
//ShowOutputFolder();
}
private static IList <Dictionary <String, Object> > BookmarkDepth(PdfReader reader, PdfDictionary outline, IntHashtable pages)
{
List <Dictionary <String, Object> > list = new List <Dictionary <String, Object> >();
while (outline != null)
{
Dictionary <String, Object> map = new Dictionary <string, object>();
PdfString title = (PdfString)PdfReader.GetPdfObjectRelease(outline.Get(PdfName.TITLE));
map["Title"] = title.ToUnicodeString();
PdfArray color = (PdfArray)PdfReader.GetPdfObjectRelease(outline.Get(PdfName.C));
if (color != null && color.Size == 3)
{
ByteBuffer outp = new ByteBuffer();
outp.Append(color.GetAsNumber(0).FloatValue).Append(' ');
outp.Append(color.GetAsNumber(1).FloatValue).Append(' ');
outp.Append(color.GetAsNumber(2).FloatValue);
map["Color"] = PdfEncodings.ConvertToString(outp.ToByteArray(), null);
}
PdfNumber style = (PdfNumber)PdfReader.GetPdfObjectRelease(outline.Get(PdfName.F));
if (style != null)
{
int f = style.IntValue;
String s = "";
if ((f & 1) != 0)
{
s += "italic ";
}
if ((f & 2) != 0)
{
s += "bold ";
}
s = s.Trim();
if (s.Length != 0)
{
map["Style"] = s;
}
}
PdfNumber count = (PdfNumber)PdfReader.GetPdfObjectRelease(outline.Get(PdfName.COUNT));
if (count != null && count.IntValue < 0)
{
map["Open"] = "false";
}
try {
PdfObject dest = PdfReader.GetPdfObjectRelease(outline.Get(PdfName.DEST));
if (dest != null)
{
MapGotoBookmark(map, dest, pages); //changed by ujihara 2004-06-13
}
else
{
PdfDictionary action = (PdfDictionary)PdfReader.GetPdfObjectRelease(outline.Get(PdfName.A));
if (action != null)
{
if (PdfName.GOTO.Equals(PdfReader.GetPdfObjectRelease(action.Get(PdfName.S))))
{
dest = PdfReader.GetPdfObjectRelease(action.Get(PdfName.D));
if (dest != null)
{
MapGotoBookmark(map, dest, pages);
}
}
else if (PdfName.URI.Equals(PdfReader.GetPdfObjectRelease(action.Get(PdfName.S))))
{
map["Action"] = "URI";
map["URI"] = ((PdfString)PdfReader.GetPdfObjectRelease(action.Get(PdfName.URI))).ToUnicodeString();
}
else if (PdfName.JAVASCRIPT.Equals(PdfReader.GetPdfObjectRelease(action.Get(PdfName.S))))
{
map["Action"] = "JS";
map["Code"] = PdfReader.GetPdfObjectRelease(action.Get(PdfName.JS)).ToString();
}
else if (PdfName.GOTOR.Equals(PdfReader.GetPdfObjectRelease(action.Get(PdfName.S))))
{
dest = PdfReader.GetPdfObjectRelease(action.Get(PdfName.D));
if (dest != null)
{
if (dest.IsString())
{
map["Named"] = dest.ToString();
}
else if (dest.IsName())
{
map["NamedN"] = PdfName.DecodeName(dest.ToString());
}
else if (dest.IsArray())
{
PdfArray arr = (PdfArray)dest;
StringBuilder s = new StringBuilder();
s.Append(arr[0].ToString());
s.Append(' ').Append(arr[1].ToString());
for (int k = 2; k < arr.Size; ++k)
{
s.Append(' ').Append(arr[k].ToString());
}
map["Page"] = s.ToString();
}
}
map["Action"] = "GoToR";
PdfObject file = PdfReader.GetPdfObjectRelease(action.Get(PdfName.F));
if (file != null)
{
if (file.IsString())
{
map["File"] = ((PdfString)file).ToUnicodeString();
}
else if (file.IsDictionary())
{
file = PdfReader.GetPdfObject(((PdfDictionary)file).Get(PdfName.F));
if (file.IsString())
{
map["File"] = ((PdfString)file).ToUnicodeString();
}
}
}
PdfObject newWindow = PdfReader.GetPdfObjectRelease(action.Get(PdfName.NEWWINDOW));
if (newWindow != null)
{
map["NewWindow"] = newWindow.ToString();
}
}
else if (PdfName.LAUNCH.Equals(PdfReader.GetPdfObjectRelease(action.Get(PdfName.S))))
{
map["Action"] = "Launch";
PdfObject file = PdfReader.GetPdfObjectRelease(action.Get(PdfName.F));
if (file == null)
{
file = PdfReader.GetPdfObjectRelease(action.Get(PdfName.WIN));
}
if (file != null)
{
if (file.IsString())
{
map["File"] = ((PdfString)file).ToUnicodeString();
}
else if (file.IsDictionary())
{
file = PdfReader.GetPdfObjectRelease(((PdfDictionary)file).Get(PdfName.F));
if (file.IsString())
{
map["File"] = ((PdfString)file).ToUnicodeString();
}
}
}
}
}
}
}
catch {
//empty on purpose
}
PdfDictionary first = (PdfDictionary)PdfReader.GetPdfObjectRelease(outline.Get(PdfName.FIRST));
if (first != null)
{
map["Kids"] = BookmarkDepth(reader, first, pages);
}
list.Add(map);
outline = (PdfDictionary)PdfReader.GetPdfObjectRelease(outline.Get(PdfName.NEXT));
}
return(list);
}
public void AddAnnotation(PdfAnnotation annot)
{
ArrayList allAnnots = new ArrayList();
if (annot.IsForm())
{
PdfFormField field = (PdfFormField)annot;
if (field.Parent != null)
{
return;
}
ExpandFields(field, allAnnots);
if (cstp.fieldTemplates == null)
{
cstp.fieldTemplates = new Hashtable();
}
}
else
{
allAnnots.Add(annot);
}
for (int k = 0; k < allAnnots.Count; ++k)
{
annot = (PdfAnnotation)allAnnots[k];
if (annot.IsForm())
{
if (!annot.IsUsed())
{
Hashtable templates = annot.Templates;
if (templates != null)
{
foreach (object tpl in templates.Keys)
{
cstp.fieldTemplates[tpl] = null;
}
}
}
PdfFormField field = (PdfFormField)annot;
if (field.Parent == null)
{
AddDocumentField(field.IndirectReference);
}
}
if (annot.IsAnnotation())
{
PdfObject pdfobj = PdfReader.GetPdfObject(pageN.Get(PdfName.ANNOTS), pageN);
PdfArray annots = null;
if (pdfobj == null || !pdfobj.IsArray())
{
annots = new PdfArray();
pageN.Put(PdfName.ANNOTS, annots);
}
else
{
annots = (PdfArray)pdfobj;
}
annots.Add(annot.IndirectReference);
if (!annot.IsUsed())
{
PdfRectangle rect = (PdfRectangle)annot.Get(PdfName.RECT);
if (rect != null && (rect.Left != 0 || rect.Right != 0 || rect.Top != 0 || rect.Bottom != 0))
{
int rotation = reader.GetPageRotation(pageN);
Rectangle pageSize = reader.GetPageSizeWithRotation(pageN);
switch (rotation)
{
case 90:
annot.Put(PdfName.RECT, new PdfRectangle(
pageSize.Top - rect.Bottom,
rect.Left,
pageSize.Top - rect.Top,
rect.Right));
break;
case 180:
annot.Put(PdfName.RECT, new PdfRectangle(
pageSize.Right - rect.Left,
pageSize.Top - rect.Bottom,
pageSize.Right - rect.Right,
pageSize.Top - rect.Top));
break;
case 270:
annot.Put(PdfName.RECT, new PdfRectangle(
rect.Bottom,
pageSize.Right - rect.Left,
rect.Top,
pageSize.Right - rect.Right));
break;
}
}
}
}
if (!annot.IsUsed())
{
annot.SetUsed();
cstp.AddToBody(annot, annot.IndirectReference);
}
}
}
public void AlterContents()
{
if (over == null && under == null)
{
return;
}
PdfArray ar = null;
PdfObject content = PdfReader.GetPdfObject(pageN.Get(PdfName.CONTENTS), pageN);
if (content == null)
{
ar = new PdfArray();
pageN.Put(PdfName.CONTENTS, ar);
}
else if (content.IsArray())
{
ar = (PdfArray)content;
}
else if (content.IsStream())
{
ar = new PdfArray();
ar.Add(pageN.Get(PdfName.CONTENTS));
pageN.Put(PdfName.CONTENTS, ar);
}
else
{
ar = new PdfArray();
pageN.Put(PdfName.CONTENTS, ar);
}
ByteBuffer out_p = new ByteBuffer();
if (under != null)
{
out_p.Append(PdfContents.SAVESTATE);
ApplyRotation(pageN, out_p);
out_p.Append(under.InternalBuffer);
out_p.Append(PdfContents.RESTORESTATE);
}
if (over != null)
{
out_p.Append(PdfContents.SAVESTATE);
}
PdfStream stream = new PdfStream(out_p.ToByteArray());
stream.FlateCompress(cstp.CompressionLevel);
PdfIndirectReference ref1 = cstp.AddToBody(stream).IndirectReference;
ar.AddFirst(ref1);
out_p.Reset();
if (over != null)
{
out_p.Append(' ');
out_p.Append(PdfContents.RESTORESTATE);
out_p.Append(PdfContents.SAVESTATE);
ApplyRotation(pageN, out_p);
out_p.Append(over.InternalBuffer);
out_p.Append(PdfContents.RESTORESTATE);
stream = new PdfStream(out_p.ToByteArray());
stream.FlateCompress(cstp.CompressionLevel);
ar.Add(cstp.AddToBody(stream).IndirectReference);
}
pageN.Put(PdfName.RESOURCES, pageResources.Resources);
}
private void SerObject(PdfObject obj, int level, ByteBuffer bb, Dictionary <RefKey, int> serialized)
{
if (level <= 0)
{
return;
}
if (obj == null)
{
bb.Append("$Lnull");
return;
}
PdfIndirectReference refe = null;
ByteBuffer savedBb = null;
if (obj.IsIndirect())
{
refe = (PdfIndirectReference)obj;
RefKey key = new RefKey(refe);
if (serialized.ContainsKey(key))
{
bb.Append(serialized[key]);
return;
}
else
{
savedBb = bb;
bb = new ByteBuffer();
}
}
obj = PdfReader.GetPdfObject(obj);
if (obj.IsStream())
{
bb.Append("$B");
SerDic((PdfDictionary)obj, level - 1, bb, serialized);
if (level > 0)
{
bb.Append(DigestAlgorithms.Digest("MD5", PdfReader.GetStreamBytesRaw((PRStream)obj)));
}
}
else if (obj.IsDictionary())
{
SerDic((PdfDictionary)obj, level - 1, bb, serialized);
}
else if (obj.IsArray())
{
SerArray((PdfArray)obj, level - 1, bb, serialized);
}
else if (obj.IsString())
{
bb.Append("$S").Append(obj.ToString());
}
else if (obj.IsName())
{
bb.Append("$N").Append(obj.ToString());
}
else
{
bb.Append("$L").Append(obj.ToString());
}
if (savedBb != null)
{
RefKey key = new RefKey(refe);
if (!serialized.ContainsKey(key))
{
serialized[key] = CalculateHash(bb.Buffer);
}
savedBb.Append(bb);
}
}
/**
* Gets the button appearance.
* @throws IOException on error
* @throws DocumentException on error
* @return the button appearance
*/
public PdfAppearance GetAppearance()
{
PdfAppearance app = GetBorderAppearance();
Rectangle box = new Rectangle(app.BoundingBox);
if ((text == null || text.Length == 0) && (layout == LAYOUT_LABEL_ONLY || (image == null && template == null && iconReference == null)))
{
return(app);
}
if (layout == LAYOUT_ICON_ONLY && image == null && template == null && iconReference == null)
{
return(app);
}
BaseFont ufont = RealFont;
bool borderExtra = borderStyle == PdfBorderDictionary.STYLE_BEVELED || borderStyle == PdfBorderDictionary.STYLE_INSET;
float h = box.Height - borderWidth * 2;
float bw2 = borderWidth;
if (borderExtra)
{
h -= borderWidth * 2;
bw2 *= 2;
}
float offsetX = (borderExtra ? 2 * borderWidth : borderWidth);
offsetX = Math.Max(offsetX, 1);
float offX = Math.Min(bw2, offsetX);
tp = null;
float textX = float.NaN;
float textY = 0;
float fsize = fontSize;
float wt = box.Width - 2 * offX - 2;
float ht = box.Height - 2 * offX;
float adj = (iconFitToBounds ? 0 : offX + 1);
int nlayout = layout;
if (image == null && template == null && iconReference == null)
{
nlayout = LAYOUT_LABEL_ONLY;
}
Rectangle iconBox = null;
while (true)
{
switch (nlayout)
{
case LAYOUT_LABEL_ONLY:
case LAYOUT_LABEL_OVER_ICON:
if (text != null && text.Length > 0 && wt > 0 && ht > 0)
{
fsize = CalculateFontSize(wt, ht);
textX = (box.Width - ufont.GetWidthPoint(text, fsize)) / 2;
textY = (box.Height - ufont.GetFontDescriptor(BaseFont.ASCENT, fsize)) / 2;
}
goto case LAYOUT_ICON_ONLY;
case LAYOUT_ICON_ONLY:
if (nlayout == LAYOUT_LABEL_OVER_ICON || nlayout == LAYOUT_ICON_ONLY)
{
iconBox = new Rectangle(box.Left + adj, box.Bottom + adj, box.Right - adj, box.Top - adj);
}
break;
case LAYOUT_ICON_TOP_LABEL_BOTTOM:
if (text == null || text.Length == 0 || wt <= 0 || ht <= 0)
{
nlayout = LAYOUT_ICON_ONLY;
continue;
}
float nht = box.Height * 0.35f - offX;
if (nht > 0)
{
fsize = CalculateFontSize(wt, nht);
}
else
{
fsize = 4;
}
textX = (box.Width - ufont.GetWidthPoint(text, fsize)) / 2;
textY = offX - ufont.GetFontDescriptor(BaseFont.DESCENT, fsize);
iconBox = new Rectangle(box.Left + adj, textY + fsize, box.Right - adj, box.Top - adj);
break;
case LAYOUT_LABEL_TOP_ICON_BOTTOM:
if (text == null || text.Length == 0 || wt <= 0 || ht <= 0)
{
nlayout = LAYOUT_ICON_ONLY;
continue;
}
nht = box.Height * 0.35f - offX;
if (nht > 0)
{
fsize = CalculateFontSize(wt, nht);
}
else
{
fsize = 4;
}
textX = (box.Width - ufont.GetWidthPoint(text, fsize)) / 2;
textY = box.Height - offX - fsize;
if (textY < offX)
{
textY = offX;
}
iconBox = new Rectangle(box.Left + adj, box.Bottom + adj, box.Right - adj, textY + ufont.GetFontDescriptor(BaseFont.DESCENT, fsize));
break;
case LAYOUT_LABEL_LEFT_ICON_RIGHT:
if (text == null || text.Length == 0 || wt <= 0 || ht <= 0)
{
nlayout = LAYOUT_ICON_ONLY;
continue;
}
float nw = box.Width * 0.35f - offX;
if (nw > 0)
{
fsize = CalculateFontSize(wt, nw);
}
else
{
fsize = 4;
}
if (ufont.GetWidthPoint(text, fsize) >= wt)
{
nlayout = LAYOUT_LABEL_ONLY;
fsize = fontSize;
continue;
}
textX = offX + 1;
textY = (box.Height - ufont.GetFontDescriptor(BaseFont.ASCENT, fsize)) / 2;
iconBox = new Rectangle(textX + ufont.GetWidthPoint(text, fsize), box.Bottom + adj, box.Right - adj, box.Top - adj);
break;
case LAYOUT_ICON_LEFT_LABEL_RIGHT:
if (text == null || text.Length == 0 || wt <= 0 || ht <= 0)
{
nlayout = LAYOUT_ICON_ONLY;
continue;
}
nw = box.Width * 0.35f - offX;
if (nw > 0)
{
fsize = CalculateFontSize(wt, nw);
}
else
{
fsize = 4;
}
if (ufont.GetWidthPoint(text, fsize) >= wt)
{
nlayout = LAYOUT_LABEL_ONLY;
fsize = fontSize;
continue;
}
textX = box.Width - ufont.GetWidthPoint(text, fsize) - offX - 1;
textY = (box.Height - ufont.GetFontDescriptor(BaseFont.ASCENT, fsize)) / 2;
iconBox = new Rectangle(box.Left + adj, box.Bottom + adj, textX - 1, box.Top - adj);
break;
}
break;
}
if (textY < box.Bottom + offX)
{
textY = box.Bottom + offX;
}
if (iconBox != null && (iconBox.Width <= 0 || iconBox.Height <= 0))
{
iconBox = null;
}
bool haveIcon = false;
float boundingBoxWidth = 0;
float boundingBoxHeight = 0;
PdfArray matrix = null;
if (iconBox != null)
{
if (image != null)
{
tp = new PdfTemplate(writer);
tp.BoundingBox = new Rectangle(image);
writer.AddDirectTemplateSimple(tp, PdfName.FRM);
tp.AddImage(image, image.Width, 0, 0, image.Height, 0, 0);
haveIcon = true;
boundingBoxWidth = tp.BoundingBox.Width;
boundingBoxHeight = tp.BoundingBox.Height;
}
else if (template != null)
{
tp = new PdfTemplate(writer);
tp.BoundingBox = new Rectangle(template.Width, template.Height);
writer.AddDirectTemplateSimple(tp, PdfName.FRM);
tp.AddTemplate(template, template.BoundingBox.Left, template.BoundingBox.Bottom);
haveIcon = true;
boundingBoxWidth = tp.BoundingBox.Width;
boundingBoxHeight = tp.BoundingBox.Height;
}
else if (iconReference != null)
{
PdfDictionary dic = (PdfDictionary)PdfReader.GetPdfObject(iconReference);
if (dic != null)
{
Rectangle r2 = PdfReader.GetNormalizedRectangle(dic.GetAsArray(PdfName.BBOX));
matrix = dic.GetAsArray(PdfName.MATRIX);
haveIcon = true;
boundingBoxWidth = r2.Width;
boundingBoxHeight = r2.Height;
}
}
}
if (haveIcon)
{
float icx = iconBox.Width / boundingBoxWidth;
float icy = iconBox.Height / boundingBoxHeight;
if (proportionalIcon)
{
switch (scaleIcon)
{
case SCALE_ICON_IS_TOO_BIG:
icx = Math.Min(icx, icy);
icx = Math.Min(icx, 1);
break;
case SCALE_ICON_IS_TOO_SMALL:
icx = Math.Min(icx, icy);
icx = Math.Max(icx, 1);
break;
case SCALE_ICON_NEVER:
icx = 1;
break;
default:
icx = Math.Min(icx, icy);
break;
}
icy = icx;
}
else
{
switch (scaleIcon)
{
case SCALE_ICON_IS_TOO_BIG:
icx = Math.Min(icx, 1);
icy = Math.Min(icy, 1);
break;
case SCALE_ICON_IS_TOO_SMALL:
icx = Math.Max(icx, 1);
icy = Math.Max(icy, 1);
break;
case SCALE_ICON_NEVER:
icx = icy = 1;
break;
default:
break;
}
}
float xpos = iconBox.Left + (iconBox.Width - (boundingBoxWidth * icx)) * iconHorizontalAdjustment;
float ypos = iconBox.Bottom + (iconBox.Height - (boundingBoxHeight * icy)) * iconVerticalAdjustment;
app.SaveState();
app.Rectangle(iconBox.Left, iconBox.Bottom, iconBox.Width, iconBox.Height);
app.Clip();
app.NewPath();
if (tp != null)
{
app.AddTemplate(tp, icx, 0, 0, icy, xpos, ypos);
}
else
{
float cox = 0;
float coy = 0;
if (matrix != null && matrix.Size == 6)
{
PdfNumber nm = matrix.GetAsNumber(4);
if (nm != null)
{
cox = nm.FloatValue;
}
nm = matrix.GetAsNumber(5);
if (nm != null)
{
coy = nm.FloatValue;
}
}
app.AddTemplateReference(iconReference, PdfName.FRM, icx, 0, 0, icy, xpos - cox * icx, ypos - coy * icy);
}
app.RestoreState();
}
if (!float.IsNaN(textX))
{
app.SaveState();
app.Rectangle(offX, offX, box.Width - 2 * offX, box.Height - 2 * offX);
app.Clip();
app.NewPath();
if (textColor == null)
{
app.ResetGrayFill();
}
else
{
app.SetColorFill(textColor);
}
app.BeginText();
app.SetFontAndSize(ufont, fsize);
app.SetTextMatrix(textX, textY);
app.ShowText(text);
app.EndText();
app.RestoreState();
}
return(app);
}
public static Stream GenerateFromTemplate(DocumentTemplate dt, DiscoDataContext Database, IAttachmentTarget Data, User CreatorUser, DateTime TimeStamp, DocumentState State, bool FlattenFields = false)
{
// Validate Data
switch (dt.Scope)
{
case DocumentTemplate.DocumentTemplateScopes.Device:
if (!(Data is Device))
throw new ArgumentException("This AttachmentType is configured for Devices only", "Data");
break;
case DocumentTemplate.DocumentTemplateScopes.Job:
if (!(Data is Job))
throw new ArgumentException("This AttachmentType is configured for Jobs only", "Data");
break;
case DocumentTemplate.DocumentTemplateScopes.User:
if (!(Data is User))
throw new ArgumentException("This AttachmentType is configured for Users only", "Data");
break;
default:
throw new InvalidOperationException("Invalid AttachmentType Scope");
}
Database.Configuration.LazyLoadingEnabled = true;
// Override FlattenFields if Document Template instructs.
if (dt.FlattenForm)
FlattenFields = true;
ConcurrentDictionary<string, Expression> expressionCache = dt.PdfExpressionsFromCache(Database);
string templateFilename = dt.RepositoryFilename(Database);
PdfReader pdfReader = new PdfReader(templateFilename);
MemoryStream pdfGeneratedStream = new MemoryStream();
PdfStamper pdfStamper = new PdfStamper(pdfReader, pdfGeneratedStream);
pdfStamper.FormFlattening = FlattenFields;
pdfStamper.Writer.CloseStream = false;
IDictionary expressionVariables = Expression.StandardVariables(dt, Database, CreatorUser, TimeStamp, State);
foreach (string pdfFieldKey in pdfStamper.AcroFields.Fields.Keys)
{
if (pdfFieldKey.Equals("DiscoAttachmentId", StringComparison.OrdinalIgnoreCase))
{
AcroFields.Item fields = pdfStamper.AcroFields.Fields[pdfFieldKey];
string fieldValue = dt.CreateUniqueIdentifier(Database, Data, CreatorUser, TimeStamp, 0).ToJson();
if (FlattenFields)
pdfStamper.AcroFields.SetField(pdfFieldKey, String.Empty);
else
pdfStamper.AcroFields.SetField(pdfFieldKey, fieldValue);
IList<AcroFields.FieldPosition> pdfFieldPositions = pdfStamper.AcroFields.GetFieldPositions(pdfFieldKey);
for (int pdfFieldOrdinal = 0; pdfFieldOrdinal < fields.Size; pdfFieldOrdinal++)
{
AcroFields.FieldPosition pdfFieldPosition = pdfFieldPositions[pdfFieldOrdinal];
// Create Binary Unique Identifier
var pageUniqueId = dt.CreateUniqueIdentifier(Database, Data, CreatorUser, TimeStamp, pdfFieldPosition.page);
var pageUniqueIdBytes = pageUniqueId.ToQRCodeBytes();
// Encode to QRCode byte array
var pageUniqueIdWidth = (int)pdfFieldPosition.position.Width;
var pageUniqueIdHeight = (int)pdfFieldPosition.position.Height;
var pageUniqueIdEncoded = QRCodeBinaryEncoder.Encode(pageUniqueIdBytes, pageUniqueIdWidth, pageUniqueIdHeight);
// Encode byte array to Image
var pageUniqueIdImageData = CCITTG4Encoder.Compress(pageUniqueIdEncoded, pageUniqueIdWidth, pageUniqueIdHeight);
var pageUniqueIdImage = iTextSharp.text.Image.GetInstance(pageUniqueIdWidth, pageUniqueIdHeight, false, 256, 1, pageUniqueIdImageData, null);
// Add to the pdf page
pageUniqueIdImage.SetAbsolutePosition(pdfFieldPosition.position.Left, pdfFieldPosition.position.Bottom);
pdfStamper.GetOverContent(pdfFieldPosition.page).AddImage(pageUniqueIdImage);
}
// Hide Fields
PdfDictionary field = fields.GetValue(0);
if ((PdfName)field.Get(PdfName.TYPE) == PdfName.ANNOT)
{
field.Put(PdfName.F, new PdfNumber(6));
}
else
{
PdfArray fieldKids = (PdfArray)field.Get(PdfName.KIDS);
foreach (PdfIndirectReference fieldKidRef in fieldKids)
{
((PdfDictionary)pdfReader.GetPdfObject(fieldKidRef.Number)).Put(PdfName.F, new PdfNumber(6));
}
}
}
else
{
Expression fieldExpression = null;
if (expressionCache.TryGetValue(pdfFieldKey, out fieldExpression))
{
if (fieldExpression.IsDynamic)
{
Tuple<string, bool, object> fieldExpressionResult = fieldExpression.Evaluate(Data, expressionVariables);
if (fieldExpressionResult.Item3 != null)
{
IImageExpressionResult imageResult = (fieldExpressionResult.Item3 as IImageExpressionResult);
if (imageResult != null)
{
// Output Image
AcroFields.Item fields = pdfStamper.AcroFields.Fields[pdfFieldKey];
IList<AcroFields.FieldPosition> pdfFieldPositions = pdfStamper.AcroFields.GetFieldPositions(pdfFieldKey);
for (int pdfFieldOrdinal = 0; pdfFieldOrdinal < fields.Size; pdfFieldOrdinal++)
{
AcroFields.FieldPosition pdfFieldPosition = pdfFieldPositions[pdfFieldOrdinal];
iTextSharp.text.Image pdfImage = iTextSharp.text.Image.GetInstance(imageResult.GetImage((int)pdfFieldPosition.position.Width, (int)pdfFieldPosition.position.Height));
pdfImage.SetAbsolutePosition(pdfFieldPosition.position.Left, pdfFieldPosition.position.Bottom);
pdfStamper.GetOverContent(pdfFieldPosition.page).AddImage(pdfImage);
}
if (!fieldExpressionResult.Item2 && !imageResult.ShowField)
{
// Hide Fields
PdfDictionary field = fields.GetValue(0);
if ((PdfName)field.Get(PdfName.TYPE) == PdfName.ANNOT)
{
field.Put(PdfName.F, new PdfNumber(6));
}
else
{
PdfArray fieldKids = (PdfArray)field.Get(PdfName.KIDS);
foreach (PdfIndirectReference fieldKidRef in fieldKids)
{
((PdfDictionary)pdfReader.GetPdfObject(fieldKidRef.Number)).Put(PdfName.F, new PdfNumber(6));
}
}
}
}
}
pdfStamper.AcroFields.SetField(pdfFieldKey, fieldExpressionResult.Item1);
if (fieldExpressionResult.Item2) // Expression Error
{
AcroFields.Item fields = pdfStamper.AcroFields.Fields[pdfFieldKey];
for (int pdfFieldOrdinal = 0; pdfFieldOrdinal < fields.Size; pdfFieldOrdinal++)
{
PdfDictionary field = fields.GetValue(pdfFieldOrdinal);
PdfDictionary fieldMK;
if (field.Contains(PdfName.MK))
fieldMK = field.GetAsDict(PdfName.MK);
else
{
fieldMK = new PdfDictionary(PdfName.MK);
field.Put(PdfName.MK, fieldMK);
}
fieldMK.Put(PdfName.BC, new PdfArray(new float[] { 1, 0, 0 }));
}
}
}
}
else
{
throw new InvalidOperationException("Pdf template field expressions are out of sync with the expression cache");
}
}
State.FlushFieldCache();
}
pdfStamper.Close();
pdfReader.Close();
if (dt.Scope == DocumentTemplate.DocumentTemplateScopes.Job)
{
// Write Job Log
Job j = (Job)Data;
JobLog jl = new JobLog()
{
JobId = j.Id,
TechUserId = CreatorUser.UserId,
Timestamp = DateTime.Now
};
jl.Comments = string.Format("# Document Generated\r\n**{0}** [{1}]", dt.Description, dt.Id);
Database.JobLogs.Add(jl);
}
pdfGeneratedStream.Position = 0;
return pdfGeneratedStream;
}
/**
* This function behaves the same as 'get', but will never return an indirect reference,
* it will always look such references up and return the actual object.
* @param key
* @return null, or a non-indirect object
*/
public virtual PdfObject GetDirectObject(PdfName key)
{
return(PdfReader.GetPdfObject(Get(key)));
}
private static List<string> ExtractImagesFromPDF(string filename)
{
List<string> files = new List<string>();
try
{
PdfReader pdf = new PdfReader(filename);
for (int pageNumber = 1; pageNumber <= pdf.NumberOfPages; pageNumber++)
{
List<System.Drawing.Image> imgs = new List<System.Drawing.Image>();
PdfDictionary pg = pdf.GetPageN(pageNumber);
PdfDictionary res = (PdfDictionary)PdfReader.GetPdfObject(pg.Get(PdfName.RESOURCES));
PdfDictionary xobj = (PdfDictionary)PdfReader.GetPdfObject(res.Get(PdfName.XOBJECT));
if (xobj != null)
{
foreach (PdfName name in xobj.Keys)
{
PdfObject obj = xobj.Get(name);
if (obj.IsIndirect())
{
PdfDictionary tg = (PdfDictionary)PdfReader.GetPdfObject(obj);
PdfName type = (PdfName)PdfReader.GetPdfObject(tg.Get(PdfName.SUBTYPE));
if (PdfName.IMAGE.Equals(type))
{
int XrefIndex = Convert.ToInt32(((PRIndirectReference)obj).Number.ToString(System.Globalization.CultureInfo.InvariantCulture));
PdfObject pdfObj = pdf.GetPdfObject(XrefIndex);
PdfStream pdfStrem = (PdfStream)pdfObj;
byte[] bytes = PdfReader.GetStreamBytesRaw((PRStream)pdfStrem);
if ((bytes != null))
{
using (MemoryStream memStream = new MemoryStream(bytes))
{
memStream.Position = 0;
imgs.Add(System.Drawing.Image.FromStream(memStream));
}
}
}
}
}
}
Bitmap FinalImage;
if (imgs.Count == 1)
{
FinalImage = new Bitmap(imgs[0]);
}
else
{
FinalImage = new Bitmap(MergeImages(imgs));
}
string path = Path.Combine(o.OutputDirectory, String.Format(@"{0}-{1}.jpg", Path.GetFileNameWithoutExtension(filename), pageNumber.ToString().PadLeft(pdf.NumberOfPages.ToString().Length, '0')));
FinalImage.Save(path, ImageFormat.Jpeg);
FinalImage.Dispose();
files.Add(path);
}
pdf.Close();
}
catch (Exception ex)
{
Console.Error.WriteLine(ex.Message);
_error = true;
}
return files;
}
private void doType1Tt()
{
PdfObject enc = PdfReader.GetPdfObject(_font.Get(PdfName.Encoding));
if (enc == null)
{
fillEncoding(null);
}
else
{
if (enc.IsName())
{
fillEncoding((PdfName)enc);
}
else
{
PdfDictionary encDic = (PdfDictionary)enc;
enc = PdfReader.GetPdfObject(encDic.Get(PdfName.Baseencoding));
if (enc == null)
{
fillEncoding(null);
}
else
{
fillEncoding((PdfName)enc);
}
PdfArray diffs = encDic.GetAsArray(PdfName.Differences);
if (diffs != null)
{
_diffmap = new IntHashtable();
int currentNumber = 0;
for (int k = 0; k < diffs.Size; ++k)
{
PdfObject obj = diffs[k];
if (obj.IsNumber())
{
currentNumber = ((PdfNumber)obj).IntValue;
}
else
{
int[] c = GlyphList.NameToUnicode(PdfName.DecodeName(((PdfName)obj).ToString()));
if (c != null && c.Length > 0)
{
Uni2Byte[c[0]] = currentNumber;
_diffmap[c[0]] = currentNumber;
}
++currentNumber;
}
}
}
}
}
PdfArray newWidths = _font.GetAsArray(PdfName.Widths);
PdfNumber first = _font.GetAsNumber(PdfName.Firstchar);
PdfNumber last = _font.GetAsNumber(PdfName.Lastchar);
if (BuiltinFonts14.ContainsKey(_fontName))
{
BaseFont bf;
bf = CreateFont(_fontName, WINANSI, false);
int[] e = Uni2Byte.ToOrderedKeys();
for (int k = 0; k < e.Length; ++k)
{
int n = Uni2Byte[e[k]];
widths[n] = bf.GetRawWidth(n, GlyphList.UnicodeToName(e[k]));
}
if (_diffmap != null)
{ //widths for differences must override existing ones
e = _diffmap.ToOrderedKeys();
for (int k = 0; k < e.Length; ++k)
{
int n = _diffmap[e[k]];
widths[n] = bf.GetRawWidth(n, GlyphList.UnicodeToName(e[k]));
}
_diffmap = null;
}
_ascender = bf.GetFontDescriptor(ASCENT, 1000);
_capHeight = bf.GetFontDescriptor(CAPHEIGHT, 1000);
_descender = bf.GetFontDescriptor(DESCENT, 1000);
_italicAngle = bf.GetFontDescriptor(ITALICANGLE, 1000);
_llx = bf.GetFontDescriptor(BBOXLLX, 1000);
_lly = bf.GetFontDescriptor(BBOXLLY, 1000);
_urx = bf.GetFontDescriptor(BBOXURX, 1000);
_ury = bf.GetFontDescriptor(BBOXURY, 1000);
}
if (first != null && last != null && newWidths != null)
{
int f = first.IntValue;
for (int k = 0; k < newWidths.Size; ++k)
{
widths[f + k] = newWidths.GetAsNumber(k).IntValue;
}
}
fillFontDesc(_font.GetAsDict(PdfName.Fontdescriptor));
}
private void DoType1TT()
{
CMapToUnicode toUnicode = null;
PdfObject enc = PdfReader.GetPdfObject(font.Get(PdfName.ENCODING));
if (enc == null)
{
PdfName baseFont = font.GetAsName(PdfName.BASEFONT);
if (BuiltinFonts14.ContainsKey(fontName) &&
(PdfName.SYMBOL.Equals(baseFont) || PdfName.ZAPFDINGBATS.Equals(baseFont)))
{
FillEncoding(baseFont);
}
else
{
FillEncoding(null);
}
toUnicode = ProcessToUnicode();
if (toUnicode != null)
{
IDictionary <int, int> rm = toUnicode.CreateReverseMapping();
foreach (KeyValuePair <int, int> kv in rm)
{
uni2byte[kv.Key] = kv.Value;
byte2uni[kv.Value] = kv.Key;
}
}
}
else
{
if (enc.IsName())
{
FillEncoding((PdfName)enc);
}
else if (enc.IsDictionary())
{
PdfDictionary encDic = (PdfDictionary)enc;
enc = PdfReader.GetPdfObject(encDic.Get(PdfName.BASEENCODING));
if (enc == null)
{
FillEncoding(null);
}
else
{
FillEncoding((PdfName)enc);
}
FillDiffMap(encDic, toUnicode);
}
}
if (BuiltinFonts14.ContainsKey(fontName))
{
BaseFont bf = BaseFont.CreateFont(fontName, WINANSI, false);
int[] e = uni2byte.ToOrderedKeys();
for (int k = 0; k < e.Length; ++k)
{
int n = uni2byte[e[k]];
widths[n] = bf.GetRawWidth(n, GlyphList.UnicodeToName(e[k]));
}
if (diffmap != null)
{
//widths for differences must override existing ones
e = diffmap.ToOrderedKeys();
for (int k = 0; k < e.Length; ++k)
{
int n = diffmap[e[k]];
widths[n] = bf.GetRawWidth(n, GlyphList.UnicodeToName(e[k]));
}
diffmap = null;
}
Ascender = bf.GetFontDescriptor(ASCENT, 1000);
CapHeight = bf.GetFontDescriptor(CAPHEIGHT, 1000);
Descender = bf.GetFontDescriptor(DESCENT, 1000);
ItalicAngle = bf.GetFontDescriptor(ITALICANGLE, 1000);
fontWeight = bf.GetFontDescriptor(FONT_WEIGHT, 1000);
llx = bf.GetFontDescriptor(BBOXLLX, 1000);
lly = bf.GetFontDescriptor(BBOXLLY, 1000);
urx = bf.GetFontDescriptor(BBOXURX, 1000);
ury = bf.GetFontDescriptor(BBOXURY, 1000);
}
FillWidths();
FillFontDesc(font.GetAsDict(PdfName.FONTDESCRIPTOR));
}
/// <summary>Parses images from pdf document.</summary>
/// <param name="filePath">The pdf-file full path.</param>
/// <returns>Collection of images and streams that are associated with them.</returns>
public static List<ParsedImage> ParseImages(string filePath)
{
var imgList = new List<ParsedImage>();
var raf = new RandomAccessFileOrArray(filePath);
var reader = new PdfReader(raf, null);
try
{
for (var pageNumber = 1; pageNumber <= reader.NumberOfPages; pageNumber++)
{
var pg = reader.GetPageN(pageNumber);
var size = reader.GetPageSize(pageNumber);
var res = (PdfDictionary)PdfReader.GetPdfObject(pg.Get(PdfName.RESOURCES));
var xobj = (PdfDictionary)PdfReader.GetPdfObject(res.Get(PdfName.XOBJECT));
if (xobj == null)
{
continue;
}
foreach (var name in xobj.Keys)
{
var obj = xobj.Get(name);
if (!obj.IsIndirect())
{
continue;
}
var tg = (PdfDictionary)PdfReader.GetPdfObject(obj);
var type = (PdfName)PdfReader.GetPdfObject(tg.Get(PdfName.SUBTYPE));
if (!PdfName.IMAGE.Equals(type))
{
continue;
}
var refIndex = Convert.ToInt32(((PRIndirectReference)obj).Number.ToString(CultureInfo.InvariantCulture));
var pdfObj = reader.GetPdfObject(refIndex);
var pdfStrem = (PdfStream)pdfObj;
var bytes = PdfReader.GetStreamBytesRaw((PRStream)pdfStrem);
if (bytes == null)
{
continue;
}
var memStream = new MemoryStream(bytes) { Position = 0 };
var img = Image.FromStream(memStream);
imgList.Add(new ParsedImage
{
Image = img,
ImageStream = memStream,
Format = img.RawFormat,
Width = size.Width,
Height = size.Height,
PerformedRotation = RotateFlipType.RotateNoneFlipNone
});
}
}
}
catch (Exception exception)
{
Console.WriteLine(exception.Message);
}
finally
{
reader.Close();
raf.Close();
}
return imgList;
}
private void DoType1TT()
{
PdfObject enc = PdfReader.GetPdfObject(font.Get(PdfName.ENCODING));
if (enc == null)
{
FillEncoding(null);
}
else
{
if (enc.IsName())
{
FillEncoding((PdfName)enc);
}
else if (enc.IsDictionary())
{
PdfDictionary encDic = (PdfDictionary)enc;
enc = PdfReader.GetPdfObject(encDic.Get(PdfName.BASEENCODING));
if (enc == null)
{
FillEncoding(null);
}
else
{
FillEncoding((PdfName)enc);
}
PdfArray diffs = encDic.GetAsArray(PdfName.DIFFERENCES);
if (diffs != null)
{
CMap toUnicode = null;
diffmap = new IntHashtable();
int currentNumber = 0;
for (int k = 0; k < diffs.Size; ++k)
{
PdfObject obj = diffs[k];
if (obj.IsNumber())
{
currentNumber = ((PdfNumber)obj).IntValue;
}
else
{
int[] c = GlyphList.NameToUnicode(PdfName.DecodeName(((PdfName)obj).ToString()));
if (c != null && c.Length > 0)
{
uni2byte[c[0]] = currentNumber;
diffmap[c[0]] = currentNumber;
}
else
{
if (toUnicode == null)
{
toUnicode = ProcessToUnicode();
if (toUnicode == null)
{
toUnicode = new CMap();
}
}
string unicode = toUnicode.Lookup(new byte[] { (byte)currentNumber }, 0, 1);
if ((unicode != null) && (unicode.Length == 1))
{
this.uni2byte[unicode[0]] = currentNumber;
this.diffmap[unicode[0]] = currentNumber;
}
}
++currentNumber;
}
}
}
}
}
PdfArray newWidths = font.GetAsArray(PdfName.WIDTHS);
PdfNumber first = font.GetAsNumber(PdfName.FIRSTCHAR);
PdfNumber last = font.GetAsNumber(PdfName.LASTCHAR);
if (BuiltinFonts14.ContainsKey(fontName))
{
BaseFont bf;
bf = BaseFont.CreateFont(fontName, WINANSI, false);
int[] e = uni2byte.ToOrderedKeys();
for (int k = 0; k < e.Length; ++k)
{
int n = uni2byte[e[k]];
widths[n] = bf.GetRawWidth(n, GlyphList.UnicodeToName(e[k]));
}
if (diffmap != null) //widths for differences must override existing ones
{
e = diffmap.ToOrderedKeys();
for (int k = 0; k < e.Length; ++k)
{
int n = diffmap[e[k]];
widths[n] = bf.GetRawWidth(n, GlyphList.UnicodeToName(e[k]));
}
diffmap = null;
}
Ascender = bf.GetFontDescriptor(ASCENT, 1000);
CapHeight = bf.GetFontDescriptor(CAPHEIGHT, 1000);
Descender = bf.GetFontDescriptor(DESCENT, 1000);
ItalicAngle = bf.GetFontDescriptor(ITALICANGLE, 1000);
llx = bf.GetFontDescriptor(BBOXLLX, 1000);
lly = bf.GetFontDescriptor(BBOXLLY, 1000);
urx = bf.GetFontDescriptor(BBOXURX, 1000);
ury = bf.GetFontDescriptor(BBOXURY, 1000);
}
if (first != null && last != null && newWidths != null)
{
int f = first.IntValue;
int nSize = f + newWidths.Size;
if (widths.Length < nSize)
{
int[] tmp = new int[nSize];
System.Array.Copy(widths, 0, tmp, 0, f);
widths = tmp;
}
for (int k = 0; k < newWidths.Size; ++k)
{
widths[f + k] = newWidths.GetAsNumber(k).IntValue;
}
}
FillFontDesc(font.GetAsDict(PdfName.FONTDESCRIPTOR));
}
