Some test text!

< iOS samples

BookmarkTest - Swift

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

//---------------------------------------------------------------------------------------
// Copyright (c) 2001-2017 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
    }
}