If you've ever found yourself repeating some task more than once, you're an ideal candidate for becoming an AppleScript techno-wizard. AppleScript is particularly good at taking the boredom and tedium out of using your laptop by performing all sorts of tasks automatically. To illustrate, consider a few jobs that would take a fair amount of time to do by hand but are a snap with AppleScript:

By using AppleScript, you can also often automate your work from beginning to end, despite the fact that you need multiple applications to do so. Look at a few scenarios, and you'll begin to appreciate why AppleScript is such a powerful technology:

As you can imagine, there are literally thousands of ways that you can use AppleScript to automate your workflow. (Whoops, I just used a BST, or Business Software Term. A workflow is a single document or project that one or more people work on using multiple applications. In other words, your document can be automatically manipulated in multiple applications using the same script.)

Each script that you encounter will be in one of these three formats:

Two of the three possible script types (compiled scripts and text files) require some sort of host application before they'll perform any action. Luckily, Snow Leopard provides you with just such a host: the AppleScript Editor application, which comes with Mac OS X and can execute any AppleScript with ease. With the AppleScript Editor, you can also do much more, including

To launch the AppleScript Editor application, navigate to the Utilities folder (open your Applications folder and then open the Utilities folder) and double-click the AppleScript Editor icon. The AppleScript Editor application displays an empty, script-editing window, as shown in Figure 2-2.

After you have the AppleScript Editor application running, you can run any AppleScript that you can find. To get you started, Apple has conveniently provided a handful of useful scripts. Navigate to the Scripts folder, which is located in the Library folder.

Figure 2.2. The AppleScript Editor slices and dices . . . and even checks syntax. Order now!

Double-click the script to open it. Because it's a compiled script and not an application script, the AppleScript Editor automatically loads the script and comes to the foreground (see Figure 2-3). This particular script opens the Font Book application and checks for empty font collections. If any are found, the script displays a prompt asking for confirmation and then deletes the empty collection if you click the OK button. To see the script in action, click the Run button or press

Figure 2.3. Click the Run button in the Editor toolbar to execute the script you've loaded.

You needn't wear a pocket protector or tape the bridge of your glasses to become proficient with AppleScript. In fact, the AppleScript Editor can get you up and running with AppleScript in no time at all. The secret weapon of the AppleScript author is the Record function of the AppleScript Editor. You click the Record button, perform one or more actions in a recordable application, and then return to the AppleScript Editor, where you click the Stop button. The AppleScript Editor stores each of your actions and compiles the whole list into an AppleScript.

To try it yourself, take the following steps to automate actions in the Finder:

When you're finished, you should be looking at a complete AppleScript. To test your work, return to the Finder and return any icons or windows that you might have moved or repositioned to their original locations. (You don't want to run a script that doesn't appear to have any effect.) Then return to the AppleScript Editor and click the Run button to watch your automated Finder tasks being performed.

An AppleScript novice can perform all kinds of amazing feats with the recording features of the AppleScript Editor. Because AppleScript uses a kind of pseudo-English language, it's usually pretty easy to figure out what's going on behind the scenes. Consider the following script for an example:

tell app "Finder"
   activate
   set windowList to every window -- save list of open windows
   repeat with theWindow in windowList
      tell theWindow
         if collapsed is true then
         -- do nothing, because the window is collapsed
         else
            set collapsed to true
         end if
      end tell
   end repeat
end tell

(By the way, in the preceding code, I bolded and italicized the commands you'll be working with, but they don't have to be bolded for the script to work.) Anyway, the first thing that you might notice about this script is the first line: the tell command, which indicates that this script relates to the Finder. This script activates the Finder, creates a list of open windows, and then examines the state of each window: Is it collapsed or not collapsed? (In Snow Leopard, a collapsed, or minimized, window appears in the Dock.)

One of two possible results occurs:

This continues until the script has examined all open windows. The end result? All open windows end up minimized in the Dock.

Another thing to note about this script is that it has two comments in it (save list and do nothing). Comments can help you remember what you were thinking months later when you open the script again. Although comments help us humans know what's happening, they don't really have any other function. An AppleScript comment begins with two dashes (-).

Here's a big-time Mark's Maxim that every script author should remember:

Perhaps the greatest resource for AppleScript novices and experts alike is the AppleScript Dictionary. Although many applications are scriptable, not all are. To be scriptable, an application must contain an AppleScript Dictionary. An AppleScript Dictionary details the various commands and objects of an application that you can access via AppleScript.

The AppleScript Editor application allows you to peer inside an application and view its AppleScript Dictionary. To open an application's Dictionary, choose File

After you select an application and click Choose, the AppleScript Editor displays that application's AppleScript Dictionary. An application's dictionary lists all the features of that application that are scriptable.

Scriptable features are divided into categories, called Suites, which you can see on the left side of the AppleScript Dictionary. Every Mac application is supposed to support the Standard Suite, which lists common terms that most applications should support.

Figure 2.4. Viewing the AppleScript Dictionary within the AppleScript Editor.

Click an item in the Suite on the left side of the Dictionary to view detailed information about its capabilities, as shown in Figure 2-5.

Figure 2.5. Click an item in a Suite to view details about its capabilities and syntax.

By surveying the various Suites of an application, you begin to see what tasks you can automate. The Finder, with its huge AppleScript Dictionary, is perhaps the most scriptable of all applications (followed closely by mammoths like FileMaker Pro).

Although a full discussion of AppleScript programming is beyond the scope of this book — after all, we have other things to talk about, too — that doesn't mean that you can't produce some quick and useful scripts. Most AppleScripts begin with a command that addresses the application that you want to automate. Enter this command into a new AppleScript document, which you create by pressing

tell application "Finder"

This is like saying, "Hey, Finder, listen up! I'm going to send commands your way!" The double quotation marks surround the application name that you're addressing in the command.

Similarly, after you finish instructing the Finder what tasks you want performed, you must also tell it to stop listening. As such, typical scripts end with

end tell

With the shell of a script in place, all you have to do is add commands between the tell and end tell commands of the script. If you want your script to force an application to the foreground, an activate command is usually the first line within the shell of your script.

tell application "Finder"
  activate
end tell

Believe it or not, this is technically a complete and valid script! It doesn't do much, though, so add some more functionality to make it accomplish something worthwhile. For example, suppose you want to perform some housekeeping chores each time you log in to your MacBook. Some desirable tasks might include

(Okay, I'll grant that hearing your MacBook say "Hello!" isn't a housekeeping chore, but it makes the whole script that much more fun — and really impresses your visitors, too. No one ever said programming had to be boring!)

To add these functions, you can do so by using a language you already know: English. As I mention earlier, Apple tries (and sometimes succeeds) to make AppleScript as English-like as possible. That way, you don't have to know some silly computer language; just use your native tongue. For example, to empty the Trash, tell the Finder to do so.

empty trash

The trickiest line of code might be the speech, and that's only because you need to remember to add quotation marks. AppleScript thinks that anything without quotation marks is an AppleScript command.

say "Hello!"

The result is a super-simple script that anyone can read but that performs two powerful functions. The completed script looks like this:

tell app "Finder"
  activate
  empty trash
  say "Hello!"
end tell

After you complete the script, choose File

The most readily available AppleScript reference is built into Mac OS X. From within Automator, choose Help

In addition to the built-in AppleScript help in the Finder, the Internet has much to offer in the way of AppleScript training and examples. As are so many other excellent Web resources, AppleScripts are free!

Not all AppleScripts are created equal: When downloading scripts from the Internet, make sure that they're compatible with Snow Leopard (Mac OS X v. 10.6).

www.apple.com/applescript

automatorworld.com