I wrote about my favorite tools around the PDF file format in the past. It’s time to add a couple more items to the list.

Over the last few months I’ve been working with two more products that I can recommend wholeheartedly:

PD4ML

There are a number of HTML to PDF converters available, but if your HTML is anything but basic, chances are that every single one of them does not render one or more features in your documents accurately enough… After looking at a number of them, I came across PD4ML and it looked good right from the first document I fed to it. There were a few problems, but PD4ML’s support was great in helping me out, even though I only had an evaluation license. At the end, all known problems were taken care of in the next formal release I received.

PD4ML is available as either a Java library or a .NET component. The Java JAR can actually be used as an application to get a good idea about how the generated PDF would look.

The library is available in a standard and a Pro version – there are a number of differences, which are listed in the “Products Comparison Chart” – the most important difference for me is that the Pro version supports font embedding.

ABCpdf

As I’ve mentioned before, I’m a fan of iText (mainly because it’s Java based, and I can use it on any system that has a Java VM), but I was looking for a library that had rasterization capabilities. I found ABCpdf, and it’s a great tool that does everything I want a PDF library to do (as long as I can use .NET, ASP or VB). It can read PDF documents, modify them and write them out again, create PDF documents from scratch, convert other formats to PDF (e.g. HTML – even with FLash support, EPS, XPS, SVG). It can even use OpenOffice.org to import MS Office documents. One of the more important features for me is the ability to access low level PDF objects – either to get more information about the PDF file and it’s objects, or to make changes that are not available via other high level calls. ABCpdf also allows me to do that.

ABCpdf comes in two versions, Standard and Professional. The “PDF Component Comparison Chart” on the web site lists the differences between the two versions.

Nuance (the people behind OmniPage and Dragon Naturally Speaking and a bunch of other things) release a competitor to the free Adobe Reader – the free Nuance PDF Reader (http://www.nuance.com/imaging/products/pdf-reader.asp). The feature list looks very promising:

• Fill and save PDF forms
• Annotate PDFs
• Convert PDF files to Word Excel or RTF
• Can disable JavaScript
• 100% compatibility with Adobe Acrobat (we have to wait to see how compatible it really is)
• Supports PDF Portfolios

Now to the things that it does not do:

• No support for Mac OS X or Linux
• No participation in online document reviews

I’ve not spent enough time with it yet to offer a detailed review, but it’s certainly a good alternative to the Adobe Reader. Competition is a good thing, maybe Adobe will take a few cues from Nuance for their next release of Reader.

Converting PDF documents to PowerPoint presentations is probably not something you need every day. I think I needed it once when the original PowerPoint file of a presentation I needed to give was no longer available, but the PDF file created from that presentation was. I did not have access to AnyBizSoft PDF to PowerPoint Converter back then, so a lot of copy&pasting took place.

Today you can download a free version of that software from GiveAwayOfTheDay.com. I’ve played around with the application a little, and it really does what it promises: PDF elements get converted to editable PowerPoint page elements.

Here is a list of the key features of AnyBizSoft PDF to PowerPoint Converter:

1. Convert PDF files to PPT presentations quickly and accurately
2. Retain all the layouts, images, and hyperlinks in the output documents
3. Produce an editable and dynamic PPT presentation with a few clicks
4. Convert up to 200 PDF files at the same time
5. Support Office 2010 and Windows 7

I cannot vouch for the last two list items, but I know that it worked for up to seven files, and that all the other claims are true. If you think you’ll ever need to convert a PDF file to PowerPoint, give AnyBizSoft PDF Converter a try – and if you do it (download and activate) today from GiveAwayOfTheDay.com it will not even cost you a dime.

Have you ever tried to fill a PDF form in Adobe Reader and to then save that filed document to your hard disk? Did it work? Chances are that it did not.

Have you ever thought about why the Adobe Reader is called “Reader”? The answer is pretty obvious, it’s because it is only reading and displaying (and printing) PDF files – that is, it is not writing them. That also includes that it will not save a modified document. You would need the “Adobe Writer” – or “Adobe Acrobat” as it is called for that.

But regardless of the name, we can “trick” the Reader into writing a filled form to the disk. OK, it’s not really a trick, Adobe did implement this feature, so it’s official, and we are not hacking or cracking anything.

Adobe has a server based solution that does allow you to create PDF files that are “reader enabled”: Adobe LiveCycle Reader Extensions ES
That technology allows you to “Fill in, sign, comment on, or save Adobe PDF files using only Adobe Reader”. Sounds like the perfect solution. Let me tell you a little secret: Whenever you hear the terms “Adobe” and “Server” in the same sentence, it usually means expensive…

Here is another secret – not really, it’s documented in a lot of places, but Acrobat users often don’t know about it: You can use Adobe Acrobat to “reader enable” PDF files as well. However, when you agreed to the EULA during the installation of Acrobat, you also agreed to using this technology only for a form with a maximum of 500 copies. The reason for that is of course, that Adobe still wants to sell the server based solution for document workflows that involve more copies.

So, let’s take a look at the EULA and find out exactly what we agreed to:

“15.12.3 For any unique Extended Document, you may only either (a) Deploy such Extended Document to an unlimited number of unique recipients but shall not extract information from more than five hundred (500) unique instances of such Extended Document or any hardcopy representation of such Extended Document containing filled form fields; or (b) Deploy such Extended Document to no more than five hundred (500) unique recipients without limits on the number of times you may extract information from such Extended Document returned to you filled-in by such Recipients. Notwithstanding anything herein to the contrary, obtaining additional licenses to use Acrobat Pro or Acrobat Pro Extended shall not increase the foregoing limits (that is, the foregoing limits are the aggregate total limits regardless of how many additional licenses to use Acrobat Pro or Acrobat Pro Extended you may have obtained). “

You may want to review that with your lawyer, I’m just an engineer, and in no position to give legal advice. I’ll however let you know what my interpretation of that section is: We have two options, we can either distribute our enabled form to an unlimited number of users, but we can only process a maximum of 500 unique responses. So, if we distribute our form to 1000 recipients, and we get 500 copies back, we are good. If we receive 501 replies, we can process the first 500, but the last one we cannot even look at. It also does not matter if we receive the filled out forms via a printed sheet of paper, or electronically. The second option is a bit more complicated, and you really should talk to your lawyer about that. To me it seems that you can distribute 500 copies of your form to 500 unique recipients, and they can then submit that form as often as they want. This could e.g. be a form that needs to be submitted once a week. Every one of your (up to 500) users/customers/clients has a copy of that form, and then once a week they fill in new data and submit the form.

Now we know what we can do with these forms, but we still don’t know how to use Acrobat for that. Let me show you a few screen shots.

Let’s assume you have a PDF form that you want to distribute, open that file in Acrobat and select “Forms>Distribute Form”:

This will bring up the dialog that we need to work with for the next few steps:

As you can see, I’ve selected to manually collect the responses in my email. That’s the most straight forward option and does not require any other configuration. The information presented below the selection does give you a pretty good idea about what it is. For now, let’s stick with the email option, but please, play around with the other options and let me know if you run into problems.

In the next step we specify the target location on our local hard disk for the protected (and now reader-enabled) copy of our file:

Now we need to add some information about us, the author:

We get one more chance to revise our decision about the delivery method, so if you want to take a different approach, and use Acrobat.com to collect the returned forms, here is your last chance. I will stick with the email option:

Once we click on the “Finish” button, the form will be prepared and saved, and Acrobat will display the Tracker interface. That dialog can also be opened via the “Forms>Track Forms” menu item (see the menu screen shot from above). I will talk more about that in a future post.

All you have to do now is to distribute your form. In a future post I will talk about how to process the returned data.

If allowing your users to locally save a form, you are done. They now can partially fill a form, save it, open it at a later time and continue with the form.

Have you ever needed a PDF version of a document, but you either did not have the correct source application (e.g. MS Word, PowerPoint, …), or you didn’t have access to a PDF converter (even though the free PrimoPDF is just a mouse click away). Or, did somebody email you a PowerPoint presentation, but you don’t have access to PowerPoint? But you do have access to a PDF viewer (either the free Adobe Reader, or Preview.app on the Mac). How would you convert a Word, Excel or PowerPoint document to PDF?

Google Docs to the rescue! Did you know that Google Docs can import a number of standard file formats into it’s word processor, spread sheet and presentation applications? Once you have imported your document, you just select to print… That’s it. Oh, I probably should explain that Google converts your document to PDF for printing purposes and then downloads that PDF to your computer. So just open that PDF file, and there is your document, now converted to a portable, easy to open file.

A while ago I tried to create an interactive dynamic stamp in Acrobat. These are dynamic stamps (like for example a stamp that automatically puts the current date into a field that is part of the stamp), but with a UI component that pops up and queries the user for some information that also gets embedded as part of the stamp (e.g. a phone number or a name).

I was not very successful. I could not figure out how to make sure that the UI only gets triggered when the stamp gets applied, and not when the stamp file gets loaded by Acrobat.

Then I came across an article by Rick Borstein titled “Add Dynamic Exhibit Stamps in Acrobat using a free stamp set” on the Acrobat for Legal Professionals blog. It had all the parts that are required, ot even came with a couple of sample stamps. It also gave credit to the original source for that information: Acrobat JavaScript Guru Thom Parker

Thom provides all the theory behind why this works – very interesting to read if you are into that kind of stuff. It’s however not required to understand all that if you just want to use these stamps. You can just download Rick’s sample files and modify them until they fit your needs.

However if you want a dynamic stamp that shows more than just one line of interactively provided information, the examples do not work. They only provide one one-line input field and then put that one line on the PDF document. I wanted a stamp that could actually take several lines of user input and use that in a stamp. I had some work to do…

Acrobat’s JavaScript does allow to create custom user interfaces by creating a data structure and then calling executeDialog() with that data as parameter. Instead of a simple call to app.response() like in Thom’s and Rick’s examples, I needed to create a more complicated UI structure and embed that in the examples.

Here is the original code from the example:

var cAsk = "Enter Exhibit Number" ;
var cTitle = "Exhibit Number:  ";
if(event.source.forReal && (event.source.stampName == "#UdzyXagRctZoS5p43TZ43C"))
{
  var cMsg = app.response(cAsk, cTitle);
  event.value = cMsg;
  event.source.source.info.exhibit = cMsg;
}

var dialog = {
  retString: "",

  commit:function (dialog) { // called when OK pressed
    var results = dialog.store();
    this.retString = results["stxt"];
  },

  description:
  {
    name: "Stamp Information",    // Dialog box title
    elements:
    [
      {
        type: "view",
        elements:
        [
          {
            name: "Enter Multi-line Information: ",
            type: "static_text",
          },
          {
            item_id: "stxt",
            type: "edit_text",
            multiline: true,
            width: 300,
            height: 80
          },
          {
            type: "ok_cancel",
            ok_name: "Ok",
            cancel_name: "Cancel"
          },
        ]
      },
    ]
  }
}; 

if(event.source.forReal && (event.source.stampName == "#UdzyXagRctZoS5p43TZ43C"))
{
  if ("ok" == app.execDialog(dialog))
  {
    var cMsg = dialog.retString;
    event.value = cMsg;
    event.source.source.info.exhibit = cMsg;
  }
}

1. Open the “Exhibit+Stamp.pdf” document in Adobe Acrobat Pro
2. Go to the second page in this document – that’s the first stamp
3. Select the TouchUp Object Tool (e.g. via Tools>Advanced Editing>TouchUp Object Tool)
4. Right-click on the lower part of the stamp (where the UserData1 field) and select Properties… from the menu
5. Select the Options tab and check the “Multi-line” checkbox
6. Select the Calclate tab and click on the Edit button next to the custom calculation script and replace the old script with the one from above
7. Save the script with the OK button, then close the properties dialog

That’s it – just install the stamp file as described in Rick’s document. Done.

Of will of course be hard to see two or more lines in the relatively small stamp, so you may have to change the layout of the stamp to actually make use of the additional lines.f

If you’ve seen my resume – or talked to me lately, you know that I create Acrobat plug-ins for a living. When people hear that, they usually think something like “Don’t forget to pick up the dry cleaning” or “I need to bring my cat to the vet for the rabies shot”… Yes, I understand, this may not be the most exciting topic, but probably only because you don’t know enough about what these “plug-ins” are, so let me explain.

 

Adobe Acrobat is a very powerful tool, more powerful that most users actually realize. I wont go into any details about how powerful exactly – at least not today. Lets just say that it has something for everybody. However, you may need something in addition to what Adobe provides, something that still is in the general area of PDF. Adobe may not have considered your needs because either the target market for “your” feature is too small, or to far out there… Or you are so far ahead of everybody else that they have not even thought about that feature yet.

Adobe did however do a very interesting thing: They created an interface that allows 3rd party developers to create solutions based on Adobe Acrobat – using plug-ins. It is a very powerful interface, and hence not something that you can pick up in an afternoon. There are several thousand pages of API documentation that one needs to understand before a plug-in should be written.

A plug-in is – from a technical point of view – a module or library that gets loaded dynamically at runtime. Acrobat will scan it’s plug-ins directory and will load any modules it finds. Once loaded, such a plug-in can extend Acrobat by e.g. adding menu items, toolbuttons, or event handlers (e.g. a function that gets executed whenever a documents gets loaded).

 

Interestingly enough, the plug-ins directory of a fresh Adobe Acrobat installation is not empty… A lot of Acrobat’s functionality is actually implemented as plug-ins. You can verify that on a Windows system by temporarily disabling all plug-ins by holding down the Shift key when bringing up Acrobat. That will load the application without any plug-ins. When you compare the toolbar or the menu bar with a fully loaded application, you’ll see what portion of the Acrobat core functionality is actually implemented in plug-ins.

The plug-in interface has different abstraction levels (COS, PDE, AV, …). If there is enough interest, I will provide information about how to navigate that API, and how to structure a plug-in.

The Acrobat SDK is available for free from Adobe’s Acrobat Development Center.

Here are a few examples of commercially available plug-ins that I’ve used:

• Enfocus PitStop Professional:
  This is a preflight tool.
• Quite Imposing Plus:
  The best PDF based imposition tool that I am aware of.
• Enfocus Browser:
  Allows to review and change the internal structure of a PDF file.

OK, I have to admit, the title is just for show I don’t really want to gut a PDF – that would mean to kill it, and PDFs are pretty useful, so we should treat them well…

What I’m after is to extract arbitrary information from a PDF file – information that may not be accessible in any other way. Some 3rd party Acrobat plug-ins save information in a PDF file so that once the document is opened again, the plug-in “knows” that the current file was already processed, or that a user interface window can be populated with the previously saved settings, or … There are many reasons why that could come in handy.

If you take a look at the PDF Reference document, you can find all the information necessary to understand how data can be saved in a PDF file. Adobe does allow 3rd party developers to store information in a PDF file as long as it is clear that the data is private. The developer can make sure that nobody else reads that information by accident by using a four letter developer prefix for all such data.

I’ve mentioned before that there are tools that allow us to look at the structure of a PDF file (e.g. the Enfocus Browser, or with Acrobat’s own Preflight tool). For now let’s assume that the data we are interested in is actually saved in the PDF’s metadata stream – if you don’t know what that means, please go back to the PDF Reference document.

[more after the jump] For this example, let’s try something simple that just illustrates the process and the tools we need. With that knowledge and background, it is easy to perform more sophisticated tasks with PDF files.

Every newer PDF files does not only contain the meta data in form of the document info dictionary, but also as XMP meta data – this is a XML based format. Let’s try to extract that XML data stream from a PDF file.

Because I don’t want to hide the interesting parts of the solution by infrastructure, I am hardcoding the PDF filename and the text output file name, I’m also assuming that the iText library JAR file is in the same directory as the source code.

Here is the complete program, I’ll go through the different sections once we’ve compiled and executed it:

/* based on some sample code from iText library */

import java.io.*;

import com.lowagie.text.Document;
import com.lowagie.text.DocumentException;
import com.lowagie.text.pdf.PdfReader;
import com.lowagie.text.pdf.PdfDictionary;
import com.lowagie.text.pdf.PdfName;
import com.lowagie.text.pdf.PdfStream;
import com.lowagie.text.pdf.PRStream;

public class MetaData {

    public static void main(String[] args) {

    System.out.println("Trying to extract XML metadata");

        try {

            PdfReader reader = new PdfReader("first.pdf");

            PdfDictionary dict = reader.getCatalog();

            PdfDictionary metaData = dict.getAsStream(new PdfName("Metadata"));
            if (metaData == null)
            {
                System.out.println("Cannot get metaData");
                return;
            }

            if (metaData.isStream())
            {
                OutputStream f = new FileOutputStream("metaData.txt");

                byte[] data = PdfReader.getStreamBytes((PRStream) metaData);
                f.write(data);

                f.close();

            }
            else
            {
                System.out.println("Metadata is not a stream object");
            }

        }
        catch (Exception de) {
               de.printStackTrace();
        }
    }
}

Let’s assume that the source code is in a file named MetaData.java, to compile and run the program, we would need to execute the following commands:

javac MetaData.java
java MetaData

Before you execute the program, make sure that there is a PDF file named “first.pdf” in the same directory as the program and the iText library.

How Does It Work?

import java.io.*;

import com.lowagie.text.Document;
import com.lowagie.text.DocumentException;
import com.lowagie.text.pdf.PdfReader;
import com.lowagie.text.pdf.PdfDictionary;
import com.lowagie.text.pdf.PdfName;
import com.lowagie.text.pdf.PdfStream;
import com.lowagie.text.pdf.PRStream;

In the next few lines, we define our class and declare our main function. Also, the whole iText related code is in one try/catch block. For a real application, you want to create smaller try/catch blocks so that you can recover from problems.

public class MetaData {

    public static void main(String[] args) {

    System.out.println("Trying to extract XML metadata");

        try {

Now we are ready to create a new PdfReader object – this is how iText accesses the data in a PDF file. From that PdfReader object we can then get the “Catalog” which is the root object of all COS objects that are used in this dococument:

            PdfReader reader = new PdfReader("first.pdf");
            PdfDictionary dict = reader.getCatalog();

The meta data is stored as a stream (if you don’t know what that is, read up on it in the PDF spec) as a direct child of the Catalog dictionary (again, if you don’t know what that is, read up on it). This means that we can access it without any further navigating through the COS objects. For a real project, chances are that you have to go a few more levels deep into the COS structure. The PdfDictionary object has a method to get a stream:

            PdfDictionary metaData = dict.getAsStream(new PdfName("Metadata"));
            if (metaData == null)
            {
                System.out.println("Cannot get metaData");
                return;
            }

When it comes to software, I’m not a very trusting person, so I want to make sure that we are indeed dealing with a stream and nothing else. Therefore I will call the isStream() method to find out if that’s the case. If we are dealing with a stream, I’m creating a new FileOutputStream (a text file that will receive the XML data), and then I am reading the actual COS stream data and writing it to the output file. iText will take care of any filters that were applied to the stream data (e.g. compression), so I don’t have to deal with that directly.

           if (metaData.isStream())
            {
                OutputStream f = new FileOutputStream("metaData.txt");

                byte[] data = PdfReader.getStreamBytes((PRStream) metaData);
                f.write(data);

                f.close();

            }
            else
            {
                System.out.println("Metadata is not a stream object");
            }

That’s it. Now we just need to make sure that we do have catch block for our exception handler:

        catch (Exception de) {
               de.printStackTrace();
        }
    }
}

Instead of saving the XML meta data to a file, we could have used a Java based XML parser and extracted data from it.

The same technique can also be used to read other data from a PDF file (e.g. names, numbers, …).

Let me know if you have more questions about either iText, or how to access information in a PDF file with it.

No, this is not about my patent pending idea of a sheet splitter that turns duplex documents into simplex documents… This post is about a problem that comes up every now and then: When you scan a book or a magazine, chances are that you end up with two physical pages on your scanned image, and your document looks something like this:

Pages one and two are on the same scan, three and four are, and five and six and so on.

How can we split such a combined page into it’s two parts?

There are of course different solutions to this problem, some more complicated than others, some producing better results than others.

The most straight forward approach would be to write an Acrobat plug-in or a standalone application (e.g. using the iText library) that takes the source page, determines what needs to be copied to the new page that should represent the left half of the original page, and then just copy those page elements. With a scanned source document, this would potentially mean that the scanned image needs to be cropped and placed on the target page. Sounds complicated, and it is complicated. Is there an easier way to accomplish the same results?

[More after the jump]

If we have access the Acrobat, we can use JavaScript to mimic the behavior of the just described application. With Acrobat’s JavaScript, we do of course not have access to the page content elements, so we need to find a different way to end up with the same results.

JavaScript gives us access to the crop box of a PDF page (if you don’t know what that is, read up on page boxes in the PDF Reference), this means we can find out how big a page is, but also set the crop box to configure which part of the page should be displayed in the viewer, or should get printed.

So, if our combined page is 11×17″, and we want to extract two 8 1/2×11″ pages, we first need to “select” the left half of the page, and then the right half of the same page.

Here is the script that will do just that:
SplitPages.js

Copy that file to the Acrobat JavaScript directory – for Acrobat 9 on a Windows machine that would be

c:\Program Files\Adobe\Acrobat 9.0\Acrobat\JavaScript

Now let’s take a look at the different parts of the script:

ProcessDocument = app.trustedFunction(function()
{
    // create a new document
    app.beginPriv();
    var newDoc = app.newDoc();
    app.endPriv();

    var i = 0;
    while (i < this.numPages)
    {
        newDoc.insertPages( {
            nPage: newDoc.numPages-1,
            cPath: this.path,
            nStart: i
        });
        newDoc.insertPages( {
            nPage: newDoc.numPages-1,
            cPath: this.path,
            nStart: i
        });
        // we did this twice so that we can then split each copy of the page into a left
        // and right half. 
        i++;
    }

In these few lines we copy every page from the source document (this.path, which is the path to the active document) to our newly created document – and we are doing that twice. This is necessary because we need to crop out the left half of the page for the first page, and the right half of the page for the second page. After this loop, we will have twice as many pages in our new document than we have in our source document.

    if (newDoc.numPages > 1)
    {
        newDoc.deletePages(0);  // this gets rid of the page that was created with the newDoc call.
    }

Now that we have all the pages in our new document, we no longer need the blank page we got when we created the document. So, we delete it.

    // at this point we have a documnent with every page from the source document
    // copied twice

    for (i=0; i<newDoc.numPages; i++)
    {
        // determine the crop box of the page
        var cropRect = newDoc.getPageBox("Crop", i);
        var halfWidth = (cropRect[2]-cropRect[0])/2;

        var cropLeft = new Array();
        cropLeft[0] = cropRect[0];
        cropLeft[1] = cropRect[1];
        cropLeft[2] = cropRect[0] + halfWidth;
        cropLeft[3] = cropRect[3];

The previous few lines create a new Array. A page box is represented as an array of four values. We can now assign the partially modified values to the new page box. As you can see, three of the four values just are copies of the original crop box. Array element 2 however gets modified. It is the original X value for the lower left point of the crop box, and we add half of our page width to that number. This means, the new right edge of the modified page box is now at the halfway point between the two sides.

        var cropRight = new Array();
        cropRight[0] = cropRect[2] - halfWidth;
        cropRight[1] = cropRect[1];
        cropRight[2] = cropRect[2];
        cropRight[3] = cropRect[3];

        if (i%2 == 0)
        {
     newDoc.setPageBoxes( {
         cBox: "Crop",
         nStart: i,
         rBox: cropLeft
         });
        }
        else
        {
     newDoc.setPageBoxes( {
         cBox: "Crop",
         nStart: i,
         rBox: cropRight
         });
        }
    }
}
)

This is a bit tricky… Acrobat starts to count pages with page 0. The first page in the document is on the left half of our first sheet. All of a sudden, our first page is actually an even page number (0), and not like in “normal” books an odd number (1). This means that for all even numbers we need to crop the left half, and for all odd numbers we need to crop the right half.

We test for “evenness” by performing the modulo operation on our page number. If the result is 0, we know we have an even number, so we can use the left side crop box. If the operation returns 1, we are dealing with an odd page number, and we will use the ride side crop box.

The new crop box gets applied with the doc.setPageBoxes() method.

// add the menu item
app.addMenuItem({
     cName: "splitPagesJS",     // this is the internal name used for this menu item
     cUser: "Split Pages",       // this is the label that is used to display the menu item
     cParent: "Document",              // this is the parent menu. The file menu would use "File"
     cExec: "ProcessDocument()",  // this is the JavaScript code to execute when this menu item is selected
     cEnable: "event.rc = (event.target != null);",       // when should this menu item be active?
     nPos: 0
});

Almost done… We’ve implemented the functionality to split the pages, now we just need a mechanism to actually start our little program. I’ve chosen to create a menu item under the “Document” menu. That menu item is only available (not grayed out), if we have an active document.

Disclaimer: Of course, there is no such thing as a sheet splitter, and therefore there is no patent application. It’s a joke.

As promised, here are some PDF related tools that I don’t use, but either have used, have played with, or just know about how good they are. These are the tools that I recommend when somebody asks me “what would you use to do XYZ?”.

PrimoPDF

The best free PDF generator. Just see my previous blog post. If you need a PDF generator, download that program.

NitroPDF

From the friendly people who bring you PrimoPDF. This is a package that competes with Acrobat. It can edit PDFs, create forms, fill forms, create PDFs, … And it’s cheaper than Acrobat. There is a free eval version available. Download it, play with it and see if it covers all your PDF needs. If not, there is always Acrobat. An upcoming release will have OCR support (after release 6).

PDF Enhancer

The PDF Enhancer is a very powerful tool to “enhance” PDFs. Enhancement in this case can mean a lot of different things: Make them smaller, fix common PDF problems, embed fonts, add or modify color management information, … There are different versions available, even a server version. Apago also has a free eval version that you can download to see if it fits your needs.

Enfocus PitStop Professional

PitStop is a preflight tool that I used in my previous job. In addition to preflight capabilities, it also implements the Enfocus Certified PDF Workflow that allows a PDF file to contain an audit trail of all operations that were performed on it. In addition to PitStop Professional, Enfocus also offers the PitStop server, which can do anything Pitstop Professional can do in an automated fashion.

Quite Imposing Plus

This is simply the best imposition tool for PDFs. If you need to impose a PDF, Quite Imposing Plus can do it. It is not the easiest tool to work with. One of the best features of it is that you can create sample PDF files with page numbers to figure out how exactly an imposition scheme needs to be set up. Once you’ve figured that out, you can just re-run the same process again on your real document.

PDFLib

PDFLib is a great tool to programatically create PDF files. I’ve used an older version a few years ago. I’ve followed the development of the library over the years, and I still can recommend it as an alternative to iText.