Essential Actionscript 3. 0

Table of Contents

Foreword; Preface; Beginners Welcome; Expert Guidance; What's In This Book; What's Not In This Book; Authoring Tool Agnosticism; ActionScript Overview; This Book's Example Files; Using Code Examples; Typographical Conventions; How to Contact Us; Acknowledgments; Part I: ActionScript from the Ground Up; Chapter 1: Core Concepts; 1.1 Tools for Writing ActionScript Code; 1.2 Flash Client Runtime Environments; 1.3 Compilation; 1.4 Quick Review; 1.5 Classes and Objects; 1.6 Creating a Program; 1.7 Packages; 1.8 Defining a Class; 1.9 Virtual Zoo Review; 1.10 Constructor Methods; 1.11 Creating Objects; 1.12 Variables and Values; 1.13 Constructor Parameters and Arguments; 1.14 Expressions; 1.15 Assigning One Variable's Value to Another; 1.16 An Instance Variable for Our Pet; 1.17 Instance Methods; 1.18 Members and Properties; 1.19 Virtual Zoo Review; 1.20 Break Time!; Chapter 2: Conditionals and Loops; 2.1 Conditionals; 2.2 Loops; 2.3 Boolean Logic; 2.4 Back to Classes and Objects; Chapter 3: Instance Methods Revisited; 3.1 Omitting the this Keyword; 3.2 Bound Methods; 3.3 Using Methods to Examine and Modify an Object's State; 3.4 Get and Set Methods; 3.5 Handling an Unknown Number of Parameters; 3.6 Up Next: Class-Level Information and Behavior; Chapter 4: Static Variables and Static Methods; 4.1 Static Variables; 4.2 Constants; 4.3 Static Methods; 4.4 Class Objects; 4.5 C++ and Java Terminology Comparison; 4.6 On to Functions; Chapter 5: Functions; 5.1 Package-Level Functions; 5.2 Nested Functions; 5.3 Source-File-Level Functions; 5.4 Accessing Definitions from Within a Function; 5.5 Functions as Values; 5.6 Function Literal Syntax; 5.7 Recursive Functions; 5.8 Using Functions in the Virtual Zoo Program; 5.9 Back to Classes; Chapter 6: Inheritance; 6.1 A Primer on Inheritance; 6.2 Overriding Instance Methods; 6.3 Constructor Methods in Subclasses; 6.4 Preventing Classes from Being Extended and Methods from Being Overridden; 6.5 Subclassing Built-in Classes; 6.6 The Theory of Inheritance; 6.7 Abstract Not Supported; 6.8 Using Inheritance in the Virtual Zoo Program; 6.9 Virtual Zoo Program Code; 6.10 It's Runtime!; Chapter 7: Compiling and Running a Program; 7.1 Compiling with the Flash Authoring Tool; 7.2 Compiling with Flex Builder 2; 7.3 Compiling with mxmlc; 7.4 Compiler Restrictions; 7.5 The Compilation Process and the Classpath; 7.6 Strict-Mode Versus Standard-Mode Compilation; 7.7 The Fun's Not Over; Chapter 8: Datatypes and Type Checking; 8.1 Datatypes and Type Annotations; 8.2 Untyped Variables, Parameters, Return Values, and Expressions; 8.3 Strict Mode's Three Special Cases; 8.4 Warnings for Missing Type Annotations; 8.5 Detecting Reference Errors at Compile Time; 8.6 Casting; 8.7 Conversion to Primitive Types; 8.8 Default Variable Values; 8.9 null and undefined; 8.10 Datatypes in the Virtual Zoo; 8.11 More Datatype Study Coming Up; Chapter 9: Interfaces; 9.1 The Case for Interfaces; 9.2 Interfaces and Multidatatype Classes; 9.3 Interface Syntax and Use; 9.4 Another Multiple-Type Example; 9.5 More Essentials Coming; Chapter 10: Statements and Operators; 10.1 Statements; 10.2 Operators; 10.3 Up Next: Managing Lists of Information; Chapter 11: Arrays; 11.1 What Is an Array?; 11.2 The Anatomy of an Array; 11.3 Creating Arrays; 11.4 Referencing Array Elements; 11.5 Determining the Size of an Array; 11.6 Adding Elements to an Array; 11.7 Removing Elements from an Array; 11.8 Checking the Contents of an Array with the toString( ) Method; 11.9 Multidimensional Arrays; 11.10 On to Events; Chapter 12: Events and Event Handling; 12.1 ActionScript Event Basics; 12.2 Accessing the Target Object; 12.3 Accessing the Object That Registered the Listener; 12.4 Preventing Default Event Behavior; 12.5 Event Listener Priority; 12.6 Event Listeners and Memory Management; 12.7 Custom Events; 12.8 Type Weakness in ActionScript's Event Architecture; 12.9 Handling Events Across Security Boundaries; 12.10 What's Next?; Chapter 13: Exceptions and Error Handling; 13.1 The Exception-Handling Cycle; 13.2 Handling Multiple Types of Exceptions; 13.3 Exception Bubbling; 13.4 The finally Block; 13.5 Nested Exceptions; 13.6 Control-Flow Changes in try/catch/finally; 13.7 Handling a Built-in Exception; 13.8 More Gritty Work Ahead; Chapter 14: Garbage Collection; 14.1 Eligibility for Garbage Collection; 14.2 Incremental Mark and Sweep; 14.3 Disposing of Objects Intentionally; 14.4 Deactivating Objects; 14.5 Garbage Collection Demonstration; 14.6 On to ActionScript Backcountry; Chapter 15: Dynamic ActionScript; 15.1 Dynamic Instance Variables; 15.2 Dynamically Adding New Behavior to an Instance; 15.3 Dynamic References to Variables and Methods; 15.4 Using Dynamic Instance Variables to Create Lookup Tables; 15.5 Using Functions to Create Objects; 15.6 Using Prototype Objects to Augment Classes; 15.7 The Prototype Chain; 15.8 Onward!; Chapter 16: Scope; 16.1 Global Scope; 16.2 Class Scope; 16.3 Static Method Scope; 16.4 Instance Method Scope; 16.5 Function Scope; 16.6 Scope Summary; 16.7 The Internal Details; 16.8 Expanding the Scope Chain via the with Statement; 16.9 On to Namespaces; Chapter 17: Namespaces; 17.1 Namespace Vocabulary; 17.2 ActionScript Namespaces; 17.3 Creating Namespaces; 17.4 Using a Namespace to Qualify Variable and Method Definitions; 17.5 Qualified Identifiers; 17.6 A Functional Namespace Example; 17.7 Namespace Accessibility; 17.8 Qualified-Identifier Visibility; 17.9 Comparing Qualified Identifiers; 17.10 Assigning and Passing Namespace Values; 17.11 Open Namespaces and the use namespace Directive; 17.12 Namespaces for Access-Control Modifiers; 17.13 Applied Namespace Examples; 17.14 Final Core Topics; Chapter 18: XML and E4X; 18.1 Understanding XML Data as a Hierarchy; 18.2 Representing XML Data in E4X; 18.3 Creating XML Data with E4X; 18.4 Accessing XML Data; 18.5 Processing XML with for-each-in and for-in; 18.6 Accessing Descendants; 18.7 Filtering XML Data; 18.8 Traversing XML Trees; 18.9 Changing or Creating New XML Content; 18.10 Loading XML Data; 18.11 Working with XML Namespaces; 18.12 Converting XML and XMLList to a String; 18.13 Determining Equality in E4X; 18.14 More to Learn; Chapter 19: Flash Player Security Restrictions; 19.1 What's Not in This Chapter; 19.2 The Local Realm, the Remote Realm, and Remote Regions; 19.3 Security-Sandbox-Types; 19.4 Security Generalizations Considered Harmful; 19.5 Restrictions on Loading Content, Accessing Content as Data, Cross-Scripting, and Loading Data; 19.6 Socket Security; 19.7 Example Security Scenarios; 19.8 Choosing a Local Security-Sandbox-Type; 19.9 Distributor Permissions (Policy Files); 19.10 Creator Permissions (allowDomain( )); 19.11 Import Loading; 19.12 Handling Security Violations; 19.13 Security Domains; 19.14 Two Common Security-Related Development Issues; 19.15 On to !; Part II: Display and Interactivity; Chapter 20: The Display API and the Display List; 20.1 Display API Overview; 20.2 The Display List; 20.3 Containment Events; 20.4 Custom Graphical Classes; 20.5 Go with the Event Flow; Chapter 21: Events and Display Hierarchies; 21.1 Hierarchical Event Dispatch; 21.2 Event Dispatch Phases; 21.3 Event Listeners and the Event Flow; 21.4 Using the Event Flow to Centralize Code; 21.5 Determining the Current Event Phase; 21.6 Distinguishing Events Targeted at an Object from Events Targeted at That Object's Descendants; 21.7 Stopping an Event Dispatch; 21.8 Event Priority and the Event Flow; 21.9 Display-Hierarchy Mutation and the Event Flow; 21.10 Custom Events and the Event Flow; 21.11 On to Input Events; Chapter 22: Interactivity; 22.1 Mouse-Input Events; 22.2 Focus Events; 22.3 Keyboard-Input Events; 22.4 Text-Input Events; 22.5 Flash Player-Level Input Events; 22.6 From the Program to the Screen; Chapter 23: Screen Updates; 23.1 Scheduled Screen Updates; 23.2 Post-Event Screen Updates; 23.3 Redraw Region; 23.4 Optimization with the Event.RENDER Event; 23.5 Let's Make It Move!; Chapter 24: Programmatic Animation; 24.1 No Loops; 24.2 Animating with the ENTER_FRAME Event; 24.3 Animating with the TimerEvent.TIMER Event; 24.4 Choosing Between Timer and Event.ENTER_FRAME; 24.5 A Generalized Animator; 24.6 Velocity-Based Animation; 24.7 Moving On to Strokes 'n' Fills; Chapter 25: Drawing with Vectors; 25.1 Graphics Class Overview; 25.2 Drawing Lines; 25.3 Drawing Curves; 25.4 Drawing Shapes; 25.5 Removing Vector Content; 25.6 Example: An Object-Oriented Shape Library; 25.7 From Lines to Pixels; Chapter 26: Bitmap Programming; 26.1 The BitmapData and Bitmap Classes; 26.2 Pixel Color Values; 26.3 Creating a New Bitmap Image; 26.4 Loading an External Bitmap Image; 26.5 Examining a Bitmap; 26.6 Modifying a Bitmap; 26.7 Copying Graphics to a BitmapData Object; 26.8 Applying Filters and Effects; 26.9 Freeing Memory Used by Bitmaps; 26.10 Words, Words, Words; Chapter 27: Text Display and Input; 27.1 Creating and Displaying Text; 27.2 Modifying a Text Field's Content; 27.3 Formatting Text Fields; 27.4 Fonts and Text Rendering; 27.5 Missing Fonts and Glyphs; 27.6 Determining Font Availability; 27.7 Determining Glyph Availability; 27.8 Embedded-Text Rendering; 27.9 Text Field Input; 27.10 Text Fields and the Flash Authoring Tool; 27.11 Loading . . . Please Wait . . .; Chapter 28: Loading External Display Assets; 28.1 Using Loader to Load Display Assets at Runtime; 28.2 Compile-Time Type-Checking for Runtime-Loaded Assets; 28.3 Accessing Assets in Multiframe .swf Files; 28.4 Instantiating a Runtime-Loaded Asset; 28.5 Using Socket to Load Display Assets at Runtime; 28.6 Removing Runtime Loaded .swf Assets; 28.7 Embedding Display Assets at Compile Time; 28.8 On to; Part III: Applied ActionScript Topics; Chapter 29: ActionScript and the Flash Authoring Tool; 29.1 The Flash Document; 29.2 Timelines and Frames; 29.3 Timeline Scripting; 29.4 The Document Class; 29.5 Symbols and Instances; 29.6 Linked Classes for Movie Clip Symbols; 29.7 Accessing Manually Created Symbol Instances; 29.8 Accessing Manually Created Text; 29.9 Programmatic Timeline Control; 29.10 Instantiating Flash Authoring Symbols via ActionScript; 29.11 Instance Names for Programmatically Created Display Objects; 29.12 Linking Multiple Symbols to a Single Superclass; 29.13 The Composition-Based Alternative to Linked Classes; 29.14 Preloading Classes; 29.15 Up Next: Using the Flex Framework; Chapter 30: A Minimal MXML Application; 30.1 The General Approach; 30.2 A Real UI Component Example; 30.3 Sharing with Your Friends; Chapter 31: Distributing a Class Library; 31.1 Sharing Class Source Files; 31.2 Distributing a Class Library as a .swc File; 31.3 Distributing a Class Library as a .swf File; 31.4 But Is It Really Over?; Appendix A: The Final Virtual Zoo; Colophon;

Colin Moock is an independent ActionScript expert whose world-renowned books have educated Flash programmers since 1999. He is the author of the canonical "Essential ActionScript 2.0" (O'Reilly, 2004) and "ActionScript for Flash MX: The Definitive Guide" (O'Reilly, 2003, 2001). Moock runs one of the web's oldest Flash developer sites, www.moock.org and is the co-creator of Unity, a client/server framework for creating multiuser applications.