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);
}
static IntHashtable createMetric(String s) {
IntHashtable h = new IntHashtable();
StringTokenizer tk = new StringTokenizer(s);
while (tk.hasMoreTokens()) {
int n1 = Integer.parseInt(tk.nextToken());
h.put(n1, Integer.parseInt(tk.nextToken()));
}
return h;
}
@Override
protected int getNewObjectNumber(PdfReader reader, int number, int generation) {
IntHashtable refs = readers2intrefs.get(reader);
int n = refs.get(number);
if (n == 0) {
n = getIndirectReferenceNumber();
refs.put(number, n);
}
return n;
}
/**
* Gets the width of a <CODE>char</CODE> in normalized 1000 units.
*
* @param char1 the unicode <CODE>char</CODE> to get the width of
* @return the width in normalized 1000 units
*/
@Override
public int getWidth(int char1) {
int c = char1;
if (!cidDirect) c = translationMap[c];
int v;
if (vertical) v = vMetrics.get(c);
else v = hMetrics.get(c);
if (v > 0) return v;
else return 1000;
}
@Override
byte[] convertToBytes(int char1) {
if (cjkMirror != null) return cjkMirror.convertToBytes(char1);
else if (isType0) {
int[] ws = metrics.get(Integer.valueOf(char1));
if (ws != null) {
int g = ws[0];
return new byte[] {(byte) (g / 256), (byte) g};
} else return new byte[0];
} else {
if (uni2byte.containsKey(char1)) return new byte[] {(byte) uni2byte.get(char1)};
else return new byte[0];
}
}
@Override
public int getWidth(String text) {
int total = 0;
for (int k = 0; k < text.length(); ++k) {
int c = text.charAt(k);
if (!cidDirect) c = translationMap[c];
int v;
if (vertical) v = vMetrics.get(c);
else v = hMetrics.get(c);
if (v > 0) total += v;
else total += 1000;
}
return total;
}
/**
* @param key
* @param value
*/
public void put(int key, O value) {
Object[] recs = hashtable.get(key);
if (recs == null) {
recs = new Object[1];
hashtable.put(key, recs);
} else {
Object[] old = recs;
recs = new Object[old.length + 1];
for (int i = 0; i < old.length; i++) {
recs[i] = old[i];
}
hashtable.put(key, recs);
}
recs[recs.length - 1] = value;
}
/** Creates the new PDF by merging the fields and forms. */
protected void closeIt() throws IOException {
for (int k = 0; k < readers.size(); ++k) {
readers.get(k).removeFields();
}
for (int r = 0; r < readers.size(); ++r) {
PdfReader reader = readers.get(r);
for (int page = 1; page <= reader.getNumberOfPages(); ++page) {
pageRefs.add(getNewReference(reader.getPageOrigRef(page)));
pageDics.add(reader.getPageN(page));
}
}
mergeFields();
createAcroForms();
for (int r = 0; r < readers.size(); ++r) {
PdfReader reader = readers.get(r);
for (int page = 1; page <= reader.getNumberOfPages(); ++page) {
PdfDictionary dic = reader.getPageN(page);
PdfIndirectReference pageRef = getNewReference(reader.getPageOrigRef(page));
PdfIndirectReference parent = root.addPageRef(pageRef);
dic.put(PdfName.PARENT, parent);
propagate(dic, pageRef, false);
}
}
for (Map.Entry<PdfReader, IntHashtable> entry : readers2intrefs.entrySet()) {
PdfReader reader = entry.getKey();
try {
file = reader.getSafeFile();
file.reOpen();
IntHashtable t = entry.getValue();
int keys[] = t.toOrderedKeys();
for (int k = 0; k < keys.length; ++k) {
PRIndirectReference ref = new PRIndirectReference(reader, keys[k]);
addToBody(PdfReader.getPdfObjectRelease(ref), t.get(keys[k]));
}
} finally {
try {
file.close();
// TODO: Removed - the user should be responsible for closing all PdfReaders. But, this
// could cause a lot of memory leaks in code out there that hasn't been properly closing
// things - maybe add a finalizer to PdfReader that calls PdfReader#close() ??
// reader.close();
} catch (Exception e) {
// empty on purpose
}
}
}
pdf.close();
}
private void fillEncoding(PdfName encoding) {
if (PdfName.MAC_ROMAN_ENCODING.equals(encoding) || PdfName.WIN_ANSI_ENCODING.equals(encoding)) {
byte b[] = new byte[256];
for (int k = 0; k < 256; ++k) b[k] = (byte) k;
String enc = WINANSI;
if (PdfName.MAC_ROMAN_ENCODING.equals(encoding)) enc = MACROMAN;
String cv = PdfEncodings.convertToString(b, enc);
char arr[] = cv.toCharArray();
for (int k = 0; k < 256; ++k) {
uni2byte.put(arr[k], k);
}
} else {
for (int k = 0; k < 256; ++k) {
uni2byte.put(stdEnc[k], k);
}
}
}
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;
}
@Override
public byte[] convertToBytes(String text) {
if (cjkMirror != null) return cjkMirror.convertToBytes(text);
else if (isType0) {
char[] chars = text.toCharArray();
int len = chars.length;
byte[] b = new byte[len * 2];
int bptr = 0;
for (int k = 0; k < len; ++k) {
int[] ws = metrics.get(Integer.valueOf(chars[k]));
if (ws != null) {
int g = ws[0];
b[bptr++] = (byte) (g / 256);
b[bptr++] = (byte) g;
}
}
if (bptr == b.length) return b;
else {
byte[] nb = new byte[bptr];
System.arraycopy(b, 0, nb, 0, bptr);
return nb;
}
} else {
char cc[] = text.toCharArray();
byte b[] = new byte[cc.length];
int ptr = 0;
for (int k = 0; k < cc.length; ++k) {
if (uni2byte.containsKey(cc[k])) b[ptr++] = (byte) uni2byte.get(cc[k]);
}
if (ptr == b.length) return b;
else {
byte[] b2 = new byte[ptr];
System.arraycopy(b, 0, b2, 0, ptr);
return b2;
}
}
}
private PdfDictionary getCIDFont(PdfIndirectReference fontDescriptor, IntHashtable cjkTag) {
PdfDictionary dic = new PdfDictionary(PdfName.FONT);
dic.put(PdfName.SUBTYPE, PdfName.CIDFONTTYPE0);
dic.put(PdfName.BASEFONT, new PdfName(fontName + style));
dic.put(PdfName.FONTDESCRIPTOR, fontDescriptor);
int keys[] = cjkTag.toOrderedKeys();
String w = convertToHCIDMetrics(keys, hMetrics);
if (w != null) dic.put(PdfName.W, new PdfLiteral(w));
if (vertical) {
w = convertToVCIDMetrics(keys, vMetrics, hMetrics);
if (w != null) dic.put(PdfName.W2, new PdfLiteral(w));
} else dic.put(PdfName.DW, new PdfNumber(1000));
PdfDictionary cdic = new PdfDictionary();
cdic.put(PdfName.REGISTRY, new PdfString((String) fontDesc.get("Registry"), null));
cdic.put(PdfName.ORDERING, new PdfString((String) fontDesc.get("Ordering"), null));
cdic.put(PdfName.SUPPLEMENT, new PdfLiteral((String) fontDesc.get("Supplement")));
dic.put(PdfName.CIDSYSTEMINFO, cdic);
return dic;
}
private void doType1TT() {
CMapToUnicode toUnicode = null;
PdfObject enc = PdfReader.getPdfObject(font.get(PdfName.ENCODING));
if (enc == null) {
fillEncoding(null);
try {
toUnicode = processToUnicode();
if (toUnicode != null) {
Map<Integer, Integer> rm = toUnicode.createReverseMapping();
for (Map.Entry<Integer, Integer> kv : rm.entrySet()) {
uni2byte.put(kv.getKey().intValue(), kv.getValue().intValue());
}
}
} catch (Exception ex) {
throw new ExceptionConverter(ex);
}
} 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) {
diffmap = new IntHashtable();
int currentNumber = 0;
for (int k = 0; k < diffs.size(); ++k) {
PdfObject obj = diffs.getPdfObject(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.put(c[0], currentNumber);
diffmap.put(c[0], currentNumber);
} else {
if (toUnicode == null) {
toUnicode = processToUnicode();
if (toUnicode == null) {
toUnicode = new CMapToUnicode();
}
}
final String unicode = toUnicode.lookup(new byte[] {(byte) currentNumber}, 0, 1);
if ((unicode != null) && (unicode.length() == 1)) {
this.uni2byte.put(unicode.charAt(0), currentNumber);
this.diffmap.put(unicode.charAt(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;
try {
bf = BaseFont.createFont(fontName, WINANSI, false);
} catch (Exception e) {
throw new ExceptionConverter(e);
}
int e[] = uni2byte.toOrderedKeys();
for (int k = 0; k < e.length; ++k) {
int n = uni2byte.get(e[k]);
widths[n] = bf.getRawWidth(n, GlyphList.unicodeToName(e[k]));
}
if (diffmap != null) { // widths for diffmap must override existing ones
e = diffmap.toOrderedKeys();
for (int k = 0; k < e.length; ++k) {
int n = diffmap.get(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);
}
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.arraycopy(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));
}
private void fillMetrics(byte[] touni, IntHashtable widths, int dw) {
try {
PdfContentParser ps = new PdfContentParser(new PRTokeniser(touni));
PdfObject ob = null;
boolean notFound = true;
int nestLevel = 0;
int maxExc = 50;
while ((notFound || nestLevel > 0)) {
try {
ob = ps.readPRObject();
} catch (Exception ex) {
if (--maxExc < 0) break;
continue;
}
if (ob == null) break;
if (ob.type() == PdfContentParser.COMMAND_TYPE) {
if (ob.toString().equals("begin")) {
notFound = false;
nestLevel++;
} else if (ob.toString().equals("end")) {
nestLevel--;
} else if (ob.toString().equals("beginbfchar")) {
while (true) {
PdfObject nx = ps.readPRObject();
if (nx.toString().equals("endbfchar")) break;
String cid = decodeString((PdfString) nx);
String uni = decodeString((PdfString) ps.readPRObject());
if (uni.length() == 1) {
int cidc = cid.charAt(0);
int unic = uni.charAt(uni.length() - 1);
int w = dw;
if (widths.containsKey(cidc)) w = widths.get(cidc);
metrics.put(Integer.valueOf(unic), new int[] {cidc, w});
}
}
} else if (ob.toString().equals("beginbfrange")) {
while (true) {
PdfObject nx = ps.readPRObject();
if (nx.toString().equals("endbfrange")) break;
String cid1 = decodeString((PdfString) nx);
String cid2 = decodeString((PdfString) ps.readPRObject());
int cid1c = cid1.charAt(0);
int cid2c = cid2.charAt(0);
PdfObject ob2 = ps.readPRObject();
if (ob2.isString()) {
String uni = decodeString((PdfString) ob2);
if (uni.length() == 1) {
int unic = uni.charAt(uni.length() - 1);
for (; cid1c <= cid2c; cid1c++, unic++) {
int w = dw;
if (widths.containsKey(cid1c)) w = widths.get(cid1c);
metrics.put(Integer.valueOf(unic), new int[] {cid1c, w});
}
}
} else {
PdfArray a = (PdfArray) ob2;
for (int j = 0; j < a.size(); ++j, ++cid1c) {
String uni = decodeString(a.getAsString(j));
if (uni.length() == 1) {
int unic = uni.charAt(uni.length() - 1);
int w = dw;
if (widths.containsKey(cid1c)) w = widths.get(cid1c);
metrics.put(Integer.valueOf(unic), new int[] {cid1c, w});
}
}
}
}
}
}
}
} catch (Exception e) {
throw new ExceptionConverter(e);
}
}
static {
for (int l = 0; l < hwKeyboardLayouts.length; l++)
hwKeyboardLayoutsLst.put(hwKeyboardLayouts[l], dummy);
}
protected boolean keyDown(final int keycode, int time) {
System.out.println("***** keyDown *****");
System.out.println("keycode=" + keycode);
char altedKey = '0';
boolean useAltedKey = false;
final int key;
boolean isAltedKeyboard = false;
try {
isAltedKeyboard = hwKeyboardLayoutsLst.containsKey(Keypad.getHardwareLayout());
// System.out.println("hw layout " + Integer.toString(Keypad.getHardwareLayout()) +
// (isAltedKeyboard ? " alted" : " non-alted") );
} catch (Exception e) {
System.out.println("contains Exception " + e);
}
if (isAltedKeyboard) { // Alted keyboard
altedKey = Keypad.map(Keypad.key(keycode), KeypadListener.STATUS_ALT);
if ((altedKey == '#') || (altedKey == '*')) { // enable zoom in zoom out.
useAltedKey = true;
}
}
if (keyDownStackAddress == 0) {
Logger.log("keyDownStackAddress = 0, before stack init ");
return true;
}
key = Keypad.key(keycode);
System.out.println("key is = " + key);
final int status = Keypad.status(keycode);
// System.out.println("key=" + keycode + " status=" + status);
if (key == Keypad.KEY_MENU) {
System.out.println("***** MENU BUTTON PRESSED *****");
menu_open = true;
try {
if (c_on_menu_key_down == 0) {
c_on_menu_key_down = CibylCallTable.getAddressByName("rim_on_menu_button");
}
if (c_on_menu_key_down != 0) {
// FIXME - should send keycode to C and C should trans to UTF8
updateUTF8Key(keycode);
CibylCallTable.call(c_on_menu_key_down, keyDownStackAddress, key, status, time, 0);
}
} catch (Exception t) {
Logger.log("Exception in UI action: " + t);
t.printStackTrace();
}
return false; // return false so RIM will open the menu as necessary.
} else if (key == Keypad.KEY_VOLUME_DOWN) {
SoundMgr.updateSoundLevel(-10);
} else if (key == Keypad.KEY_VOLUME_UP) {
SoundMgr.updateSoundLevel(10);
} else if ((key == Keypad.KEY_SEND)
|| (key == Keypad.KEY_APPLICATION)
|| (key == Keypad.KEY_SPEAKERPHONE)
|| (key == Keypad.KEY_CONVENIENCE_1)
|| (key == Keypad.KEY_CONVENIENCE_2)) {
return false;
} else if (key == Keypad.KEY_END) {
return false;
} else {
try {
if (c_on_key_down == 0) c_on_key_down = CibylCallTable.getAddressByName("rim_on_key_down");
} catch (Throwable t) {
Logger.log("Exception in keyDown: " + t);
t.printStackTrace();
System.exit(0);
}
if (c_on_key_down != 0) {
// FIXME - should send keycode to C and C should trans to UTF8
if (!useAltedKey) updateUTF8Key(keycode);
else updateUTF8Key(altedKey);
UIWorker.addUIEvent(c_on_key_down, key, status, time, 0, true);
}
}
return true;
}
/**
* @param key
* @return the value in the map with key
*/
public Object[] get(int key) {
return (Object[]) hashtable.get(key);
}
/**
* Checks if a reference refers to a page object.
*
* @param ref the reference that needs to be checked
* @return true is the reference refers to a page object.
*/
protected boolean isPage(PRIndirectReference ref) {
IntHashtable refs = pages2intrefs.get(ref.getReader());
if (refs != null) return refs.containsKey(ref.getNumber());
else return false;
}
/**
* Checks if a reference has already been "visited" in the copy process.
*
* @param ref the reference that needs to be checked
* @return true if the reference was already visited
*/
protected boolean isVisited(PRIndirectReference ref) {
IntHashtable refs = visited.get(ref.getReader());
if (refs != null) return refs.containsKey(ref.getNumber());
else return false;
}
static String convertToHCIDMetrics(int keys[], IntHashtable h) {
if (keys.length == 0) return null;
int lastCid = 0;
int lastValue = 0;
int start;
for (start = 0; start < keys.length; ++start) {
lastCid = keys[start];
lastValue = h.get(lastCid);
if (lastValue != 0) {
++start;
break;
}
}
if (lastValue == 0) return null;
StringBuffer buf = new StringBuffer();
buf.append('[');
buf.append(lastCid);
int state = FIRST;
for (int k = start; k < keys.length; ++k) {
int cid = keys[k];
int value = h.get(cid);
if (value == 0) continue;
switch (state) {
case FIRST:
{
if (cid == lastCid + 1 && value == lastValue) {
state = SERIAL;
} else if (cid == lastCid + 1) {
state = BRACKET;
buf.append('[').append(lastValue);
} else {
buf.append('[').append(lastValue).append(']').append(cid);
}
break;
}
case BRACKET:
{
if (cid == lastCid + 1 && value == lastValue) {
state = SERIAL;
buf.append(']').append(lastCid);
} else if (cid == lastCid + 1) {
buf.append(' ').append(lastValue);
} else {
state = FIRST;
buf.append(' ').append(lastValue).append(']').append(cid);
}
break;
}
case SERIAL:
{
if (cid != lastCid + 1 || value != lastValue) {
buf.append(' ').append(lastCid).append(' ').append(lastValue).append(' ').append(cid);
state = FIRST;
}
break;
}
}
lastValue = value;
lastCid = cid;
}
switch (state) {
case FIRST:
{
buf.append('[').append(lastValue).append("]]");
break;
}
case BRACKET:
{
buf.append(' ').append(lastValue).append("]]");
break;
}
case SERIAL:
{
buf.append(' ').append(lastCid).append(' ').append(lastValue).append(']');
break;
}
}
return buf.toString();
}
/**
* Sets a reference to "visited" in the copy process.
*
* @param ref the reference that needs to be set to "visited"
* @return true if the reference was set to visited
*/
protected boolean setVisited(PRIndirectReference ref) {
IntHashtable refs = visited.get(ref.getReader());
if (refs != null) return refs.put(ref.getNumber(), 1) != 0;
else return false;
}
static String convertToVCIDMetrics(int keys[], IntHashtable v, IntHashtable h) {
if (keys.length == 0) return null;
int lastCid = 0;
int lastValue = 0;
int lastHValue = 0;
int start;
for (start = 0; start < keys.length; ++start) {
lastCid = keys[start];
lastValue = v.get(lastCid);
if (lastValue != 0) {
++start;
break;
} else lastHValue = h.get(lastCid);
}
if (lastValue == 0) return null;
if (lastHValue == 0) lastHValue = 1000;
StringBuffer buf = new StringBuffer();
buf.append('[');
buf.append(lastCid);
int state = FIRST;
for (int k = start; k < keys.length; ++k) {
int cid = keys[k];
int value = v.get(cid);
if (value == 0) continue;
int hValue = h.get(lastCid);
if (hValue == 0) hValue = 1000;
switch (state) {
case FIRST:
{
if (cid == lastCid + 1 && value == lastValue && hValue == lastHValue) {
state = SERIAL;
} else {
buf.append(' ')
.append(lastCid)
.append(' ')
.append(-lastValue)
.append(' ')
.append(lastHValue / 2)
.append(' ')
.append(V1Y)
.append(' ')
.append(cid);
}
break;
}
case SERIAL:
{
if (cid != lastCid + 1 || value != lastValue || hValue != lastHValue) {
buf.append(' ')
.append(lastCid)
.append(' ')
.append(-lastValue)
.append(' ')
.append(lastHValue / 2)
.append(' ')
.append(V1Y)
.append(' ')
.append(cid);
state = FIRST;
}
break;
}
}
lastValue = value;
lastCid = cid;
lastHValue = hValue;
}
buf.append(' ')
.append(lastCid)
.append(' ')
.append(-lastValue)
.append(' ')
.append(lastHValue / 2)
.append(' ')
.append(V1Y)
.append(" ]");
return buf.toString();
}
protected boolean isVisited(PdfReader reader, int number, int generation) {
IntHashtable refs = readers2intrefs.get(reader);
return refs.containsKey(number);
}
