Essential ActionScript 3.0 Colin Moock

Spis treści książki

• Essential ActionScript 3.0
  • SPECIAL OFFER: Upgrade this ebook with OReilly
  • Foreword
  • Preface
    • Beginners Welcome
    • Expert Guidance
    • Whats In This Book
    • What's Not In This Book
    • Authoring Tool Agnosticism
    • ActionScript Overview
      • The Core Language
      • Flash Runtime Clients
      • Runtime APIs
      • Components
      • The Flash File Format (SWF)
      • ActionScript Development Tools
    • This Book's Example Files
    • Using Code Examples
    • Typographical Conventions
    • How to Contact Us
    • Acknowledgments
  • I. ActionScript from the Ground Up
    • 1. Core Concepts
      • 1.1. Tools for Writing ActionScript Code
      • 1.2. Flash Client Runtime Environments
      • 1.3. Compilation
        • 1.3.1. Just-In-Time Compilation
      • 1.4. Quick Review
      • 1.5. Classes and Objects
      • 1.6. Creating a Program
      • 1.7. Packages
      • 1.8. Defining a Class
        • 1.8.1. Access Control Modifiers for Classes
      • 1.9. Virtual Zoo Review
      • 1.10. Constructor Methods
      • 1.11. Creating Objects
        • 1.11.1. Literal Syntax
        • 1.11.2. Object Creation Example: Adding a Pet to the Zoo
      • 1.12. Variables and Values
        • 1.12.1. Local Variables
        • 1.12.2. Instance Variables
          • 1.12.2.1. Access-control modifiers for instance variables
      • 1.13. Constructor Parameters and Arguments
      • 1.14. Expressions
      • 1.15. Assigning One Variable's Value to Another
        • 1.15.1. Copies and References
      • 1.16. An Instance Variable for Our Pet
      • 1.17. Instance Methods
        • 1.17.1. Access Control Modifiers for Instance Methods
        • 1.17.2. Method Parameters and Arguments
        • 1.17.3. Method Return Values
        • 1.17.4. Method Signatures
      • 1.18. Members and Properties
      • 1.19. Virtual Zoo Review
      • 1.20. Break Time!
    • 2. Conditionals and Loops
      • 2.1. Conditionals
        • 2.1.1. The if Statement
          • 2.1.1.1. An if statement with no else
          • 2.1.1.2. Chaining if statements
        • 2.1.2. The switch Statement
      • 2.2. Loops
        • 2.2.1. The while Statement
        • 2.2.2. Processing Lists with Loops
        • 2.2.3. Ending a Loop with the break Statement
        • 2.2.4. The do-while Statement
        • 2.2.5. The for Statement
      • 2.3. Boolean Logic
        • 2.3.1. Logical OR
        • 2.3.2. Logical AND
        • 2.3.3. Logical NOT
      • 2.4. Back to Classes and Objects
    • 3. Instance Methods Revisited
      • 3.1. Omitting the this Keyword
        • 3.1.1. Managing Parameter/Variable Name Conflicts
      • 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
    • 4. Static Variables and Static Methods
      • 4.1. Static Variables
      • 4.2. Constants
      • 4.3. Static Methods
        • 4.3.1. The Class Initializer
      • 4.4. Class Objects
      • 4.5. C++ and Java Terminology Comparison
      • 4.6. On to Functions
    • 5. Functions
      • 5.1. Package-Level Functions
        • 5.1.1. Global 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
    • 6. Inheritance
      • 6.1. A Primer on Inheritance
        • 6.1.1. Static Methods and Static Variables Not Inherited
      • 6.2. Overriding Instance Methods
        • 6.2.1. Invoking an Overridden Instance Method
      • 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.6.1. Why Inheritance?
        • 6.6.2. Polymorphism and Dynamic Binding
        • 6.6.3. Inheritance Versus Composition
          • 6.6.3.1. Is-A, Has-A, and Uses-A
          • 6.6.3.2. When to use composition over inheritance
      • 6.7. Abstract Not Supported
      • 6.8. Using Inheritance in the Virtual Zoo Program
        • 6.8.1. Creating Types of Pet Food
        • 6.8.2. Preparing VirtualZoo for Onscreen Display
      • 6.9. Virtual Zoo Program Code
      • 6.10. It's Runtime!
    • 7. Compiling and Running a Program
      • 7.1. Compiling with the Flash Authoring Tool
      • 7.2. Compiling with Flex Builder 2
        • 7.2.1. Moving the Main Class to the Unnamed Package
        • 7.2.2. Compiling the Program
        • 7.2.3. Running the Program
      • 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.6.1. Enabling Standard-Mode Compilation in Flex Builder 2
        • 7.6.2. Enabling Standard-Mode Compilation in the Flash Authoring Tool
      • 7.7. The Fun's Not Over
    • 8. Datatypes and Type Checking
      • 8.1. Datatypes and Type Annotations
        • 8.1.1. Compatible Types
        • 8.1.2. Detecting Type Mismatch Errors with 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.6.1. Avoiding Unwanted Type Mismatch Errors
        • 8.6.2. Upcasting and Downcasting
        • 8.6.3. Using the as Operator to Cast to Date and Array
      • 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
    • 9. Interfaces
      • 9.1. The Case for Interfaces
      • 9.2. Interfaces and Multidatatype Classes
      • 9.3. Interface Syntax and Use
        • 9.3.1. Interface Naming Conventions
        • 9.3.2. Interface Inheritance
        • 9.3.3. Marker Interfaces
      • 9.4. Another Multiple-Type Example
      • 9.5. More Essentials Coming
    • 10. Statements and Operators
      • 10.1. Statements
      • 10.2. Operators
        • 10.2.1. Number of Operands
        • 10.2.2. Operator Precedence
        • 10.2.3. Operator Associativity
        • 10.2.4. Datatypes and Operators
        • 10.2.5. Operator Overview
      • 10.3. Up Next: Managing Lists of Information
    • 11. Arrays
      • 11.1. What Is an Array?
      • 11.2. The Anatomy of an Array
        • 11.2.1. Array Elements
        • 11.2.2. Array Element Indexing
        • 11.2.3. Array Size
      • 11.3. Creating Arrays
        • 11.3.1. Creating Arrays with Array Literals
        • 11.3.2. Creating Arrays with the new Operator
      • 11.4. Referencing Array Elements
        • 11.4.1. Retrieving an Element's Value
        • 11.4.2. Setting an Element's Value
      • 11.5. Determining the Size of an Array
      • 11.6. Adding Elements to an Array
        • 11.6.1. Adding New Elements Directly
        • 11.6.2. Adding New Elements with the length Variable
        • 11.6.3. Adding New Elements with Array Methods
          • 11.6.3.1. The push( ) method
          • 11.6.3.2. The unshift( ) method
          • 11.6.3.3. The splice( ) method
          • 11.6.3.4. The concat( ) method
      • 11.7. Removing Elements from an Array
        • 11.7.1. Removing Elements with the delete Operator
        • 11.7.2. Removing Elements with the length Variable
        • 11.7.3. Removing Elements with Array Methods
          • 11.7.3.1. The pop( ) method
          • 11.7.3.2. The shift( ) method
          • 11.7.3.3. The splice( ) method
      • 11.8. Checking the Contents of an Array with the toString( ) Method
      • 11.9. Multidimensional Arrays
      • 11.10. On to Events
    • 12. Events and Event Handling
      • 12.1. ActionScript Event Basics
        • 12.1.1. Registering an Event Listener for an Event
          • 12.1.1.1. Step 1: Determine the event type's name
          • 12.1.1.2. Step 2: Determine the event object's datatype
          • 12.1.1.3. Step 3: Create the event listener
          • 12.1.1.4. Step 4: Register for the event
          • 12.1.1.5. Step 5: Wait for the event to occur
        • 12.1.2. Two More Event Listener Registration Examples
        • 12.1.3. Unregistering an Event Listener for an Event
        • 12.1.4. Event Vocabulary Review
      • 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.6.1. Weak Listener References
      • 12.7. Custom Events
        • 12.7.1. A Custom "gameOver" Event
        • 12.7.2. A Custom "toggle" Event
        • 12.7.3. Preventing Default Behavior for Custom Events
      • 12.8. Type Weakness in ActionScript's Event Architecture
      • 12.9. Handling Events Across Security Boundaries
        • 12.9.1. Module.swf Listener Registers with Main.swf Object
        • 12.9.2. Main.Swf Listener Receives Notification for an Event Targeted at a Module.swf Display Object
        • 12.9.3. An Alternative to allowDomain( ): Shared Events
      • 12.10. What's Next?
    • 13. Exceptions and Error Handling
      • 13.1. The Exception-Handling Cycle
      • 13.2. Handling Multiple Types of Exceptions
        • 13.2.1. Determining Exception Type Granularity
          • 13.2.1.1. Options 1 and 2: Using a single custom-exception type
          • 13.2.1.2. Option 3: Using configurable debugging messages
          • 13.2.1.3. Option 4: Multiple custom VirtualPetNameException subclasses
      • 13.3. Exception Bubbling
        • 13.3.1. Uncaught Exceptions
      • 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.7.1. Error Events for Problem Conditions
      • 13.8. More Gritty Work Ahead
    • 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
    • 15. Dynamic ActionScript
      • 15.1. Dynamic Instance Variables
        • 15.1.1. Processing Dynamic Instance Variables with for-each-in and for-in Loops
      • 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.4.1. Making Lookup Tables with Object Literals
      • 15.5. Using Functions to Create Objects
      • 15.6. Using Prototype Objects to Augment Classes
      • 15.7. The Prototype Chain
      • 15.8. Onward!
    • 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
    • 17. Namespaces
      • 17.1. Namespace Vocabulary
      • 17.2. ActionScript Namespaces
      • 17.3. Creating Namespaces
        • 17.3.1. Choosing the Namespace URI
        • 17.3.2. Defining the Namespace
        • 17.3.3. Explicit Versus Implicit URIs
        • 17.3.4. Namespace Terminology Review
      • 17.4. Using a Namespace to Qualify Variable and Method Definitions
        • 17.4.1. User-Defined Namespace Attributes in the Top-Level of a Class Only
      • 17.5. Qualified Identifiers
        • 17.5.1. Expanded Names
      • 17.6. A Functional Namespace Example
      • 17.7. Namespace Accessibility
        • 17.7.1. Accessibility of Package-Level Namespace Definitions
        • 17.7.2. Accessibility of Class-Level Namespace Definitions
        • 17.7.3. Accessibility of Function-Level Namespace Definitions
      • 17.8. Qualified-Identifier Visibility
      • 17.9. Comparing Qualified Identifiers
      • 17.10. Assigning and Passing Namespace Values
        • 17.10.1. Assigning a Namespace Value to a Variable
        • 17.10.2. Namespaces as Method Arguments and Return Values
        • 17.10.3. A Namespace Value Example
      • 17.11. Open Namespaces and the use namespace Directive
        • 17.11.1. Open Namespaces and Scope
        • 17.11.2. Opening Multiple Namespaces
      • 17.12. Namespaces for Access-Control Modifiers
        • 17.12.1. Import Opens Public Namespaces
      • 17.13. Applied Namespace Examples
        • 17.13.1. Example: Framework-Internal Visibility
        • 17.13.2. Example: Permission-Based Access Control
        • 17.13.3. Example: Program Modes
      • 17.14. Final Core Topics
    • 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.4.1. Accessing the Root XML Node
        • 18.4.2. Accessing Child Nodes
        • 18.4.3. Accessing Text Nodes
        • 18.4.4. Accessing Parent Nodes
        • 18.4.5. Accessing Sibling Nodes
        • 18.4.6. Accessing Attributes
        • 18.4.7. Accessing Comments and Processing Instructions
        • 18.4.8. Accessing Attributes and Elements Whose Names Contain Reserved Characters
        • 18.4.9. Treating XMLList as XML, Revisited
      • 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.9.1. Changing the Contents of an Element
        • 18.9.2. Changing an Attribute Value
        • 18.9.3. Replacing an Entire Element
        • 18.9.4. Adding New Attributes and Elements
          • 18.9.4.1. Adding a new child after all existing children
          • 18.9.4.2. Adding a new child after a specific existing child
          • 18.9.4.3. Adding a new child before a specific existing child
          • 18.9.4.4. Adding a new child before all existing children
        • 18.9.5. Deleting Elements and Attributes
        • 18.9.6. References to Parts of a Document Are Not Live
        • 18.9.7. Using XML Entities for Special Characters
        • 18.9.8. Assigning Values to an XMLList
      • 18.10. Loading XML Data
      • 18.11. Working with XML Namespaces
        • 18.11.1. Accessing Namespace-Qualified Elements and Attributes
        • 18.11.2. Creating Namespace-Qualified Elements and Attributes
      • 18.12. Converting XML and XMLList to a String
        • 18.12.1. Converting XMLList to a String
        • 18.12.2. Converting an XML Element to a String
        • 18.12.3. Converting an Attribute to a String
        • 18.12.4. Converting Comments and Processing-Instructions to Strings
      • 18.13. Determining Equality in E4X
        • 18.13.1. XML Equality
        • 18.13.2. XMLList Equality
        • 18.13.3. QName Equality
        • 18.13.4. Namespace Equality
      • 18.14. More to Learn
    • 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.3.1. How Security-Sandbox-Types Are Assigned
      • 19.4. Security Generalizations Considered Harmful
      • 19.5. Restrictions on Loading Content, Accessing Content as Data, Cross-Scripting, and Loading Data
        • 19.5.1. Loading Content
        • 19.5.2. Accessing Content as Data
        • 19.5.3. Cross-Scripting
        • 19.5.4. Loading Data
        • 19.5.5. Restrictions on Loading Content, Accessing Content as Data, Loading Data, and Cross-Scripting
      • 19.6. Socket Security
      • 19.7. Example Security Scenarios
        • 19.7.1. Snoopy Email AttachmentWithout Flash Player Security
        • 19.7.2. Snoopy Email AttachmentWith Flash Player Security
        • 19.7.3. Internal Corporate InformationWithout Flash Player Security
        • 19.7.4. Internal Corporate InformationWith Flash Player Security
        • 19.7.5. Cross-Web Site InformationWithout Flash Player Security
        • 19.7.6. Cross-Web Site InformationWith Flash Player Security
      • 19.8. Choosing a Local Security-Sandbox-Type
        • 19.8.1. Compiling a Local-with-Filesystem .swf File
        • 19.8.2. Compiling a Local-with-Networking .swf File
        • 19.8.3. Granting Local Trust
        • 19.8.4. Developers Automatically Trusted
        • 19.8.5. Default Local Security-Sandbox-Type
      • 19.9. Distributor Permissions (Policy Files)
        • 19.9.1. Authorizing Loading-Data and Accessing-Content-as-Data Operations
          • 19.9.1.1. Creating the policy file
          • 19.9.1.2. Posting the policy file
          • 19.9.1.3. Obtaining a policy file's permission to load data
          • 19.9.1.4. Obtaining a policy file's permission to access content as data
        • 19.9.2. Using a Policy File to Authorize Socket Connections
          • 19.9.2.1. Create the policy file
          • 19.9.2.2. Socket-based policy-file retrieval
          • 19.9.2.3. HTTP-based policy-file retrieval
      • 19.10. Creator Permissions (allowDomain( ))
        • 19.10.1. Allowing .swf Files Served Over HTTP to Cross-Script .swf Files Served Over HTTPS
      • 19.11. Import Loading
      • 19.12. Handling Security Violations
      • 19.13. Security Domains
        • 19.13.1. Ambiguous Use of the Term "Sandbox"
      • 19.14. Two Common Security-Related Development Issues
        • 19.14.1. Accessing Internet Subdomains
        • 19.14.2. Accessing the Loader Class's Instance Variable Content
      • 19.15. On to Part II!
  • II. Display and Interactivity
    • 20. The Display API and the Display List
      • 20.1. Display API Overview
        • 20.1.1. Extending the Core-Display Class Hierarchy
      • 20.2. The Display List
        • 20.2.1. Containers and Depths
        • 20.2.2. Removing Assets from Containers
        • 20.2.3. Removing Assets from Memory
        • 20.2.4. Removing All Children
        • 20.2.5. Reparenting Assets
        • 20.2.6. Traversing Objects in a Display Hierarchy
        • 20.2.7. Manipulating Objects in Containers Collectively
        • 20.2.8. Descendant Access to a .swf File's Main Class Instance
          • 20.2.8.1. The rebirth of _root
          • 20.2.8.2. Whither _level0?
      • 20.3. Containment Events
        • 20.3.1. The Event.ADDED and Event.REMOVED Events
        • 20.3.2. A Real-World Containment-Event Example
        • 20.3.3. The ADDED_TO_STAGE and REMOVED_FROM_STAGE Events
          • 20.3.3.1. Custom Event.ADDED_TO_STAGE and Event.REMOVED_FROM_STAGE events
      • 20.4. Custom Graphical Classes
      • 20.5. Go with the Event Flow
    • 21. Events and Display Hierarchies
      • 21.1. Hierarchical Event Dispatch
      • 21.2. Event Dispatch Phases
      • 21.3. Event Listeners and the Event Flow
        • 21.3.1. Registering an Ancestor Listener for the Capture Phase
        • 21.3.2. Registering an Ancestor Listener for the Bubbling Phase
        • 21.3.3. Registering an Ancestor Listener for Both the Capture Phase and the Bubbling Phase
        • 21.3.4. Registering a Listener with the Event Target
        • 21.3.5. The Dual Purpose of the useCapture Parameter
        • 21.3.6. Removing Event Listeners
      • 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.9.1. Event Listener List Mutation
      • 21.10. Custom Events and the Event Flow
      • 21.11. On to Input Events
    • 22. Interactivity
      • 22.1. Mouse-Input Events
        • 22.1.1. Flash Player's Built-in Mouse Events
        • 22.1.2. Registering for Mouse Events
        • 22.1.3. Mouse Events and Overlapping Display Objects
        • 22.1.4. Finding the Mouse Pointer's Position
        • 22.1.5. Handling Mouse Events "Globally"
      • 22.2. Focus Events
        • 22.2.1. Focusing Objects Programmatically
        • 22.2.2. Focusing Objects with the Keyboard
        • 22.2.3. Focusing Objects with the Mouse
          • 22.2.3.1. Handling descendant focus through a single ancestor
        • 22.2.4. Flash Player's Focus Events
      • 22.3. Keyboard-Input Events
        • 22.3.1. Global Keyboard-Event Handling
        • 22.3.2. Object-Specific Keyboard-Event Handling
        • 22.3.3. Determining the Most Recently Pressed or Released Key
          • 22.3.3.1. Multilocation keys
        • 22.3.4. Detecting Multiple Simultaneous Key Presses
        • 22.3.5. Mouse Events and Modifier Keys
        • 22.3.6. Determining the Character Associated with a Key
      • 22.4. Text-Input Events
        • 22.4.1. The TextEvent.TEXT_INPUT and Event.CHANGE Events
        • 22.4.2. The Event.SCROLL Event
        • 22.4.3. The TextEvent.LINK Event
      • 22.5. Flash Player-Level Input Events
        • 22.5.1. The Event.ACTIVATE and Event.DEACTIVATE Events
        • 22.5.2. The Event.RESIZE Event
        • 22.5.3. The Event.MOUSE_LEAVE Event
      • 22.6. From the Program to the Screen
    • 23. Screen Updates
      • 23.1. Scheduled Screen Updates
        • 23.1.1. No Screen Updates Within Code Blocks
        • 23.1.2. Setting the Frame Rate
        • 23.1.3. Designated Frame Rate Versus Actual Frame Rate
      • 23.2. Post-Event Screen Updates
        • 23.2.1. Post-Event Updates for Timer Events
        • 23.2.2. Automatic Post-Event Screen Updates
      • 23.3. Redraw Region
      • 23.4. Optimization with the Event.RENDER Event
      • 23.5. Let's Make It Move!
    • 24. Programmatic Animation
      • 24.1. No Loops
      • 24.2. Animating with the ENTER_FRAME Event
        • 24.2.1. Frame Rate's Effect on Event.ENTER_FRAME Animations
      • 24.3. Animating with the TimerEvent.TIMER Event
        • 24.3.1. Frame Rate's Effect on Timer
      • 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
    • 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
    • 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.5.1. getPixel32() Versus getPixel( )
        • 26.5.2. Transparency's Effect on Color-Value Retrieval
        • 26.5.3. ColorPicker: A getPixel32( ) Example
        • 26.5.4. Retrieving the Color of a Region of Pixels
        • 26.5.5. Other Examination Tools
      • 26.6. Modifying a Bitmap
        • 26.6.1. Improve Performance with BitmapData.lock( )
        • 26.6.2. ScribbleAS3: A setPixel32( ) Example
        • 26.6.3. Assigning the Color of a Region of Pixels
        • 26.6.4. Other Manipulation Tools
        • 26.6.5. Resizing a Bitmap
      • 26.7. Copying Graphics to a BitmapData Object
        • 26.7.1. The BitmapData Class's Instance Method draw( )
          • 26.7.1.1. How draw( ) handles Alpha channel values
          • 26.7.1.2. No arbitrary screen captures
        • 26.7.2. The BitmapData Class's Instance Method copyPixels( )
      • 26.8. Applying Filters and Effects
        • 26.8.1. Applying Filters
      • 26.9. Freeing Memory Used by Bitmaps
      • 26.10. Words, Words, Words
    • 27. Text Display and Input
      • 27.1. Creating and Displaying Text
        • 27.1.1. Word Wrapping
        • 27.1.2. Automatic Resizing
        • 27.1.3. Rotated, Skewed, and Transparent Text Requires Embedded Fonts
      • 27.2. Modifying a Text Field's Content
      • 27.3. Formatting Text Fields
        • 27.3.1. Formatting Text with the TextFormat Class
          • 27.3.1.1. Available TextFormat variables
          • 27.3.1.2. Embedded font warning: Bold and italic require separate fonts
          • 27.3.1.3. setTextFormat( ) does not apply to future text assignments
          • 27.3.1.4. Applying paragraph-level formatting
          • 27.3.1.5. Retrieving formatting information for a span of characters
          • 27.3.1.6. Default formatting for text fields
        • 27.3.2. Formatting Text with HTML
          • 27.3.2.1. Entity support
          • 27.3.2.2. Quoting attribute values
          • 27.3.2.3. Interactions between the text and htmlText variables
          • 27.3.2.4. Unrecognized tags and attributes
        • 27.3.3. Formatting Text with the StyleSheet Class
          • 27.3.3.1. Notable style sheet limitations in ActionScript
          • 27.3.3.2. Formatting text with a programmatically created style sheet
          • 27.3.3.3. Class selectors
          • 27.3.3.4. Formatting XML tags with CSS
          • 27.3.3.5. Formatting text with an externally loaded style sheet
      • 27.4. Fonts and Text Rendering
        • 27.4.1. Embedding Font Outlines in the Flash Authoring Tool
        • 27.4.2. Embedding Font Outlines in Flex Builder 2 and mxmlc
        • 27.4.3. Formatting Text with an Embedded Font
          • 27.4.3.1. Using bold and italic with embedded fonts
        • 27.4.4. Loading Fonts at Runtime
      • 27.5. Missing Fonts and Glyphs
      • 27.6. Determining Font Availability
      • 27.7. Determining Glyph Availability
      • 27.8. Embedded-Text Rendering
        • 27.8.1. Tweaking the FlashType Renderer
      • 27.9. Text Field Input
        • 27.9.1. Text Entry
          • 27.9.1.1. Formatting user input
        • 27.9.2. Text Selection
        • 27.9.3. Hypertext Links
      • 27.10. Text Fields and the Flash Authoring Tool
      • 27.11. Loading . . . Please Wait . . .
    • 28. Loading External Display Assets
      • 28.1. Using Loader to Load Display Assets at Runtime
        • 28.1.1. Creating the Loader Instance
        • 28.1.2. Specifying the Asset's Location
        • 28.1.3. Starting the Load Operation
        • 28.1.4. Accessing the Loaded Asset
        • 28.1.5. Displaying the Loaded Asset On Screen
        • 28.1.6. Displaying Load Progress
          • 28.1.6.1. Why not use Event.OPEN?
        • 28.1.7. Handling Load Errors
          • 28.1.7.1. Environment-specific behavior for load failures
          • 28.1.7.2. Debugging with HTTPStatusEvent
      • 28.2. Compile-Time Type-Checking for Runtime-Loaded Assets
        • 28.2.1. Opting Out of Compile-Time Type-Checking
        • 28.2.2. Give the Compiler Access to the Loaded Class
        • 28.2.3. Add the Module Class File to Main.swf's source-path
        • 28.2.4. Add the Module Class File to Main.swf's library-path
        • 28.2.5. Add the Module Class File to Main.swf's external-library-path
      • 28.3. Accessing Assets in Multiframe .swf Files
      • 28.4. Instantiating a Runtime-Loaded Asset
        • 28.4.1. Instantiating a Loaded .swf File
        • 28.4.2. Instantiating a Loaded Image
      • 28.5. Using Socket to Load Display Assets at Runtime
        • 28.5.1. Server-Side: Sending the Asset
        • 28.5.2. Client-Side: Receiving the Asset
          • 28.5.2.1. Creating and connecting to the socket
          • 28.5.2.2. Placing bytes in a buffer
          • 28.5.2.3. Creating a display asset from the loaded bytes
      • 28.6. Removing Runtime Loaded .swf Assets
      • 28.7. Embedding Display Assets at Compile Time
        • 28.7.1. A Note on File Size and Memory Consumption
        • 28.7.2. General [Embed] Syntax
        • 28.7.3. Supported Asset Types
        • 28.7.4. Embedding Bitmap Images
        • 28.7.5. Embedding SVG
        • 28.7.6. Embedding Entire .swf Files
        • 28.7.7. Embedding Symbols from Legacy .swf Files
        • 28.7.8. Embedding Files as Binary Data
        • 28.7.9. Using getDefinition( ) to Access a Class in an Embedded .swf File
        • 28.7.10. An [Embed] Example
        • 28.7.11. Clean the Project to See Changes
      • 28.8. On to Part III
  • III. Applied ActionScript Topics
    • 29. ActionScript and the Flash Authoring Tool
      • 29.1. The Flash Document
      • 29.2. Timelines and Frames
        • 29.2.1. Keyframes and Regular Frames
      • 29.3. Timeline Scripting
      • 29.4. The Document Class
        • 29.4.1. Variable and Function Definitions in Frame Scripts
      • 29.5. Symbols and Instances
        • 29.5.1. Types of Symbols
        • 29.5.2. Movie Clip Symbols
      • 29.6. Linked Classes for Movie Clip Symbols
      • 29.7. Accessing Manually Created Symbol Instances
        • 29.7.1. Instance Names
        • 29.7.2. Matching Variables for Instance Names
      • 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
    • 30. A Minimal MXML Application
      • 30.1. The General Approach
        • 30.1.1. Create the Flex Project
        • 30.1.2. Create the Application Point of Entry
        • 30.1.3. Trigger the Application Point of Entry
      • 30.2. A Real UI Component Example
      • 30.3. Sharing with Your Friends
    • 31. Distributing a Class Library
      • 31.1. Sharing Class Source Files
      • 31.2. Distributing a Class Library as a .swc File
        • 31.2.1. Creating a .swc-Based Class Library in Flex Builder 2
        • 31.2.2. Using a .swc-Based Class Library in Flex Builder 2
        • 31.2.3. Creating a .swc-Based Class Library in the Flash Authoring Tool
        • 31.2.4. Using a .swc-Based Class Library in the Flash Authoring Tool
      • 31.3. Distributing a Class Library as a .swf File
        • 31.3.1. Creating a .swf-Based Class Library in Flex Builder 2
          • 31.3.1.1. Compiling a .swf file using mxmlc
        • 31.3.2. Using a .swf-Based Class Library in Flex Builder 2
        • 31.3.3. Creating a .swf-Based Class Library in the Flash Authoring Tool
        • 31.3.4. Using a .swf-Based Class Library in Flash CS3
      • 31.4. But Is It Really Over?
  • A. The Final Virtual Zoo
  • Index
  • About the Author
  • Colophon
  • SPECIAL OFFER: Upgrade this ebook with OReilly

pokaż cały spis treści

ukryj recenzje