Пример #1
0
        public void GetPageDetails_IfPdfPageHasUriLinkWithoutScheme_ObjectEditionHasPageUriLinkAddedUriScheme()
        {
            // Arrange
            const int page02Index = 1;
            var       pdfDoc      = new PDFDoc();

            try
            {
                var pdfPage01 = pdfDoc.PageCreate();
                var pdfPage02 = pdfDoc.PageCreate();

                pdfDoc.PagePushBack(pdfPage01);
                pdfDoc.PagePushBack(pdfPage02);

                // create annot of pdfPage02
                // uri type of annot to an uri with mailto scheme
                var uriAcion  = PDFAction.CreateURI(pdfDoc, WebUriWithoutScheme);
                var linkAnnot = Annot.CreateLink(pdfDoc, new Rect(X1, Y1, X2, Y2), uriAcion);
                pdfPage02.AnnotInsert(0, linkAnnot);

                // Act
                _testEntityPrivate.Invoke(GetPageDetailsMethodName, pdfDoc);
            }
            finally
            {
                pdfDoc.Dispose();
            }

            // Assert
            var page02LinkCollection = _objectEdition.PageCollection[page02Index].LinkCollection;
            var page02Links          = ConvertToLinkArray(page02LinkCollection);

            page02Links.ShouldSatisfyAllConditions(
                () => page02Links.Length.ShouldBe(1),
                () => page02Links.ShouldContain(link => link.LinkType == UriLinkType),
                () => page02Links.First().LinkURL.ShouldStartWith(HttpScheme));
        }
Пример #2
0
        public void GetPageDetails_IfPdfPageHasGoToLink_ObjectEditionPageHasGoToLink()
        {
            // Arrange
            const int page01Index = 0;
            var       pdfDoc      = new PDFDoc();

            try
            {
                var pdfPage01 = pdfDoc.PageCreate();
                var pdfPage02 = pdfDoc.PageCreate();
                pdfDoc.PagePushBack(pdfPage01);
                pdfDoc.PagePushBack(pdfPage02);

                // create annot of pdfPage01
                // goto type of annot links to pdfPage02
                var destination = Destination.CreateFit(pdfPage02);
                var gotoAction  = PDFAction.CreateGoto(destination);
                var linkAnnot   = Annot.CreateLink(pdfDoc, new Rect(X1, Y1, X2, Y2), gotoAction);
                pdfPage01.AnnotInsert(0, linkAnnot);

                // Act
                _testEntityPrivate.Invoke(GetPageDetailsMethodName, pdfDoc);
            }
            finally
            {
                pdfDoc.Dispose();
            }

            // Assert
            var page01LinkCollection = _objectEdition.PageCollection[page01Index].LinkCollection;
            var page01Links          = ConvertToLinkArray(page01LinkCollection);

            page01Links.ShouldSatisfyAllConditions(
                () => page01Links.Length.ShouldBe(1),
                () => page01Links.ShouldContain(link => link.LinkType == GoToLinkType));
        }
Пример #3
0
        // Prints out the outline tree to the standard output
        static void PrintOutlineTree(Bookmark item)
        {
            for (; item.IsValid(); item = item.GetNext())
            {
                PrintIndent(item);
                Console.Write("{0:s}{1:s} ACTION -> ", (item.IsOpen() ? "- " : "+ "), item.GetTitle());

                // Print Action
                pdftron.PDF.Action action = item.GetAction();
                if (action.IsValid())
                {
                    if (action.GetType() == pdftron.PDF.Action.Type.e_GoTo)
                    {
                        Destination dest = action.GetDest();
                        if (dest.IsValid())
                        {
                            Page page = dest.GetPage();
                            Console.WriteLine("GoTo Page #{0:d}", page.GetIndex());
                        }
                    }
                    else
                    {
                        Console.WriteLine("Not a 'GoTo' action");
                    }
                }
                else
                {
                    Console.WriteLine("NULL");
                }

                if (item.HasChildren())                  // Recursively print children sub-trees
                {
                    PrintOutlineTree(item.GetFirstChild());
                }
            }
        }
        static void Main(string[] args)
        {
            PDFNet.Initialize();

            // Relative path to the folder containing test files.
            // string input_path =  "../../TestFiles/";
            string output_path = "../../TestFiles/Output/";

            // The vector used to store the name and count of all fields.
            // This is used later on to clone the fields
            Dictionary <string, int> field_names = new Dictionary <string, int>();

            //----------------------------------------------------------------------------------
            // Example 1: Programatically create new Form Fields and Widget Annotations.
            //----------------------------------------------------------------------------------
            try
            {
                using (PDFDoc doc = new PDFDoc())
                {
                    // Create a blank new page and add some form fields.
                    Page blank_page = doc.PageCreate();

                    // Text Widget Creation
                    // Create an empty text widget with black text.
                    TextWidget text1 = TextWidget.Create(doc, new Rect(110, 700, 380, 730));
                    text1.SetText("Basic Text Field");
                    text1.RefreshAppearance();
                    blank_page.AnnotPushBack(text1);
                    // Create a vertical text widget with blue text and a yellow background.
                    TextWidget text2 = TextWidget.Create(doc, new Rect(50, 400, 90, 730));
                    text2.SetRotation(90);
                    // Set the text content.
                    text2.SetText("    ****Lucky Stars!****");
                    // Set the font type, text color, font size, border color and background color.
                    text2.SetFont(Font.Create(doc, Font.StandardType1Font.e_helvetica_oblique));
                    text2.SetFontSize(28);
                    text2.SetTextColor(new ColorPt(0, 0, 1), 3);
                    text2.SetBorderColor(new ColorPt(0, 0, 0), 3);
                    text2.SetBackgroundColor(new ColorPt(1, 1, 0), 3);
                    text2.RefreshAppearance();
                    // Add the annotation to the page.
                    blank_page.AnnotPushBack(text2);
                    // Create two new text widget with Field names employee.name.first and employee.name.last
                    // This logic shows how these widgets can be created using either a field name string or
                    // a Field object
                    TextWidget text3 = TextWidget.Create(doc, new Rect(110, 660, 380, 690), "employee.name.first");
                    text3.SetText("Levi");
                    text3.SetFont(Font.Create(doc, Font.StandardType1Font.e_times_bold));
                    text3.RefreshAppearance();
                    blank_page.AnnotPushBack(text3);
                    Field      emp_last_name = doc.FieldCreate("employee.name.last", Field.Type.e_text, "Ackerman");
                    TextWidget text4         = TextWidget.Create(doc, new Rect(110, 620, 380, 650), emp_last_name);
                    text4.SetFont(Font.Create(doc, Font.StandardType1Font.e_times_bold));
                    text4.RefreshAppearance();
                    blank_page.AnnotPushBack(text4);

                    // Signature Widget Creation (unsigned)
                    SignatureWidget signature1 = SignatureWidget.Create(doc, new Rect(110, 560, 260, 610));
                    signature1.RefreshAppearance();
                    blank_page.AnnotPushBack(signature1);

                    // CheckBox Widget Creation
                    // Create a check box widget that is not checked.
                    CheckBoxWidget check1 = CheckBoxWidget.Create(doc, new Rect(140, 490, 170, 520));
                    check1.RefreshAppearance();
                    blank_page.AnnotPushBack(check1);
                    // Create a check box widget that is checked.
                    CheckBoxWidget check2 = CheckBoxWidget.Create(doc, new Rect(190, 490, 250, 540), "employee.name.check1");
                    check2.SetBackgroundColor(new ColorPt(1, 1, 1), 3);
                    check2.SetBorderColor(new ColorPt(0, 0, 0), 3);
                    // Check the widget (by default it is unchecked).
                    check2.SetChecked(true);
                    check2.RefreshAppearance();
                    blank_page.AnnotPushBack(check2);

                    // PushButton Widget Creation
                    PushButtonWidget pushbutton1 = PushButtonWidget.Create(doc, new Rect(380, 490, 520, 540));
                    pushbutton1.SetTextColor(new ColorPt(1, 1, 1), 3);
                    pushbutton1.SetFontSize(36);
                    pushbutton1.SetBackgroundColor(new ColorPt(0, 0, 0), 3);
                    // Add a caption for the pushbutton.
                    pushbutton1.SetStaticCaptionText("PushButton");
                    pushbutton1.RefreshAppearance();
                    blank_page.AnnotPushBack(pushbutton1);

                    // ComboBox Widget Creation
                    ComboBoxWidget combo1 = ComboBoxWidget.Create(doc, new Rect(280, 560, 580, 610));
                    // Add options to the combobox widget.
                    combo1.AddOption("Combo Box No.1");
                    combo1.AddOption("Combo Box No.2");
                    combo1.AddOption("Combo Box No.3");
                    // Make one of the options in the combo box selected by default.
                    combo1.SetSelectedOption("Combo Box No.2");
                    combo1.SetTextColor(new ColorPt(1, 0, 0), 3);
                    combo1.SetFontSize(28);
                    combo1.RefreshAppearance();
                    blank_page.AnnotPushBack(combo1);

                    // ListBox Widget Creation
                    ListBoxWidget list1 = ListBoxWidget.Create(doc, new Rect(400, 620, 580, 730));
                    // Add one option to the listbox widget.
                    list1.AddOption("List Box No.1");
                    // Add multiple options to the listbox widget in a batch.
                    string[] list_options = new string[2] {
                        "List Box No.2", "List Box No.3"
                    };
                    list1.AddOptions(list_options);
                    // Select some of the options in list box as default options
                    list1.SetSelectedOptions(list_options);
                    // Enable list box to have multi-select when editing.
                    list1.GetField().SetFlag(Field.Flag.e_multiselect, true);
                    list1.SetFont(Font.Create(doc, Font.StandardType1Font.e_times_italic));
                    list1.SetTextColor(new ColorPt(1, 0, 0), 3);
                    list1.SetFontSize(28);
                    list1.SetBackgroundColor(new ColorPt(1, 1, 1), 3);
                    list1.RefreshAppearance();
                    blank_page.AnnotPushBack(list1);

                    // RadioButton Widget Creation
                    // Create a radio button group and add three radio buttons in it.
                    RadioButtonGroup  radio_group  = RadioButtonGroup.Create(doc, "RadioGroup");
                    RadioButtonWidget radiobutton1 = radio_group.Add(new Rect(140, 410, 190, 460));
                    radiobutton1.SetBackgroundColor(new ColorPt(1, 1, 0), 3);
                    radiobutton1.RefreshAppearance();
                    RadioButtonWidget radiobutton2 = radio_group.Add(new Rect(310, 410, 360, 460));
                    radiobutton2.SetBackgroundColor(new ColorPt(0, 1, 0), 3);
                    radiobutton2.RefreshAppearance();
                    RadioButtonWidget radiobutton3 = radio_group.Add(new Rect(480, 410, 530, 460));
                    // Enable the third radio button. By default the first one is selected
                    radiobutton3.EnableButton();
                    radiobutton3.SetBackgroundColor(new ColorPt(0, 1, 1), 3);
                    radiobutton3.RefreshAppearance();
                    radio_group.AddGroupButtonsToPage(blank_page);

                    // Custom push button annotation creation
                    PushButtonWidget custom_pushbutton1 = PushButtonWidget.Create(doc, new Rect(260, 320, 360, 360));
                    // Set the annotation appearance.
                    custom_pushbutton1.SetAppearance(CreateCustomButtonAppearance(doc, false), Annot.AnnotationState.e_normal);
                    // Create 'SubmitForm' action. The action will be linked to the button.
                    FileSpec           url           = FileSpec.CreateURL(doc, "http://www.pdftron.com");
                    pdftron.PDF.Action button_action = pdftron.PDF.Action.CreateSubmitForm(url);
                    // Associate the above action with 'Down' event in annotations action dictionary.
                    Obj annot_action = custom_pushbutton1.GetSDFObj().PutDict("AA");
                    annot_action.Put("D", button_action.GetSDFObj());
                    blank_page.AnnotPushBack(custom_pushbutton1);

                    // Add the page as the last page in the document.
                    doc.PagePushBack(blank_page);

                    // If you are not satisfied with the look of default auto-generated appearance
                    // streams you can delete "AP" entry from the Widget annotation and set
                    // "NeedAppearances" flag in AcroForm dictionary:
                    //    doc.GetAcroForm().PutBool("NeedAppearances", true);
                    // This will force the viewer application to auto-generate new appearance streams
                    // every time the document is opened.
                    //
                    // Alternatively you can generate custom annotation appearance using ElementWriter
                    // and then set the "AP" entry in the widget dictionary to the new appearance
                    // stream.
                    //
                    // Yet another option is to pre-populate field entries with dummy text. When
                    // you edit the field values using PDFNet the new field appearances will match
                    // the old ones.
                    doc.RefreshFieldAppearances();

                    doc.Save(output_path + "forms_test1.pdf", 0);

                    Console.WriteLine("Done.");
                }
            }
            catch (PDFNetException e)
            {
                Console.WriteLine(e.Message);
            }

            //----------------------------------------------------------------------------------
            // Example 2:
            // Fill-in forms / Modify values of existing fields.
            // Traverse all form fields in the document (and print out their names).
            // Search for specific fields in the document.
            //----------------------------------------------------------------------------------
            try
            {
                using (PDFDoc doc = new PDFDoc(output_path + "forms_test1.pdf"))
                {
                    doc.InitSecurityHandler();

                    FieldIterator itr;
                    for (itr = doc.GetFieldIterator(); itr.HasNext(); itr.Next())
                    {
                        Field  field          = itr.Current();
                        string cur_field_name = field.GetName();
                        // Add one to the count for this field name for later processing
                        field_names[cur_field_name] = (field_names.ContainsKey(cur_field_name) ? field_names[cur_field_name] + 1 : 1);

                        Console.WriteLine("Field name: {0}", field.GetName());
                        Console.WriteLine("Field partial name: {0}", field.GetPartialName());
                        string str_val = field.GetValueAsString();

                        Console.Write("Field type: ");
                        Field.Type type = field.GetType();
                        switch (type)
                        {
                        case Field.Type.e_button:
                            Console.WriteLine("Button");
                            break;

                        case Field.Type.e_radio:
                            Console.WriteLine("Radio button: Value = " + str_val);
                            break;

                        case Field.Type.e_check:
                            field.SetValue(true);
                            Console.WriteLine("Check box: Value = " + str_val);
                            break;

                        case Field.Type.e_text:
                        {
                            Console.WriteLine("Text");

                            // Edit all variable text in the document
                            String old_value = "none";
                            if (field.GetValue() != null)
                            {
                                old_value = field.GetValue().GetAsPDFText();
                            }

                            field.SetValue("This is a new value. The old one was: " + old_value);
                        }
                        break;

                        case Field.Type.e_choice:
                            Console.WriteLine("Choice");
                            break;

                        case Field.Type.e_signature:
                            Console.WriteLine("Signature");
                            break;
                        }

                        Console.WriteLine("------------------------------");
                    }

                    // Search for a specific field
                    Field fld = doc.GetField("employee.name.first");
                    if (fld != null)
                    {
                        Console.WriteLine("Field search for {0} was successful", fld.GetName());
                    }
                    else
                    {
                        Console.WriteLine("Field search failed.");
                    }

                    // Regenerate field appearances.
                    doc.RefreshFieldAppearances();
                    doc.Save(output_path + "forms_test_edit.pdf", 0);
                    Console.WriteLine("Done.");
                }
            }
            catch (PDFNetException e)
            {
                Console.WriteLine(e.Message);
            }

            //----------------------------------------------------------------------------------
            // Sample: Form templating
            // Replicate pages and form data within a document. Then rename field names to make
            // them unique.
            //----------------------------------------------------------------------------------
            try
            {
                // Sample: Copying the page with forms within the same document
                using (PDFDoc doc = new PDFDoc(output_path + "forms_test1.pdf"))
                {
                    doc.InitSecurityHandler();

                    Page src_page = doc.GetPage(1);
                    doc.PagePushBack(src_page);                      // Append several copies of the second page
                    doc.PagePushBack(src_page);                      // Note that forms are successfully copied
                    doc.PagePushBack(src_page);
                    doc.PagePushBack(src_page);

                    // Now we rename fields in order to make every field unique.
                    // You can use this technique for dynamic template filling where you have a 'master'
                    // form page that should be replicated, but with unique field names on every page.
                    foreach (KeyValuePair <string, int> cur_field in field_names)
                    {
                        RenameAllFields(doc, cur_field.Key, cur_field.Value);
                    }

                    doc.Save(output_path + "forms_test1_cloned.pdf", 0);
                    Console.WriteLine("Done.");
                }
            }
            catch (PDFNetException e)
            {
                Console.WriteLine(e.Message);
            }

            //----------------------------------------------------------------------------------
            // Sample:
            // Flatten all form fields in a document.
            // Note that this sample is intended to show that it is possible to flatten
            // individual fields. PDFNet provides a utility function PDFDoc.FlattenAnnotations()
            // that will automatically flatten all fields.
            //----------------------------------------------------------------------------------
            try
            {
                using (PDFDoc doc = new PDFDoc(output_path + "forms_test1.pdf"))
                {
                    doc.InitSecurityHandler();

                    bool auto = true;
                    if (auto)
                    {
                        doc.FlattenAnnotations();
                    }
                    else                      // Manual flattening
                    {
                        // Traverse all pages
                        PageIterator pitr = doc.GetPageIterator();
                        for (; pitr.HasNext(); pitr.Next())
                        {
                            Page page = pitr.Current();
                            for (int i = page.GetNumAnnots() - 1; i >= 0; --i)
                            {
                                Annot annot = page.GetAnnot(i);
                                if (annot.GetType() == Annot.Type.e_Widget)
                                {
                                    annot.Flatten(page);
                                }
                            }
                        }
                    }

                    doc.Save(output_path + "forms_test1_flattened.pdf", 0);
                    Console.WriteLine("Done.");
                }
            }
            catch (PDFNetException e)
            {
                Console.WriteLine(e.Message);
            }
        }
Пример #5
0
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        static void Main(string[] args)
        {
            PDFNet.Initialize();

            // Relative path to the folder containing test files.
            string input_path  = "../../TestFiles/";
            string output_path = "../../TestFiles/Output/";


            // The following example illustrates how to create and edit the outline tree
            // using high-level Bookmark methods.
            try
            {
                using (PDFDoc doc = new PDFDoc(input_path + "numbered.pdf"))
                {
                    doc.InitSecurityHandler();

                    // Lets first create the root bookmark items.
                    Bookmark red   = Bookmark.Create(doc, "Red");
                    Bookmark green = Bookmark.Create(doc, "Green");
                    Bookmark blue  = Bookmark.Create(doc, "Blue");

                    doc.AddRootBookmark(red);
                    doc.AddRootBookmark(green);
                    doc.AddRootBookmark(blue);

                    // You can also add new root bookmarks using Bookmark.AddNext("...")
                    blue.AddNext("foo");
                    blue.AddNext("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)
                    Destination red_dest = Destination.CreateFit(doc.GetPage(1));
                    red.SetAction(pdftron.PDF.Action.CreateGoto(red_dest));

                    // Create an explicit destination to the first green page in the document
                    green.SetAction(pdftron.PDF.Action.CreateGoto(
                                        Destination.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.
                    String             key         = "blue1";
                    pdftron.PDF.Action blue_action = pdftron.PDF.Action.CreateGoto(key,
                                                                                   Destination.CreateFit(doc.GetPage(19)));

                    blue.SetAction(blue_action);

                    // We can now add children Bookmarks
                    Bookmark sub_red1 = red.AddChild("Red - Page 1");
                    sub_red1.SetAction(pdftron.PDF.Action.CreateGoto(Destination.CreateFit(doc.GetPage(1))));
                    Bookmark sub_red2 = red.AddChild("Red - Page 2");
                    sub_red2.SetAction(pdftron.PDF.Action.CreateGoto(Destination.CreateFit(doc.GetPage(2))));
                    Bookmark sub_red3 = red.AddChild("Red - Page 3");
                    sub_red3.SetAction(pdftron.PDF.Action.CreateGoto(Destination.CreateFit(doc.GetPage(3))));
                    Bookmark sub_red4 = sub_red3.AddChild("Red - Page 4");
                    sub_red4.SetAction(pdftron.PDF.Action.CreateGoto(Destination.CreateFit(doc.GetPage(4))));
                    Bookmark sub_red5 = sub_red3.AddChild("Red - Page 5");
                    sub_red5.SetAction(pdftron.PDF.Action.CreateGoto(Destination.CreateFit(doc.GetPage(5))));
                    Bookmark sub_red6 = sub_red3.AddChild("Red - Page 6");
                    sub_red6.SetAction(pdftron.PDF.Action.CreateGoto(Destination.CreateFit(doc.GetPage(6))));

                    // Example of how to find and delete a bookmark by title text.
                    Bookmark foo = doc.GetFirstBookmark().Find("foo");
                    if (foo.IsValid())
                    {
                        foo.Delete();
                    }

                    Bookmark bar = doc.GetFirstBookmark().Find("bar");
                    if (bar.IsValid())
                    {
                        bar.Delete();
                    }

                    // Adding color to Bookmarks. Color and other formatting can help readers
                    // get around more easily in large PDF documents.
                    red.SetColor(1, 0, 0);
                    green.SetColor(0, 1, 0);
                    green.SetFlags(2);                                          // set bold font
                    blue.SetColor(0, 0, 1);
                    blue.SetFlags(3);                                           // set bold and italic

                    doc.Save(output_path + "bookmark.pdf", 0);
                    Console.WriteLine("Done. Result saved in bookmark.pdf");
                }
            }
            catch (PDFNetException e)
            {
                Console.WriteLine(e.Message);
            }


            // The following example illustrates how to traverse the outline tree using
            // Bookmark navigation methods: Bookmark.GetNext(), Bookmark.GetPrev(),
            // Bookmark.GetFirstChild () and Bookmark.GetLastChild ().
            try
            {
                // Open the document that was saved in the previous code sample
                using (PDFDoc doc = new PDFDoc(output_path + "bookmark.pdf"))
                {
                    doc.InitSecurityHandler();

                    Bookmark root = doc.GetFirstBookmark();
                    PrintOutlineTree(root);

                    Console.WriteLine("Done.");
                }
            }
            catch (PDFNetException e)
            {
                Console.WriteLine(e.Message);
            }

            // 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.
            try
            {
                using (PDFDoc doc = new PDFDoc(output_path + "bookmark.pdf"))
                {
                    doc.InitSecurityHandler();

                    // Create file specification (the file referred to by the remote bookmark)
                    Obj file_spec = doc.CreateIndirectDict();
                    file_spec.PutName("Type", "Filespec");
                    file_spec.PutString("F", "bookmark.pdf");

                    FileSpec           spec        = new FileSpec(file_spec);
                    pdftron.PDF.Action goto_remote = pdftron.PDF.Action.CreateGotoRemote(spec, 5, true);

                    Bookmark remoteBookmark1 = Bookmark.Create(doc, "REMOTE BOOKMARK 1");
                    remoteBookmark1.SetAction(goto_remote);
                    doc.AddRootBookmark(remoteBookmark1);

                    // Create another remote bookmark, but this time using the low-level SDF/Cos API.
                    Bookmark remoteBookmark2 = Bookmark.Create(doc, "REMOTE BOOKMARK 2");
                    doc.AddRootBookmark(remoteBookmark2);
                    Obj gotoR = remoteBookmark2.GetSDFObj().PutDict("A");
                    {                                // Create the 'Action' dictionary.
                        gotoR.PutName("S", "GoToR"); // Set action type
                        gotoR.PutBool("NewWindow", true);

                        // Set the file specification
                        gotoR.Put("F", file_spec);

                        // Set the destination.
                        Obj dest = gotoR.PutArray("D");
                        dest.PushBackNumber(9);                          // jump to the tenth page. Note that Acrobat indexes pages from 0.
                        dest.PushBackName("Fit");                        // Fit the page
                    }

                    doc.Save(output_path + "bookmark_remote.pdf", SDFDoc.SaveOptions.e_linearized);
                    Console.WriteLine("Done. Result saved in bookmark_remote.pdf");
                }
            }
            catch (PDFNetException e)
            {
                Console.WriteLine(e.Message);
            }
        }