Essential ActionScript 3.0 (Paperback)

Description

ActionScript 3.0 is a huge upgrade to Flash's programming language. The enhancements to ActionScript's performance, feature set, ease of use, cleanliness, and sophistication are considerable. Essential ActionScript 3.0 focuses on the core language and object-oriented programming, along with the Flash Player API. Essential ActionScript has become the #1 resource for the Flash and ActionScript development community, and the reason is the author, Colin Moock. Many people even refer to it simply as "The Colin Moock book."

And for good reason: No one is better at turning ActionScript inside out, learning its nuances and capabilities, and then explaining everything in such an accessible way. Colin Moock is not just a talented programmer and technologist; he's also a gifted teacher.

Essential ActionScript 3.0 is a radically overhauled update to Essential ActionScript 2.0. True to its roots, the book once again focuses on the core language and object-oriented programming, but also adds a deep look at the centerpiece of Flash Player's new API: display programming. Enjoy hundreds of brand new pages covering exciting new language features, such as the DOM-based event architecture, E4X, and namespaces--all brimming with real-world sample code.

The ActionScript 3.0 revolution is here, and Essential ActionScript 3.0's steady hand is waiting to guide you through it.

Adobe Developer Library is a co-publishing partnership between O'Reilly Media and Adobe Systems, Inc. and is designed to produce the number one information resources for developers who use Adobe technologies. Created in 2006, the Adobe Developer Library is the official source for comprehensive learning solutions to help developers create expressive and interactive web applications that can reach virtually anyone on any platform. With top-notch books and innovative online resources covering the latest in rich Internet application development, the Adobe Developer Library offers expert training and in-depth resources, straight from the source.

Table of Contents

Foreword

Preface

Part I. ActionScript from the Ground Up

1. Core Concepts

     Tools for Writing ActionScript Code

     Flash Client Runtime Environments

     Compilation

     Quick Review

     Classes and Objects

     Creating a Program

     Packages

     Defining a Class

     Virtual Zoo Review

     Constructor Methods

     Creating Objects

     Variables and Values

     Constructor Parameters and Arguments
     Expressions

     Assigning One Variable's Value to Another

     An Instance Variable for Our Pet

     Instance Methods

     Members and Properties

     Virtual Zoo Review

     Break Time!

2. Conditionals and Loops

     Conditionals

     Loops

     Boolean Logic

     Back to Classes and Objects

3. Instance Methods Revisited

     Omitting the this Keyword

     Bound Methods

     Using Methods to Examine and Modify an Object's State

     Get and Set Methods

     Handling an Unknown Number of Parameters

     Up Next: Class-Level Information and Behavior

4. Static Variables and Static Methods

     Static Variables

     Constants

     Static Methods

     Class Objects

     C++ and Java Terminology Comparison

     On to Functions

5. Functions

     Package-Level Functions

     Nested Functions

     Source-File-Level Functions

     Accessing Definitions from Within a Function

     Functions as Values

     Function Literal Syntax

     Recursive Functions

     Using Functions in the Virtual Zoo Program

     Back to Classes

6. Inheritance

     A Primer on Inheritance

     Overriding Instance Methods

     Constructor Methods in Subclasses

     Preventing Classes from Being Extended and Methods from Being Overridden

     Subclassing Built-in Classes

     The Theory of Inheritance

     Abstract Not Supported

     Using Inheritance in the Virtual Zoo Program

     Virtual Zoo Program Code

     It's Runtime!

7. Compiling and Running a Program

     Compiling with the Flash Authoring Tool

     Compiling with Flex Builder 2

     Compiling with mxmlc

     Compiler Restrictions

     The Compilation Process and the Classpath

     Strict-Mode Versus Standard-Mode Compilation

     The Fun's Not Over

8. Datatypes and Type Checking

     Datatypes and Type Annotations

     Untyped Variables, Parameters, Return Values, and Expressions

     Strict Mode's Three Special Cases

     Warnings for Missing Type Annotations

     Detecting Reference Errors at Compile Time

     Casting

     Conversion to Primitive Types

     Default Variable Values

     null and undefined

     Datatypes in the Virtual Zoo

     More Datatype Study Coming Up

9. Interfaces

     The Case for Interfaces

     Interfaces and Multidatatype Classes

     Interface Syntax and Use

     Another Multiple-Type Example

     More Essentials Coming

10. Statements and Operators

     Statements

     Operators

     Up Next: Managing Lists of Information

11. Arrays

     What Is an Array?

     The Anatomy of an Array

     Creating Arrays

     Referencing Array Elements

     Determining the Size of an Array

     Adding Elements to an Array

     Removing Elements from an Array

     Checking the Contents of an Array with the toString(  ) Method

     Multidimensional Arrays

     On to Events

12. Events and Event Handling

     ActionScript Event Basics

     Accessing the Target Object

     Accessing the Object That Registered the Listener

     Preventing Default Event Behavior

     Event Listener Priority

     Event Listeners and Memory Management

     Custom Events

     Type Weakness in ActionScript's Event Architecture

     Handling Events Across Security Boundaries

     What's Next?

13. Exceptions and Error Handling

     The Exception-Handling Cycle

     Handling Multiple Types of Exceptions

     Exception Bubbling

     The finally Block

     Nested Exceptions

     Control-Flow Changes in try/catch/finally

     Handling a Built-in Exception

     More Gritty Work Ahead

14. Garbage Collection

     Eligibility for Garbage Collection

     Incremental Mark and Sweep

     Disposing of Objects Intentionally

     Deactivating Objects

     Garbage Collection Demonstration

     On to ActionScript Backcountry

15. Dynamic ActionScript

     Dynamic Instance Variables

     Dynamically Adding New Behavior to an Instance

     Dynamic References to Variables and Methods

     Using Dynamic Instance Variables to Create Lookup Tables

     Using Functions to Create Objects

     Using Prototype Objects to Augment Classes

     The Prototype Chain

     Onward!

16. Scope

     Global Scope

     Class Scope

     Static Method Scope

     Instance Method Scope

     Function Scope

     Scope Summary

     The Internal Details

     Expanding the Scope Chain via the with Statement

     On to Namespaces

17. Namespaces

     Namespace Vocabulary

     ActionScript Namespaces

     Creating Namespaces

     Using a Namespace to Qualify Variable and Method Definitions

     Qualified Identifiers

     A Functional Namespace Example

     Namespace Accessibility

     Qualified-Identifier Visibility

     Comparing Qualified Identifiers

     Assigning and Passing Namespace Values

     Open Namespaces and the use namespace Directive

     Namespaces for Access-Control Modifiers

     Applied Namespace Examples

     Final Core Topics

18. XML and E4X

     Understanding XML Data as a Hierarchy

     Representing XML Data in E4X

     Creating XML Data with E4X

     Accessing XML Data

     Processing XML with for-each-in and for-in

     Accessing Descendants

     Filtering XML Data

     Traversing XML Trees

     Changing or Creating New XML Content

     Loading XML Data

     Working with XML Namespaces

     Converting XML and XMLList to a String

     Determining Equality in E4X

     More to Learn

19. Flash Player Security Restrictions

     What's Not in This Chapter

     The Local Realm, the Remote Realm, and Remote Regions

     Security-Sandbox-Types

     Security Generalizations Considered Harmful

     Restrictions on Loading Content, Accessing Content as Data, Cross-Scripting, and Loading Data

     Socket Security

     Example Security Scenarios

     Choosing a Local Security-Sandbox-Type

     Distributor Permissions (Policy Files)

     Creator Permissions (allowDomain(  ))

     Import Loading

     Handling Security Violations

     Security Domains

     Two Common Security-Related Development Issues

     On to Part II!

Part II. Display and Interactivity

20. The Display API and the Display List

     Display API Overview

     The Display List

     Containment Events

     Custom Graphical Classes

     Go with the Event Flow

21. Events and Display Hierarchies

     Hierarchical Event Dispatch

     Event Dispatch Phases

     Event Listeners and the Event Flow

     Using the Event Flow to Centralize Code

     Determining the Current Event Phase

     Distinguishing Events Targeted at an Object from Events Targeted at That Object's Descendants

     Stopping an Event Dispatch

     Event Priority and the Event Flow

     Display-Hierarchy Mutation and the Event Flow

     Custom Events and the Event Flow

     On to Input Events

22. Interactivity

     Mouse-Input Events

     Focus Events

     Keyboard-Input Events

     Text-Input Events

     Flash Player-Level Input Events

     From the Program to the Screen

23. Screen Updates

     Scheduled Screen Updates

     Post-Event Screen Updates

     Redraw Region

     Optimization with the Event.RENDER Event

     Let's Make It Move!

24. Programmatic Animation

     No Loops

     Animating with the ENTER_FRAME Event

     Animating with the TimerEvent.TIMER Event

     Choosing Between Timer and Event.ENTER_FRAME

     A Generalized Animator

     Velocity-Based Animation

     Moving On to Strokes 'n' Fills

25. Drawing with Vectors

     Graphics Class Overview

     Drawing Lines

     Drawing Curves

     Drawing Shapes

     Removing Vector Content

     Example: An Object-Oriented Shape Library

     From Lines to Pixels

26. Bitmap Programming

     The BitmapData and Bitmap Classes

     Pixel Color Values

     Creating a New Bitmap Image

     Loading an External Bitmap Image

     Examining a Bitmap

     Modifying a Bitmap

     Copying Graphics to a BitmapData Object

     Applying Filters and Effects

     Freeing Memory Used by Bitmaps

     Words, Words, Words

27. Text Display and Input

     Creating and Displaying Text

     Modifying a Text Field's Content

     Formatting Text Fields

     Fonts and Text Rendering

     Missing Fonts and Glyphs

     Determining Font Availability

     Determining Glyph Availability

     Embedded-Text Rendering

     Text Field Input

     Text Fields and the Flash Authoring Tool

     Loading . . . Please Wait . . . 

28. Loading External Display Assets

     Using Loader to Load Display Assets at Runtime

     Compile-Time Type-Checking for Runtime-Loaded Assets

     Accessing Assets in Multiframe .swf Files

     Instantiating a Runtime-Loaded Asset

     Using Socket to Load Display Assets at Runtime

     Removing Runtime Loaded .swf Assets

     Embedding Display Assets at CompileTime

     On to Part III

Part III. Applied ActionScript Topics

29. ActionScript and the Flash Authoring Tool

     The Flash Document

     Timelines and Frames

     Timeline Scripting

     The Document Class

     Symbols and Instances

     Linked Classes for Movie Clip Symbols

     Accessing Manually Created Symbol Instances

     Accessing Manually Created Text

     Programmatic Timeline Control

     Instantiating Flash Authoring Symbols via ActionScript

     Instance Names for Programmatically Created Display Objects

     Linking Multiple Symbols to a Single Superclass

     The Composition-Based Alternative to Linked Classes

     Preloading Classes

     Up Next: Using the Flex Framework

30. A Minimal MXML Application

     The General Approach

     A Real UI Component Example

     Sharing with Your Friends

31. Distributing a Class Library

     Sharing Class Source Files

     Distributing a Class Library as a .swc File

     Distributing a Class Library as a .swf File

Appendix 

Index