How to use

PdfDictionary

in

com.lowagie.text.pdf

protected static PdfDictionary duplicatePdfDictionary(PdfDictionary original,
  PdfDictionary copy, PdfReader newReader) {
 if (copy == null)
  copy = new PdfDictionary();
 for (Object o : original.getKeys()) {
  PdfName key = (PdfName) o;
  copy.put(key, duplicatePdfObject(original.get(key), newReader));
 }
 return copy;
}

protected void readFields() {
  catalog = trailer.getAsDict(PdfName.ROOT);
  PdfDictionary fdf = catalog.getAsDict(PdfName.FDF);
  if (fdf == null)
    return;
  PdfString fs = fdf.getAsString(PdfName.F);
  if (fs != null)
    fileSpec = fs.toUnicodeString();
  PdfArray fld = fdf.getAsArray(PdfName.FIELDS);
  if (fld == null)
    return;
  encoding = fdf.getAsName(PdfName.ENCODING);
  PdfDictionary merged = new PdfDictionary();
  merged.put(PdfName.KIDS, fld);
  kidNode(merged, "");
}

Set<PdfName> allkeys = dictionary.getKeys();
for (PdfName key: allkeys) {
  PdfObject value = dictionary.get(key);
  PdfObject direct = PdfReader.getPdfObject(indirect);

void setPageAction(PdfName actionType, PdfAction action) {
  if (pageAA == null) {
    pageAA = new PdfDictionary();
  }
  pageAA.put(actionType, action);
}

void addAdditionalAction(PdfName actionType, PdfAction action)  {
  if (additionalActions == null)  {
    additionalActions = new PdfDictionary();
  }
  if (action == null)
    additionalActions.remove(actionType);
  else
    additionalActions.put(actionType, action);
  if (additionalActions.size() == 0)
    additionalActions = null;
}

if (item == null)
  return false;
PdfDictionary acroForm = (PdfDictionary)PdfReader.getPdfObject(reader.getCatalog().get(PdfName.ACROFORM), reader.getCatalog());
PdfArray arrayf = acroForm.getAsArray(PdfName.FIELDS);
if (arrayf == null)
  return false;
  PdfDictionary wd = item.getWidget( k );
  PdfDictionary pageDic = reader.getPageN(pageV);
  PdfArray annots = pageDic.getAsArray(PdfName.ANNOTS);
  if (annots != null) {
    if (removeRefFromArray(annots, ref) == 0) {
      pageDic.remove(PdfName.ANNOTS);
      markUsed(pageDic);
  PdfReader.killIndirect(ref);
  PdfIndirectReference kid = ref;
  while ((ref = wd.getAsIndirectObject(PdfName.PARENT)) != null) {
    wd = wd.getAsDict( PdfName.PARENT );
    PdfArray kids = wd.getAsArray(PdfName.KIDS);
    if (removeRefFromArray(kids, kid) != 0)
      break;

void createWidgets(ArrayList 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 (Iterator it = merged.getKeys().iterator(); it.hasNext();) {
      PdfName key = (PdfName)it.next();
      if (widgetKeys.containsKey(key))
        widget.put(key, merged.get(key));
    }
    widget.put(iTextTag, new PdfNumber(item.getTabOrder(k).intValue() + 1));
    list.add(widget);
  }
}
 

  /**
   * @see com.lowagie.text.pdf.interfaces.PdfVersion#addDeveloperExtension(com.lowagie.text.pdf.PdfDeveloperExtension)
   * @since    2.1.6
   */
  public void addDeveloperExtension(PdfDeveloperExtension de) {
    if (extensions == null) {
      extensions = new PdfDictionary();
    }
    else {
      PdfDictionary extension = extensions.getAsDict(de.getPrefix());
      if (extension != null) {
        int diff = de.getBaseversion().compareTo(extension.getAsName(PdfName.BASEVERSION));
        if (diff < 0)
          return;
        diff = de.getExtensionLevel() - extension.getAsNumber(PdfName.EXTENSIONLEVEL).intValue();
        if (diff <= 0)
          return;
      }
    }
    extensions.put(de.getPrefix(), de.getDeveloperExtensions());
  }
}

 float factor = 2.5f;
PdfReader reader = new PdfReader(src);
int n = reader.getNumberOfPages();
PdfDictionary page;
for (int p = 1; p <= n; p++) {
  page = reader.getPageN(p);
  if (page.getAsNumber(PdfName.USERUNIT) == null)
    page.put(PdfName.USERUNIT, new PdfNumber(factor));
}
PdfStamper stamper = new PdfStamper(reader, new FileOutputStream(dest));
stamper.close();
reader.close();

 PdfReader reader = new PdfReader(resource);

PdfDictionary form = reader.getCatalog().getAsDict(PdfName.ACROFORM);
PdfArray fields = form.getAsArray(PdfName.FIELDS);
for (PdfObject object: fields)
{
  PdfDictionary field = (PdfDictionary) PdfReader.getPdfObject(object);
  if ("Text1".equals(field.getAsString(PdfName.T).toString()))
  {
    PdfDictionary newField = new PdfDictionary();
    PRIndirectReference newFieldRef = reader.addPdfObject(newField);
    fields.add(newFieldRef);
    newField.putAll(field);
    newField.put(PdfName.T, new PdfString("foobar"));
    PdfArray newKids = new PdfArray();
    newField.put(PdfName.KIDS, newKids);
    PdfArray kids = field.getAsArray(PdfName.KIDS);
    PdfObject widget = kids.remove(0);
    newKids.add(widget);
    PdfDictionary widgetDict = (PdfDictionary) PdfReader.getPdfObject(widget);
    widgetDict.put(PdfName.PARENT, newFieldRef);
    break;
  }
}

PdfStamper stamper = new PdfStamper(reader, result);
stamper.close();

protected void kidNode(PdfDictionary merged, String name) {
  PdfArray kids = merged.getAsArray(PdfName.KIDS);
  if (kids == null || kids.isEmpty()) {
    if (name.length() > 0)
      name = name.substring(1);
    fields.put(name, merged);
  }
  else {
    merged.remove(PdfName.KIDS);
    for (int k = 0; k < kids.size(); ++k) {
      PdfDictionary dic = new PdfDictionary();
      dic.merge(merged);
      PdfDictionary newDic = kids.getAsDict(k);
      PdfString t = newDic.getAsString(PdfName.T);
      String newName = name;
      if (t != null)
        newName += "." + t.toUnicodeString();
      dic.merge(newDic);
      dic.remove(PdfName.T);
      kidNode(dic, newName);
    }
  }
}

  /**
   * Moves the field keys from <CODE>from</CODE> to <CODE>to</CODE>. The moved keys
   * are removed from <CODE>from</CODE>.
   * @param from the source
   * @param to the destination. It may be <CODE>null</CODE>
   */    
  public static void moveFields(PdfDictionary from, PdfDictionary to) {
    for (Iterator i = from.getKeys().iterator(); i.hasNext();) {
      PdfName key = (PdfName)i.next();
      if (fieldKeys.containsKey(key)) {
        if (to != null)
          to.put(key, from.get(key));
        i.remove();
      }
    }
  }
}

 PdfReader reader = new PdfReader(resourceStream);
PdfStamper stamper = new PdfStamper(reader, outputStream);

for (int page = 1; page <= reader.getNumberOfPages(); page++)
{
  PdfDictionary pageDictionary = reader.getPageN(page);
  PdfArray annotationArray = pageDictionary.getAsArray(PdfName.ANNOTS);
  if (annotationArray == null)
    continue;
  for (PdfObject object : annotationArray)
  {
    PdfObject directObject = PdfReader.getPdfObject(object);
    if (directObject instanceof PdfDictionary)
    {
      PdfDictionary annotationDictionary = (PdfDictionary) directObject;
      PdfNumber flagsNumber = annotationDictionary.getAsNumber(PdfName.F);
      int flags = flagsNumber != null ? flagsNumber.intValue() : 0;
      flags |= PdfAnnotation.FLAGS_READONLY;
      annotationDictionary.put(PdfName.F, new PdfNumber(flags));
    }
  }
}

stamper.close();

PdfString stringOpt = vals.getAsString(PdfName.OPT);
if (stringOpt != null) {
 names.put(stringOpt.toUnicodeString(), null);
} else {
 PdfArray arrayOpt = vals.getAsArray(PdfName.OPT);
 if (arrayOpt != null) {
  for (int k = 0; k < arrayOpt.size(); ++k) {
 dic = dic.getAsDict(PdfName.AP);
 if (dic == null) {
  continue;
 dic = dic.getAsDict(PdfName.N);
 if (dic == null) {
  continue;
 for (Object o : dic.getKeys()) {
  String name = PdfName.decodeName(o.toString());
  names.put(name, null);

void setThumbnail(Image image, int page) throws DocumentException {
  PdfIndirectReference thumb = getImageReference(addDirectImageSimple(image));
  reader.resetReleasePage();
  PdfDictionary dic = reader.getPageN(page);
  dic.put(PdfName.THUMB, thumb);
  reader.resetReleasePage();
}

/**
 * Add PDF meta values to the target PDF document.
 */
private void addPdfMetaValuesToPdfDocument( ITextRenderer renderer ) {
  
  Iterator pdfNameIter = this.pdfInfoValues.keySet().iterator();
  while (pdfNameIter.hasNext()) {
    PdfName pdfName = (PdfName) pdfNameIter.next();
    PdfString pdfString = (PdfString) pdfInfoValues.get( pdfName );
    XRLog.render(Level.FINEST, "pdfName=" + pdfName + ", pdfString=" + pdfString );
    renderer.getOutputDevice().getWriter().getInfo().put( pdfName, pdfString );            
  }
  if ( XRLog.isLoggingEnabled() ) {
    XRLog.render(Level.FINEST, "added " + renderer.getOutputDevice().getWriter().getInfo().getKeys() );            
  }
}

private void pushPageAttributes(PdfDictionary nodePages) {
  PdfDictionary dic = new PdfDictionary();
  if (!pageInh.isEmpty()) {
    dic.putAll((PdfDictionary)pageInh.get(pageInh.size() - 1));
  }
  for (int k = 0; k < pageInhCandidates.length; ++k) {
    PdfObject obj = nodePages.get(pageInhCandidates[k]);
    if (obj != null)
      dic.put(pageInhCandidates[k], obj);
  }
  pageInh.add(dic);
}

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;
}
 

private void serDic(PdfDictionary dic, int level, ByteBuffer bb) throws IOException {
  bb.append("$D");
  if (level <= 0)
    return;
  Object[] keys = dic.getKeys().toArray();
  Arrays.sort(keys);
  for (int k = 0; k < keys.length; ++k) {
    serObject((PdfObject)keys[k], level, bb);
    serObject(dic.get((PdfName)keys[k]), level, bb);
  }
}
 

public ArrayList getLinks(int page) {
  pageRefs.resetReleasePage();
  ArrayList result = new ArrayList();
  PdfDictionary pageDic = pageRefs.getPageN(page);
  if (pageDic.get(PdfName.ANNOTS) != null) {
    PdfArray annots = pageDic.getAsArray(PdfName.ANNOTS);
    for (int j = 0; j < annots.size(); ++j) {
      PdfDictionary annot = (PdfDictionary)getPdfObjectRelease(annots.getPdfObject(j));
      if (PdfName.LINK.equals(annot.get(PdfName.SUBTYPE))) {
        result.add(new PdfAnnotation.PdfImportedLink(annot));
      }
    }
  }
  pageRefs.releasePage(page);
  pageRefs.resetReleasePage();
  return result;
}