Adobe Flex Training Course

Overview

This is a four-day, hands-on introduction to develop rich Internet applications (RIAs) for the Adobe Flash platform using the Adobe Flex 4 framework.

Objective

At the end of Adobe Flex training course, the participants will learn how to develop client rich applications with Flex and connect Flex front end to remote, dynamic data using Flex Data services with Flex.

Suggested Audience - Developers wishing to build rich Internet applications in Flex.

Duration - 4 days

Prerequisites - Programming and XML experience

Syllabus

1. Introducing Adobe Flex 4 Introducing the Adobe Flash Platform Introducing the technologies Building Flex applications Experiencing applications Learning more about Flex Understanding Flex development technologies Understanding the Flex framework, SDK and tool Understanding Adobe Flash Builder 4 Understanding Flash Player Debugger Version Understanding Flex application deployment Exploring the Flash Builder interface Grouping projects with workspaces Understanding the workbench Understanding editors Understanding views Understanding perspectives Adding and configuring components in Design mode Creating a Flex project Using the New Flex Project wizard	2. Understanding Flex 4 Fundamentals Understanding Adobe Flex namespaces Understanding how namespaces translate into Flex libraries Understanding Flex components Assigning component properties Adding images Laying out and styling with Flash Builder Setting component properties Setting styles using a CSS style sheet Compiling and running an application Compiling the application in Flash Builder Running the application Creating custom components Controlling component layout in containers Defining and using a custom component Introducing skinning Defining a skin class Applying a skin class Accessing and using structured data within a custom component Declaring non-visual objects in MXML Defining inline event handlers Generating event handler functions Introducing data binding Implementing data binding Declaring and using bindable properties Passing data to an embedded control through a custom component property Updating visual controls using dynamic data Capturing the current item in a list control Using data binding to dynamically update visual controls Adding and removing event listeners using Action Script
3. Introducing Object Oriented Programming Introducing OOP terminology Understanding classes Understanding instances and objects Understanding class relationships Understanding MXML classes Exploring the Flex framework classes Creating class instances Extending the Flex framework classes Creating a class property Creating the property Controlling access Creating and using a public property Writing a class definition in Action Script Creating a class Packaging a class Naming a class Understanding the constructor Creating class properties Assigning property values through the constructor Making properties or classes bindable Creating instances of an Action Script class Creating class methods	4. Understanding Components and Layouts Introducing visual components Introducing Spark v/s MX components Understanding components Introducing Spark layout classes Defining the layout property Understanding the Basic Layout class Understanding the Horizontal Layout class Understanding the Vertical Layout class Understanding the Tile Layout class Custom layout classes Introducing the Spark container classes Understanding how the containers work Understanding the Spark containers Reviewing the Application container Introducing the Group container Introducing the Panel container Introducing the Border container Sample application layout Defining layout properties Using constraints to control component layout Understanding constraint-based layout basics Rules to control component layout Constraint-based vs. traditional container layout Visually assigning anchors Adding scrollbars to containers Implementing the Scroller class
5. Handling Events Understanding events Handling framework events Handling user events Implementing event handlers Using inline Action Script in MXML Creating Action Script event handler functions Defining a function in an MXML document Creating functions in external files Understanding the event object Introducing the event object Exploring event object properties Data typing the event object Understanding event bubbling Distinguishing current Target and target Introducing event bubbling Adding event listeners with Action Script	6. Using the Form Container Using the Form container Introducing the Form components Creating a Form custom component Customizing the Form Item container display Using sequence labels Using help content Using prompts with text controls Using a custom required icon Displaying the Spark Form in a stacked layout Creating a Form with the stacked layout using CSS
7. Validating and Formatting Data Using formatters Introducing MX formatters Introducing Spark formatters Defining formatters Using formatters Validating form data Introducing MX validators Introducing Spark validators Creating a validator with MXML Creating a validator with Action Script Handling required values Triggering validation with events When validation fails Using a custom error icon Using the Spark Number Validator class Triggering validation with Action Script Suppressing automatic validation Using the validate() method Triggering multiple validators	8. Controlling Navigation Understanding MX navigator containers Controlling container display Introducing the MX navigator containers Using the View Stack container Understanding View Stack basics Navigating with the MX Link Bar control Navigating with the Spark Tab Bar and Button Bar controls Displaying and resizing the View Stack child containers Deferring instantiation of View Stack child containers Using a Spark container inside MX navigator containers Creating custom navigation for the View Stack container Setting the active View Stack child container Enabling buttons dynamically Using the Tab Navigator container Using the Accordion container
9. Controlling Application State Understanding view states Introducing view states Creating view states in Design mode Creating view states with code Controlling view states Introducing the current State property Switching between states	10. Animating Components and States Applying effects to components Interacting with users using animated effects Understanding effect basics Reviewing available effects Defining an effect Playing an effect Creating composite effects Applying transitions to application state changes Creating transitions Adding and removing components during animations
11. Controlling Visual Display with Styling Creating global application styles Generating the styles using the Appearance view in Design mode Flash Builder automatically creates CSS file Global v/s Application selector Defining styles and skins for components Creating Flex component selectors Create custom component selectors Applying a component skin via CSS Introducing advanced CSS selectors Descendent selector id selector Class selector Pseudo selector	12. Skinning Spark Components Introducing skinning Understanding Spark skins Setting styles inline in the MXML tags Introducing the skinnable Spark container classes Creating a skin for Spark components Incorporating visual elements drawn in other programs Introducing FXG Changing the default display of skin parts Reviewing the content Group skin part for containers Understanding a Button control's skin part Understanding the Panel container's skin parts Finding skin parts for any component Choosing a component to display the skin part
13. Implementing Advanced Skinning Techniques Implementing different visual states for a skin Understanding skin states in Button component Assigning properties for each state Adding transitions in skin states Animating the button states Accessing custom component properties from a skin Defining the custom property in the custom component Creating the skin and component contract Referencing the properties in the skin Adding scrollbars to skins Using the Scroller with nonskinnable containers Using the Scroller with skinnable containers	14. Accessing Remote Data Using HTTP Service to load remote data Using the HTTP Service class Process for making HTTP requests Retrieving data with last Result Understanding the Array Collection results Using results in data bindings Handling returned data and faults Handling results Handling faults Displaying messages with an Alert pop-up Using result and fault handlers example Making HTTP requests with parameters Using explicit parameter passing Using parameter binding Using the Flash Builder wizards Understanding the Call Responder class Creating a master/detail form
15. Creating a Typed Data Model Understanding the need for a typed data model Working with a model of generic data Creating a model of typed data Understanding value objects Creating value objects Creating an Action Script class for typed data Reviewing class paths and packages Creating class files Defining class access modifiers Creating class constructors Defining class properties Instantiating an Action Script class Populating an Array Collection with value objects Comparing Array Collection with Array List Understanding data bindings with value objects Making Action Script class properties bindable Binding the view to the model Binding two-way Refactoring value objects Downcasting object references	16. Extending Events Understanding the problem with bindings The problem of using bindings Creating loosely coupled components Defining the event type Defining the event in the dispatching component Triggering the event from a user or system event Instantiating the event Dispatching the event to the main application Handling the event in the main application Extending the Event class Creating the extended class Extending the Event class Adding properties Creating the constructor Using the extended event class Using the Metadata compiler directive Dispatch the extended event Handling the event in the main application Dispatching a value object with the extended event Accommodating a value object in the extended event Overriding the clone method Passing a parameter to toggle event bubbling
17. Rendering Content with the Data Group Container Displaying string data in an item renderer Understanding Data Group container basics Implementing the Data Group container Using the default item renderer Creating a custom item renderer Understanding the limits of the default item renderer Creating a custom item renderer Creating a nested item renderer Referencing an external item renderer class Using data in an item renderer Specifying how to visually render items Determining a renderer at runtime Using the Scroller with a Data Group Using the Skinnable Data Container Implementing the Skinnable Data Container Creating the skin component	18. Displaying Data Using the DataGrid Using the DataGrid control Supplying data to a DataGrid control Specifying DataGrid control columns Formatting DataGrid control columns Setting column widths with a typical item Formatting data in a label function Creating reusable label functions Using item renderers and item editors Understanding Item renderers versus item editors Introducing the types of item renderers and item editors Creating custom item renderer and item editor components Using events and selected items with a DataGrid component Customizing the DataGrid skin
19. Deploying Flex and AIR Applications Compiling the Flex application Compiling automatically Modifying compiler settings Embedding the SWF in the HTML wrapper Understanding the runtime shared libraries Creating a Flex application production build Creating a release build Creating a desktop application Creating an AIR project Understanding some differences between Flex and AIR applications Exporting a release build