private void OutlineTravel(PRIndirectReference outline) {
     while (outline != null) {
         PdfDictionary outlineR = (PdfDictionary)PdfReader.GetPdfObjectRelease(outline);
         PRIndirectReference first = (PRIndirectReference)outlineR.Get(PdfName.FIRST);
         if (first != null) {
             OutlineTravel(first);
         }
         PdfReader.KillIndirect(outlineR.Get(PdfName.DEST));
         PdfReader.KillIndirect(outlineR.Get(PdfName.A));
         PdfReader.KillIndirect(outline);
         outline = (PRIndirectReference)outlineR.Get(PdfName.NEXT);
     }
 }

     internal FieldInformation(String fieldName, PdfDictionary info, PRIndirectReference refi) {
         this.fieldName = fieldName;
 	    this.info = info;
         this.refi = refi;
     }

 internal RefKey(PRIndirectReference refi)
 {
     num = refi.Number;
     gen = refi.Generation;
 }

 /**
 * 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 parentPath the pathname of the field, up to this point or null
 */
 virtual protected void IterateFields(PdfArray fieldlist, PRIndirectReference fieldDict, String parentPath) {
     foreach (PRIndirectReference refi in fieldlist.ArrayList) {
         PdfDictionary dict = (PdfDictionary) PdfReader.GetPdfObjectRelease(refi);
         
         // if we are not a field dictionary, pass our parent's values
         PRIndirectReference myFieldDict = fieldDict;
         String fullPath = parentPath;
         PdfString tField = (PdfString)dict.Get(PdfName.T);
         bool isFieldDict = tField != null;
         
         if (isFieldDict) {
             myFieldDict = refi;
             if (parentPath == null) {
                 fullPath = tField.ToString();
             } else {
                 fullPath = parentPath + '.' + tField.ToString();
             }
         }
         
         PdfArray kids = (PdfArray)dict.Get(PdfName.KIDS);
         if (kids != null) {
             PushAttrib(dict);
             IterateFields(kids, myFieldDict, fullPath);
             stack.RemoveAt(stack.Count - 1);   // pop
         }
         else {          // leaf node
             if (myFieldDict != null) {
                 PdfDictionary mergedDict = (PdfDictionary)stack[stack.Count - 1];
                 if (isFieldDict)
                     mergedDict = MergeAttrib(mergedDict, dict);
                 
                 mergedDict.Put(PdfName.T, new PdfString(fullPath));
                 FieldInformation fi = new FieldInformation(fullPath, mergedDict, myFieldDict);
                 fields.Add(fi);
                 fieldByName[fullPath] = fi;
             }
         }
     }
 }

 internal void InsertPage(int pageNumber, Rectangle mediabox)
 {
     Rectangle media = new Rectangle(mediabox);
     int rotation = media.Rotation % 360;
     PdfDictionary page = new PdfDictionary(PdfName.PAGE);
     PdfDictionary resources = new PdfDictionary();
     PdfArray procset = new PdfArray();
     procset.Add(PdfName.PDF);
     procset.Add(PdfName.TEXT);
     procset.Add(PdfName.IMAGEB);
     procset.Add(PdfName.IMAGEC);
     procset.Add(PdfName.IMAGEI);
     resources.Put(PdfName.PROCSET, procset);
     page.Put(PdfName.RESOURCES, resources);
     page.Put(PdfName.ROTATE, new PdfNumber(rotation));
     page.Put(PdfName.MEDIABOX, new PdfRectangle(media, rotation));
     PRIndirectReference pref = reader.AddPdfObject(page);
     PdfDictionary parent;
     PRIndirectReference parentRef;
     if (pageNumber > reader.NumberOfPages) {
         PdfDictionary lastPage = reader.GetPageNRelease(reader.NumberOfPages);
         parentRef = (PRIndirectReference)lastPage.Get(PdfName.PARENT);
         parentRef = new PRIndirectReference(reader, parentRef.Number);
         parent = (PdfDictionary)PdfReader.GetPdfObject(parentRef);
         PdfArray kids = (PdfArray)PdfReader.GetPdfObject(parent.Get(PdfName.KIDS), parent);
         kids.Add(pref);
         MarkUsed(kids);
         reader.pageRefs.InsertPage(pageNumber, pref);
     }
     else {
         if (pageNumber < 1)
             pageNumber = 1;
         PdfDictionary firstPage = reader.GetPageN(pageNumber);
         PRIndirectReference firstPageRef = reader.GetPageOrigRef(pageNumber);
         reader.ReleasePage(pageNumber);
         parentRef = (PRIndirectReference)firstPage.Get(PdfName.PARENT);
         parentRef = new PRIndirectReference(reader, parentRef.Number);
         parent = (PdfDictionary)PdfReader.GetPdfObject(parentRef);
         PdfArray kids = (PdfArray)PdfReader.GetPdfObject(parent.Get(PdfName.KIDS), parent);
         ArrayList ar = kids.ArrayList;
         int len = ar.Count;
         int num = firstPageRef.Number;
         for (int k = 0; k < len; ++k) {
             PRIndirectReference cur = (PRIndirectReference)ar[k];
             if (num == cur.Number) {
                 ar.Insert(k, pref);
                 break;
             }
         }
         if (len == ar.Count)
             throw new Exception("Internal inconsistence.");
         MarkUsed(kids);
         reader.pageRefs.InsertPage(pageNumber, pref);
         CorrectAcroFieldPages(pageNumber);
     }
     page.Put(PdfName.PARENT, parentRef);
     while (parent != null) {
         MarkUsed(parent);
         PdfNumber count = (PdfNumber)PdfReader.GetPdfObjectRelease(parent.Get(PdfName.COUNT));
         parent.Put(PdfName.COUNT, new PdfNumber(count.IntValue + 1));
         parent = (PdfDictionary)PdfReader.GetPdfObject(parent.Get(PdfName.PARENT));
     }
 }

 /**
 * Reuses an existing image.
 * @param ref the reference to the image dictionary
 * @throws BadElementException on error
 * @return the image
 */    
 public static Image GetInstance(PRIndirectReference iref) {
     PdfDictionary dic = (PdfDictionary)PdfReader.GetPdfObjectRelease(iref);
     int width = ((PdfNumber)PdfReader.GetPdfObjectRelease(dic.Get(PdfName.WIDTH))).IntValue;
     int height = ((PdfNumber)PdfReader.GetPdfObjectRelease(dic.Get(PdfName.HEIGHT))).IntValue;
     Image imask = null;
     PdfObject obj = dic.Get(PdfName.SMASK);
     if (obj != null && obj.IsIndirect()) {
         imask = GetInstance((PRIndirectReference)obj);
     }
     else {
         obj = dic.Get(PdfName.MASK);
         if (obj != null && obj.IsIndirect()) {
             PdfObject obj2 = PdfReader.GetPdfObjectRelease(obj);
             if (obj2 is PdfDictionary)
                 imask = GetInstance((PRIndirectReference)obj);
         }
     }
     Image img = new ImgRaw(width, height, 1, 1, null);
     img.imageMask = imask;
     img.directReference = iref;
     return img;
 }

 internal void InsertPage(int pageNumber, Rectangle mediabox) {
     Rectangle media = new Rectangle(mediabox);
     int rotation = media.Rotation % 360;
     PdfDictionary page = new PdfDictionary(PdfName.PAGE);
     page.Put(PdfName.RESOURCES, new PdfDictionary());
     page.Put(PdfName.ROTATE, new PdfNumber(rotation));
     page.Put(PdfName.MEDIABOX, new PdfRectangle(media, rotation));
     PRIndirectReference pref = reader.AddPdfObject(page);
     PdfDictionary parent;
     PRIndirectReference parentRef;
     if (pageNumber > reader.NumberOfPages) {
         PdfDictionary lastPage = reader.GetPageNRelease(reader.NumberOfPages);
         parentRef = (PRIndirectReference)lastPage.Get(PdfName.PARENT);
         parentRef = new PRIndirectReference(reader, parentRef.Number);
         parent = (PdfDictionary)PdfReader.GetPdfObject(parentRef);
         PdfArray kids = (PdfArray)PdfReader.GetPdfObject(parent.Get(PdfName.KIDS), parent);
         kids.Add(pref);
         MarkUsed(kids);
         reader.pageRefs.InsertPage(pageNumber, pref);
     }
     else {
         if (pageNumber < 1)
             pageNumber = 1;
         PdfDictionary firstPage = reader.GetPageN(pageNumber);
         PRIndirectReference firstPageRef = reader.GetPageOrigRef(pageNumber);
         reader.ReleasePage(pageNumber);
         parentRef = (PRIndirectReference)firstPage.Get(PdfName.PARENT);
         parentRef = new PRIndirectReference(reader, parentRef.Number);
         parent = (PdfDictionary)PdfReader.GetPdfObject(parentRef);
         PdfArray kids = (PdfArray)PdfReader.GetPdfObject(parent.Get(PdfName.KIDS), parent);
         int len = kids.Size;
         int num = firstPageRef.Number;
         for (int k = 0; k < len; ++k) {
             PRIndirectReference cur = (PRIndirectReference)kids[k];
             if (num == cur.Number) {
                 kids.Add(k, pref);
                 break;
             }
         }
         if (len == kids.Size)
             throw new Exception(MessageLocalization.GetComposedMessage("internal.inconsistence"));
         MarkUsed(kids);
         reader.pageRefs.InsertPage(pageNumber, pref);
         CorrectAcroFieldPages(pageNumber);
     }
     page.Put(PdfName.PARENT, parentRef);
     while (parent != null) {
         MarkUsed(parent);
         PdfNumber count = (PdfNumber)PdfReader.GetPdfObjectRelease(parent.Get(PdfName.COUNT));
         parent.Put(PdfName.COUNT, new PdfNumber(count.IntValue + 1));
         parent = parent.GetAsDict(PdfName.PARENT);
     }
 }

 /**
 * 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 virtual PdfIndirectReference CopyIndirect(PRIndirectReference inp)
 {
     PdfIndirectReference theRef;
     RefKey key = new RefKey(inp);
     IndirectReferences iRef;
     indirects.TryGetValue(key, out iRef);
     if (iRef != null) {
         theRef = iRef.Ref;
         if (iRef.Copied) {
             return theRef;
         }
     }
     else {
         theRef = body.PdfIndirectReference;
         iRef = new IndirectReferences(theRef);
         indirects[key] =  iRef;
     }
     PdfObject obj = PdfReader.GetPdfObjectRelease(inp);
     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;
 }

 /** Creates a new instance of DocumentFont */
 internal DocumentFont(PdfDictionary font) {
     this.refFont = null;
     this.font = font;
     Init();
 }