/**
* Writes the PDF representation of this <CODE>PdfArray</CODE> as an array of <CODE>byte</CODE> to
* the specified <CODE>OutputStream</CODE>.
*
* @param writer for backwards compatibility
* @param os the <CODE>OutputStream</CODE> to write the bytes to.
*/
@Override
public void toPdf(final PdfWriter writer, final OutputStream os) throws IOException {
PdfWriter.checkPdfIsoConformance(writer, PdfIsoKeys.PDFISOKEY_OBJECT, this);
os.write('[');
Iterator<PdfObject> i = arrayList.iterator();
PdfObject object;
int type = 0;
if (i.hasNext()) {
object = i.next();
if (object == null) object = PdfNull.PDFNULL;
object.toPdf(writer, os);
}
while (i.hasNext()) {
object = i.next();
if (object == null) object = PdfNull.PDFNULL;
type = object.type();
if (type != PdfObject.ARRAY
&& type != PdfObject.DICTIONARY
&& type != PdfObject.NAME
&& type != PdfObject.STRING) os.write(' ');
object.toPdf(writer, os);
}
os.write(']');
}
/**
* 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;
}
public void setDictionary(int id, PdfObject value) {
value.setID(id);
switch (id) {
case PdfDictionary.Encrypt:
Encrypt = value;
break;
case PdfDictionary.Extends:
Extends = value;
break;
case PdfDictionary.Info:
Info = value;
break;
case PdfDictionary.Root:
Root = value;
break;
// case PdfDictionary.XObject:
// XObject=value;
// break;
default:
super.setDictionary(id, value);
}
}
@SuppressWarnings("unchecked")
void mergeField(String name, AcroFields.Item item) {
HashMap<String, Object> map = fieldTree;
StringTokenizer tk = new StringTokenizer(name, ".");
if (!tk.hasMoreTokens()) return;
while (true) {
String s = tk.nextToken();
Object obj = map.get(s);
if (tk.hasMoreTokens()) {
if (obj == null) {
obj = new HashMap();
map.put(s, obj);
map = (HashMap<String, Object>) obj;
continue;
} else if (obj instanceof HashMap) map = (HashMap<String, Object>) obj;
else return;
} else {
if (obj instanceof HashMap) return;
PdfDictionary merged = item.getMerged(0);
if (obj == null) {
PdfDictionary field = new PdfDictionary();
if (PdfName.SIG.equals(merged.get(PdfName.FT))) hasSignature = true;
for (Object element : merged.getKeys()) {
PdfName key = (PdfName) element;
if (fieldKeys.containsKey(key)) field.put(key, merged.get(key));
}
ArrayList<Object> list = new ArrayList<Object>();
list.add(field);
createWidgets(list, item);
map.put(s, list);
} else {
ArrayList<Object> list = (ArrayList<Object>) obj;
PdfDictionary field = (PdfDictionary) list.get(0);
PdfName type1 = (PdfName) field.get(PdfName.FT);
PdfName type2 = (PdfName) merged.get(PdfName.FT);
if (type1 == null || !type1.equals(type2)) return;
int flag1 = 0;
PdfObject f1 = field.get(PdfName.FF);
if (f1 != null && f1.isNumber()) flag1 = ((PdfNumber) f1).intValue();
int flag2 = 0;
PdfObject f2 = merged.get(PdfName.FF);
if (f2 != null && f2.isNumber()) flag2 = ((PdfNumber) f2).intValue();
if (type1.equals(PdfName.BTN)) {
if (((flag1 ^ flag2) & PdfFormField.FF_PUSHBUTTON) != 0) return;
if ((flag1 & PdfFormField.FF_PUSHBUTTON) == 0
&& ((flag1 ^ flag2) & PdfFormField.FF_RADIO) != 0) return;
} else if (type1.equals(PdfName.CH)) {
if (((flag1 ^ flag2) & PdfFormField.FF_COMBO) != 0) return;
}
createWidgets(list, item);
}
return;
}
}
}
/**
* Add a chained action.
*
* @param na the next action
*/
public void next(PdfAction na) {
PdfObject nextAction = get(PdfName.NEXT);
if (nextAction == null) put(PdfName.NEXT, na);
else if (nextAction.isDictionary()) {
PdfArray array = new PdfArray(nextAction);
array.add(na);
put(PdfName.NEXT, array);
} else {
((PdfArray) nextAction).add(na);
}
}
@Override
public void setDictionary(final int id, final PdfObject value) {
value.setID(id);
switch (id) {
case PdfDictionary.TR:
TR = value;
break;
default:
super.setDictionary(id, value);
}
}
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;
}
/** 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));
}
}
public void setIntNumber(int id, int value) {
switch (id) {
case PdfDictionary.First:
First = value;
break;
case PdfDictionary.Prev:
// some PDFs can get multiple values and second one wrong
if (Prev == -1) Prev = value;
break;
case PdfDictionary.Size:
Size = value;
break;
//
// case PdfDictionary.Height:
// Height=value;
// break;
//
case PdfDictionary.XRefStm:
XRefStm = value;
break;
default:
super.setIntNumber(id, value);
}
}
@Override
public void setFloatNumber(final int id, final float value) {
switch (id) {
default:
super.setFloatNumber(id, value);
}
}
@Override
public void setDoubleArray(final int id, final double[] value) {
switch (id) {
default:
super.setDoubleArray(id, value);
}
}
/** @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);
}
}
@Override
public void setStringArray(final int id, final byte[][] value) {
switch (id) {
default:
super.setStringArray(id, value);
}
}
@Override
public void setFloatArray(final int id, final float[] value) {
switch (id) {
default:
super.setFloatArray(id, value);
}
}
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"));
}
}
}
public void alterContents() throws IOException {
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 = new ByteBuffer();
if (under != null) {
out.append(PdfContents.SAVESTATE);
applyRotation(pageN, out);
out.append(under.getInternalBuffer());
out.append(PdfContents.RESTORESTATE);
}
if (over != null) out.append(PdfContents.SAVESTATE);
PdfStream stream = new PdfStream(out.toByteArray());
stream.flateCompress(cstp.getCompressionLevel());
PdfIndirectReference ref1 = cstp.addToBody(stream).getIndirectReference();
ar.addFirst(ref1);
out.reset();
if (over != null) {
out.append(' ');
out.append(PdfContents.RESTORESTATE);
out.append(PdfContents.SAVESTATE);
applyRotation(pageN, out);
out.append(over.getInternalBuffer());
out.append(PdfContents.RESTORESTATE);
stream = new PdfStream(out.toByteArray());
stream.flateCompress(cstp.getCompressionLevel());
ar.add(cstp.addToBody(stream).getIndirectReference());
}
pageN.put(PdfName.RESOURCES, pageResources.getResources());
}
public void checkParentForResources(final PdfObject pdfObject) {
/** if no resource, check parent for one (in theory should recurse up whole tree) */
if (pdfObject.getDictionary(PdfDictionary.Resources) == null) {
final String parent = pdfObject.getStringKey(PdfDictionary.Parent);
if (parent != null) {
final PdfObject parentObj = new PageObject(parent);
readObject(parentObj);
final PdfObject resObj = parentObj.getDictionary(PdfDictionary.Resources);
if (resObj != null) {
pdfObject.setDictionary(PdfDictionary.Resources, resObj);
}
}
}
}
public void setStringArray(int id, byte[][] value) {
switch (id) {
case PdfDictionary.ID:
ID = value;
break;
default:
super.setStringArray(id, value);
}
}
/**
* Writes the PDF representation of this <CODE>PdfDictionary</CODE> as an array of <CODE>byte
* </CODE> to the given <CODE>OutputStream</CODE>.
*
* @param writer for backwards compatibility
* @param os the <CODE>OutputStream</CODE> to write the bytes to.
* @throws IOException
*/
@Override
public void toPdf(final PdfWriter writer, final OutputStream os) throws IOException {
os.write('<');
os.write('<');
// loop over all the object-pairs in the HashMap
PdfObject value;
int type = 0;
for (Entry<PdfName, PdfObject> e : hashMap.entrySet()) {
e.getKey().toPdf(writer, os);
value = e.getValue();
type = value.type();
if (type != PdfObject.ARRAY
&& type != PdfObject.DICTIONARY
&& type != PdfObject.NAME
&& type != PdfObject.STRING) os.write(' ');
value.toPdf(writer, os);
}
os.write('>');
os.write('>');
}
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 void setBoolean(int id, boolean value) {
switch (id) {
// case PdfDictionary.ImageMask:
// ImageMask=value;
// break;
default:
super.setBoolean(id, value);
}
}
@Override
public void setFloatArray(final int id, final float[] value) {
switch (id) {
case PdfDictionary.Matrix:
Matrix = value;
break;
default:
super.setFloatArray(id, value);
}
}
public void setDoubleArray(int id, double[] value) {
switch (id) {
// case PdfDictionary.FontMatrix:
// FontMatrix=value;
// break;
default:
super.setDoubleArray(id, value);
}
}
public void setMixedArray(int id, byte[][] value) {
switch (id) {
// case PdfDictionary.Differences:
// Differences=value;
// break;
default:
super.setMixedArray(id, value);
}
}
@Override
public void setMixedArray(final int id, final byte[][] value) {
switch (id) {
case PdfDictionary.BM:
BM = value;
break;
default:
super.setMixedArray(id, value);
}
}
public void setFloatArray(int id, float[] value) {
switch (id) {
// case PdfDictionary.Matrix:
// Matrix=value;
// break;
default:
super.setFloatArray(id, value);
}
}
public void setName(int id, byte[] value) {
switch (id) {
// case PdfDictionary.CMapName:
// rawCMapName=value;
// break;
default:
super.setName(id, value);
}
}
public void setKeyArray(int id, byte[][] value) {
switch (id) {
// case PdfDictionary.TR:
// TR=value;
// break;
default:
super.setKeyArray(id, value);
}
}
@Override
public void setName(final int id, final byte[] value) {
switch (id) {
case PdfDictionary.Name:
rawName = value;
break;
default:
super.setName(id, value);
}
}
public void setTextStreamValue(int id, byte[] value) {
switch (id) {
// case PdfDictionary.ID:
// rawID=value;
// break;
//
default:
super.setTextStreamValue(id, value);
}
}
