Applied ActionScript 3.0

Applied ActionScript 3.0 is our flagship course teaching ActionScript. We took care writing it, imagining at every stage what we, as trainees, would like to gain from such a course. The result is, as far as we know, the most comprehensive anywhere in the world teaching ActionScript 3.0.

Course contents

Revision 3 (July 2010)

  1. Unit 1: Introduction
    1. About the course
      1. About your trainer
      2. Pre-requisites
      3. How the course is structured
        1. A realistic project
        2. Useful theory
        3. Course hours
        4. After-course support
      4. Previewing the course project
    2. How to approach programming
      1. Some required skills of a successful programmer
    3. Introducing ActionScript 3.0
      1. A list of changes with ActionScript 3.0
      2. ActionScript 3.0 compatibility
  2. Unit 2: Setting up the work environment
    1. A tour of IDEs
      1. Introduction
      2. Adobe Flex Builder
      3. FlashDevelop
    2. Establishing the working folders
      1. About the configuration folders installed with Flash
      2. About classpaths
      3. About packages
      4. Configuring FlashDevelop
  3. Unit 3: Beginning the project
    1. The anatomy of a Flash project
      1. The FLA
        1. Disadvantages of using the timeline
      2. ActionScript files
      3. External assets
    2. Creating the initial files
      1. Creating the FLA
      2. Classes
        1. The Array class
      3. The structure of a class file
        1. CamelCase
        2. Comments
        3. The "package" keyword
        4. Curly braces
        5. Semi-colons
        6. Import statements
        7. Class definition
        8. The "extends" keyword
        9. Static variables
        10. Instance variables
        11. Static methods
        12. Constructor functions
        13. Instance methods
        14. Accessor methods
        15. Class property attributes
      4. Creating a class file
        1. Associating a class file with an FLA
      5. Trace statements
  4. Unit 4: Populating the main class
    1. The Display List
      1. About the display list
      2. Display object types
      3. Advantages of the display list
      4. Manipulating the display list
        1. Adding items to the display list
        2. The display list and depth
        3. Removing items from the display list
        4. Traversing the display list
        5. Other useful properties and methods of display objects
      5. About variables
      6. Creating a Sprite
    2. Functions
      1. The basic structure of a function
        1. Arguments
        2. Return type
        3. Local variables
        4. The void return type
    3. Using TextFields
      1. Creating TextFields with code
      2. Embedding fonts
      3. Using stylesheets
    4. The Drawing API
      1. Introducing the Shape class
        1. The graphics property
      2. Using the Drawing API
    5. Handling the stage
      1. Accessing the stage
      2. Changing stage behaviour
      3. Hiding the default menu
      4. Keeping content centred
        1. Creating an event handler
        2. Listening for events
      5. Using constants
  5. Unit 5: Beginning the Accordion Menu
    1. The Accordion Menu class
      1. Modelling an application
      2. Dividing a project into classes
      3. Dividing the Accordion Menu into classes
      4. Creating the shell of the AccordionMenu class
      5. Instantiating the AccordionMenu class from the main class
    2. Working with XML
      1. Introduction to XML
        1. Using CDATA
      2. Introducing E4X
      3. ActionScript 3.0’s XML handling classes
      4. Loading XML
        1. URLRequest
        2. URLLoader
      5. Accessing loaded XML data
        1. Accessing the XML document itself
        2. Accessing a list of elements by name
        3. Accessing a particular element
        4. Accessing an attribute by name
        5. Accessing XML data anonymously
        6. Looping through XML data
      6. More to E4X
      7. Populating the Accordion menu with XML
        1. Preparing the XML file
        2. Creating a function to load the XML
        3. Sending the XML into the Accordion menu
  6. Unit 6: Developing the Accordion Menu
    1. Further modelling
      1. Considering the structure
      2. The AccordionMenu class
      3. How the menu will work
    2. The AccordionMenuItem class
      1. Creating the shell of the AccordionMenuItem class
      2. Populating the menu with AccordionMenuItems
        1. Using a for… each… in loop
      3. Fleshing out the AccordionMenuItem class
        1. Private and public variables in action
        2. Using getters and setters
      4. Displaying and formatting dynamic text from XML
      5. Masking items with ActionScript
  7. Unit 7: Introducing Interactivity
    1. About event handling
      1. Introduction
      2. Events
        1. Event objects
      3. The event flow
        1. Advantages of the event flow
      4. Handling events
        1. Input events
    2. Implementing event handling
      1. Assigning event handlers and functions
      2. Enabling button-like behaviour for Sprites
      3. Assigning additional event handlers
  8. Unit 8: Animation in ActionScript 3.0
    1. A tour of animation options in ActionScript 3.0
      1. Introduction
        1. The problem with conventional tweening
      2. Direct coding
      3. The Tween class
        1. Robert Penner’s easing equations
      4. Open source tweening solutions
        1. MCTween
        2. Tweener
        3. AS3 Animation System
        4. Fuse Kit
        5. Twease
        6. TweenLite
    2. Animating AccordionMenuItems
      1. Installing TweenLite
      2. Reviewing the application state
      3. Using TweenLite
  9. Unit 9: Loading external display assets
    1. Loading and displaying images from XML data
      1. Reviewing the application
      2. The ImageLoader class
      3. Fleshing out the ImageLoader class
        1. The Loader class
        2. The URLRequest class
        3. The LoaderInfo class
      4. Fine tuning
        1. Masking loaded images using the Drawing API
        2. Creating a menu background using the Drawing API
        3. Fading in loaded images using ActionScript 3.0
      5. The Timer class
        1. Introduction to the Tmer class
        2. Using the Timer class
      6. Creating filters
        1. About filters
        2. Applying filters
      7. Creating filters
        1. About filters
        2. Applying filters
    2. Preloading external assets
      1. About preloading
      2. How to preload in ActionScript 3.0
      3. Implementing preloading
        1. Beginning a Preloader class
        2. Initiating a Preloader instance
        3. Completing the Preloader class
  10. Unit 10: Wrapping up
    1. Embedding Flash applications for the web
      1. Embedding Flash
        1. Tags used
      2. Internet Explorer active content issue
        1. The bad news
        2. The good news
        3. The even better news
      3. Flash detection
        1. Automatic notification
        2. Active X detection
        3. Previous approaches
        4. The recommended solution
      4. Using SWFObject
        1. ExpressInstall
    2. Where to go from here
      1. Where you can go from here
        1. Useful tips
        2. Common ‘gotcha’s
        3. Useful resources
      2. Where we will go from here
        1. Advanced ActionScript 3.0