Learn AppleScript - The Comprehensive Guide to Scripting and Automation on Mac OS X

Title Page

Copyright Page

Contents at a Glance

Table of Contents

Foreword

About the Authors

About the Technical Reviewer

Acknowledgments

Introduction

If You Have Never Scripted Before…

If You Are Already an AppleScript User…

If You Are an Experienced Programmer…

Resources

Formatting Conventions Used in This Book

Errata

Part I Welcome to AppleScript

Chapter 1 Introducing AppleScript

Automating with AppleScript: From Small Tasks to Large

Automating Small Tasks

Automating Large Tasks

When to Automate (or Not)?

The Golden Triangle: Scriptable Applications, the AppleScript Language, and the Scripts You Write

What Is a Scriptable Application?

Introducing Objects

Introducing Commands

What Is the AppleScript Language?

What Is a Script?

Your First AppleScript: Hello World!

Summary

Chapter 2 AppleScript in Principle

The Four Key Concepts of Application Scripting

How Applications Represent Information As Objects

How Applications Manipulate Objects Using Commands

How Applications Organize Their Objects into Object Models

How Applications Describe Their Objects and Commands in Dictionaries

The Four Key Concepts of the AppleScript Language

How AppleScript Represents Information As Objects

How AppleScript Manipulates Objects Using Commands, Operators, and Variables

Using Commands

Using Operators

Using Variables

How AppleScript Makes Decisions on What to Do and When to Do It

How AppleScript Organizes Code Using Handlers and Script Objects

Tying It All Together: What Makes AppleScript Special

The English-like Syntax

Built-in Application Scripting Support

Attaching Scripts to Applications

The AppleScript Community

Summary

Chapter 3 AppleScript in Practice

The Project: Tidy Desktop

Planning the Script

Writing the Script

Creating the Folder Name

Getting Today’s Date As Text

Putting the Name Together

Interacting with the File System

Addressing the Finder

Creating the Archive Folder

Moving the Files

Final Thoughts

Improving Reliability

Adding Features

Documenting Your Code

Summary

Part II Understanding AppleScript

Chapter 4 Writing Scripts in AppleScript Editor

Working with Script Windows

Compiling a Script

Running and Stopping a Script

Recording a Script

Viewing the Result of Running a Script

Viewing the Events Sent by a Running Script

Adding a Description to a Script

Viewing Application Dictionaries

Other Useful AppleScript Editor Features

Using the Library Window

Navigating to a Handler in a Script

Viewing the Event Log History

Scripting the AppleScript Editor

Using Context Menu Scripts

Viewing the Bundle Contents Drawer

Setting the Script Formatting Preferences

Saving Scripts

Text-Based Scripts

Compiled Scripts

Saving Scripts As Run Only

Saving Scripts As Bundles

Script-Based Applications (Applets)

Droplets

Stay-Open Applets

Saving Applets As Run Only

Customizing the Startup Screen

Other Tools for Writing and Running AppleScripts

The System-wide Script Menu

Where Are the Menu Scripts Stored?

Adding Your Own Scripts

Third-Party AppleScript Editors

Smile

Script Debugger

Developing GUI Applications

Command-Line Tools

Summary

Chapter 5 Understanding How Application Scripting Works

A Quick Application Scripting Example

Understanding Objects

How Objects Are Categorized by Class

Introducing Object Properties

Introducing Object Elements

Understanding Commands

Introducing Command Names

Introducing Command Parameters

Commands Must Be Targeted at Objects

Commands Can Return Results or Report Errors

Understanding the Application Object Model

How Objects Can Contain Other Objects

How AppleScript Refers to Application Objects

Exploring a Typical Object Model

Understanding Application Dictionaries

Introducing AppleScript Editor’s Dictionary Viewer

How Classes Are Documented

Viewing the Properties and Elements Defined by a Class

How Inheritance Describes Features Shared Between Classes

Class Definitions Can Be Spread Across More than One Suite!

Browsing the Containment Hierarchy

How Commands Are Documented

Application Dictionaries Don’t Tell You Everything!

More on application Objects

Creating application Objects

Identifying Applications by Name

Identifying Applications by Path

Identifying Applications by Bundle ID

Identifying Applications by Remote URL

The Standard Properties of application Objects

How AppleScript Compiles tell application ... Blocks

More on Constructing References

Referring to Properties

Referring to Elements

Identifying All Elements

Identifying an Element by Its Index, or Position

Identifying an Element by Its Name

Identifying an Element by Its Unique ID

Identifying an Element Before or After Another Element

Identifying a Range of Elements

Identifying Elements Using the whose Clause

Referring to Insertion Locations

Summary

Chapter 6 Learning to Work with AppleScript Objects

How AppleScript Represents Information As Objects

What Kinds of Objects Does AppleScript Provide?

Creating New Objects

Getting Information from Objects

How AppleScript Works with Objects

Manipulating Objects with Commands

Introducing the Five Built-in Commands

Introducing Scripting Addition Commands

Introducing User-Defined Commands

Manipulating Objects with Operators

What Makes Operators Special?

What Kinds of Operators Does AppleScript Provide?

The Concatenation Operator

Math Operators

Comparison Operators

Containment Operators

Boolean Operators

The Coercion Operator

The a reference to Operator

Coercing Objects

Storing Objects in Variables

How Are Identifiers Written?

Where Can Variables Be Used?

Working with Boolean Objects

Boolean Operators

The not Operator

The and Operator

The or Operator

How Boolean Operators Are Evaluated

Boolean-Related Coercions

Summary

Chapter 7 Working with Text

Introducing Text

A Brief History of Text

When Is Text Not Text?

Understanding Character Sets

The Problem with Character Sets

Unicode to the Rescue!

Introducing Text in AppleScript 2.0

How to Write Literal Strings in AppleScript

The Properties of Text

The class Property

The length Property

The quoted form Property

The id Property

The Elements of Text

Characters

Words

Paragraphs

Text Ranges

Operators and Commands

Joining Strings

Comparing Strings

Checking for Strings Within Strings

Considering and Ignoring Attributes

The count Command

The offset Command

Coercing to and from Text

Working with Text Item Delimiters

Splitting Strings with Text Item Delimiters

Combining List Items into a Single String

Finding and Replacing Text

How AppleScript Text Works in Tiger

The Many Different Classes of Text

Working with the Various Text Classes

The ASCII number and ASCII character Commands

Example Projects

Defining a Find-and-Replace Command

Transferring Meeting Arrangements from Mail to iCal

Getting the Message from Mail

Parsing the Message Text

Creating the Event in iCal

Summary

Chapter 8 Working with Numbers

Introducing Integers and Reals

Operators and Commands

Math Operations

Adding, Subtracting, Multiplying, and Dividing Numbers

Negating Numbers

Calculating the Integral and Remainder

Using the Exponent Operator

Comparison Operations

Comparing Reals Can Be Trickier Than You Think

Performing Multiple Comparisons

Introducing Operator Precedence

The round Command

Rounding Up

Rounding Down

Rounding Toward Zero

Rounding to Nearest

Rounding As Taught in School

The random number Command

Random Number Result

Parameters

Coercing to and from Numbers

Example Projects

Defining a Round-to-Decimal-Places Command

Blackjack!

Kitchen Timer

Summary

Chapter 9 Working with Dates

Introducing Dates

Understanding Date and Time Formats

Forming Dates On-the-Fly

Specifying a Time Relative to a Date

The Properties of Dates

The class Property

The year Property

The month Property

The day Property

The weekday Property

The hours Property

The minutes Property

The seconds Property

The time Property

The date string Property

The short date string Property

The time string Property

Setting Date Properties

Operators and Commands

Comparison Operators

Math Operators

Some Useful Constants

Calculating Time Differences

The current date Command

The time to GMT Command

Example Projects

Deleting Old Files

Creating the Script

Adding the User Interaction Portion

Alarm Clock

Summary

Chapter 10 Working with Lists and Records

Introducing Lists and Records

What Is a List?

What Is a Record?

How Are Lists and Records Used in Scripts?

Working with Lists

The Properties of a List

The class Property

The length Property

The rest Property

The reverse Property

The Elements of a List

Getting Items

Setting Items

Adding Items

“Removing” Items

Operators and Commands

Concatenating Lists

Comparing Lists

Checking for Sublists

The starts with Operator

The ends with Operator

The contains Operator

The is in Operator

More Uses for Containment Operators

Counting Lists

Coercing to and from Lists

Processing List Items with a Repeat Loop

Sorting Items in a List

Working with Records

Getting and Setting the Properties of a Record

Operators and Commands

Concatenating Records

Comparing Records

Checking for Subrecords

Coercing from Records

Counting Records

Example Project: Measuring Word Frequency in TextEdit

Planning the Script

Developing the Script

Conclusion

Summary

Chapter 11 Storing Objects in Variables

Creating Variables

Declaring Your Variables

Choosing Your Variable Names

When Keywords and Identifiers Conflict

Tips for Avoiding Problems with Variable Names

Follow Good Naming Practices

Break All the Rules!

Working with Local Variables

Understanding Local Variable Scope

Passing Values to and from User-Defined Handlers

Working with Properties and Global Variables

Understanding Property and Global Variable Scope

How Properties (and Global Variables) Can Retain Values Between Runs

When to Use Properties and Global Variables

Managing User Preferences

Enabling Debugging Code

Clarifying the Meaning of Important Hard-Coded Values

Importing Script Libraries

Using AppleScript’s Built-in Variables

Variables Containing Predefined Values

The return, linefeed, space, tab, and quote Variables

The weeks, days, hours, and minutes Variables

The pi Variable

Variables Containing Objects of Special Interest

The it Variable

The me Variable

The result Variable

Summary

Chapter 12 More on Commands

Understanding How and Where Commands Are Defined

Application-Defined Commands

Scripting Addition Commands

AppleScript Commands

User-Defined Commands

Picking the Right Target for Your Commands

The Five Standard AppleScript Commands

The get Command

The set Command

The copy Command

The count Command

The run Command

Commands That All Applications Understand

The run Command

The launch Command

The open Command

The activate Command

The quit Command

The Standard Suite of Application Commands

The get Command

The set Command

The make Command

The exists Command

The count Command

The move Command

The duplicate Command

The delete Command

The print Command

The save Command

The close Command

More on Working with get, set, and copy Commands

When Do Implicit get Commands Occur?

When Are Explicit get Commands Necessary?

Telling the Difference Between AppleScript and Application set Commands

Getting and Setting Multiple Values in a Single Statement

Using copy As an Application Command

Changing How Commands Are Handled

Considering and Ignoring Application Responses

Considering and Ignoring Other Attributes

Controlling the Timeout Delay for Long-Running Commands

Sending Commands to Remote Applications

Enabling Remote Apple Events

Talking to Remote Machines

Authenticating Access to Remote Machines

Compiling Scripts Offline

Using the choose remote application Command

Targeting Remote Applications by User and Process IDs

Launching Remote Applications

Summary

Chapter 13 More on Operators and Coercions

Understanding the a reference to Operator

Introducing Unit Type Conversions

A Summary of AppleScript Coercions

Coercing Class and Constant Names

Coercing Numbers and Text

Coercing File Objects

Coercing Lists

A Summary of AppleScript Operators

Boolean Logic Operators

The Concatenation Operator

Math Operators

Comparison Operators

Containment Operators

The Coercion Operator

The a reference to Operator

Operator Precedence in Detail

Understanding Precedence

Understanding Forms of Association

Understanding when You Should Use Parentheses

Summary

Chapter 14 Making Decisions Using Conditionals and Loops

Choosing Your Course with Conditional Blocks

Understanding the Basic Conditional Statement

The Different Flavors of Conditional Statements

Offering an Alternative Ending with the else Clause

Offering Multiple Choices with else if Clauses

Tips for Writing Conditional Statements

Using a Condition in a Single Line

Avoiding Unneeded Conditional Statements

Is It True?

Testing a Value Against Multiple Options

Running an Assembly Line with Repeat Loops

The Different Flavors of Repeat Loops

Repeating Forever

Repeating n Times

Repeating with Numbers in a Range

Repeating with Items in a List

Repeating While/Until a Condition Is Met

Tips for Writing Repeat Statements

Using Loops to Avoid Repetition

Naming Loop Variables

Choosing the Right Loop for the Job

Avoid Looping when Possible

Summary

Chapter 15 Making Decisions When Dealing with Errors

Understanding Compilation Errors

Simple Typos

Unbalanced Statements

Unbalanced Parentheses and Unescaped Quotes

Unrecognized Keywords

Reserved Word Mishaps

Invalid Date Literals

Understanding Runtime Errors

How Runtime Errors Work in AppleScript

Understanding the Psychology of an Error

Understanding the Anatomy of an Error

Trapping Runtime Errors

Using the try Block

Using the Full try Statement

Knowing What to Do in Case of an Error

Putting Error Numbers to Use

Testing For Multiple Error Numbers

Nesting try Handlers

Generating Runtime Errors

Tips for Handling Runtime Errors

Being Careful Not to Trap Too Much

Providing More Detailed Error Messages

Using a Scriptwide try Statement

Logging Errors to a File

Understanding Common Error Numbers

Identifying Operating System Errors

Identifying Apple Event Errors

Identifying Application Scripting Errors

Identifying AppleScript Language Errors

Summary

Chapter 16 Interacting with the User

Creating Basic Dialog Boxes and Gathering Text Input

Introducing the display dialog Command

From the Dictionary: display dialog

From the Dictionary: dialog reply

Using the Basic Form of the Command

Dealing with the Erroneous Cancel Button

Creating Custom Buttons

Specifying a Default Button

Specifying a Cancel Button

Adding a Title

Showing Icons in Dialog Boxes

Using an Icon File in a Dialog Box

Getting Text Input from the User

Creating Password Dialog Boxes

Dismissing Dialogs Automatically

Validating User-Entered Text

Introducing the display alert Command

From the Dictionary: display alert

Using the Basic Form of the Command

Using the message Parameter

Using the as Parameter

Setting the Button Behavior

Introducing the choose from list Command

From the Dictionary: choose from list

Getting the Results of the Command

Using the Basic Command

Creating a Custom Prompt

Adding a Title

Setting the Default Selection

Restricting the Selection

Customizing Buttons

Choosing Files, Folders, and Disks

Introducing the choose file Command

From the Dictionary: choose file

Getting the Results of the Command

Figuring Out When to Use the Command

Using the Basic Command

Creating a Custom Prompt

Restricting to Specific File Types

Setting the Default Location

Picking Invisibles

Allowing Multiple Selections

Showing Package Contents

Introducing the choose file name Command

From the Dictionary: choose file name

choose file name vs. choose file

Figuring Out When to Use the Command

Getting the Results of the Command

Using the Basic Command

Creating a Custom Prompt

Setting a Default Name and Location

Replacing an Existing File

Seeing an Example in Action

Introducing the choose folder Command

From the Dictionary: choose folder

Using the Command

Figuring Out When to Use the Command

Setting the Parameters

Choosing a Folder Once

Choosing Other Types of Items

Introducing the choose application Command

From the Dictionary: choose application

Using the Command

Introducing the choose remote application Command

From the Dictionary: choose remote application

Using the Command

Introducing the choose URL Command

From the Dictionary: choose URL

Using the Command

Introducing the choose color Command

From the Dictionary: choose color

Getting the Results of the Command

Figuring Out When to Use the Command

Using the Basic Command and Using It with Parameters

Summary

Chapter 17 Working with Files

Identifying Files, Folders, and Disks

Using Path Strings

Let’s start with an example of an HFS path: Understanding HFS Paths

Understanding POSIX Paths

Using File System Objects

Understanding Alias Objects

How Aliases Work

Using Aliases to Keep Track of File System Items

Converting to and from Alias Objects

Understanding File “Objects”

How Files (Really) Work

Converting to and from File References

Understanding POSIX File Objects

How POSIX Files Work

Converting to and from POSIX File Objects

File URL Strings

Reading and Writing Files

Commands for Reading and Writing Files

Reading Files

From the Dictionary

Using the read Command

Opening and Closing Access to Files

From the Dictionary

Opening a File for Reading or Writing

The open for access Result

Read Command Parameters

Reading Different Kinds of Data

Using a Delimiter to Read Text into a List

Reading a Specific Number of Bytes

The from and to Parameters

The before and until Parameters

Using the open for access and read Commands Together

Working with the End-of-File (EOF) Commands

From the Dictionary

Getting a File’s EOF

Setting a File’s EOF

Writing Files

From the Dictionary

Using the write Command

How Much to Write and Where to Start

Useful File Writing Handlers

Using the write Command to Create a Script Log

Saving and Loading AppleScript Lists and Records

Dealing with Text File Encodings

About ASCII, MacRoman, and Unicode Character Sets

Reading and Writing Text Files in Different Encodings

Reading and Writing UTF-8 Encoded Files

Reading and Writing UTF-16 Encoded Files

Reading and Writing Files in Other Encodings

What Happens if the Wrong Encoding is Used?

A Summary of Common Text File Encodings

Further Reading on Text Encodings

Summary

Chapter 18 Organizing Your Code with Handlers

What Are User-Defined Handlers?

Creating a Simple Handler

Using Parameters

What’s the Result?

Using the return Statement

Working with Return Values

Can a Handler Return More Than One Result?

Specifying Handler Parameters

Using Positional Parameters

Definition for Positional Parameter Handlers

Defining and Calling Positional Parameter Handlers

Adding Parameters

Using Labeled Parameters

Definition for Positional Parameter Handlers

Using Predefined Parameter Labels

Making Up Your Own Labels

Calling Handlers with Boolean Parameters

Introducing Recursion

Using the run Handler in Scripts

I’ve Never Seen No run Handler!

When Should You Make the run Handler Explicit?

Working with Handlers in Applets

Using the Standard Event Handlers

The run Event Handler

The open Event Handler

The reopen Event Handler

The quit Event Handler

The idle Event Handler

Using User-Defined Handlers from Other Scripts

Tips for Designing and Using Handlers

Organizing Code

Reusing Code

Thinking Ahead

Thinking Small

Reorganizing Existing Code

Example Project: A Reusable Associative List

Designing the Associative List

Writing the Essential Handlers

Writing the Extra Handlers

Revising the Design

Conclusion

Summary

Chapter 19 Organizing Your Code with Script Objects

Introducing Script Objects

What Is a Script Library?

What Is Object-Oriented Programming?

Understanding Script Objects

Defining a Script Object in a Script

Loading and Storing Script Objects from Disk

How Variable Scope Works in Script Objects

Working with Script Libraries

What Advantages Do Script Libraries Provide?

Creating Your First Script Library

Where Should You Save Your Library?

What Are the Options for Loading Script Libraries?

Using the load script Command

Using AppleMods Loader

Beginning Object-Oriented Programming

Your First Object: A Better Associative List

Planning the Conversion

Converting the make_associative_list Handler

Repackaging the Remaining Handlers

Using the Object-Oriented Associative List

Extending Objects Through Inheritance

A Quick Reminder of General Inheritance Concepts

How Inheritance Works with Script Objects

Implementing Case-Insensitive and Case-Sensitive Associative Lists

Testing the New Associative List Objects

Creating Plug-and-Play Objects

Planning the Logging System

Designing the LogBase Object

Defining the Concrete Log Objects

Testing the Finished Logging System

Conclusion

Summary

Part III Putting AppleScript to Work

Chapter 20 Scripting the File System

How the Finder Represents the Mac OS X File System

Understanding Containers

Understanding Files

Understanding Packages

Understanding the computer-object Class

How System Events Represents the Mac OS X File System

Understanding Files

Understanding Folders

Understanding Disks

Understanding System Events’ alias Class

Other Classes of Interest

The user Class

The domain Class

The login item Class

Working with Finder Items

Opening and Closing Items

Duplicating Files and Folders

Deleting Files and Folders

Moving Files and Folders

Checking if Items Exist

Making New Items

Sorting Lists of Finder References

Ejecting Disks

Selecting Items in a Finder Window

Converting Finder References to AppleScript Aliases

More on Working with Folders

Filtering the Content of Folders

Getting the Entire Contents of a Folder

Locating Important Files and Folders with Standard Additions

Avoiding Hardcoded Paths to the Startup Disk and Home Folder

Getting the Path to the Currently Running Script

Getting Paths to Resources in an Application Bundle

Mounting Volumes

Summary

Chapter 21 Scripting Apple Applications

Scripting iTunes

Understanding the iTunes Object Model

Working with Sources

Working with Tracks and Playlists

Example Project: My Themed Playlist

Gathering the User Input

Preparing the Playlist

Adding the Tracks to the Playlist

Scripting Mail

Working with Mailboxes

Working with Messages

Creating Outgoing Messages

Working with Mail Rules

Example Project: Building a Monthly Message Archive

Preparing to Write the Script

Creating the Sub-Mailboxes

Putting It All Together

Scripting iCal

Working with Calendars

Working with Events

Scripting Address Book

Working with People

Working with Groups

Working with Rollovers

Example Project: Looking Up Contact Information by Name

Scripting Automator

Using the Run AppleScript Action

Understanding the Action’s Input and Output

Understanding the Action’s Parameters

Filtering Files with Run AppleScript

Scripting the Automator Application

Summary

Chapter 22 Extending AppleScript with Scripting Additions

Introducing Scripting Additions and Scriptable Faceless Background Applications

Scripting Additions in Detail

Scripting Additions and the AppleScript Language

Installing Scripting Additions

Missing Additions and Garbled Scripts

Distributing Scripting Additions with Your Scripts

Embedding Scripting Additions Within a Script Application

Using the Mac OS X Installer to Install Your Script and Scripting Additions

Understanding Scripting Addition Compatibility Issues

Caution: Mac OS 9 Scripting Additions Don’t Work on Mac OS X

Using PowerPC-Only Scripting Additions on Intel-Based Macs

Using 32-Bit-Only Scripting Additions on 64-Bit Macs

Working Around Scripting Addition Limitations

Understanding Scriptable Faceless Background Applications

Installing Scriptable FBAs

Distributing Scriptable FBAs with Your Scripts

Examples of AppleScript Extensions

Built-in Extensions

Third-Party Extensions

Using the Standard Additions Scripting Addition

Providing Audio Feedback

The beep Command

The say Command

Pausing Your Scripts

The delay Command

Getting and Setting the System Volume

The get volume settings Command

The set volume Command

Getting System Information

The system attribute Command

The system info Command

Working with URLs

The open location Command

Coercing URLs

Using the Image Events Faceless Background Application

Processing Text with the Satimage ScriptingAddition

Downloading and Installing the Satimage Scripting Addition

Performing Simple Find and Replace Tasks

Counting Occurrences of a Substring in a String

Finding and Replacing Substrings in a File

Searching and Replacing Across Many Files

Finding and Replacing Text with Regular Expressions

A Brief Background on Regular Expressions

Using Satimage Regular Expression Commands

Batch-Changing File Names

Summary

Chapter 23 AppleScript Amenities

Using the Services Menu

AppleScript Editor Services

Creating Your Own Services

Scheduling Scripts with iCal

Triggering Scripts with Folder Actions

Defining Event Handlers for Folder Actions

Where Are Folder Action Scripts Stored?

Managing Your Folder Actions

Using the Folder Actions Setup Utility

Using Scripts

Creating Your First Folder Action

Create Your Folder Action Script

Save Your Script

Create Your Hot Folder

Activate the Folder Actions Setup Utility

Attach the Folder Action Script to the Folder

Test Your Folder Action

Controlling Applications with GUI Scripting

Enabling GUI Scripting

The GUI Scripting Dictionary

GUI Scripting Object Structure

Basic GUI Scripting Examples

Using GUI Scripting Commands

The click Command

The keystroke Command

The key code Command

Example Project: Searching in Preview

Introducing PreFab UI Browser

Beginning the Script

Performing the Search

Getting Data from the Search Table

Understanding the Limitations of GUI Scripting

Working with the Clipboard

Getting Clipboard Data into AppleScript

Understanding How the Mac Clipboard Works

Finding Out What’s on the Clipboard

Getting Specific Types of Data from the Clipboard

Setting the Clipboard Data

Using the cut, copy, and paste Commands in Applications

Using the set the clipboard to Command

Using GUI Scripting

Example Project: Creating PDF Cuttings from Selections in Preview

Summary

Chapter 24 Scripting iWork and Office

Scripting iWork

Scripting Pages

Creating a New Document

Working with a Document’s Paragraphs

Adding Headers and Footers to a Document

Drawing Shapes in Pages

Adding Tables and Charts

Tips for Scripting Pages

Scripting Keynote

Creating a Slideshow

Choosing a Theme

Filling Slides with Content

Working with Transitions

Scripting an Advanced Screen Reader

Scripting Numbers

Creating Sheets and Tables

Working with Cells

Scripting Microsoft Office

Working with Microsoft Entourage

Disable the Security Warning

Creating Messages

Some Shortcuts

Working with Contacts

Creating Contacts

Selecting and Changing Multiple Contacts

Setting Categories

Creating Calendar Events

Extracting Information from a Whole Lot of Messages in a Folder

Working with Excel

Creating Workbooks and Worksheets

Working with Ranges

Creating Charts

Working with Word

Creating a Word Document

Working with Selected Text

Where Next?

Summary

Chapter 25 Scripting Data and Databases

Automating FileMaker Pro with AppleScript

The FileMaker Object Model and the Commands You Can Use

The database Class

The window Class

The table Class

The layout Class

The record, field, and cell Classes

Finding Data Quickly with the whose Clause

Using the whose Clause to Retrieve Relational Data

Using the find Command

Running AppleScripts from Inside FileMaker Pro

Scripting Runtime Labs’ MacSQL

Getting Connected

Using a Simple select Command

More on Result Sets

Some Useful Handlers

Database Events

Database Events Classes and Commands

Database Events Examples

Summary

Chapter 26 Scripting Adobe InDesign

Learning by Example

Understanding the InDesign Object Model

How InDesign Organizes Its Many Properties

How InDesign Manages Units of Measurement

How to Set Properties Safely when Making New Objects

Working with Documents

Working with Document Layers

Understanding InDesign References

Working with Text

Working with Text Stories

Working with References to Text

Working with Graphics

Drawing Lines

Example Project: An InDesign Scripts Launcher

Working with Tables

Importing Table Text from a Spreadsheet

Copying Formatting Between Cells

Working with Selections

Example Project: Captioning a Selected Graphic

Example Project: Cleaning Up Selected Text

Labeling Objects for Use in Workflow Scripts

Taking Advantage of AppleScript-Specific Preferences

Example Project: Replacing Tags with Images

Preparing InDesign

Processing the Tags

Preparing the Image Files

Placing the Graphics

Testing the Script

Using InDesign on a Server

Summary

Chapter 27 Interacting with the Unix Command Line

Why and When Are Shell Scripts Used in AppleScript?

Understanding Unix Scripting Concepts

The Unix Command Line and Mac Desktop Compared

How the Unix Command Line Works

The Shell

Commands

Pipes

Other Redirections

Getting Help

Built-in Help

Other Sources of Help

Things to Watch Out For

Data in Unix Is “Dumb”

Unix Doesn’t Know About Different Character Sets

Unix Understands POSIX File Paths Only

Watch Where You Use Spaces and Other Special Characters!

Unix Assumes You Know What You’re Doing

Some Useful Unix Commands

Running Shell Scripts from AppleScript

Scripting the Terminal Application

Understanding Terminal’s Object Model

Using the do script Command

A Simple do script Example

Limitations of the do script Command

Using the do shell script Command

From the Dictionary

Understanding the do shell script Command’s Parameters

The Direct Parameter

The as Parameter

The administrator privileges Parameter

The user name and password Parameters

The altering line endings Parameter

How do shell script Deals with Unicode

A Simple do shell script Example

Limitations of the do shell script Command

No User Interaction

Performance Overheads

Can’t Directly Supply Data to Standard Input

Assembling Shell Script Strings

Unix File Paths

Quoting Arguments

Absolute Paths, Relative Paths, and the Working Directory

Passing Data to Standard Input

Using echo

Using Temporary Files

Creating the Temporary File

Writing the Temporary File

Redirecting the Shell Script

Running AppleScript from Shell Scripts

Using the osascript Command

Passing Parameters to the Script

Other Related Commands

Example Projects

Simple Text Processing Handlers

Encoding URLs

Changing Case

Changing File System Permissions

Analyzing PDF Files

Summary

Chapter 28 Using Smile: The AppleScript Integrated Production Environment

Introducing Smile

Introducing Smile’s Integrated Engine Architecture

About Smile’s Terminal

Why Should You Use Smile?

Downloading Smile

Using Smile

Using the AppleScript Command-Line Environment

Using Smile’s Custom Dialog Boxes

Creating the Interface

Programming the Functionality

Using Regular Expressions

Using the Graphic Engine

Using SmileLab

Example Project: Adding Text to a PDF Document

Preparing the PDF

Rolling Up the Scripts into a Graphical Interface

Building the Interface

Programming the Dialog Box

Handling User Clicks

Further Exercises

Summary

Chapter 29 Tips and Techniques for Improving Your Scripts

Design, in a Nutshell

Taking Your Scripting Skills to the Next Level

How Much Design Do Your Scripts Need?

Starting Out Is Hard (But Gets Easier with Practice)

How the Design-Driven Approach Changes the Way You Think About Code

Testing and Debugging Your Code

General Testing Tips and Techniques

Design Your Scripts for Easy Testing

Test Your Code with Bad Data As Well As Good

Test Your Code As You Go

Why Testing Matters

Debugging in AppleScript Editor

Viewing Intermediate Results with return and error Statements

Monitoring a Script’s Progress Using Dialog Boxes

Using the Event Log

Debugging in Script Debugger

Using the start log and stop log Commands

Using the Script Window

Using the Debugging Mode

Stepping Through Scripts

Keeping Track of Changes

Comparing Scripts with FileMerge

Managing Your Code with Source Control

Improving the Performance of Your Code

The Dos and Don’ts of Optimization

When Should You Optimize?

Where Should You Optimize?

Profiling Your Code with Timing Commands

Common AppleScript Optimizations

Building Up Large Lists

Building Up Large Strings

Manipulating Multiple Application Objects with a Single Command

Filtering Multiple Application Objects with whose Clause References

Advanced Optimization Techniques

Assessing Your Code’s Efficiency with Big O Notation

Improving the Efficiency of AppleScript Lists

Linear Search vs. Binary Search

Bubble Sort vs. Quicksort

Summary

Chapter 30 Creating Cocoa Applications with AppleScriptObjC

Example Project: HelloAppleScriptObjC

Creating the Project in Xcode

Adding the AppleScript Code in Xcode

Constructing the Interface in Interface Builder

Understanding Interface Builder’s Interface

The MainMenu Window

The Application Window

The MainMenu.xib – English Window

The Library Palette

Adding the GUI Objects

Making Connections

Building and Testing the Application

Understanding How Cocoa Works

Understanding Outlets

Understanding Targets and Actions

How AppleScript Interacts with Cocoa Objects

Modifying HelloAppleScriptObjC to Set the Text Field

Updating the Code and Testing the Changes

What Is All That Code in the Default AppleScript File?

Example Project: PlaySound

Creating the Project and Adding the Code

Constructing the Interface

Building and Testing the Application

Understanding How It Works

Viewing the Cocoa Documentation in Xcode

How Cocoa Classes Are Documented

How Cocoa Methods Are Documented

The Method Name

Parameters

Return Value

Discussion, Availability, See Also, Related Sample Code, and Declared In

Example Project: SnapShot

Creating the Project and Starting the Code

Constructing the Interface

Completing the Code

Understanding How It Works

Preparing the Text Fields Using an awakeFromNib Handler

Building and Testing the Application

Modifying SnapShot to Use Cocoa Bindings

Adjusting the Code for Bindings

Setting Up Bindings in Interface Builder

Building and Testing the Application

Modifying PlaySound to Use Bundled Sound Files

Adding the Sound File Resources to the Project

Adding the Code

Adding the Pop-Up Button

Building and Testing the Application

Understanding How It Works

Example Project: KitchenTimer

Creating the Project and Starting the Code

Constructing the Interface

Completing the Code

Extra Exercises

Where Next?

Summary

Conclusion

Index