var newString = ScriptObject.trim(oldString);

These function calls can become lengthy in situations where the script object is located on a different page than your method call. For example:

var newString = form1.page1.subform1.ScriptObject.trim(oldString);

The prototype property is probably one of the most under-utilized scripting features when it comes to LiveCycle form development. However, it is so powerful as it allows you to easily extend and reuse JavaScript intrinsic classes and your own. For instance, the trim function can be rewritten as follows:

String.prototype.trim = function() { return this.replace(/^\s+/, '').replace(/\s+$/, ''); }

And to use it:

var oldString = "    Hello   ";
var newString = oldString.trim();
// newString -> "Hello";

You may also want to have another method called "strip" that performs the same task.

String.prototype.strip = String.prototype.trim;

As you can see, your function is simpler and easy to use. Using the prototype property for custom functions also prevents your code from breaking in case you change the name or location of the script object and provides a natural way to extend objects even if you did not author them.

Based on my past projects where the requirement was to create resuable Designer library components for multiple teams, I usually wrap my script objects in a subform, make it into a library component (xfo) or a form fragment and share it with other form developers.

Also to make the JavaScript interpreter in Acrobat/Reader aware of your prototype extensions, you must load all your prototype definitions when the form loads. You can achieve this by wrapping the prototype function and property definitions inside a function and call that function in the subform initialize event. For instance:

function initialize()
{
	String.prototype.trim...
	String.prototype.strip...
	...
}

In my sample form, once the extensions have been initialized, it will print out the below messages in the debugger console.

Initializing Array extensions...
Array extensions initialized.
Initializing String extensions...
String extensions initialized.

One last note - as you develop these prototype functions, don't forget to include documentation comments to increase readability and ease of use. Feel free to share your experiences or ask any question you may have.

Resources

• Sample
• For more information about the prototype property, click here.
• LiveCycle Designer ES Scripting Basics
• LiveCycle Designer ES Scripting Reference
• For more information about Form Fragments, click here.

/* ActionScript */
// Register an ActionScript method as callable from the container
ExternalInterface.addCallback("find", find);

// Find a product
public function find(itemId:String):void
{
	...
}

On the PDF side, all you need to do is to get hold of the Flash object and call into the ActionScript method by using the callAS( methodName:String, <argument1, argument2, and so on...>) as follows:

/* JavaScript */

// Get hold of the first Flash object on the first page
var annot = getAnnotsRichMedia(0)[0];

if ( annot ) 
{
	// if exists, call the function called "find"
	// and pass an item ID as an argument	
	annot.callAS( "find", "B000NDIB6Y");
}

Again, what the callAS method does is calling into ActionScript via ExternalInterface calling convention to an exposed method. The example I mentioned in this post can be downloaded here. Acrobat/Reader 9 is required. If you want to reuse the Flex application, you will need to register for an Amazon Web Services and their Associates accounts.

Downloads

• Acrobat 9
• Sample PDF
• Sample Flex

How-to Steps:

1. Create a blank PDF or open an existing one in Acrobat 9.
2. Add a button by going into the form editing mode.
   
   
   
   
3. Add a Run Javascript action to the button.
   
   
   
   
4. Add the Flex SWF to the PDf by using the Flash tool.
   
   
   
   
5. Editing the Flash properties to make it start as soon as the PDF is opened.
   
   
   
   
6. Save the PDF and the end result should look similar to this.
   
   
   

There are a number of free and commercial third party tools you could use to convert images to hex-encoded strings. However, none of the tools fits my workflow in terms of flexibility and extensibility. So I have created a Java utility library, called Acrobat Dialog Image Generator (ADIG), which allows you to generate a hex-encoded string or a skeleton Acrobat dialog box with an embedded image.

You can invoke ADIG via a command-line interface, ANT or an API call. Here are some sample invocations:

Command-line

java -jar adig.jar /Users/lerlop/Pictures/test.jpg /Users/lerlop/Desktop/

This will reads in test.jpg and generates a JavaScript dialog file called test.jpg.txt on my desktop. Here is a sample.

ANT

ant -buildfile adig.xml

This will also produce the same result as the command-line option but everything is defined in the following build file.

    
<?xml version="1.0" encoding="UTF-8"?>
<project name="MyProject" default="GeneratorAcrobatDialogImage" basedir=".">
	<taskdef
		name="adig"
		classname="com.adobe.consulting.ant.tasks.GenerateAcrobatDialogImage"
		classpath="../../build/adig.jar"/>

	<target name="GeneratorAcrobatDialogImage">
		<adig imagePath="/Users/lerlop/Pictures/test.jpg" outputPath="/Users/lerlop/Desktop"/>
	</target>
</project>
    

API Call

String hexString = AcrobatDialogImageGenerator. generateHexEncodedString(imagePath);

By calling this static method in your Java code, you can generate a hex-encoded string from an image and assign it to a String object. This particular option is very useful when you try to perform any kind of batch operations. For instance, I can call this method to dynamically insert an image to a JavaScript dialog defined in an XDP before calling LiveCycle Forms to render it as a PDF.

To use the generated dialog JavaScript code in your form design, you can follow these simple steps:

1. Run ADIG via command-line or ANT to get a generated file. The generate code should like this.
2. Open your form in LiveCycle Designer (note: XFA form not AcroForm).
3. Create and name a new script object. It does not matter where the script object is located as long as you can reference it later. For simplicity, create it on page 1 and let’s call it DialogSO.
   
4. Copy all the code from the generated file and paste it into the script object.
   
5. Now create a button object so you can use it to launch the dialog box. Note that you could launch the dialog box in any event such as form::docReady or form::initialize.
   
6. The last thing is to make the button launch the dialog box. In the click event of the button, type in the following function call: DialogSO.launchDialog();
   

There you have it. You can extend the dialog box in any way you like by adding dialog elements to the dialog body. Please refer to the JavaScript for Acrobat API Reference.

I want to note that there are commercial tools out there that will let you design and extend Acrobat dialog boxes far more than just adding an image and generating dialog JavaScript template. If you are looking for a WYSIWYG tool to design dialog boxes, WindJack’s AcroDialogs may be more suitable for your needs.

Downloads:

• adig.jar
• Sample form
• Sample generated output