Flash CS3 includes a Behaviors panel, which was introduced in Flash MX 2004. This panel is designed to help a novice who is just starting to use Flash for design and development. You can open the Behaviors panel, shown in Figure 18.1, by choosing Window

Figure 18.1. The Behaviors panel showing a Button component with a behavior applied

If you create a new Flash document (ActionScript 2.0) and select the first frame of Layer 1, you can click the Add Behavior (+) button at the top-left corner of the Behaviors panel to see a list of categories (see Figure 18.2).

Figure 18.2. The categories in the Add Behavior menu

These categories represent a variety of objects you can control with one or more behaviors. So what do behaviors do? In the simplest sense, a behavior is automated scripting. When you add a behavior to an event handler, Flash CS3 generates the necessary ActionScript code to make that behavior happen. Let's take a quick look at a Web behavior.

We won't discuss any other behaviors in this chapter, as you can find specific categories of behaviors explained in other parts of the book:

Behaviors enable you to learn by example — you can add a behavior to an object and look at the code used to describe the interaction.

Every interactive authoring system uses a language (or code) that enables elements within the system to communicate. Just as there are several languages that people use to speak to one another around the globe, there are hundreds of programming languages in use today. In an effort to make Flash more usable to computer programmers, Flash's scripting language, called ActionScript, changed much of its formatting in Flash 5 to mirror JavaScript, a fundamental element for adding advanced interactivity to HTML Web pages. Right now, we focus on using the most basic Flash ActionScript.

Flash CS3 has a specific interface element that enables you to add interactive commands to Flash movies — the Actions panel. Unlike behaviors and the Behaviors panel, you don't use menus to add interactive functionality — you type the ActionScript code describing the interactivity in (or out of) of the Actions panel. You can open the Actions panel in a number of ways:

If you have a keyframe selected in the Timeline window, the Actions panel will be titled Actions - Frame (see Figure 18.5). If you have a Movie Clip symbol instance selected on the Stage, you'll see the name Actions - Movie Clip. If you have a Button symbol instance selected on the Stage, the Actions panel will be titled Actions – Button. If you have a component selected, the Actions panel will read Actions – Component. Don't be confused — there is only one Actions panel. Flash CS3 simply lets you know the object to which you are assigning actions.

As shown in Figure 18.5, the Actions panel in Flash CS3 has three distinct areas (counter-clockwise from the left): the Actions toolbox, the Script navigator, and the Script pane. The new Script Assist area is available within the Script pane. There are two auto-snap dividers, one dividing the Actions toolbox and Script navigator from the Script pane, and another subdividing the Actions toolbox and Script navigator. You may want to practice opening and closing these dividers, as well as dragging each to your preferred width and height, respectively. Figures 18.5 and 18.6 show a breakdown of the Actions panel in Flash CS3. The following list details the three areas:

For this chapter, you'll work primarily within the Timeline Control booklet, located within the Global Functions booklet in the Actions toolbox.

Figure 18.6. The Script Assist mode displays a more user-friendly interface for controlling action parameters.

You can add actions to the Script pane in one of three ways:

To delete actions, select the action line(s) in the Script pane, and press the Delete or Backspace key on the keyboard.

After you have added an action to the Script pane, you can specify parameters (or arguments) for the action. Depending on the action, you may or may not need to type such parameters. By default, Flash CS3 provides code hints as you type actions into the Script pane. The Show Code Hint button enables you to see the parameters for an action, as shown in the gotoAndPlay action in Figure 18.5.

More importantly, the Script Assist mode makes it much easier for you to add and adjust settings for basic actions, especially those you find in the Timeline Control booklet. You use the Script Assist mode throughout this chapter to learn the basic control actions.

You should get in the habit of clicking the Check Syntax button (the blue check mark) to make sure you didn't mistype an action. If you have an error, the Output panel displays some information related to the error, indicating the line number where the syntax error occurs.

For now, look at two booklets in the Actions toolbox's Global Functions booklet: Timeline Control and Browser/Network. The Timeline Control actions are listed in alphabetical order. The first eight actions in this booklet, including gotoAndPlay, gotoAndStop, play, and stop, control the playback of the movie. The last action, stopAllSounds, is a global command to handle sound playback.

The Browser/Network actions — fscommand, getURL, loadMovie/loadMovieNum, loadVariables/loadVariablesNum, and unloadMovie/unloadMovieNum — enable movies to load external files and communicate with the browser, a Web server, or the stand-alone player. In this chapter, we get you up and running with the getURL action, which enables you to link to other Web resources outside of the Flash movie (such as Web pages and file downloads).

The remaining Action booklets primarily offer extended ActionScript programming capabilities. We discuss many of these actions in later chapters.

Some of the most difficult concepts for beginners to understand with code writing are white space, parentheses ( ( ) ), semicolons ( ; ), and curly braces ( {} ). In the following paragraphs, you learn how each of these affects your ActionScript code.

White space

White space is a collective term referring to any blank areas between lines of code. It includes spaces inserted by the spacebar, indentations inserted with the Tab key, and line returns inserted with the Enter or Return key. When Flash CS3 compiles your ActionScript code into the Flash movie, the white space between your lines of code usually will not generate any errors. For example, the following code works exactly the same:

on(release){ getURL("mypage.html"); }

or

on(release){
   getURL("mypage.html");
}

or

on      (             release ){
getURL("mypage.html");
}

However, white space is an issue when it separates the key terms in the action, such as:

get URL("mypage.html");

The space between get and URL will cause an error when Flash CS3 tries to create the Flash movie.

Tip

To check if your syntax is correct, click the Check Syntax button in the Actions panel. If you do have any white space errors, the Output panel will display information related to the error. Also, if you code has errors, you are prevented from entering the Script Assist mode.

Deprecated and incompatible actions: What are they?

As the ActionScript language of Flash continues to expand and encompass new functionality, older actions coexist with newer and better actions (or methods, properties, event handlers, and functions, which we'll discuss later). Although Flash Player 9 will continue to support ActionScript 2.0 and earlier actions, it's better not to use older actions if the newest version of the Flash Player has a new way of accomplishing the same task. Older actions that have been replaced with a new action (or new way to perform the same task) are called deprecated actions. The Actions panel in Flash CS3 houses all deprecated actions in the Deprecated booklet of the Actions pane. Why shouldn't you use these actions? As you'll see in more advanced scripting, ActionScript 2.0 and 3.0 have specific syntax to target Movie Clips and determine whether certain frames have loaded, among other features of the ActionScript "dot syntax" language. The following figure shows the actions within the Deprecated

Although you should avoid actions that are highlighted in the Deprecated booklet if possible, Flash Player 9 continues to support them.

Flash CS3 also lets you know if certain actions are not supported with the Player version that is selected in the Flash format tab of the Publish Settings (File

Flash Player 4 (or earlier) and Flash Lite 1.0/1.1 will not support the onClipEvent or updateAfterEvent actions (among others), as these actions were introduced in Flash Player 5.

These "go to" actions change the current frame of the movie to the target frame specified as the action's parameter. There are two variations:

Both actions enable you to jump to certain areas of the Flash movie. The parameters of these actions start with the largest time unit, the scene, and end with the smallest one, the frame.

You can specify frames in other scenes as the target of goto actions with the scene parameter. As shown in the following code, you type the name of the scene first, with double quotes around the name, and then the frame number (without quotes) or frame label. In this example, "Scene 2" is the name of the scene and "animate_in" is the frame label in that scene to jump to.

gotoAndPlay("Scene 2", "animate_in");

However, if you only specify one parameter in a gotoAndPlay or gotoAndStop action, the parameter is interpreted as a frame label. For example, the following code tells the current timeline to jump to its "menu" frame label:

gotoAndStop("menu");

There are three methods of specifying the frame to which the movie should go when it receives a goto action. The methods for specifying the frame are

The nextFrame and prevFrame actions act like a gotoAndStop action, in that they both transport the timeline to a new position and stop.

These actions advance the Flash movie to a new scene. Here's how they work:

These simple actions are the true foundations of Flash timeline control. play sets a movie or a Movie Clip instance in motion. When a play action is executed, Flash starts the sequential display of each frame's contents along the current timeline.

The rate at which the frames are displayed is measured as frames per second, or fps. The fps rate can be set from 0.01 to 120 (meaning that the play action can cause the display of as little as 1 frame every 100 seconds to as many as 120 frames in 1 second, subject to the limitations of the computer's processing speed). The default fps is 12.

After play has started, frames continue to be displayed one after the other, until another action interrupts the flow, or the end of the movie or Movie Clip's timeline is reached. If the end of a movie's timeline is reached, the movie either loops (begins playing again at frame 1, Scene 1) or stops on the last frame.

After the end of the Movie Clip's timeline is reached, playback loops back to the beginning of the clip, and the clip continues playing. To prevent looping, add a stop action to the last frame of your Movie Clip.

stop, as you may have guessed, halts the progression of a movie or Movie Clip that is in a play state. stop is often used with buttons for user-controlled playback of a movie, or on frames to end an animated sequence.

A simple but powerful action that mutes any sounds playing in the movie at the time the action is executed, stopAllSounds does not disable sounds permanently — it simply cancels any sounds that happen to be currently playing. It is sometimes used as a quick-and-dirty method for making buttons that shut off background looping soundtracks. stopAllSounds is not appropriate for controlling whether individual (or specific) sounds are played or muted.

Want to link to a Web page from a Flash movie? No problem. That's what getURL is for. You can find the getURL action in the Global Functions

getURL has three parameters that are familiar to Web builders (the first one, url, is required for this action to work):

Here are some examples of how you can write a getURL action. The following code tells the browser to load the URL, www.wiley.com, into the current browser window:

getURL("http://www.wiley.com");

Alternatively, you can specify a unique target for the loaded URL. The following example loads an HTML document named menu.html into a frame named menu_frame:

getURL("menu.html", "menu_frame");

A more advanced usage of the getURL action sends variables from the Flash movie to a Web server's script, which is set up to receive the variables. The following code looks up the version of the Flash Player playing the movie and sends to a script that logs the information:

var playerVersion = getVersion();
getURL("http://www.mysite.com/scripts/log.cfm", "_self", "GET");

As we mention with the goto actions, you can also use expressions with getURL actions. Expressions can be used as parameters of any ActionScript action. The following example uses a string variable to specify the URL used by a getURL action:

var siteURL = "http://www.flashsupport.com";
getURL(siteURL);

You should start familiarizing yourself with the ActionScript notation that Flash uses for each action (see Table 18.2). As you use Flash for more advanced interactivity, you'll need to have a firm grasp of code notation. Part VII, "Approaching ActionScript," teaches you how to start building more advanced code.

Imagine that you have a short, endlessly looping movie in which a wire-frame cube rotates. Now imagine that you want to add a button to your movie that, when clicked, stops the cube from rotating by stopping the playback of the looping movie. Here's what you need to do:

To make any interactivity in your movies, you simply have to apply the basic principles you used to make the stop button: Decide which action (or actions) you want to happen, and indicate when you want that action to happen with an event handler. Let's look now at more event handlers you can use to make those actions happen.

Three primary event handlers exist in Flash: those that detect mouse activity on Button instances (button manipulation), those that recognize when a key is pressed on the keyboard (key presses), and those that respond to the progression of the timeline (keyframes).

on (release, releaseOutside){
   stop();
}

on (keyPress "<Enter>"){
   trace("The Enter key was pressed.");
}

on (release, keyPress "<Space>"){
   stop();
}