For a few years now Adobe has been telling 3rd party developers that the ADM (Adobe Dialog Manager) will be discontinued, and that existing plug-ins may have to be ported to something else. If I remember correctly, this started with Acrobat 7 or 8, but back then it was a soft threat – everything still worked, and there wasn’t much incentive to start porting plug-ins. However, with the release of the Acrobat 9 SDK the ADM related header files were gone, but ADM based plug-ins were still working (at least some of them).

The removal of the header files does send a strong signal, but what was an even stronger signal for me was that one of the ADM based plug-in I was working on was no longer working correctly on some versions of Windows.

As far as Adobe is concerned, ADM is no longer supported – that means there won’t be any bug fixes for it, but the plug-in has to work with Acrobat 9 on any Windows system that’s supported by Acrobat 9. So, what is a developer to do in such a situation?

Adobe does not give us much guidance in what to chose as a replacement for ADM. The most obvious choice is to stick with the native UI framework that comes with the operating system, but the advantage of ADM was that one could write UI code that would run in both Windows and Mac plug-ins. One of the sample plug-ins – wxPlugin – that comes with the Acrobat SDK is based on wxWidgets. To me that was a pretty strong hint that wxWidgets would be a good choice…

However, even though the Mac version of the SDK does come with the wxPlugin code and even contains a XCode project file, it does not compile. After some work, trying to come up with a combination of wxWidget configuration options and wxPlugin project settings, I was able to create an Acrobat plug-in that worked.

In order to “fix” the Mac’s version of the wxPlugin I first had to compile wxWidgets. Use the following configure command line to create the static wxWidget libraries that can be linked with the project:

configure CC=gcc-4.0 CXX=g++-4.0 LD=g++-4.0 --enable-universal_binary \
--disable-shared --with-macosx-sdk=/Developer/SDKs/MacOSX10.4u.sdk \
--with-mmacosx-version-min=10.4 --enable-debug

Just install the libraries and include files according to the instructions provided by Adobe.

A closer inspection of the plug-in code then revealed that the part that actually did anything was commented out for the Mac with #ifndef MAC_PLATFORM statements, so I removed those and the last thing to do was to remove the reference to the libexpat library – it is provided by the operating system and does not have to be provided by wxWidgets.

With a working environment on the Mac, wxWidgets is a viable alternative for ADM for either new Acrobat plug-ins, or existing plug-ins that need to be modified to make them compatible with the current version of Acrobat.

If your Acrobat plug-ins are still using ADM, now would be a good time to think about what to do about that… If you need any help, let me know.

Acrobat’s JavaScript is a great tool to extend the application, or to automate reoccurring tasks. There are several ways a JavaScript can be added to the application or a document (e.g. folder level scripts, validation scripts, event handling scripts, …), but regardless of how a script is written, chances are that the developer wants to test parts of the script in Acrobat’s Javascript console. This console window can be shown by either using the “Advanced>Document Processing>JavaScript Debugger…” menu item or Ctrl-J on Windows or Cmd-J on a Mac:

After the console or debugger window comes up, the user can then enter Javascript and execute it…

… that is, as long as a full keyboard with a numeric keypad is used. In Adobe’s documentation, we find the following instructions to execute Javascript typed into the console window:

The JavaScript console allows you to evaluate single or multiple lines of code. There are three ways to evaluate JavaScript code while using the interactive console:

• To evaluate a portion of a line of code, highlight the portion and press either the Enter key on the numeric keypad or press Ctrl + Enter.
• To evaluate a single line of code, make sure the cursor is positioned on that line and press either the Enter key on the numeric keypad or press Ctrl + Enter.
• To evaluate multiple lines of code, highlight those lines and press either the Enter key on the numeric keypad or press Ctrl + Enter.

That works fine as long as you have access to the numeric keypad, but on a MacBook or a MacBook Pro without that keypad. No key combination involving fn, ctrl, cmd or option with the Return or Enter key will result in the Javascript getting executed.

The virtual keyboard to the rescue: Mac OS comes with a handy keyboard viewer that allows us to send the correct key code to the application. To bring up the keyboard viewer, bring up the Mac OS System Preferences first and select the “Keyboard” category:

Make sure that the option “Show Keyboard & Character Viewer in menu bar” is selected. Once this is done, you can access the keyboard viewer from the menu bar:

Now comes the tricky part: Write some Javascript in the console window and place the cursor on the line you want to execute or select the snippet of the Javascript that should be executed. In the following example I’m using code from Adobe’s Javascript API documentation:

  var menuItems = app.listMenuItems()
  for( var i in menuItems)
    console.println(menuItems[i] + "\n")

With the console prepped, bring up the keyboard viewer and start pushing keys – real keys that is: Hold down the “fn” and the “control” key, then move the mouse pointer to the “Enter” key on the keyboard viewer and click it…

… and voila, the script gets executed:

This is not the most straight forward method, but at least it’s possible to use the Javascript console to execute code when using a MacBook.

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 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.

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.

What tools am I using to create/process/debug PDF documents? Here is list of my top tools and why I like them.

Adobe Acrobat Pro

Here are a few tasks that I use Acrobat for:

• Create

If you want the best quality PDF document, how can you go wrong with the Distiller from the people who invented PDF? There are many ways to create PDF files, but for high quality press work, I would not trust any other application.

• Edit and Process

Optimize, preflight, manage colors, insert pages, extract pages, remove pages, change page boxes, create interactive forms… Do I need to say more? Pretty much anything that’s possible with a PDF document can be done with Acrobat. Sure, there are other tools that can do some of these tasks as well, but there is no other tool that covers the broad range of features available in Acrobat.

• Debug

The preflight tool allows to check for syntax errors in PDF files, traverse the internal structure of PDF documents, look at fonts, …

• Programming

I also write software for Acrobat. That’s either done as a plug-in or as JavaScript, for demo purposes I occasionally also write sample VB programs that utilize Acrobat’s Inter-application Communication API.

Adobe Reader

Ghostscript

XPDF

iText

pdftk

It is a tool to do a number of things with PDF files (concatenate files, break a multi-page file into individual page documents, flatten forms, …). Take a look at the page that lits pdftk sample command lines to learn more about what is supported.

There is a small problem with pdftk: It’s no longer supported, and it cannot handle PDF files that use some of the newer PDF features. Also, there are (at least) two versions that are currently getting distributed: Get the newest one from http://www.pdfhacks.com/pdftk and not the one from AccessPDF. (Update: Both links now have the same version).

Mac OS X

Enfocus Browser

• An Acrobat plug-in


• A standalone application

My Favorite Acrobat 8 Feature

The Enfocus Browser is Back

One of the best features of the Browser is that it allows you to actually modify the PDF structure, however, you better hold back on that until you’ve read the PDF spec a couple of times. It’s very easy to break a PDF file by making just a few changes.

One of the biggest advantages of the standalone version is that I can look at a PDF file that may not open in Acrobat and find out why.

There are a number of other applications that I don’t user personally, but that I do recommend to others because I know how good these apps are. More about that in a future post.