ADOBE® FLEX® 3: DEVELOPER GUIDE

Table of contents

1. Chapter 1: Developing Applications in MXML
   1. About MXML
      1. Writing a simple application
      2. Compiling MXML to SWF Files
      3. The relationship of MXML tags to ActionScript classes
      4. Understanding a Flex application structure
   2. Developing applications
      1. Laying out a user interface using containers
      2. Adding user interface controls
      3. Using the id property with MXML tags
      4. Using XML namespaces
      5. Using MXML to trigger run-time code
      6. Binding data between components
      7. Using RPC services
      8. Storing data in a data model
      9. Validating data
      10. Formatting data
      11. Using Cascading Style Sheets (CSS)
      12. Using skins
      13. Using effects
      14. Defining custom MXML components
2. Chapter 2: MXML Syntax
   1. Basic MXML syntax
      1. Naming MXML files
      2. Using tags that represent ActionScript classes
   2. Setting component properties
      1. Setting scalar properties
      2. Setting properties using constants
      3. Setting the default property
      4. Escaping characters using the backslash character
      5. Setting String properties using the backslash character
      6. Including a newline character in a String value
      7. Setting Arrays of scalar values
      8. Setting Object properties
      9. Populating an Object with an Array
      10. Populating Arrays of objects
      11. Setting properties that contain XML data
      12. Setting style and effect properties in MXML
      13. Setting event properties in MXML
      14. Specifying a URL value
      15. Specifying a RegExp value
      16. Using compiler tags
      17. MXML tag rules
3. Chapter 3: Using ActionScript
   1. Using ActionScript in Flex applications
      1. ActionScript compilation
      2. About generated ActionScript
      3. Using ActionScript in MXML event handlers
      4. Using ActionScript blocks in MXML files
      5. Accessing ActionScript documentation
   2. Working with Flex components
      1. Referring to Flex components
      2. Calling component methods
      3. Creating visual Flex components in ActionScript
      4. About scope
   3. Comparing, including, and importing ActionScript code
      1. Including ActionScript files
      2. Importing classes and packages
   4. Techniques for separating ActionScript from MXML
      1. One MXML document (event handling logic in event attribute)
      2. One MXML document (event handling logic in block)
      3. One MXML document and one ActionScript file (event handling logic in separate script file)
   5. Creating ActionScript components
   6. Performing object introspection
      1. Using for..in loops
      2. Using the introspection API
4. Chapter 4: Using Events
   1. About events
      1. About the Event flow
      2. About the Event class
      3. About event subclasses
      4. About the EventDispatcher class
   2. Using events
      1. Specifying the Event object
      2. Accessing the currentTarget property
      3. Registering event handlers (1/2)
      4. Registering event handlers (2/2)
      5. Defining multiple listeners for a single event
      6. Registering a single listener with multiple components
      7. Passing additional parameters to listener functions
   3. Manually dispatching events
   4. Event propagation
      1. About the target and currentTarget properties
      2. Capturing phase
      3. Targeting phase
      4. Bubbling phase
      5. Detecting the event phase
      6. Stopping propagation
      7. Examples
   5. Event priorities
   6. Using event subclasses
   7. About keyboard events
      1. Handling keyboard events
      2. Understanding the keyCode and charCode properties
      3. Understanding KeyboardEvent precedence
      4. Handling keyboard-related mouse events
5. Chapter 5: Flex Data Access
   1. About data access
      1. REST-style services
      2. Web services
      3. Remote object services
      4. Considerations for accessing server-side data
      5. HTTPService components
      6. WebService components
      7. RemoteObject components
   2. Comparing Flex data access to other technologies
      1. Client-side processing and server-side processing
      2. Data source access
      3. Flash Professional data management
6. Chapter 6: Using Flex Visual Components
   1. About visual components
   2. Class hierarchy for visual components
   3. Using the UIComponent class
      1. Commonly used UIComponent properties
      2. Using components in MXML and ActionScript
      3. Configuring components: syntax summary
   4. Sizing visual components
   5. Handling events
   6. Applying styles
   7. Applying behaviors
   8. Applying skins
   9. Changing the appearance of a component at run time
   10. Extending components
7. Chapter 7: Using Data Providers and Collections
   1. About collections and data provider components
      1. About collections
      2. About data provider components
      3. Specifying data providers in MXML applications
      4. Setting a data providers in ActionScript
      5. Example: Using a collection
   2. Using simple data access properties and methods
   3. Working with data views
      1. Sorting and filtering data for viewing
      2. Using a view cursor
      3. Example: Updating an Array by using data view methods and properties
   4. Collection events and manual change notification
      1. Collection events
      2. Collection change notification
      3. Example: Modifying data in a DataGrid control
   5. Hierarchical data objects
      1. About hierarchical data objects
      2. Data descriptors and hierarchical data structure (1/2)
      3. Data descriptors and hierarchical data structure (2/2)
      4. XML-based data objects
      5. XMLListCollection objects
   6. Remote data in data provider components
   7. Data providers and the uid property
8. Chapter 8: Sizing and Positioning Components
   1. About sizing and positioning
      1. About layout in Flex
      2. About Flex frames of reference
      3. About component sizing
      4. About component positioning
      5. Component layout patterns
      6. Basic layout rules and considerations
      7. Manually forcing layout
   2. Sizing components
      1. Flex sizing properties
      2. Determining and controlling component sizes
      3. Flex component sizing techniques (1/2)
      4. Flex component sizing techniques (2/2)
      5. Sizing containers and components toolbox
   3. Positioning and laying out controls
      1. Automatic positioning
      2. Absolute positioning
   4. Using constraints to control component layout
      1. Creating a constraint-based layout
      2. Using constraint rows and columns (1/2)
      3. Using constraint rows and columns (2/2)
9. Chapter 9: Controls
   1. About controls
      1. Text controls
      2. Data provider controls
      3. Menu controls
      4. Flex controls
   2. Working with controls
      1. Class hierarchy of controls
      2. Sizing controls
      3. Positioning controls
      4. Changing the appearance of controls
   3. Button control
      1. Creating a Button control
      2. Skinning a Button control
   4. PopUpButton control
      1. Creating a PopUpButton control
      2. User interaction
   5. ButtonBar and ToggleButtonBar controls
      1. Creating a ButtonBar control
      2. Handling ButtonBar events
   6. LinkBar control
      1. Creating a LinkBar control
   7. TabBar control
      1. Creating a TabBar control
      2. Passing data to a TabBar control
      3. Handling TabBar control events
   8. CheckBox control
      1. Creating a CheckBox control
      2. CheckBox control user interaction
   9. RadioButton control
      1. About the RadioButton control
      2. Creating a RadioButton control
      3. RadioButton user interaction
      4. Creating a group by using the tag
   10. NumericStepper control
       1. Creating a NumericStepper control
       2. Sizing a NumericStepper control
       3. User interaction
   11. DateChooser and DateField controls
       1. About the DateChooser control
       2. About the DateField control
       3. Creating a DateChooser or DateField control
       4. Using the Date class
       5. Specifying header, weekday, and today’s day text styles
       6. Specifying selectable dates
       7. Setting DateChooser and DateField properties in ActionScript
       8. Formatting dates with the DateField control
       9. User interaction
   12. LinkButton control
       1. Creating a LinkButton control
       2. LinkButton control user interaction
   13. HSlider and VSlider controls
       1. About Slider controls
       2. Creating a Slider control
       3. Using slider events
       4. Using multiple thumbs
       5. Using data tips
       6. Keyboard navigation
   14. SWFLoader control
       1. Creating a SWFLoader control
       2. Interacting with a loaded Flex application
       3. Externalizing application classes
       4. Sizing a SWFLoader control
   15. Image control
       1. About importing images
       2. SVG drawing restrictions
       3. Controlling image importing with the Image control
       4. Techniques for using the Image control
   16. VideoDisplay control
       1. Using media in Flex
       2. About the VideoDisplay control
       3. Setting the size of a media component
       4. Using methods of the VideoDisplay control
       5. Adding a cue point
       6. Streaming video from a camera
       7. Using the VideoDisplay control with Flash Media Server 2
   17. ColorPicker control
       1. About the ColorPicker control
       2. Creating a ColorPicker control
       3. User interaction
   18. Alert control
       1. Sizing the Alert control
       2. Using event listeners with the Alert control
       3. Specifying an Alert control icon
   19. ProgressBar control
       1. ProgressBar control modes
       2. Creating a ProgressBar control
       3. Defining the label of a ProgressBar control
   20. HRule and VRule controls
       1. Creating HRule and VRule controls
       2. Sizing HRule and VRule controls
       3. Setting style properties
   21. ScrollBar control
       1. Creating a ScrollBar control
       2. Sizing a ScrollBar control
       3. User interaction
10. Chapter 10: Using Text Controls
    1. About text controls
    2. Using the text property
       1. Specifying special characters in the text property
       2. Specifying special characters in ActionScript
    3. Using the htmlText property
       1. Specifying HTML tags and text
       2. Using tags in HTML text (1/2)
       3. Using tags in HTML text (2/2)
    4. Selecting and modifying text
       1. Selecting text
       2. Modifying text
       3. Example: Changing selected text in a RichTextEditor control
    5. Label control
       1. Creating a Label control
       2. Sizing a Label control
    6. TextInput control
       1. Creating a TextInput control
       2. Sizing a TextInput control
       3. Binding to a TextInput control
    7. Text control
       1. Creating a Text control
       2. Sizing a Text control
    8. TextArea control
       1. Creating a TextArea control
       2. Sizing the TextArea control
    9. RichTextEditor control
       1. About the RichTextEditor control
       2. Creating a RichTextEditor control
       3. Sizing the RichTextEditor control
       4. Programming RichTextEditor subcontrols
11. Chapter 11: Using Menu-Based Controls
    1. About menu-based controls
    2. Defining menu structure and data
       1. About menu data providers
       2. Specifying and using menu entry information
       3. Example: An Array menu data provider
       4. Example: An XML menu data provider with icons
    3. Menu-based control events
       1. Menu control events
       2. MenuBar events
       3. Example: Using Menu control events
       4. PopUpMenuButton control events
    4. Menu control
       1. About the Menu Control
       2. Menu control user interaction
    5. MenuBar control
       1. About the MenuBar control
       2. Creating a MenuBar control
       3. MenuBar control user interaction
    6. PopUpMenuButton control
       1. About the PopUpMenuButton control
       2. Creating a PopUpMenuButton control
       3. PopUpMenuButton user interaction
12. Chapter 12: Using Data-Driven Controls
    1. List control
       1. List control sizing
       2. Creating a List control
       3. List control user interaction
    2. HorizontalList control
       1. About HorizontaList controls
       2. Creating a HorizontalList control
       3. HorizontalList control user interaction
    3. TileList control
       1. About the TileList control
       2. Creating a TileList control
       3. TileList control user interaction
    4. ComboBox control
       1. About the ComboBox control
       2. Creating a ComboBox control
       3. ComboBox control user interaction
    5. DataGrid control
       1. About the DataGrid control
       2. Creating a DataGrid control
       3. Handling events in a DataGrid control
       4. Sorting data in DataGrid controls
       5. DataGrid control user interaction
    6. Tree control
       1. About Tree controls
       2. Creating a Tree control
       3. Handling Tree control events
       4. Expanding a tree node
       5. Specifying Tree control icons
       6. Tree user interaction
13. Chapter 13: Introducing Containers
    1. About containers
       1. About container layout
       2. About layout containers and navigator containers
    2. Using containers
       1. Flex containers
       2. Class hierarchy for containers
       3. Container example
       4. Using container events
       5. Disabling containers
       6. Using the Panel container
       7. Defining a default button
    3. Using scroll bars
       1. Using container scroll properties
       2. Scroll bar layout considerations
       3. Controlling scroll delay and interval
    4. Using Flex coordinates
       1. About the coordinate systems
       2. Using coordinate properties and methods
       3. Example: Using the mouse position in a Canvas container
    5. Creating and managing component instances at run time
       1. About the display list and container children
       2. Creating and removing components at run time
       3. Controlling child order
14. Chapter 14: Application Container
    1. About the Application container
       1. Sizing an Application container and its children
       2. Overriding the default Application container styles
       3. Viewing the application source code
       4. Specifying options of the Application container
    2. About the Application object
       1. About the Document object
       2. Accessing Document and Application object scopes
    3. Showing the download progress of an application
       1. Disabling the download progress bar
       2. Creating a custom progress bar
       3. Download progress bar events
       4. Creating a simple subclass of the DownloadProgressBar class
       5. Creating a subclass of the DownloadProgressBar class
       6. Creating a subclass of Sprite
15. Chapter 15: Using Layout Containers
    1. About layout containers
    2. Canvas layout container
       1. Creating and using a Canvas control
    3. Box, HBox, and VBox layout containers
       1. Creating a Box, HBox, or VBox container
    4. ControlBar layout container
       1. Creating a ControlBar container
    5. ApplicationControlBar layout container
       1. Creating an ApplicationControlBar container
    6. DividedBox, HDividedBox, and VDividedBox layout containers
       1. Creating a DividedBox, HDividedBox, or VDividedBox container
       2. Using the dividers
       3. Using live dragging
    7. Form, FormHeading, and FormItem layout containers
       1. About forms
       2. Creating forms
       3. Creating a FormHeading control
       4. Creating a FormItem container
       5. Laying out forms
       6. Defining a default button
       7. Specifying required fields
       8. Storing and validating form data (1/2)
       9. Storing and validating form data (2/2)
       10. Submitting data to a server
    8. Grid layout container
       1. Creating a Grid layout container
       2. Setting the row and column span
    9. Panel layout container
       1. Creating a Panel layout container
       2. Adding a ControlBar container to a Panel container
    10. Tile layout container
        1. Creating a Tile layout container
        2. Sizing and positioning a child in a Tile container
    11. TitleWindow layout container
        1. Using the PopUpManager to create a TitleWindow container (1/2)
        2. Using the PopUpManager to create a TitleWindow container (2/2)
        3. Passing data to and from a pop-up window
        4. Using the addPopUp() method
16. Chapter 16: Using Navigator Containers
    1. About navigator containers
    2. ViewStack navigator container
       1. Creating a ViewStack container
       2. Sizing the children of a ViewStack container
       3. Applying behaviors to a ViewStack container
    3. TabNavigator container
       1. Creating a TabNavigator container
       2. Sizing the children of a TabNavigator container
       3. TabNavigator container Keyboard navigation
    4. Accordion navigator container
       1. Creating an Accordion container
       2. Accordion container Keyboard navigation
       3. Using Button controls to navigate an Accordion container
       4. Handling child button events
       5. Controlling the appearance of accordion buttons
17. Chapter 17: Using Behaviors
    1. About behaviors
       1. About applying behaviors
       2. About factory and instance classes
       3. Available effects
       4. Available triggers
    2. Applying behaviors in MXML
    3. Applying behaviors in ActionScript (1/2)
    4. Applying behaviors in ActionScript (2/2)
       1. Applying behaviors using the Effect.target and Effect.targets properties
    5. Working with effects
       1. Setting effect durations
       2. Using embedded fonts with effects
       3. Creating composite effects
       4. Using the AnimateProperty effect
       5. Delaying effect start
       6. Repeating effects
       7. Using Dissolve and Fade effects with the Panel, TitleWindow, and Accordion containers
       8. Using a sound effect
       9. Using a mask effect
       10. Handling effect events
       11. Suspending background processing
       12. Using an easing function
       13. Using data effects
       14. Disabling container layout for effects
       15. Improving performance when resizing Panel containers
       16. Setting UIComponent.cachePolicy on the effect target
18. Chapter 18: Using Styles and Themes
    1. About styles
       1. Using styles in Flex
       2. External style sheets
       3. Setting global styles
       4. About style value formats
       5. Using Cascading Style Sheets (1/2)
       6. Using Cascading Style Sheets (2/2)
       7. About style inheritance (1/2)
       8. About style inheritance (2/2)
    2. Using external style sheets
       1. About the default style sheet
    3. Using local style definitions
       1. Using the Application type selector
       2. Using the global selector
    4. Using the StyleManager class
       1. Setting styles with the StyleManager
       2. Accessing selectors with the StyleManager
       3. Creating style declarations with the StyleManager
    5. Using the setStyle() and getStyle() methods
       1. Setting styles
       2. Improving performance with the setStyle() method
    6. Using inline styles
    7. Loading style sheets at run time
       1. Creating a run-time style sheet
       2. Compiling the CSS-based SWF file
       3. Loading style sheets at run time
       4. Updating CSS-based SWF files
       5. Unloading style sheets at run time
       6. Using run-time style sheets in custom components
       7. Using theme SWC files as run-time style sheets
       8. Using run-time style sheets with modules
    8. Using filters in Flex
    9. About themes
       1. Using themes
       2. About the included theme files
       3. Creating a theme SWC file
19. Chapter 19: Using Fonts
    1. About fonts
    2. Using device fonts
    3. Using embedded fonts
       1. Embedded font syntax (1/2)
       2. Embedded font syntax (2/2)
       3. Using advanced anti-aliasing
       4. Detecting embedded fonts
    4. Using multiple typefaces
    5. About the font managers
    6. Setting character ranges
       1. Setting ranges in font-face declarations
       2. Setting ranges in flex-config.xml
       3. Detecting available ranges
    7. Embedding double-byte fonts
    8. Embedding fonts from SWF files
       1. Creating Flash 8 SWF files with embedded fonts
       2. Embedding fonts from SWF files into Flex applications (1/2)
       3. Embedding fonts from SWF files into Flex applications (2/2)
    9. Troubleshooting fonts in Flex applications
       1. Resolving compiler errors
       2. Resolving run-time errors
20. Chapter 20: Creating Skins
    1. About skinning
       1. Types of skins (1/2)
       2. Types of skins (2/2)
       3. Sizing skins
       4. Skinning subcomponents
       5. Creating themes
       6. Skin resources
       7. Creating skins using Adobe tools
    2. Applying skins
       1. Applying graphical skins inline
       2. Applying programmatic skins inline
       3. Applying skins by using CSS
       4. Applying skins by using the setStyle() method
       5. Applying skins by using the Style Manager
    3. Creating graphical skins
       1. Using JPEG, GIF, and PNG files as skins
       2. Using static SWF assets as skins
       3. Using dynamic SWF assets as skins
    4. Creating programmatic skins
       1. Creating ActionScript and MXML skins
       2. Programmatic skins recipe
       3. Compiling programmatic skins
       4. Drawing programmatically (1/2)
       5. Drawing programmatically (2/2)
    5. Creating stateful skins
       1. Example: Creating a stateful skin
       2. Creating stateful skin using images
       3. Using transitions with a stateful skin
    6. Creating advanced programmatic skins
       1. Accessing the parent component
       2. Making properties styleable
21. Chapter 21: Using Drag and Drop
    1. About drag and drop
       1. About the drag-and-drop operation
       2. Performing a drag and drop
    2. Using drag-and-drop with list-based controls
       1. Dragging and dropping in the same control
       2. Drag and drop properties for list-based controls
       3. Maintaining type information during a copy
    3. Manually adding drag-and-drop support
       1. Classes used in drag-and-drop operations
       2. Drag-and-drop events for a drag initiator
       3. Drag-and-drop events for a drop target
       4. The drag-and-drop operation
       5. Example: Simple drag-and-drop operation for a nonlist-based control
       6. Example: Handling drag and drop events in a list-based control
    4. Using drag and drop with Flex applications running in AIR
    5. Drag and drop examples
       1. Example: Using a container as a drop target
       2. Example: Specifying the drag proxy
       3. Example: Handling the dragOver and dragExit events for the drop target
    6. Moving and copying data
       1. About moving data
       2. About copying data
       3. Example: Copying data from one List control to another List control
       4. Example: Copying data from a List control to a DataGrid control
       5. Example: Moving and copying data for a nonlist-based control
22. Chapter 22: Using Item Renderers and Item Editors
    1. About item renderers
       1. Default item rendering and cell editing
       2. Using custom item renderers and item editors
       3. Item renderer and item editor architecture
       4. About item renderer and item editor interfaces
       5. Application layout with item renderers and item editors
    2. Creating an item renderer and item editor
       1. Using a drop-in item renderer or item editor
       2. Using an inline item renderer or item editor
       3. Using a component as an item renderer or item editor
       4. Using editable controls in an item renderer
       5. Setting the itemRenderer or itemEditor property in ActionScript
       6. About the item renderer and item editor life cycle
       7. Accessing the listData property
       8. Handling data binding warnings from the compiler
    3. Creating drop-in item renderers and item editors
       1. Using drop-in item renderers and item editors
       2. Requirements of a drop-in item renderer in a List control
    4. Creating inline item renderers and editors
       1. Creating a simple inline item renderer or item editor
       2. Creating a complex inline item renderer or item editor
       3. Items allowed in an inline component
       4. Using the Component tag
    5. Creating item renderers and item editor components
       1. Creating an item renderer component
       2. Creating a simple item editor component
       3. Overriding the data property
       4. About using the creationComplete and dataChange events
       5. Creating an item renderer in ActionScript
    6. Working with item renderers
       1. Example: Using an item renderer with the TileList and HorizontalList controls
       2. Example: Using an item renderer with a DataGrid control
       3. Example: Using an item renderer with a List control
       4. Example: Using an item renderer with a Tree control
23. Chapter 23: Working with Item Editors
    1. The cell editing process
    2. Creating an editable cell
    3. Returning data from an item editor
       1. Defining a property to return data
    4. Sizing and positioning an item editor
    5. Creating an item editor that responds to the Enter key
    6. Using cell editing events
       1. Cell editing event classes
       2. Accessing cell data and the item editor in an event listener
       3. Determining the reason for an itemEditEnd event
    7. Item editor examples
       1. Example: Preventing a cell from being edited
       2. Example: Modifying data passed to or received from an item editor
       3. Example: Passing multiple values back from an item editor
       4. Example: Using an item renderer as an item editor
       5. Example: Using a data validator in a custom item editor
    8. Examples using item editors with the list-based controls
       1. Example: Using an item editor with a DataGrid control
       2. Example: Using a custom item editor with a List control
       3. Example: Using a custom item editor with a Tree control
24. Chapter 24: Using View States
    1. About view states
       1. Defining a login interface by using view states
       2. Example: Login form application
       3. Example: Controlling layout using view states
       4. Comparing view states to navigator containers
       5. Additional state-based application techniques
    2. Create and apply view states
       1. Creating view states
       2. View state overrides
       3. Applying view states
       4. Example: Creating a simple view state
       5. Basing a view state on another view state
       6. Using view state events
    3. Defining view state overrides
       1. Setting overrides on component properties
       2. Setting overrides on component styles
       3. Adding and removing components by using overrides (1/2)
       4. Adding and removing components by using overrides (2/2)
       5. Setting overrides on event handlers
    4. Defining view states in custom components
    5. Using view states with a custom item renderer
    6. Using view states with history management
    7. Creating your own override classes
25. Chapter 25: Using Transitions
    1. About transitions
       1. Example: Using transitions with a login form
       2. Comparing transitions to effects
    2. Defining transitions
       1. Defining multiple transitions
       2. Defining effect targets
       3. Defining the effect start and end values
    3. Handling events when using transitions
    4. Using action effects in a transition
       1. Example: Using action effects
    5. Filtering effects
       1. Example: Using a filter
       2. Defining a custom filter (1/2)
       3. Defining a custom filter (2/2)
    6. Transition tips and troubleshooting
       1. Tips
       2. Troubleshooting
26. Chapter 26: Using ToolTips
    1. About ToolTips
    2. Creating ToolTips
       1. Setting styles in ToolTips
       2. Setting the width of ToolTips
       3. Using ToolTip events
       4. Using ToolTips with NavBar controls
    3. Using the ToolTip Manager
       1. Enabling and disabling ToolTips
       2. Setting delay times
       3. Using effects with ToolTips
       4. Using dynamic ToolTip text
    4. Creating custom ToolTips
       1. Positioning custom ToolTips
    5. Using error tips
    6. Reskinning ToolTips
27. Chapter 27: Using the Cursor Manager
    1. About the Cursor Manager
    2. Creating and removing a cursor
    3. Using a busy cursor
       1. Setting a busy cursor
       2. Using the showBusyCursor property
28. Chapter 28: Dynamically Repeating Controls and Containers
    1. About Repeater components
    2. Using the Repeater component
       1. Declaring the Repeater component in MXML
       2. Referencing repeated components (1/2)
       3. Referencing repeated components (2/2)
       4. Using a Repeater component in a custom MXML component
       5. Dynamically creating components based on data type
       6. How a Repeater component executes
    3. Considerations when using a Repeater component
29. Chapter 29: Embedding Assets
    1. About embedding assets
       1. Examples of embedding assets
       2. Accessing assets at run time
       3. Supported file types
    2. Syntax for embedding assets
       1. Escaping the @ character
       2. Embed parameters
       3. About the source parameter
       4. About the MIME type
       5. Using the [Embed] metadata tag
       6. Using the @Embed() directive in MXML
       7. Embedding assets in style sheets
    3. Embedding asset types
       1. Embedding JPEG, GIF, and PNG images
       2. Embedding SVG images
       3. Embedding sounds
       4. Embedding SWF files
       5. Using 9-slice scaling with embedded images
       6. Embedding all other file types
30. Chapter 30: Creating Modular Applications
    1. Modular applications overview
       1. About modules
       2. Benefits of modules
       3. Module API details
       4. Module domains
    2. Writing modules
       1. Creating MXML-based modules
       2. Creating ActionScript-based modules
    3. Compiling modules
       1. Reducing module size
       2. Recompiling modules
       3. Debugging modules
    4. Loading and unloading modules
       1. Using the ModuleLoader class to load modules
       2. Using the ModuleManager class to load modules
       3. Loading modules from different servers
       4. Preloading modules
    5. Using ModuleLoader events
       1. Using the error event
       2. Using the progress event
    6. Passing data
       1. Accessing modules from the parent application
       2. Accessing the parent application from the modules
       3. Accessing modules from other modules
       4. Passing data with the query string
       5. Using interfaces for module communication
31. Chapter 31: Printing
    1. About printing by using Flex classes
    2. Using the FlexPrintJob class
    3. Using a print-specific output format
    4. Printing multipage output
       1. Printing known-length multipage output
       2. Using the PrintDataGrid control for multipage grids
       3. Example: Printing with multipage PrintDataGrid controls
       4. Using the PrintAdvancedDataGrid control
32. Chapter 32: Communicating with the Wrapper
    1. About exchanging data with Flex applications
       1. Accessing environment information
       2. Enabling Netscape connections
       3. About the ExternalInterface API
    2. Passing request data with flashVars properties
       1. Passing request data with flashVars properties
       2. Accessing the flashVars properties
    3. Accessing JavaScript functions from Flex
       1. Using the ExternalInterface API to access JavaScript from Flex
       2. Using the navigateToURL() method in Flex
    4. Accessing Flex from JavaScript
       1. Handling multiple browser types
       2. Editing the Flex application’s id and name properties
       3. Handling browsers that disable JavaScript
    5. About ExternalInterface API security in Flex
       1. About the call() method
       2. About the addCallback() method
33. Chapter 33: Using the Flex Ajax Bridge
    1. About the Flex Ajax Bridge
       1. When to use the Flex Ajax Bridge
       2. Requirements for using the Ajax Bridge
    2. Integrating with the Flex Ajax Bridge
       1. Automatic memory management
       2. Manually destroying objects
       3. Handling exceptions
       4. Limitations of the Flex Ajax Bridge
34. Chapter 34: Deep Linking
    1. About deep linking
       1. How deep linking works
       2. Deploying applications that use deep linking
       3. About the HistoryManager
    2. Using the BrowserManager
       1. Updating the URL
       2. Parsing the URL
       3. About BrowserManager events
    3. Setting the title of the HTML wrapper
    4. Passing request data with URL fragments
    5. Using deep linking with navigator containers
    6. Accessing information about the current URL
    7. Using the HistoryManager
       1. Using standard history management
       2. Using custom history management
35. Chapter 35: Using Shared Objects
    1. About shared objects
       1. Shared objects compared with cookies
       2. About the SharedObject class
    2. Creating a shared object
       1. Specifying a path
       2. Adding data to a shared object
       3. Creating multiple shared objects
    3. Destroying shared objects
    4. SharedObject example
36. Chapter 36: Localizing Flex Applications
    1. Introduction to localization
       1. Localizing Flex applications
       2. Choosing a locale
    2. Creating resources
       1. Compiling resources into Flex applications
       2. Properties file syntax
       3. Adding new locales
       4. About resource bundles
    3. Using resources
       1. Using the @Resource directive
       2. Using the ResourceManager
       3. Changing locales at run time with the ResourceManager
       4. About the ResourceManager
    4. Using resource modules
       1. Creating resource modules
       2. Loading resource modules at run time
       3. Preloading resource modules at run time
       4. Using a combination of compile-time resources and resource modules
       5. Unloading resource modules at run time
    5. Creating resource bundles at run time
       1. Adding, removing, or changing individual resources
       2. Enumerating resources
    6. Formatting dates, times, and currencies
    7. Adding styles and fonts to localized resources
    8. Editing framework resource properties
37. Chapter 37: Creating Accessible Applications
    1. Accessibility overview
       1. About worldwide accessibility standards
       2. Viewing the Flex Accessibility web page
    2. About screen reader technology
       1. Flash Player and Microsoft Active Accessibility
    3. Configuring Flex applications for accessibility
       1. Enabling accessibility in Flex
       2. Configuring a JAWS screen reader for Flex applications
    4. Accessible components and containers
       1. Accessibility for the AdvancedDataGrid control
    5. Creating tab order and reading order
       1. Scrolling to a component when tabbing
    6. Creating accessibility with ActionScript
       1. Implementing screen reader detection with the Accessibility.isActive() method
    7. Accessibility for hearing-impaired users
    8. Testing accessible content
38. Chapter 38: Accessing Server-Side Data with Flex
    1. Using HTTPService components
       1. Working with PHP and SQL data
       2. Working with ColdFusion and SQL data
       3. Working with JavaServer Pages
       4. Calling HTTP services in ActionScript
    2. Using WebService components
       1. Calling web services in ActionScript
       2. Reserved Operation names
       3. Reading WSDL documents
       4. RPC-oriented operations and document-oriented operations
       5. Stateful web services
       6. Working with SOAP headers
       7. Redirecting a web service to a different URL
       8. Serializing web service data
    3. Using RemoteObject components
       1. Sample RemoteObject application
       2. Calling RemoteObject components in ActionScript
       3. Accessing Java objects in the source path
       4. Accessing EJBs and other objects in JNDI
       5. Reserved method names
       6. Serializing between ActionScript and Java
    4. Explicit parameter passing and parameter binding
       1. Explicit parameter passing with RemoteObject and WebService components
       2. Explicit parameter passing with HTTPService components
       3. Parameter binding with RemoteObject components
       4. Parameter binding with HTTPService components
       5. Parameter binding with WebService components
    5. Handling service results
       1. Handling result and fault events
       2. Handling results as XML with the e4x result format
       3. Handling web service results that contain .NET DataSets or DataTables
39. Chapter 39: Representing Data
    1. About data representation
       1. Data binding
       2. Data models
       3. Data validation
       4. Data formatting
40. Chapter 40: Binding Data
    1. About data binding
       1. When data binding occurs
       2. Properties that support data binding
       3. Data binding uses
    2. Data binding examples
       1. Using data binding with data models
       2. Binding a source property to more than one destination property
       3. Binding more than one source property to a destination property
       4. Defining bidirectional bindings
    3. Binding to functions, Objects, and Arrays
       1. Using functions as the source for a data binding
       2. Using data binding with Objects
       3. Binding with arrays
    4. Using ActionScript in data binding expressions
       1. Using ActionScript expressions in curly braces
       2. Using ActionScript expressions in Binding tags
    5. Using an E4X expression in a data binding expression
       1. Using an E4X expression in curly braces
       2. Using an E4X expression in an tag
    6. Defining data bindings in ActionScript
       1. Differences between defining bindings in MXML and ActionScript
       2. Example: Defining a data binding in ActionScript
       3. Defining binding watchers
    7. Using the Bindable metadata tag
    8. Considerations for using the binding feature
       1. Debugging data binding
41. Chapter 41: Storing Data
    1. About data models
    2. Defining a data model
       1. The tag
       2. The tag
       3. Script-based models
       4. Class-based models
    3. Specifying an external source for an tag or tag
    4. Using validators with a data model
    5. Using a data model as a value object
    6. Binding data into an XML data model
42. Chapter 42: Validating Data
    1. Validating data
       1. About validators
       2. About the source and property properties
       3. About triggering validation
       4. About validating required fields
       5. About validation errors
       6. About validation events
       7. About custom validation
    2. Using validators
       1. Triggering validation by using events
       2. Triggering validation programmatically (1/2)
       3. Triggering validation programmatically (2/2)
       4. Validating required fields
       5. Enabling and disabling a validator
       6. Using data binding to configure validators
    3. General guidelines for validation
    4. Working with validation errors
       1. Configuring error messages
       2. Changing the color of the validation error message
       3. Showing a validation error by using errorString
       4. Clearing a validation error
       5. Specifying a listener for validation
    5. Working with validation events
       1. Explicitly handling component validation events
       2. Explicitly handing validator validation events
    6. Using standard validators
       1. Validating credit card numbers
       2. Validating currency
       3. Validating dates
       4. Validating e-mail addresses
       5. Validating numbers
       6. Validating phone numbers
       7. Validating using regular expressions
       8. Validating social security numbers
       9. Validating strings
       10. Validating ZIP codes
43. Chapter 43: Formatting Data
    1. Using formatters
    2. Writing an error handler function
    3. Using the standard formatters
       1. Formatting currency
       2. Formatting dates
       3. Formatting numbers
       4. Formatting phone numbers
       5. Formatting zip codes