/**
* Gets the content stream of a page as a PdfStream object.
*
* @param pageNumber the page of which you want the stream
* @param compressionLevel the compression level you want to apply to the stream
* @return a PdfStream object
* @since 2.1.3 (the method already existed without param compressionLevel)
*/
PdfStream getFormXObject(int pageNumber, int compressionLevel) throws IOException {
PdfDictionary page = reader.getPageNRelease(pageNumber);
PdfObject contents = PdfReader.getPdfObjectRelease(page.get(PdfName.CONTENTS));
PdfDictionary dic = new PdfDictionary();
byte bout[] = null;
if (contents != null) {
if (contents.isStream()) dic.putAll((PRStream) contents);
else bout = reader.getPageContent(pageNumber, file);
} else bout = new byte[0];
dic.put(PdfName.RESOURCES, PdfReader.getPdfObjectRelease(page.get(PdfName.RESOURCES)));
dic.put(PdfName.TYPE, PdfName.XOBJECT);
dic.put(PdfName.SUBTYPE, PdfName.FORM);
PdfImportedPage impPage = (PdfImportedPage) importedPages.get(new Integer(pageNumber));
dic.put(PdfName.BBOX, new PdfRectangle(impPage.getBoundingBox()));
PdfArray matrix = impPage.getMatrix();
if (matrix == null) dic.put(PdfName.MATRIX, IDENTITYMATRIX);
else dic.put(PdfName.MATRIX, matrix);
dic.put(PdfName.FORMTYPE, ONE);
PRStream stream;
if (bout == null) {
stream = new PRStream((PRStream) contents, dic);
} else {
stream = new PRStream(reader, bout, compressionLevel);
stream.putAll(dic);
}
return stream;
}
/**
* Unpacks a file attachment.
*
* @param reader The object that reads the PDF document
* @param filespec The dictonary containing the file specifications
* @throws IOException
*/
protected static Object[] unpackFile(PdfReader reader, PdfDictionary filespec)
throws IOException {
Object arr[] = new Object[2]; // use to store name and file bytes
if (filespec == null) {
return null;
}
PdfName type = (PdfName) PdfReader.getPdfObject(filespec.get(PdfName.TYPE));
if (!PdfName.F.equals(type) && !PdfName.FILESPEC.equals(type)) {
return null;
}
PdfDictionary ef = (PdfDictionary) PdfReader.getPdfObject(filespec.get(PdfName.EF));
if (ef == null) {
return null;
}
PdfString fn = (PdfString) PdfReader.getPdfObject(filespec.get(PdfName.F));
if (fn == null) {
return null;
}
File fLast = new File(fn.toUnicodeString());
PRStream prs = (PRStream) PdfReader.getPdfObject(ef.get(PdfName.F));
if (prs == null) {
return null;
}
byte attachmentByte[] = PdfReader.getStreamBytes(prs);
arr[0] = fLast.getName();
arr[1] = attachmentByte;
return arr;
}
public static PdfStamper createSignature(
PdfReader reader, OutputStream os, char pdfVersion, File tempFile, boolean append)
throws DocumentException, IOException {
PdfStamper stp;
if (tempFile == null) {
ByteBuffer bout = new ByteBuffer();
stp = new PdfStamper(reader, bout, pdfVersion, append);
stp.sigApp = new PdfSignatureAppearance(stp.stamper);
stp.sigApp.setSigout(bout);
} else {
if (tempFile.isDirectory()) tempFile = File.createTempFile("pdf", null, tempFile);
FileOutputStream fout = new FileOutputStream(tempFile);
stp = new PdfStamper(reader, fout, pdfVersion, append);
stp.sigApp = new PdfSignatureAppearance(stp.stamper);
stp.sigApp.setTempFile(tempFile);
}
stp.sigApp.setOriginalout(os);
stp.sigApp.setStamper(stp);
stp.hasSignature = true;
PdfDictionary catalog = reader.getCatalog();
PdfDictionary acroForm =
(PdfDictionary) PdfReader.getPdfObject(catalog.get(PdfName.ACROFORM), catalog);
if (acroForm != null) {
acroForm.remove(PdfName.NEEDAPPEARANCES);
stp.stamper.markUsed(acroForm);
}
return stp;
}
/**
* Translate a PRIndirectReference to a PdfIndirectReference In addition, translates the object
* numbers, and copies the referenced object to the output file. NB: PRIndirectReferences (and
* PRIndirectObjects) really need to know what file they came from, because each file has its own
* namespace. The translation we do from their namespace to ours is *at best* heuristic, and
* guaranteed to fail under some circumstances.
*/
protected PdfIndirectReference copyIndirect(PRIndirectReference in)
throws IOException, BadPdfFormatException {
PdfIndirectReference theRef;
RefKey key = new RefKey(in);
IndirectReferences iRef = (IndirectReferences) indirects.get(key);
if (iRef != null) {
theRef = iRef.getRef();
if (iRef.getCopied()) {
return theRef;
}
} else {
theRef = body.getPdfIndirectReference();
iRef = new IndirectReferences(theRef);
indirects.put(key, iRef);
}
PdfObject obj = PdfReader.getPdfObjectRelease(in);
if (obj != null && obj.isDictionary()) {
PdfObject type = PdfReader.getPdfObjectRelease(((PdfDictionary) obj).get(PdfName.TYPE));
if (type != null && PdfName.PAGE.equals(type)) {
return theRef;
}
}
iRef.setCopied();
obj = copyObject(obj);
addToBody(obj, theRef);
return theRef;
}
/**
* Retrieves the page labels from a PDF as an array of String objects.
*
* @param reader a PdfReader object that has the page labels you want to retrieve
* @return a String array or <code>null</code> if no page labels are present
*/
public static String[] getPageLabels(PdfReader reader) {
int n = reader.getNumberOfPages();
PdfDictionary dict = reader.getCatalog();
PdfDictionary labels =
(PdfDictionary) PdfReader.getPdfObjectRelease(dict.get(PdfName.PAGELABELS));
if (labels == null) return null;
String[] labelstrings = new String[n];
HashMap<Integer, PdfObject> numberTree = PdfNumberTree.readTree(labels);
int pagecount = 1;
Integer current;
String prefix = "";
char type = 'D';
for (int i = 0; i < n; i++) {
current = Integer.valueOf(i);
if (numberTree.containsKey(current)) {
PdfDictionary d = (PdfDictionary) PdfReader.getPdfObjectRelease(numberTree.get(current));
if (d.contains(PdfName.ST)) {
pagecount = ((PdfNumber) d.get(PdfName.ST)).intValue();
} else {
pagecount = 1;
}
if (d.contains(PdfName.P)) {
prefix = ((PdfString) d.get(PdfName.P)).toUnicodeString();
}
if (d.contains(PdfName.S)) {
type = ((PdfName) d.get(PdfName.S)).toString().charAt(1);
} else {
type = 'e';
}
}
switch (type) {
default:
labelstrings[i] = prefix + pagecount;
break;
case 'R':
labelstrings[i] = prefix + RomanNumberFactory.getUpperCaseString(pagecount);
break;
case 'r':
labelstrings[i] = prefix + RomanNumberFactory.getLowerCaseString(pagecount);
break;
case 'A':
labelstrings[i] = prefix + RomanAlphabetFactory.getUpperCaseString(pagecount);
break;
case 'a':
labelstrings[i] = prefix + RomanAlphabetFactory.getLowerCaseString(pagecount);
break;
case 'e':
labelstrings[i] = prefix;
break;
}
pagecount++;
}
return labelstrings;
}
void addDocument(PdfReader reader) throws DocumentException, IOException {
if (!reader.isOpenedWithFullPermissions())
throw new BadPasswordException(
MessageLocalization.getComposedMessage("pdfreader.not.opened.with.owner.password"));
openDoc();
if (readers2intrefs.containsKey(reader)) {
reader = new PdfReader(reader);
} else {
if (reader.isTampered())
throw new DocumentException(
MessageLocalization.getComposedMessage("the.document.was.reused"));
reader.consolidateNamedDestinations();
reader.setTampered(true);
}
reader.shuffleSubsetNames();
readers2intrefs.put(reader, new IntHashtable());
readers.add(reader);
int len = reader.getNumberOfPages();
IntHashtable refs = new IntHashtable();
for (int p = 1; p <= len; ++p) {
refs.put(reader.getPageOrigRef(p).getNumber(), 1);
reader.releasePage(p);
}
pages2intrefs.put(reader, refs);
visited.put(reader, new IntHashtable());
AcroFields acro = reader.getAcroFields();
// when a document with NeedAppearances is encountered, the flag is set
// in the resulting document.
boolean needapp = !acro.isGenerateAppearances();
if (needapp) needAppearances = true;
fields.add(acro);
updateCalculationOrder(reader);
}
void addDocument(PdfReader reader, List<Integer> pagesToKeep)
throws DocumentException, IOException {
if (!readers2intrefs.containsKey(reader) && reader.isTampered())
throw new DocumentException(
MessageLocalization.getComposedMessage("the.document.was.reused"));
reader = new PdfReader(reader);
reader.selectPages(pagesToKeep);
if (reader.getNumberOfPages() == 0) return;
reader.setTampered(false);
addDocument(reader);
}
/**
* Retrieves the page labels from a PDF as an array of {@link PdfPageLabelFormat} objects.
*
* @param reader a PdfReader object that has the page labels you want to retrieve
* @return a PdfPageLabelEntry array, containing an entry for each format change or <code>null
* </code> if no page labels are present
*/
public static PdfPageLabelFormat[] getPageLabelFormats(PdfReader reader) {
PdfDictionary dict = reader.getCatalog();
PdfDictionary labels =
(PdfDictionary) PdfReader.getPdfObjectRelease(dict.get(PdfName.PAGELABELS));
if (labels == null) return null;
HashMap<Integer, PdfObject> numberTree = PdfNumberTree.readTree(labels);
Integer numbers[] = new Integer[numberTree.size()];
numbers = numberTree.keySet().toArray(numbers);
Arrays.sort(numbers);
PdfPageLabelFormat[] formats = new PdfPageLabelFormat[numberTree.size()];
String prefix;
int numberStyle;
int pagecount;
for (int k = 0; k < numbers.length; ++k) {
Integer key = numbers[k];
PdfDictionary d = (PdfDictionary) PdfReader.getPdfObjectRelease(numberTree.get(key));
if (d.contains(PdfName.ST)) {
pagecount = ((PdfNumber) d.get(PdfName.ST)).intValue();
} else {
pagecount = 1;
}
if (d.contains(PdfName.P)) {
prefix = ((PdfString) d.get(PdfName.P)).toUnicodeString();
} else {
prefix = "";
}
if (d.contains(PdfName.S)) {
char type = ((PdfName) d.get(PdfName.S)).toString().charAt(1);
switch (type) {
case 'R':
numberStyle = UPPERCASE_ROMAN_NUMERALS;
break;
case 'r':
numberStyle = LOWERCASE_ROMAN_NUMERALS;
break;
case 'A':
numberStyle = UPPERCASE_LETTERS;
break;
case 'a':
numberStyle = LOWERCASE_LETTERS;
break;
default:
numberStyle = DECIMAL_ARABIC_NUMERALS;
break;
}
} else {
numberStyle = EMPTY;
}
formats[k] = new PdfPageLabelFormat(key.intValue() + 1, numberStyle, prefix, pagecount);
}
return formats;
}
PdfImportedPage getImportedPage(int pageNumber) {
if (!reader.isOpenedWithFullPermissions())
throw new IllegalArgumentException("PdfReader not opened with owner password");
if (pageNumber < 1 || pageNumber > reader.getNumberOfPages())
throw new IllegalArgumentException("Invalid page number: " + pageNumber);
Integer i = new Integer(pageNumber);
PdfImportedPage pageT = (PdfImportedPage) importedPages.get(i);
if (pageT == null) {
pageT = new PdfImportedPage(this, writer, pageNumber);
importedPages.put(i, pageT);
}
return pageT;
}
private CMapToUnicode processToUnicode() {
CMapToUnicode cmapRet = null;
PdfObject toUni = PdfReader.getPdfObjectRelease(this.font.get(PdfName.TOUNICODE));
if (toUni instanceof PRStream) {
try {
byte[] touni = PdfReader.getStreamBytes((PRStream) toUni);
CidLocationFromByte lb = new CidLocationFromByte(touni);
cmapRet = new CMapToUnicode();
CMapParserEx.parseCid("", cmapRet, lb);
} catch (Exception e) {
cmapRet = null;
}
}
return cmapRet;
}
/**
* Grabs a page from the input document
*
* @param reader the reader of the document
* @param pageNumber which page to get
* @return the page
*/
public PdfImportedPage getImportedPage(PdfReader reader, int pageNumber) {
if (currentPdfReaderInstance != null) {
if (currentPdfReaderInstance.getReader() != reader) {
try {
currentPdfReaderInstance.getReader().close();
currentPdfReaderInstance.getReaderFile().close();
} catch (IOException ioe) {
// empty on purpose
}
currentPdfReaderInstance = reader.getPdfReaderInstance(this);
}
} else {
currentPdfReaderInstance = reader.getPdfReaderInstance(this);
}
return currentPdfReaderInstance.getImportedPage(pageNumber);
}
void applyRotation(PdfDictionary pageN, ByteBuffer out) {
if (!cstp.rotateContents) return;
Rectangle page = reader.getPageSizeWithRotation(pageN);
int rotation = page.getRotation();
switch (rotation) {
case 90:
out.append(PdfContents.ROTATE90);
out.append(page.getTop());
out.append(' ').append('0').append(PdfContents.ROTATEFINAL);
break;
case 180:
out.append(PdfContents.ROTATE180);
out.append(page.getRight());
out.append(' ');
out.append(page.getTop());
out.append(PdfContents.ROTATEFINAL);
break;
case 270:
out.append(PdfContents.ROTATE270);
out.append('0').append(' ');
out.append(page.getRight());
out.append(PdfContents.ROTATEFINAL);
break;
}
}
/**
* After reading, we index all of the fields. Recursive.
*
* @param fieldlist An array of fields
* @param fieldDict the last field dictionary we encountered (recursively)
* @param title the pathname of the field, up to this point or null
*/
protected void iterateFields(PdfArray fieldlist, PRIndirectReference fieldDict, String title) {
for (Iterator it = fieldlist.getArrayList().iterator(); it.hasNext(); ) {
PRIndirectReference ref = (PRIndirectReference) it.next();
PdfDictionary dict = (PdfDictionary) PdfReader.getPdfObjectRelease(ref);
// if we are not a field dictionary, pass our parent's values
PRIndirectReference myFieldDict = fieldDict;
String myTitle = title;
PdfString tField = (PdfString) dict.get(PdfName.T);
boolean isFieldDict = tField != null;
if (isFieldDict) {
myFieldDict = ref;
if (title == null) myTitle = tField.toString();
else myTitle = title + '.' + tField.toString();
}
PdfArray kids = (PdfArray) dict.get(PdfName.KIDS);
if (kids != null) {
pushAttrib(dict);
iterateFields(kids, myFieldDict, myTitle);
stack.remove(stack.size() - 1); // pop
} else { // leaf node
if (myFieldDict != null) {
PdfDictionary mergedDict = (PdfDictionary) stack.get(stack.size() - 1);
if (isFieldDict) mergedDict = mergeAttrib(mergedDict, dict);
mergedDict.put(PdfName.T, new PdfString(myTitle));
FieldInformation fi = new FieldInformation(myTitle, mergedDict, myFieldDict);
fields.add(fi);
fieldByName.put(myTitle, fi);
}
}
}
}
/**
* Read, and comprehend the acroform
*
* @param root the docment root
*/
public void readAcroForm(PdfDictionary root) {
if (root == null) return;
hashMap = root.hashMap;
pushAttrib(root);
PdfArray fieldlist = (PdfArray) PdfReader.getPdfObjectRelease(root.get(PdfName.FIELDS));
iterateFields(fieldlist, null, null);
}
static void mergeResources(PdfDictionary result, PdfDictionary source, PdfStamperImp writer) {
PdfDictionary dic = null;
PdfDictionary res = null;
PdfName target = null;
for (int k = 0; k < mergeTarget.length; ++k) {
target = mergeTarget[k];
PdfDictionary pdfDict = (PdfDictionary) PdfReader.getPdfObject(source.get(target));
if ((dic = pdfDict) != null) {
if ((res = (PdfDictionary) PdfReader.getPdfObject(result.get(target), result)) == null) {
res = new PdfDictionary();
}
res.mergeDifferent(dic);
result.put(target, res);
if (writer != null) writer.markUsed(res);
}
}
}
/** @since 2.1.5; before 2.1.5 the method was private */
protected void updateCalculationOrder(PdfReader reader) {
PdfDictionary catalog = reader.getCatalog();
PdfDictionary acro = catalog.getAsDict(PdfName.ACROFORM);
if (acro == null) return;
PdfArray co = acro.getAsArray(PdfName.CO);
if (co == null || co.size() == 0) return;
AcroFields af = reader.getAcroFields();
for (int k = 0; k < co.size(); ++k) {
PdfObject obj = co.getPdfObject(k);
if (obj == null || !obj.isIndirect()) continue;
String name = getCOName(reader, (PRIndirectReference) obj);
if (af.getFieldItem(name) == null) continue;
name = "." + name;
if (calculationOrder.contains(name)) continue;
calculationOrder.add(name);
}
}
void propagate(PdfObject obj, PdfIndirectReference refo, boolean restricted) throws IOException {
if (obj == null) return;
// if (refo != null)
// addToBody(obj, refo);
if (obj instanceof PdfIndirectReference) return;
switch (obj.type()) {
case PdfObject.DICTIONARY:
case PdfObject.STREAM:
{
PdfDictionary dic = (PdfDictionary) obj;
for (PdfName key : dic.getKeys()) {
if (restricted && (key.equals(PdfName.PARENT) || key.equals(PdfName.KIDS))) continue;
PdfObject ob = dic.get(key);
if (ob != null && ob.isIndirect()) {
PRIndirectReference ind = (PRIndirectReference) ob;
if (!setVisited(ind) && !isPage(ind)) {
PdfIndirectReference ref = getNewReference(ind);
propagate(PdfReader.getPdfObjectRelease(ind), ref, restricted);
}
} else propagate(ob, null, restricted);
}
break;
}
case PdfObject.ARRAY:
{
// PdfArray arr = new PdfArray();
for (Iterator<PdfObject> it = ((PdfArray) obj).listIterator(); it.hasNext(); ) {
PdfObject ob = it.next();
if (ob != null && ob.isIndirect()) {
PRIndirectReference ind = (PRIndirectReference) ob;
if (!isVisited(ind) && !isPage(ind)) {
PdfIndirectReference ref = getNewReference(ind);
propagate(PdfReader.getPdfObjectRelease(ind), ref, restricted);
}
} else propagate(ob, null, restricted);
}
break;
}
case PdfObject.INDIRECT:
{
throw new RuntimeException(
MessageLocalization.getComposedMessage("reference.pointing.to.reference"));
}
}
}
/** extracts attachments from PDF File */
@SuppressWarnings("unchecked")
protected Map extractAttachments(PdfReader reader) throws IOException {
Map fileMap = new HashMap();
PdfDictionary catalog = reader.getCatalog();
PdfDictionary names = (PdfDictionary) PdfReader.getPdfObject(catalog.get(PdfName.NAMES));
if (names != null) {
PdfDictionary embFiles =
(PdfDictionary) PdfReader.getPdfObject(names.get(new PdfName("EmbeddedFiles")));
if (embFiles != null) {
HashMap embMap = PdfNameTree.readTree(embFiles);
for (Iterator i = embMap.values().iterator(); i.hasNext(); ) {
PdfDictionary filespec = (PdfDictionary) PdfReader.getPdfObject((PdfObject) i.next());
Object fileInfo[] = unpackFile(reader, filespec);
if (fileMap.containsKey(fileInfo[0])) {
throw new RuntimeException(DUPLICATE_FILE_NAMES);
}
fileMap.put(fileInfo[0], fileInfo[1]);
}
}
}
for (int k = 1; k <= reader.getNumberOfPages(); ++k) {
PdfArray annots = (PdfArray) PdfReader.getPdfObject(reader.getPageN(k).get(PdfName.ANNOTS));
if (annots == null) {
continue;
}
for (Iterator i = annots.getArrayList().listIterator(); i.hasNext(); ) {
PdfDictionary annot = (PdfDictionary) PdfReader.getPdfObject((PdfObject) i.next());
PdfName subType = (PdfName) PdfReader.getPdfObject(annot.get(PdfName.SUBTYPE));
if (!PdfName.FILEATTACHMENT.equals(subType)) {
continue;
}
PdfDictionary filespec = (PdfDictionary) PdfReader.getPdfObject(annot.get(PdfName.FS));
Object fileInfo[] = unpackFile(reader, filespec);
if (fileMap.containsKey(fileInfo[0])) {
throw new RuntimeException(DUPLICATE_FILE_NAMES);
}
fileMap.put(fileInfo[0], fileInfo[1]);
}
}
return fileMap;
}
private IntHashtable readWidths(PdfArray ws) {
IntHashtable hh = new IntHashtable();
if (ws == null) return hh;
for (int k = 0; k < ws.size(); ++k) {
int c1 = ((PdfNumber) PdfReader.getPdfObjectRelease(ws.getPdfObject(k))).intValue();
PdfObject obj = PdfReader.getPdfObjectRelease(ws.getPdfObject(++k));
if (obj.isArray()) {
PdfArray a2 = (PdfArray) obj;
for (int j = 0; j < a2.size(); ++j) {
int c2 = ((PdfNumber) PdfReader.getPdfObjectRelease(a2.getPdfObject(j))).intValue();
hh.put(c1++, c2);
}
} else {
int c2 = ((PdfNumber) obj).intValue();
int w = ((PdfNumber) PdfReader.getPdfObjectRelease(ws.getPdfObject(++k))).intValue();
for (; c1 <= c2; ++c1) hh.put(c1, w);
}
}
return hh;
}
public static HashMap getNamedDestination(PdfReader reader, boolean fromNames) {
IntHashtable pages = new IntHashtable();
int numPages = reader.getNumberOfPages();
for (int k = 1; k <= numPages; ++k) pages.put(reader.getPageOrigRef(k).getNumber(), k);
HashMap names =
fromNames ? reader.getNamedDestinationFromNames() : reader.getNamedDestinationFromStrings();
for (Iterator it = names.entrySet().iterator(); it.hasNext(); ) {
Map.Entry entry = (Map.Entry) it.next();
ArrayList arr = ((PdfArray) entry.getValue()).getArrayList();
StringBuffer s = new StringBuffer();
try {
s.append(pages.get(((PdfIndirectReference) arr.get(0)).getNumber()));
s.append(' ').append(arr.get(1).toString().substring(1));
for (int k = 2; k < arr.size(); ++k) s.append(' ').append(arr.get(k).toString());
entry.setValue(s.toString());
} catch (Exception e) {
it.remove();
}
}
return names;
}
/**
* Add an imported page to our output
*
* @param iPage an imported page
* @throws IOException , BadPdfFormatException
*/
public void addPage(PdfImportedPage iPage) throws IOException, BadPdfFormatException {
int pageNum = setFromIPage(iPage);
PdfDictionary thePage = reader.getPageN(pageNum);
PRIndirectReference origRef = reader.getPageOrigRef(pageNum);
reader.releasePage(pageNum);
RefKey key = new RefKey(origRef);
PdfIndirectReference pageRef;
IndirectReferences iRef = (IndirectReferences) indirects.get(key);
if (iRef != null && !iRef.getCopied()) {
pageReferences.add(iRef.getRef());
iRef.setCopied();
}
pageRef = getCurrentPage();
if (iRef == null) {
iRef = new IndirectReferences(pageRef);
indirects.put(key, iRef);
}
iRef.setCopied();
PdfDictionary newPage = copyDictionary(thePage);
root.addPage(newPage);
++currentPageNumber;
}
void writeAllVisited() throws IOException {
while (!nextRound.isEmpty()) {
ArrayList vec = nextRound;
nextRound = new ArrayList();
for (int k = 0; k < vec.size(); ++k) {
Integer i = (Integer) vec.get(k);
if (!visited.containsKey(i)) {
visited.put(i, null);
int n = i.intValue();
writer.addToBody(reader.getPdfObjectRelease(n), myXref[n]);
}
}
}
}
/**
* Copy the acroform for an input document. Note that you can only have one, we make no effort to
* merge them.
*
* @param reader The reader of the input file that is being copied
* @throws IOException , BadPdfFormatException
*/
public void copyAcroForm(PdfReader reader) throws IOException, BadPdfFormatException {
setFromReader(reader);
PdfDictionary catalog = reader.getCatalog();
PRIndirectReference hisRef = null;
PdfObject o = catalog.get(PdfName.ACROFORM);
if (o != null && o.type() == PdfObject.INDIRECT) hisRef = (PRIndirectReference) o;
if (hisRef == null) return; // bugfix by John Englar
RefKey key = new RefKey(hisRef);
PdfIndirectReference myRef;
IndirectReferences iRef = (IndirectReferences) indirects.get(key);
if (iRef != null) {
acroForm = myRef = iRef.getRef();
} else {
acroForm = myRef = body.getPdfIndirectReference();
iRef = new IndirectReferences(myRef);
indirects.put(key, iRef);
}
if (!iRef.getCopied()) {
iRef.setCopied();
PdfDictionary theForm = copyDictionary((PdfDictionary) PdfReader.getPdfObject(hisRef));
addToBody(theForm, myRef);
}
}
/** convenience method. Given a reader, set our "globals" */
protected void setFromReader(PdfReader reader) {
this.reader = reader;
indirects = (HashMap) indirectMap.get(reader);
if (indirects == null) {
indirects = new HashMap();
indirectMap.put(reader, indirects);
PdfDictionary catalog = reader.getCatalog();
PRIndirectReference ref = null;
PdfObject o = catalog.get(PdfName.ACROFORM);
if (o == null || o.type() != PdfObject.INDIRECT) return;
ref = (PRIndirectReference) o;
if (acroForm == null) acroForm = body.getPdfIndirectReference();
indirects.put(new RefKey(ref), new IndirectReferences(acroForm));
}
}
/**
* Translate a PRDictionary to a PdfDictionary. Also translate all of the objects contained in it.
*/
protected PdfDictionary copyDictionary(PdfDictionary in)
throws IOException, BadPdfFormatException {
PdfDictionary out = new PdfDictionary();
PdfObject type = PdfReader.getPdfObjectRelease(in.get(PdfName.TYPE));
for (Iterator it = in.getKeys().iterator(); it.hasNext(); ) {
PdfName key = (PdfName) it.next();
PdfObject value = in.get(key);
// System.out.println("Copy " + key);
if (type != null && PdfName.PAGE.equals(type)) {
if (!key.equals(PdfName.B) && !key.equals(PdfName.PARENT)) out.put(key, copyObject(value));
} else out.put(key, copyObject(value));
}
return out;
}
private static String getCOName(PdfReader reader, PRIndirectReference ref) {
String name = "";
while (ref != null) {
PdfObject obj = PdfReader.getPdfObject(ref);
if (obj == null || obj.type() != PdfObject.DICTIONARY) break;
PdfDictionary dic = (PdfDictionary) obj;
PdfString t = dic.getAsString(PdfName.T);
if (t != null) {
name = t.toUnicodeString() + "." + name;
}
ref = (PRIndirectReference) dic.get(PdfName.PARENT);
}
if (name.endsWith(".")) name = name.substring(0, name.length() - 1);
return name;
}
void setOriginalResources(PdfDictionary resources, int newNamePtr[]) {
if (newNamePtr != null) namePtr = newNamePtr;
originalResources = resources;
forbiddenNames = new HashMap();
usedNames = new HashMap();
if (resources == null) return;
for (Iterator i = resources.getKeys().iterator(); i.hasNext(); ) {
PdfObject sub = PdfReader.getPdfObject(resources.get((PdfName) i.next()));
if (sub != null && sub.isDictionary()) {
PdfDictionary dic = (PdfDictionary) sub;
for (Iterator j = dic.getKeys().iterator(); j.hasNext(); ) {
forbiddenNames.put(j.next(), null);
}
}
}
}
void createWidgets(ArrayList<Object> list, AcroFields.Item item) {
for (int k = 0; k < item.size(); ++k) {
list.add(item.getPage(k));
PdfDictionary merged = item.getMerged(k);
PdfObject dr = merged.get(PdfName.DR);
if (dr != null)
PdfFormField.mergeResources(resources, (PdfDictionary) PdfReader.getPdfObject(dr));
PdfDictionary widget = new PdfDictionary();
for (Object element : merged.getKeys()) {
PdfName key = (PdfName) element;
if (widgetKeys.containsKey(key)) widget.put(key, merged.get(key));
}
widget.put(iTextTag, new PdfNumber(item.getTabOrder(k).intValue() + 1));
list.add(widget);
}
}
public void toPdf(PdfWriter writer, OutputStream os) throws IOException {
byte[] b = PdfReader.getStreamBytesRaw(this);
PdfEncryption crypto = null;
if (writer != null) crypto = writer.getEncryption();
PdfObject objLen = get(PdfName.LENGTH);
int nn = b.length;
if (crypto != null) nn = crypto.calculateStreamSize(nn);
put(PdfName.LENGTH, new PdfNumber(nn));
superToPdf(writer, os);
put(PdfName.LENGTH, objLen);
os.write(STARTSTREAM);
if (length > 0) {
if (crypto != null && !crypto.isEmbeddedFilesOnly()) b = crypto.encryptByteArray(b);
os.write(b);
}
os.write(ENDSTREAM);
}
/** extracts XML from PDF */
protected byte[] getXMLFromPDF(PdfReader reader) throws Exception {
XfaForm xfaForm = reader.getAcroFields().getXfa();
Node domDocument = xfaForm.getDomDocument();
if (domDocument == null) return null;
Element documentElement = ((Document) domDocument).getDocumentElement();
Element datasetsElement =
(Element) documentElement.getElementsByTagNameNS(XFA_NS, "datasets").item(0);
Element dataElement = (Element) datasetsElement.getElementsByTagNameNS(XFA_NS, "data").item(0);
Element xmlElement = (Element) dataElement.getChildNodes().item(0);
Node budgetElement = getBudgetElement(xmlElement);
byte[] serializedXML = XfaForm.serializeDoc(budgetElement);
return serializedXML;
}
