Whether or not you are heading to MAX, Twitter is a huge part of MAX this year:

• Though I have yet to follow the masses, I will attempt to tweet at @SConForms;
• You can check-out what people are saying about MAX by searching for the #adobemax tag (and if you tweet about MAX, you should use the tag as well!); and
• Each of my labs will have designated Twitter tags, #adobemax49 (Oct 6, 3:30-5pm, PST) and #adobemax357 (Oct 7, 11am-12:30pm, PST), so that attendees can collaborate, ask questions and give feedback.

The MAX Resources page has even more Twitter details, including other ways to follow MAX like FaceBook, the MAX Blog, flickr, etc.

For those of you who can’t join us this year, Adobe has just launched the MAX Online site where you’ll be able to watch live keynotes and the top 3 daily sessions.

Here’s to an awesome MAX conference this year and Happy Canadian Thanksgiving! I’ll be back to my blog as of Oct 19, after taking a little bit of time off following the conference.

In order to ensure the lab is successful in the short amount of time we have (90 minutes) to build a small end-to-end solution, the Content Creation (CCR) and Correspondence Generation (CGR) building blocks will no longer be featured. Instead, we will feature the following building blocks, which should give you a taste for their power to accelerate your own solutions:

• Selection and Capture (SNC) — capture data and guide users through filling specific forms within a given set;
• Review, Commenting and Approval (RCA) — review the submitted forms and approve or reject as needed;
• On-Demand Assembly (ODA) — automate the creation of a PDF package, a single PDF document containing a copy of submitted forms and other appropriate documentation.

In the mean time, here’s some fun MAX trivia. You never know when it might come in handy…

See you there!

Aug 24, 2009 — Added links to the CCR and CGR building blocks.

Form Guide Layout

The goal is to design a form guide which will provide two panels: one for user options and the other for results.

The first panel will expose the 4 fields inside the GuideObjects subform (which are only meant to be exposed in the form guide — hence why the GuideObjects subform has the Initialize script to hide it if the host isn’t “Flash”). The user will have the option to choose an actor and/or category for further filtering and will then click on the GetMovies button to execute the request on the Movie Service. When the requested XML is returned to the form guide, the GetMovies result handler will convert the XML into instances of MovieRow inside the Listing table.

The second panel will use a repeater layout to expose the Listing table’s contents within the form guide however this panel will only be accessible if the movie query returned 1 or more results.

Once the results are in, the user will then be able to switch (“flip”) to the PDF view which will show the Listing table in the form, from which the user could then print or archive the results.

Designing the Form Guide

Open your tutorial form in Designer and launch GuideBuilder (GB) by choosing the “Tools > Create or Edit Form Guide” command. Switch to the “Customize Appearance” tab and choose “Save Styles”, saving them to a SWC file of your choice (usually in the same folder). It’s not mandatory to do this but if you don’t specify a file name here, GB will auto-generate a style SWC (which contains information about any style customizations you might apply) named according to the wrapper you choose (e.g. “ga.wrappers.CobaltStandard.swc” for the “Cobalt Standard” wrapper — not the most meaningful name for our solution).

Back to the “Edit Guide” tab, set the guide’s title to “MAX 2008 Movie Catalog Service” (double-click on the “New Guide” label to set it), the section’s title to “Movie Catalog” and the panel’s title to “Options”. Set the panel’s layout to “Two Column”.

Options Panel

Click on the “Add or Bind Fields” button and drag the entire GuideObjects subform into the panel. You’ll see, in the “Panel Preview” pane on the lower-right, that objects in the panel are laid-out in two columns from left to right, top to bottom, according to the top-down order in which they appear in the panel. What we want is for the MatchCount field to show-up below the GetMovies button. To do this, insert a “Next Area” object (from the “Utility Objects” group at the top of the form tree) after all the objects in the panel and then drag the MatchCount field below it. The “Next Area” object causes a break in the layout algorithm, thereby forcing the following object onto the next row in the two-column layout.

To make the panel layout more pleasing, switch back to the “Set Properties” view and set the captions of the ActorList, CategoryList and MatchCount fields to be at the top and the width of both listboxes to be “100%”. Finally, override the MatchCount field’s caption (double-click on it) and set it to “Number of movies matching criteria:” (accept the warning about the caption binding being removed).

One important form guide feature is the ability to display fields in different ways. In other words, if your field is a listbox, for example, you aren’t limited to displaying it as a traditional listbox. You could choose to display it as a series of checkboxes or radio buttons, for example, or you could create your own custom control using FlexBuilder.

GB provides a checkbox control type which will suit our needs perfectly because while our listboxes are single-selection only, using checkboxes will allow the user to remove a previous selection which is important if they previously filtered by actor, for instance, and now they want to remove that filter.

For the ActorList and CategoryList fields, set their “Display field as a” property to “Check Boxes”.

At this point, the settings for the ActorList (and CategoryList) fields should look like this:

and your form guide hierarchy should look like this:

Movie Listings Panel

The second panel is a lot simpler since it just shows the Listing table’s contents and it doesn’t require as much settings.

Insert a second panel into the “Movie Catalog” section, give it a title of “Movie Listings” and set its layout to be “Repeater Grid”.

The objects named “Repeater First Column” and “Repeater Second Column” don’t apply to this type of repeater panel however they do matter in other repeater layouts and are there for consistency (should you decide to change the repeater panel type). The “Trailer” object signifies that all objects placed after it, on this panel, will go below the grid as opposed to being part of the grid (this would be good for footer objects, if we had any).

Drag the MovieRow subform (table row) into the panel between the “Repeater First Column” and “Repeater Second Column” objects (drop the subform directly in between the two objects — if you miss, just drag each object back to where it’s supposed to go).

For each field you dragged-in, set its caption as follows: “Title”, “Actor”, “Category” and “Cost”. (You should see these changes in real-time in the Panel Preview pane.) Select the Title item and set its width to 150 (which means pixels in the form guide) to ensure the titles are completely visible and then set its “Allow field to repeat” property to indicate that it, and all associated fields, should be repeated within the grid layout. The items in the panel will then get a yellow outline indicating that they are repeating items.

Now that we’ve set this up, I’ll follow-up on a comment I made in part 1 when we designed the Listing table and set the MovieRow to have 1 initial instance: There’s a bug in the Repeater Grid panel layout where the data entered into the fields in the grid will not be rendered (it’s there, you just can’t see it) unless there’s some data in the grid when the form guide is initialized. To work around the bug, we simply include an initial instance of the MovieRow and then the GetMovies result handler code simply removes the instance prior to populating the table with movie results (whether there are any or not).

The last step in setting-up this panel is to apply a Display Rule to indicate when the panel should be visible (accessible to the user) in the form guide. What we want to do is set the panel to be visible only if the MatchCount field’s value is greater than zero, meaning there’s at least one movie result from the query. To do this, you simply toggle the “Specify panel display rules” pane in the panel’s properties, choose “Use Display Rules”, add a rule, set MatchCount as the field, “greater than” as the condition and “0″ as the value.

FormBridge XFO Fix

Now that the form guide has been designed, there’s just one more thing we need to do: Apply a small fix to the FormBridge code that brokers the communication between the form guide and the PDF at runtime. The FormBridge code is normally automatically injected into the PDF when it’s generated by the GB Preview functionality or by LiveCycle when the form is rendered as a form guide with the PDF however we need to use our own “fixed” version of the FormBridge code. Otherwise, when we flip to the PDF, there will be no data in the table.

To do this, save your changes to the form guide and exit GB. Find the “Custom” pane in Designer’s Object Library and drag the “Form Bridge” object onto your form below the GuideObjects subform (where there are no objects on the page).

It shows-up as a hairline selection on the page and in the hierarchy looks like this:

Select the “ContainerFoundation_JS” script object and open the Script Editor to edit the script. Find the two instances of “saveXML()” (lines 316 and 631) using the Find dialog (Ctrl + F) and change them from

saveXML().replace(/\n/g, "");

to

saveXML();

Do not remove/change any of the code that comes before it on the same line. This fix ensures that the format of the data going across the line is correct.

With the FormBridge object in our form, GB Preview and LiveCycle will not inject their version into the PDF. The only draw-back from this approach is that if the FormBridge code changes, you’ll have to manually update it in your form as opposed to automatically getting the new version when you preview with GB or render your form with LiveCycle.

This bug should be fixed in a future release and so the workaround in the FormBridge code will eventually no longer be needed.

Flash Log and Debug Players (Optional)

You may have noticed some “trace()” statements in the code we set on the ActorList, CategoryList and GetMovies objects in part 2. This is a handy way to get a read on what’s going on (i.e. debugging) inside the form guide at runtime if you aren’t using FlexBuilder to debug it (which we’re trying to avoid in this tutorial). It’s a lot like using “console.println()” to output information to Acrobat’s JavaScript Console.

If you want to see trace statement outputs (it’s not necessary but it could be handy), you need to look at your flashlog.txt file which is auto-generated by the debug version of the Flash Player. These are normally called “debug players” or “content debuggers” and are downloadable here. To ensure that you have a debug player, you can hit this page which will tell you what version and type of Flash Player your browser is using.

Once you’ve installed a debug player, you’ll need to configure your system to enable the flashlog.txt file which will be located here, once enabled: C:\Documents and Settings\user_name\Application Data\Macromedia\Flash Player\Logs\flashlog.txt (XP) or C:\Users\user_name\AppData\Roaming\Macromedia\Flash Player\Logs\flashlog.txt (Vista).

The debugger configuration page details where to place the mm.cfg file and what to put in it in order to enable output to the flashlog.txt file. For example, if you’re running XP, you would create a new mm.cfg file in your “C:\Documents and Settings\user_name\” folder and you would put the following lines inside to enable error reporting and trace logging (i.e. output to the flashlog.txt file):

TraceOutputFileEnable=1
ErrorReportingEnable=1

Running the Solution

Now that the form guide is designed, we’re ready to run our solution: Launch GB again and this time, choose the Preview tab, select “Include PDF Preview” (to ensure that a PDF is included, otherwise you won’t be able to flip to it to see the results) and click on the Preview button.

The resulting form guide should look like this (with the pre-loaded actor and category lists):

When you click on the “Get Movies” button, the button will become temporarily disabled and then, assuming your query returned movies, the count should be updated and the “Movie Listing” panel should appear in the left toggle bar:

Now click on the “Movie Listing” panel to see the results in the form guide:

Finally, click on the “Show PDF” icon in the toolbar at the top-right to see the results (i.e. imported Movie Service data) in the PDF:

Cool? I think so! And the cherry on top is that this even works with the free Reader! Users don’t need Acrobat in order for the data to go back and forth between the form guide and the PDF.

Solution to Part 3

Try not to peek at this before you attempt to build the form guide on your own…

Download Part 3 [zip]

Minimum Requirements: Designer 8.2.1 SP1, GuideBuilder 8.2.1 SP1, Reader 9.0.

Note: If you decide to deploy this sample to LiveCycle (e.g. using FormsIVS), you’ll also need to deploy the styles SWC you created earlier. The form guide will not render without it.

Flex Code in XFA Forms

The key to today’s tutorial is understanding when and where the script you write in an XFA form (JavaScript or FormCalc) is compiled or interpreted.

For starters, form guides don’t support the FormCalc language so that just isn’t an option.

JavaScript, on the other hand, has the nice property of looking a lot like ActionScript. In fact, the two languages have enough similarities that with very little modification, any JavaScript you write in an XFA form can be converted into ActionScript which runs in a Flex form guide (in the Flash Player).

Normally, when you write JavaScript code in your forms and you run the form in Acrobat, the script isn’t compiled when the XFA form is converted into the PDF file format and it’s only interpreted when the interpreter attempts to execute it (i.e. if there’s a syntax error somewhere in your script and you never run that code, you’ll never know about the error). When you generate a form guide based on your form, however, your JavaScript is actually compiled by the Flex compiler that generates the SWC (Flash Library) which defines your form guide.

Warning: Script object code seems to be loaded and interpreted by Acrobat in one shot, instead of on a per-access basis as in form object event scripts, and any syntax errors anywhere in the script object will cause all of the script in the script object to basically be ignored. If you have functions defined in a script object and you know you’re calling a function properly but you keep getting a “function is not defined” error, use the Script Editor’s Syntax Checker tool — you’ll probably find a syntax error somewhere. After you fix it, you should be able to access your script object functions.

It also appears that Acrobat/Reader 9.0 may now be attempting to parse (but not execute) all scripts on form load which may produce syntax errors in the JavaScript Console due to the differences between JavaScript and ActionScript syntax however in my experience so far, I haven’t hit a situation where my JavaScript stops executing because of this. Nonetheless, if you’re seeing strange behaviour, it might be a good idea to check the console to make sure things are running smoothly.

What you might not have realized is that if you know that a particular portion of script will only be executed within the context of a form guide, you can actually write Flex code in your XFA form! When you generate the form guide (either by previewing using GuideBuilder or by rendering the form as a form guide via LiveCycle Forms), your Flex code will be compiled as any other Flex code would be and it’ll be executed in the same way.

That opens-up a world of possibilities and the one we’re going to explore in this tutorial is the use of the mx.rpc.http.HTTPService class to fetch data from the Movie Service and insert the results into the Listing table within the form guide, thereby causing the data to be inserted into the Listing table within the PDF form when the user switches from the form guide to the PDF.

XFA Host Name = Flash

You might recall, in yesterday’s tutorial, that I talked about the xfa.host.name property returning “Flash” when your XFA code is executing within the context of a form guide (it returns “Acrobat” when its executed within the PDF because the form’s “host” is “Acrobat”).

This is the indicator we’ll use to “protect” the Flex code we’re going to write to make sure that it’s not executed within the PDF:

if (xfa.host.name == "Flash")
{
    // do some cool stuff in Flex/ActionScript
}

Note that the XFA model in a form guide works just the same as it does within the PDF with the exception that the form guide environment only supports a subset of XFA functionality (less than in the PDF but more than in HTML).

Our Own HTTPService

Since there will 3 requests made to the Movie Service, one for the actor list, one for the category list and another for the movie listings resulting from the chosen actor and/or category (if any), the first step to take is to create some reusable code within our form that makes use of the HTTPService object.

Open the form you designed yesterday and add a new script object by right-clicking on the root subform (“movieList”) and choosing the “Insert Script Object” command.

Name your script object “FlexHttpService” and paste the code from this text file into the script object.

You’ll notice that there are some statements in this script that aren’t regular JavaScript (namely the “import” statements to get access to the HTTPService and its result and fault event classes as well as the typing of variables like “service:HTTPService”). That’s because it’s ActionScript!

I’m assuming you know enough about Flex to be able to understand what’s going on but the gist of it is that the script object’s send() function takes a URL (to the Movie Service) and two functions, the first called when the request is successful and the second called if the request fails. If the request is successful, the result handler function is called with an XML variable as its parameter. This XML variable contains the movie listing we want to insert into the Listing table.

The FlexHttpService.send() function will be the reusable piece of code that we’ll use in the two listboxes and the button, each providing its own URL and result handlers.

It’s important to note that the actual result and fault handlers given to the HTTPService object instance are inline functions. This is essential since the call to HTTPService.send() is asynchronous. When the result comes back (later), context will be lost and the service won’t be able to find a function you defined in the FlexHttpService script object. Therefore, the handlers must be inline.

ActorList Initialize Script

With the FlexHttpService defined, it’s easier to write the rest of the code to fetch the list of actors.

We want the list of actors to be retrieved when the form guide initializes so we’ll put this script in the Initialize event of the ActorList field. In the result handler, we’ll simply iterate through the items in the XML object returned and, for each actor, add his/her name and ID as an item into the ActorList field in the form guide.

Note that accessing the ActorList field in the form guide within the result handler, which is out-of-context at this point, is done by using the full SOM expression to the field, starting with xfa.form (accessing the Form DOM), followed by the root subform name (“movieList”), followed by the path to the ActorList field.

Edit the ActorList field’s Initialize event and paste the code from this text file into it.

Basically, we first clear any existing list items and call the Movie Service with the appropriate URL. In the result handler, we add items into the ActorList and then enable the list so that the user can make a selection (we don’t want the list accessible until the items have been loaded).

CategoryList Initialize Script

The CategoryList field is much the same as the ActorList field however it’ll fetch the list of categories.

Edit the CategoryList field’s Initialize event and paste the code from this text file into it.

GetMovies Click Script

Finally, we just need to set the Click event script on the GetMovies button that will fetch the movies requested by the user (optionally filtering on actor and/or category).

This script is essentially the same as the first two however it’s a little more complex since the Listing table must be retrieved and then new instances of the MovieRow must be added and their fields (Title, Actor, Category and Cost) populated with data from each movie returned from the service. Additionally, the button is disabled once its clicked and only re-enabled when the result or fault handler is called to prevent the user from clicking multiple times while a request is pending (since HTTPService.send() is asynchronous) and the MatchCount field is populated with the number of rows added to the Listing table (this will be important when we design the form guide in part 3).

Edit the GetMovies button’s Click event and paste the code from this text file into it.

Solution to Part 2

Try not to peek at this before you attempt to build the form on your own…

Download Part 2 [zip]

Minimum Requirements: The form should work back to Designer 8.0 however it was designed with Designer 8.2.1 SP1.

Updated: November 22, 2008

Throughout the tutorial, I will assume that you’ve used Designer already and you know about things like flowed vs positioned subforms. I will also assume that you’re familiar with Guide Builder’s interface for designing Form Guides.

Software Requirements

Before we get started, make sure you’re using Designer 8.2.1 SP1 and Guide Builder 8.2.1 SP1. You can download an evaluation version of Designer and Guide Builder when you download the Acrobat 9.0 Pro trial. If you haven’t installed SP1 yet, you can download it from here (note that you only need to install the Designer SP1 update — you don’t need Workbench or even LiveCycle ES to run through this tutorial).

If you already have Designer but you don’t have Acrobat, you can use Reader 9.0 to go through the tutorial.

Schema Data Connection

The first step is to connect the form to a schema which we can obtain from the Movie Service:

<movieList>
    <movie>
        <movieId/>
        <title/>
        <cost/>
        <actorName/>
        <catName/>
    </movie>
    <movie>
        <movieId/>
        <title/>
        <cost/>
        <actorName/>
        <catName/>
    </movie>
</movieList>

Save this structure to an XML file named “movieCatalog-schema.xml” somewhere where you can reference it later from your form in Designer. (It’s important that you save it as-is with the duplicated <movie> element since this will indicate to the Data Connection Wizard that the <movie> element is repeatable.)

Create a new blank form in Designer and then create a new data connection using the Data Connection Wizard available from the Data View palette’s menu button. On the first page, set the name to “MovieCatalogDC” and choose “Sample XML File”:

On the next page, choose the “movieCatalog-schema.xml” file you saved earlier and click “Finish”. You should now have a schema data connection in your form (note that Designer inferred the possible structure of the schema based on the sample XML file we provided for the data connection):

This data connection will help us set the correct bindings later.

Page Header

Next we’ll create a simple header for the form by adding a text object to the Master Page. Switch to the Master Pages tab and drag a text object onto it. Place it at the top-left and set the text to “MAX 2008 Movie Catalog”.

To make sure that what we’ll put on the body pages (in the Design View) doesn’t show-up over-top our header, make sure that the content area starts below the header text object:

Movie Listing Table

Back on the Design View, we now need to create a table which we’ll use to display the listings from the catalog. This is where that schema data connection will come-in handy as we’ll see a little later.

Our table will display 4 columns: title, actor name, category name and cost. Drag a table object onto the top-left corner of the page and give it 1 header row, 1 body row and 4 columns:

We want the table to take-up the entire width of the page but we also want the first column, title, to be wider than the other 3 since the title is usually longer than names or a dollar amount. Start by making the last 3 columns a little wider by dragging the column separator between the 2nd and 3rd and 3rd and 4th columns to the right, leaving some room to make the first column wider. Then drag the column separator between the 1st and 2nd column to the right until it won’t move anymore, which indicates that it’s the widest the first column can be made while keeping the table constrained to the page’s width.

Now double-click in each header cell and rename them to “Title”, “Actor”, “Category” and “Cost” from left to right.

(Here I’ve also set a linear-to-bottom background gradient color on the header row.)

Next, we need to set some fields into the table row where the movie data will go since they’re only text objects by default. The first 3 columns need to be text fields and the last one should be a numeric field since it’ll contain a dollar amount.

Using the Hierarchy palette, select the “Cell1″, “Cell2″ and “Cell3″ objects in the “Row1″ table row and change their object type (using the Object palette) to “Text Field”. While they’re still selected, set their Value Type to “Read Only”.

Now select the last cell in “Row1″, “Cell4″, and change its object type to “Numeric Field”. While it’s still selected, set its Value Type to “Read Only”, its Data Format to “Float” and click on the “Patterns…” button on the Object palette’s Field tab. In there, set the Display pattern to “numeric.currency{}” and set the Data pattern to “numeric.decimal{}”:

This will let the field accept a decimal number as its data and will cause it to be displayed with a currency symbol (e.g. “25.50″ is displayed as “$25.50″).

Finally, rename “Table1″ to “Listing” and “Row1″ to “MovieRow”. Inside “MovieRow”, rename “Cell1″ to “Title”, “Cell2″ to “Actor”, “Cell3″ to “Category” and “Cell4″ to “Cost”.

Schema Data Bindings

The next thing on the list is setting the data bindings into the schema data connection we created earlier. This will ensure that when data is merged into the form, after being retrieved from the Movie Service, that instances of the MovieRow table row are created accordingly and the Title, Actor, Category and Cost fields they contain populated with the right data for a particular movie.

Select the MovieRow table row object and set its binding by choosing “MovieCatalogDC > movie” from the binding popup button next to the Default Binding property. This will set the binding to “$.movie[*]“:

(The button next to the field that contains “$.movie[*]” is the binding popup button.)

This binding, with the “[*]” syntax, indicates that the MovieRow object will bind to all occurrences of the <movie> data group nodes in the data that gets merged into the form.

Finally, make the MovieRow repeatable with no min, no max but 1 initial instance:

The initial instance is essential in getting around a bug with the Form Guide Repeater Data Grid panel layout which we’ll be using in part 3 of this tutorial.

The last bindings we need to set are on the Title, Actor, Category and Cost fields that make-up the MovieRow. Set them as follows:

• Title: “$.title”
• Actor: “$.actorName”
• Category: “$.catName”
• Cost: “$.cost”

You can set these bindings manually or you can use the binding popup button to select the appropriate node from the MovieCatalogDC data connection. If you use the binding popup button, you’ll likely get the Binding Properties dialog, in which case you should choose to not to update any related properties as follows:

Under certain circumstances, the schema may contain more information about a particular element which could be automatically applied to the field such as name, caption and default value. Since we’ve already setup the fields ourselves (and since our sample XML schema didn’t have much information to start with), we don’t need this functionality.

Form Guide Only Objects

The final step in the form design is to include 4 objects which we’ll use only in the form guide that we’ll create in part 3 of this tutorial. We’ll need a listbox to hold the actor names, one to hold the category names, we’ll need a numeric field to hold the movie count and we’ll need a button that the user will click to fetch the movies that match the actor and/or category they will have selected in the lists (if any).

This is simpler to setup than it sounds. All we need to do is drag a new subform into the page (below the Listing table) and place two listboxes, one numeric field and one button inside. Rename the subform to “GuideObjects”.

Rename one listbox to “ActorList” and the other to “CategoryList”. Rename the numeric field to “MatchCount” and the button to “GetMovies”.

Set the ActorList field’s caption to “Choose an Actor (optional):” and the CategoryList field’s caption to “Choose a Category (optional):”. Set both field’s Value Type to “Read Only” since we don’t want the user to be able to interact with the listboxes until actor and category data are loaded into them (in the Form Guide, which we’ll see later in part 3).

Set the MatchCount field’s caption to “Number of matches:” and set its Value Type to “Read Only” as well since we’ll just be reporting the total number of movies that matched the criteria (actor and/or category or neither) and we won’t want the user to edit the result.

The bindings on both listboxes and the numeric field will be “None” by default which is fine. There’s no node in the schema to bind them to and we don’t need to bind them anyway.

Set the GetMovies button’s caption to “Get Movies”.

Finally, to make sure all the guide-only objects are hidden in the form, set the Initialize script of the GuideObjects subform to hide itself if the context isn’t the Form Guide. You can determine what the context is by checking the value of the xfa.host.name property. If it’s “Flash”, then you know the script is executing within the context of the Form Guide, not Acrobat. This will be very important in part 2 when we write the ActionScript code necessary to fetch the data from the Movie Service:

if (xfa.host.name != "Flash")
    this.presence = "hidden";

This is what the form should look like now:

(Note that the exact placement of the objects within the GuideObjects subform doesn’t matter since they’ll be positioned correctly in the Form Guide and won’t be displayed on the form itself.)

Getting Rid of the Page Subform

To ensure that our Listing table is free to expand and roll-out onto additional pages if there are a lot of movies returned in the listing, we need to move the Listing table and the GuideObjects subform out of the page subform and into the root subform (“movieList” at the top of the Hierarchy tree). We could just make the unnamed page subform flowed but that would introduce an extra level of subform hierarchy that just isn’t needed.

This can be done simply by right-clicking on the unnamed page subform “(untitled Subform) (page 1)” object in the Hierarchy palette and choosing the “Unwrap Subform” command. The hierarchy should now look like this:

Testing the Form

Before we go on to part 2 we should make sure that what we’ve done so far works correctly. To test our form, we simply need to merge-in some movie data from the Movie Service to make sure that it gets displayed properly in the Listing table.

You can get the full movie catalog listing simply by hitting this URL:

http://forms.stefcameron.com/services/movies/

Save what you get into an XML file named “movieCatalog-sample.xml” and set it as the Preview Data File for the form using the Form Properties dialog.

Now preview the form using the “Preview PDF” tab. You should get something that looks like this:

After you’ve determined that the table is functioning correctly (which means that the bindings are working as expected), you should remove the Preview Data File setting since it’ll interfere with the Form Guide’s function later on. (A Preview Data File can be used to initialize data in a form guide however, in this case, we don’t want all the movie data to be there already; we want to query the Movie Service for it in real-time based on any actor and/or category settings the user may have specified.)

Solution to Part 1

Try not to peek at this before you attempt to build the form on your own…

Download Part 1 [zip]

Minimum Requirements: The form should work back to Designer 8.0 however it was designed with Designer 8.2.1 SP1.

This tutorial will show you how to (1) design a form with a table that has a repeating row, (2) add some Flex code to it that will enable the use of the mx.rpc.http.HTTPService class for retrieving data from my Movie Service and (3) design a form guide that will capture the data from the service and transfer it into the PDF which could then be used to print or archive the movie listings.

In an effort to wet your appetite, I thought I would get the ball rolling by showing a little preview of the final solution.

Be sure to come back every day, Monday to Wednesday next week (November 17-19, 2008), to get the full tutorial.

But why hold back? Christmas will soon be here and in the spirit of giving, I figured I would still do my part remotely and write a series of posts over the course of the conference next week that will show you how to do the data import via Flex. I hope you’ll find it useful.

Stay tuned…

I’ll also be giving a demo of all the new and exciting features available in Designer 8.0 along with a sneak peak at what’s in store for the next release during Adobe’s “Product Tutorial” session (#09 at 9:45am on Monday, May 7, for those of you attending) led by Alain Roy, one of our Product Managers. Please join us if you can!

If you’re attending, you’ll also want to make sure you check-out Adobe’s “E-Forms Come of Age” session (#40 at 3:00pm on Tuesday, May 8 ) where Alain will demonstrate a new feature we’ve been working-on that will completely change the way your users/customers interact with your forms — you won’t want to miss this!

As he prepares for his session, I’d like to give you an opportunity to influence what he’ll talk about so that his session is as valuable to you as possible:

• Are there specific features you’d like to see a demo for? Dynamic Subforms? Conditional Breaks? Data-Nominated Subforms? Data Binding?
• Should he talk about form design methods like why and when to use repeating (dynamic) subforms, how to validate your form prior to submission, etc.?
• Anything else?