internal bool SetField(String field, PdfObject value) {
     Hashtable map = fields;
     StringTokenizer tk = new StringTokenizer(field, ".");
     if (!tk.HasMoreTokens())
         return false;
     while (true) {
         String s = tk.NextToken();
         Object obj = map[s];
         if (tk.HasMoreTokens()) {
             if (obj == null) {
                 obj = new Hashtable();
                 map[s] = obj;
                 map = (Hashtable)obj;
                 continue;
             }
             else if (obj is Hashtable)
                 map = (Hashtable)obj;
             else
                 return false;
         }
         else {
             if (!(obj is Hashtable)) {
                 map[s] = value;
                 return true;
             }
             else
                 return false;
         }
     }
 }

 public static PdfObject GetDirectObject(PdfObject obj) {
     if (obj == null)
         return null;
     while (obj.IsIndirect())
         obj = PdfReader.GetPdfObjectRelease(obj);
     return obj;
 }

 internal bool SetField(String field, PdfObject value) {
     Dictionary<String, Object> map = fields;
     StringTokenizer tk = new StringTokenizer(field, ".");
     if (!tk.HasMoreTokens())
         return false;
     while (true) {
         String s = tk.NextToken();
         Object obj;
         map.TryGetValue(s, out obj);
         if (tk.HasMoreTokens()) {
             if (obj == null) {
                 obj = new Dictionary<String, Object>();
                 map[s] = obj;
                 map = (Dictionary<string,object>)obj;
                 continue;
             }
             else if (obj is Dictionary<String, Object>)
                 map = (Dictionary<String, Object>)obj;
             else
                 return false;
         }
         else {
             if (!(obj is Dictionary<String, Object>)) {
                 map[s] = value;
                 return true;
             }
             else
                 return false;
         }
     }
 }

 /**
  * Gets the content bytes from a content object, which may be a reference
  * a stream or an array.
  * @param contentObject the object to read bytes from
  * @return the content bytes
  * @throws IOException
  */
 public static byte[] GetContentBytesFromContentObject(PdfObject contentObject) {
     byte[] result;
     switch (contentObject.Type)
     {
         case PdfObject.INDIRECT:
             PRIndirectReference refi = (PRIndirectReference) contentObject;
             PdfObject directObject = PdfReader.GetPdfObjectRelease(refi);
             result = GetContentBytesFromContentObject(directObject);
             break;
         case PdfObject.STREAM:
             PRStream stream = (PRStream) PdfReader.GetPdfObjectRelease(contentObject);
             result = PdfReader.GetStreamBytes(stream);
             break;
         case PdfObject.ARRAY:
             // Stitch together all content before calling ProcessContent(), because
             // ProcessContent() resets state.
             MemoryStream allBytes = new MemoryStream();
             PdfArray contentArray = (PdfArray) contentObject;
             ListIterator<PdfObject> iter = contentArray.GetListIterator();
             while (iter.HasNext()) {
                 PdfObject element = iter.Next();
                 byte[] b;
                 allBytes.Write(b = GetContentBytesFromContentObject(element), 0, b.Length);
                 allBytes.WriteByte((byte)' ');
             }
             result = allBytes.ToArray();
             break;
         default:
             String msg = "Unable to handle Content of type " + contentObject.GetType();
         throw new InvalidOperationException(msg);
     }
     return result;
 }

 internal void AddRange(PdfString from, PdfString to, PdfObject code) {
     byte[] a1 = DecodeStringToByte(from);
     byte[] a2 = DecodeStringToByte(to);
     if (a1.Length != a2.Length || a1.Length == 0)
         throw new ArgumentException("Invalid map.");
     byte[] sout = null;
     if (code is PdfString)
         sout = DecodeStringToByte((PdfString)code);
     int start = a1[a1.Length - 1] & 0xff;
     int end = a2[a2.Length - 1] & 0xff;
     for (int k = start; k <= end; ++k) {
         a1[a1.Length - 1] = (byte)k;
         PdfString s = new PdfString(a1);
         s.SetHexWriting(true);
         if (code is PdfArray) {
             AddChar(s, ((PdfArray)code)[k - start]);
         }
         else if (code is PdfNumber) {
             int nn = ((PdfNumber)code).IntValue + k - start;
             AddChar(s, new PdfNumber(nn));
         }
         else if (code is PdfString) {
             PdfString s1 = new PdfString(sout);
             s1.SetHexWriting(true);
             ++sout[sout.Length - 1];
             AddChar(s, s1);
         }
     }
 }

 internal override void AddChar(PdfString mark, PdfObject code) {
     if (!(code is PdfNumber))
         return;
     int codepoint;
     String s = DecodeStringToUnicode(mark);
     if (Utilities.IsSurrogatePair(s, 0))
         codepoint = Utilities.ConvertToUtf32(s, 0);
     else
         codepoint = (int)s[0];
     map[((PdfNumber)code).IntValue] = codepoint;
 }

 /**
 * Adds an object to the PDF body.
 * @param object
 * @param refNumber
 * @param inObjStm
 * @return a PdfIndirectObject
 * @throws IOException
 */
 public PdfIndirectObject AddToBody(PdfObject objecta, int refNumber, bool inObjStm) {
     PdfIndirectObject iobj = body.Add(objecta, refNumber, inObjStm);
     return iobj;
 }

 // constructors
 
 /**
 * Constructs a PDF-Trailer.
 *
 * @param        size        the number of entries in the <CODE>PdfCrossReferenceTable</CODE>
 * @param        offset      offset of the <CODE>PdfCrossReferenceTable</CODE>
 * @param        root        an indirect reference to the root of the PDF document
 * @param        info        an indirect reference to the info object of the PDF document
 * @param encryption
 * @param fileID
 * @param prevxref
 */
 
 public PdfTrailer(int size, long offset, PdfIndirectReference root, PdfIndirectReference info, PdfIndirectReference encryption, PdfObject fileID, long prevxref) {
     this.offset = offset;
     Put(PdfName.SIZE, new PdfNumber(size));
     Put(PdfName.ROOT, root);
     if (info != null) {
         Put(PdfName.INFO, info);
     }
     if (encryption != null)
         Put(PdfName.ENCRYPT, encryption);
     if (fileID != null)
         Put(PdfName.ID, fileID);
     if (prevxref > 0)
         Put(PdfName.PREV, new PdfNumber(prevxref));
 }

 virtual internal protected PdfIndirectObject Add(PdfObject objecta, int refNumber, bool inObjStm) {
     if (inObjStm && objecta.CanBeInObjStm() && writer.FullCompression) {
         PdfCrossReference pxref = AddToObjStm(objecta, refNumber);
         PdfIndirectObject indirect = new PdfIndirectObject(refNumber, objecta, writer);
         xrefs.Remove(pxref);
         xrefs[pxref] = null;
         return indirect;
     }
     else {
         PdfIndirectObject indirect = new PdfIndirectObject(refNumber, objecta, writer);
         Write(indirect, refNumber);
         return indirect;
     }
 }

 internal void SweepKids(PdfObject obj) {
     PdfObject oo = PdfReader.KillIndirect(obj);
     if (oo == null || !oo.IsDictionary())
         return;
     PdfDictionary dic = (PdfDictionary)oo;
     PdfArray kids = (PdfArray)PdfReader.KillIndirect(dic.Get(PdfName.KIDS));
     if (kids == null)
         return;
     for (int k = 0; k < kids.Size; ++k) {
         SweepKids(kids.GetPdfObject(k));
     }
 }

 /**
 * @see com.lowagie.text.pdf.interfaces.PdfViewerPreferences#addViewerPreference(com.lowagie.text.pdf.PdfName, com.lowagie.text.pdf.PdfObject)
 */
 public void AddViewerPreference(PdfName key, PdfObject value) {
     fc.AddViewerPreference(key, value); 
 }

 /** @see com.lowagie.text.pdf.interfaces.PdfViewerPreferences#addViewerPreference(com.lowagie.text.pdf.PdfName, com.lowagie.text.pdf.PdfObject) */
 internal void AddViewerPreference(PdfName key, PdfObject value) {
     this.viewerPreferences.AddViewerPreference(key, value);
 }

 protected PdfWriter.PdfBody.PdfCrossReference AddToObjStm(PdfObject obj, int nObj) {
     if (numObj >= OBJSINSTREAM)
         FlushObjStm();
     if (index == null) {
         index = new ByteBuffer();
         streamObjects = new ByteBuffer();
         currentObjNum = IndirectReferenceNumber;
         numObj = 0;
     }
     int p = streamObjects.Size;
     int idx = numObj++;
     PdfEncryption enc = writer.crypto;
     writer.crypto = null;
     obj.ToPdf(writer, streamObjects);
     writer.crypto = enc;
     streamObjects.Append(' ');
     index.Append(nObj).Append(' ').Append(p).Append(' ');
     return new PdfWriter.PdfBody.PdfCrossReference(2, nObj, currentObjNum, idx);
 }

 /**
 * Sets the default colorspace that will be applied to all the document.
 * The colorspace is only applied if another colorspace with the same name
 * is not present in the content.
 * <p>
 * The colorspace is applied immediately when creating templates and at the page
 * end for the main document content.
 * @param key the name of the colorspace. It can be <CODE>PdfName.DEFAULTGRAY</CODE>, <CODE>PdfName.DEFAULTRGB</CODE>
 * or <CODE>PdfName.DEFAULTCMYK</CODE>
 * @param cs the colorspace. A <CODE>null</CODE> or <CODE>PdfNull</CODE> removes any colorspace with the same name
 */    
 public void SetDefaultColorspace(PdfName key, PdfObject cs) {
     if (cs == null || cs.IsNull())
         defaultColorspace.Remove(key);
     defaultColorspace.Put(key, cs);
 }

 /** Adds a viewer preference
 * @param preferences the viewer preferences
 * @see PdfViewerPreferences#addViewerPreference
 */
 public override void AddViewerPreference(PdfName key, PdfObject value) {
     useVp = true;
     this.viewerPreferences.AddViewerPreference(key, value);
 }

 virtual public void MarkUsed(PdfObject obj) {
     if (append && obj != null) {
         PRIndirectReference ref_p = null;
         if (obj.Type == PdfObject.INDIRECT)
             ref_p = (PRIndirectReference)obj;
         else
             ref_p = obj.IndRef;
         if (ref_p != null)
             marked[ref_p.Number] = 1;
     }
 }

 internal static void FindAllObjects(PdfReader reader, PdfObject obj, IntHashtable hits) {
     if (obj == null)
         return;
     switch (obj.Type) {
         case PdfObject.INDIRECT:
             PRIndirectReference iref = (PRIndirectReference)obj;
             if (reader != iref.Reader)
                 return;
             if (hits.ContainsKey(iref.Number))
                 return;
             hits[iref.Number] = 1;
             FindAllObjects(reader, PdfReader.GetPdfObject(obj), hits);
             return;
         case PdfObject.ARRAY:
             PdfArray a = (PdfArray)obj;
             for (int k = 0; k < a.Size; ++k) {
                 FindAllObjects(reader, a[k], hits);
             }
             return;
         case PdfObject.DICTIONARY:
         case PdfObject.STREAM:
             PdfDictionary dic = (PdfDictionary)obj;
             foreach (PdfName name in dic.Keys) {
                 FindAllObjects(reader, dic.Get(name), hits);
             }
             return;
     }
 }

 /**
 * Returns the CrossReferenceTable of the <CODE>Body</CODE>.
 * @param os
 * @param root
 * @param info
 * @param encryption
 * @param fileID
 * @param prevxref
 * @throws IOException
 */
 virtual public void WriteCrossReferenceTable(Stream os, PdfIndirectReference root, PdfIndirectReference info, PdfIndirectReference encryption, PdfObject fileID, long prevxref) {
     int refNumber = 0;
     if (writer.FullCompression) {
         FlushObjStm();
         refNumber = IndirectReferenceNumber;
         xrefs[new PdfCrossReference(refNumber, position)] = null;
     }
     int first = ((PdfCrossReference)xrefs.GetMinKey()).Refnum;
     int len = 0;
     List<int> sections = new List<int>();
     foreach (PdfCrossReference entry in xrefs.Keys) {
         if (first + len == entry.Refnum)
             ++len;
         else {
             sections.Add(first);
             sections.Add(len);
             first = entry.Refnum;
             len = 1;
         }
     }
     sections.Add(first);
     sections.Add(len);
     if (writer.FullCompression) {
         int mid = 5;
         long mask = 0xff00000000L;
         for (; mid > 1; --mid) {
             if ((mask & position) != 0)
                 break;
             mask >>= 8;
         }
         ByteBuffer buf = new ByteBuffer();
         
         foreach (PdfCrossReference entry in xrefs.Keys) {
             entry.ToPdf(mid, buf);
         }
         PdfStream xr = new PdfStream(buf.ToByteArray());
         buf = null;
         xr.FlateCompress(writer.CompressionLevel);
         xr.Put(PdfName.SIZE, new PdfNumber(Size));
         xr.Put(PdfName.ROOT, root);
         if (info != null) {
             xr.Put(PdfName.INFO, info);
         }
         if (encryption != null)
             xr.Put(PdfName.ENCRYPT, encryption);
         if (fileID != null)
             xr.Put(PdfName.ID, fileID);
         xr.Put(PdfName.W, new PdfArray(new int[]{1, mid, 2}));
         xr.Put(PdfName.TYPE, PdfName.XREF);
         PdfArray idx = new PdfArray();
         for (int k = 0; k < sections.Count; ++k)
             idx.Add(new PdfNumber(sections[k]));
         xr.Put(PdfName.INDEX, idx);
         if (prevxref > 0)
             xr.Put(PdfName.PREV, new PdfNumber(prevxref));
         PdfEncryption enc = writer.crypto;
         writer.crypto = null;
         PdfIndirectObject indirect = new PdfIndirectObject(refNumber, xr, writer);
         indirect.WriteTo(writer.Os);
         writer.crypto = enc;
     }
     else {
         byte[] tmp = GetISOBytes("xref\n");
         os.Write(tmp, 0, tmp.Length);
         System.Collections.IEnumerator i = xrefs.Keys;
         i.MoveNext();
         for (int k = 0; k < sections.Count; k += 2) {
             first = sections[k];
             len = sections[k + 1];
             tmp = GetISOBytes(first.ToString());
             os.Write(tmp, 0, tmp.Length);
             os.WriteByte((byte)' ');
             tmp = GetISOBytes(len.ToString());
             os.Write(tmp, 0, tmp.Length);
             os.WriteByte((byte)'\n');
             while (len-- > 0) {
                 ((PdfCrossReference)i.Current).ToPdf(os);
                 i.MoveNext();
             }
         }
     }
 }

 virtual public void SetAccessibleAttribute(PdfName key, PdfObject value) {
     if (accessibleAttributes == null)
         accessibleAttributes = new Dictionary<PdfName, PdfObject>();
     accessibleAttributes[key] = value;
 }

 /** Adds a viewer preference
 * @param preferences the viewer preferences
 * @see PdfViewerPreferences#addViewerPreference
 */
 public virtual void AddViewerPreference(PdfName key, PdfObject value) {
     pdf.AddViewerPreference(key, value);
 }