Some test text!

menu
search
chevron_right iOS samples

Read, add, edit PDF outlines and bookmarks in Swift

Sample Swift code to use PDFTron SDK for programmatically reading and editing existing outline items, and for creating new PDF bookmarks using the high-level API. Learn more about our PDF Editing & Manipulation Library.

To run this sample, get started with a free trial of PDFTron SDK.

//---------------------------------------------------------------------------------------
// Copyright (c) 2001-2019 by PDFTron Systems Inc. All Rights Reserved.
// Consult legal.txt regarding legal and license information.
//---------------------------------------------------------------------------------------

import PDFNet
import Foundation

//-----------------------------------------------------------------------------------------
// The sample code illustrates how to read and edit existing outline items and create
// new bookmarks using the high-level API.
//-----------------------------------------------------------------------------------------

func PrintIndent(item: PTBookmark) -> String {
    let indent = item.getIndent() - 1
    var i = 0
    var str = ""
    
    while i < indent {
        str = str + ("  ")
        i += 1
    }
    return str
}

// Prints out the outline tree to the standard output
func PrintOutlineTree(item: PTBookmark) {
    var currentItem = item
    while currentItem.isValid() {
        let indent: String = PrintIndent(item: currentItem)
        if currentItem.isOpen() {
            print("\(indent)- \(currentItem.getTitle()!) ACTION -> ")
        }
        else {
            print("\(indent)+ \(currentItem.getTitle()!) ACTION -> ")
        }
        
        // Print Action
        let action: PTAction = currentItem.getAction()
        if action.isValid() {
            if action.getType() == e_ptGoTo {
                let dest: PTDestination = action.getDest()
                if dest.isValid() {
                    let page: PTPage = dest.getPage()
                    print("GoTo Page #\(page.getIndex())")
                }
            }
            else {
                print("Not a 'GoTo' action")
            }
        }
        else {
            print("NULL")
        }
        
        if currentItem.hasChildren() {
            PrintOutlineTree(item: currentItem.getFirstChild())
        }
        currentItem = currentItem.getNext()
    }
}

func runBookmarkTest() -> Int {
    return autoreleasepool {
        var ret: Int = 0
        
        
        // The following example illustrates how to create and edit the outline tree
        // using high-level Bookmark methods.
        do {
            try PTPDFNet.catchException {
                let doc: PTPDFDoc = PTPDFDoc(filepath: Bundle.main.path(forResource: "numbered", ofType: "pdf"))
                doc.initSecurityHandler()
                
                // Lets first create the root bookmark items.
                let red: PTBookmark = PTBookmark.create(doc, in_title: "Red")
                let green: PTBookmark = PTBookmark.create(doc, in_title: "Green")
                let blue: PTBookmark = PTBookmark.create(doc, in_title: "Blue")
                
                doc.addRootBookmark(red)
                doc.addRootBookmark(green)
                doc.addRootBookmark(blue)
                
                // You can also add new root bookmarks using Bookmark.AddNext("...")
                blue.addNext(withTitle: "foo")
                blue.addNext(withTitle: "bar")
                
                // We can now associate new bookmarks with page destinations:
                
                // The following example creates an 'explicit' destination (see
                // section '8.2.1 Destinations' in PDF Reference for more details)
                let red_dest = PTDestination.createFit(doc.getPageIterator(1).current())
                red.setAction(PTAction.createGoto(red_dest))
                
                // Create an explicit destination to the first green page in the document
                green.setAction(PTAction.createGoto(PTDestination.createFit(doc.getPage(10))))
                
                // The following example creates a 'named' destination (see
                // section '8.2.1 Destinations' in PDF Reference for more details)
                // Named destinations have certain advantages over explicit destinations.
                let buf = "blue1"
                let key = buf.data(using: .utf8)
                let blue_action = PTAction.createGoto(withNamedDestination: key, key_sz: 5, dest: PTDestination.createFit(doc.getPage(19)))
                
                blue.setAction(blue_action)
                
                // We can now add children Bookmarks
                let sub_red1: PTBookmark = red.addChild(withTitle: "Red - Page 1")
                sub_red1.setAction(PTAction.createGoto(PTDestination.createFit(doc.getPage(1))))
                let sub_red2: PTBookmark = red.addChild(withTitle: "Red - Page 2")
                sub_red2.setAction(PTAction.createGoto(PTDestination.createFit(doc.getPage(2))))
                let sub_red3: PTBookmark = red.addChild(withTitle: "Red - Page 3")
                sub_red3.setAction(PTAction.createGoto(PTDestination.createFit(doc.getPage(3))))
                let sub_red4: PTBookmark = sub_red3.addChild(withTitle: "Red - Page 4")
                sub_red4.setAction(PTAction.createGoto(PTDestination.createFit(doc.getPage(4))))
                let sub_red5: PTBookmark = sub_red3.addChild(withTitle: "Red - Page 5")
                sub_red5.setAction(PTAction.createGoto(PTDestination.createFit(doc.getPage(5))))
                let sub_red6: PTBookmark = sub_red3.addChild(withTitle: "Red - Page 6")
                sub_red6.setAction(PTAction.createGoto(PTDestination.createFit(doc.getPage(6))))
                
                // Example of how to find and delete a bookmark by title text.
                let foo: PTBookmark = doc.getFirstBookmark().find("foo")
                if foo.isValid() {
                    foo.delete()
                }
                else {
                    assert(false)
                }
                
                let bar: PTBookmark = doc.getFirstBookmark().find("bar")
                if bar.isValid() {
                    bar.delete()
                }
                else {
                    assert(false)
                }
                
                // Adding color to Bookmarks. Color and other formatting can help readers
                // get around more easily in large PDF documents.
                red.setColor(1, in_g: 0, in_b: 0)
                green.setColor(0, in_g: 1, in_b: 0)
                green.setFlags(2)   // set bold font
                blue.setColor(0, in_g: 0, in_b: 1)
                blue.setFlags(3)    // set bold and italic
                
                doc.save(toFile: URL(fileURLWithPath: NSSearchPathForDirectoriesInDomains(.documentDirectory, .userDomainMask, true)[0]).appendingPathComponent("bookmark.pdf").path, flags: 0)
            }
        } catch let e as NSError {
            print("\(e)")
            ret = 1
        }

        // The following example illustrates how to traverse the outline tree using
        // Bookmark navigation methods: Bookmark.GetNext(), Bookmark.GetPrev(),
        // Bookmark.GetFirstChild () and Bookmark.GetLastChild ().
        do {
            try PTPDFNet.catchException {
                // Open the document that was saved in the previous code sample
                let doc: PTPDFDoc = PTPDFDoc(filepath: URL(fileURLWithPath: NSSearchPathForDirectoriesInDomains(.documentDirectory, .userDomainMask, true)[0]).appendingPathComponent("bookmark.pdf").path)
                doc.initSecurityHandler()
                
                let root: PTBookmark = doc.getFirstBookmark()
                PrintOutlineTree(item: root)
                
                print("Done.")
            }
        } catch let e as NSError {
            print("\(e)")
            ret = 1
        }
        
        // The following example illustrates how to create a Bookmark to a page
        // in a remote document. A remote go-to action is similar to an ordinary
        // go-to action, but jumps to a destination in another PDF file instead
        // of the current file. See Section 8.5.3 'Remote Go-To Actions' in PDF
        // Reference Manual for details.
        do {
            try PTPDFNet.catchException {
                // Open the document that was saved in the previous code sample
                let doc: PTPDFDoc = PTPDFDoc(filepath: URL(fileURLWithPath: NSSearchPathForDirectoriesInDomains(.documentDirectory, .userDomainMask, true)[0]).appendingPathComponent("bookmark.pdf").path)
                doc.initSecurityHandler()
                
                // Create file specification (the file referred to by the remote bookmark)
                let file_spec: PTObj = doc.createIndirectDict()
                file_spec.putName("Type", name: "Filespec")
                file_spec.put("F", value: "bookmark.pdf")
                let spec = PTFileSpec(f: file_spec)
                let goto_remote = PTAction.createGotoRemote(withNewWindow: spec, page_num: 5, new_window: true)
                
                let remoteBookmark1: PTBookmark = PTBookmark.create(doc, in_title: "REMOTE BOOKMARK 1")
                remoteBookmark1.setAction(goto_remote)
                doc.addRootBookmark(remoteBookmark1)
                
                // Create another remote bookmark, but this time using the low-level SDF/Cos API.
                // Create a remote action
                let remoteBookmark2: PTBookmark = PTBookmark.create(doc, in_title: "REMOTE BOOKMARK 2")
                doc.addRootBookmark(remoteBookmark2)
                
                let gotoR: PTObj = remoteBookmark2.getSDFObj().putDict("A")
                do {
                    gotoR.putName("S", name: "GoToR")   // Set action type
                    gotoR.putBool("NewWindow", value: true)
                    
                    // Set the file specification
                    gotoR.put("F", obj: file_spec)
                    
                    // jump to the first page. Note that pages are indexed from 0.
                    let dest: PTObj = gotoR.putArray("D")  // Set the destination
                    dest.pushBackNumber(9)
                    dest.pushBackName("Fit")
                }
                doc.save(toFile: URL(fileURLWithPath: NSSearchPathForDirectoriesInDomains(.documentDirectory, .userDomainMask, true)[0]).appendingPathComponent("bookmark_remote.pdf").path, flags: e_ptlinearized.rawValue)
            }
        } catch let e as NSError {
            print("\(e)")
            ret = 1
        }
        
        return ret
    }
}
close

Free Trial

Get unlimited trial usage of PDFTron SDK to bring accurate, reliable, and fast document processing capabilities to any application or workflow.

Select a platform to get started with your free trial.

Unlimited usage. No email address required.

PDFTron Receives USD$71 Million Growth Investment Led By Silversmith Capital Partners

Learn more
close