New Toronto Group

Flex 4.5: Developing Rich Internet Applications New Toronto Group

Description

This is a four day, hands-on introduction to developing Rich Internet Applications (RIAs) for the Adobe Flash Platform using the Adobe Flex 4.5 framework. Emphasized topics include:

  • Custom components and layout control
  • Handling and extending events
  • Validating and formatting data
  • Navigation, animation, and visual state control
  • Text and style control
  • Spark component skinning
  • Introduction to remote data access
  • Working with typed data in DataGroup and DataGrid components
  • Deploying Flex applications over the web and on AIR

 

Cost

Duration

4 Days

Classes

Register for NTG Training

Flex 4.5: Developing Rich Internet Applications

Date:

Location:

Price:

New Toronto Group

4 Robert Speck Parkway, Suite 240

Mississauga ON L4Z 1S1,

Canada

 

Toll Free: 866-464-7790

Office: 905-897-7790

Fax: 905-897-9952





After pressing Submit, someone from New Toronto Group will call/email to confirm registration details, answer questions and take payment.


Prerequisites

To gain the most from this class, you should already:

  • Be familiar with basic programming concepts, processes and constructs
  • Be familiar with XML, HTML and CSS

 

Audience

Developers wishing to build rich Internet applications using the Adobe Flex 4.5 framework.

Outline

Module 1: Introducing the Course

  • Introducing mastery learning
  • Understanding the course format
  • Reviewing the course prerequisites
  • Reviewing the course outline

Module 2: Introducing Adobe Flex 4.5

  • 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.5
  • 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

Module 3: Understanding Flex 4.5 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 ActionScript

Module 4: 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 ActionScript
  • 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 ActionScript class
  • Creating class methods

Module 5: Understanding Components and Layouts

  • Introducing visual components
  • Introducing Spark vs MX components
  • Understanding components
  • Introducing Spark layout classes
  • Defining the layout property
  • Understanding the BasicLayout class
  • Understanding the HorizontalLayout class
  • Understanding the VerticalLayout class
  • Understanding the TileLayout 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 BorderContainer
  • 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

Module 6: Handling Events

  • Understanding events
  • Handling framework events
  • Handling user events
  • Implementing event handlers
  • Using inline ActionScript in MXML
  • Creating ActionScript 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
  • Datatyping the event object
  • Understanding event bubbling
  • Distinguishing currentTarget and target
  • Introducing event bubbling
  • Adding event listeners with ActionScript

Module 7: Using the Form Container

  • Using the Form container
  • Introducing the Form components
  • Creating a Form custom component
  • Customizing the FormItem 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

Module 8: 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 ActionScript
  • Handling required values
  • Triggering validation with events
  • When validation fails
  • Using a custom error icon
  • Using the Spark NumberValidator class
  • Triggering validation with ActionScript
  • Suppressing automatic validation
  • Using the validate() method
  • Triggering multiple validators

Module 9: Controlling Navigation

  • Understanding MX navigator containers
  • Controlling container display
  • Introducing the MX navigator containers
  • Using the ViewStack container
  • Understanding ViewStack basics
  • Navigating with the MX LinkBar control
  • Navigating with the Spark TabBar and ButtonBar controls
  • Displaying and resizing the ViewStack child containers
  • Deferring instantiation of ViewStack child containers
  • Using a Spark container inside MX navigator containers
  • Creating custom navigation for the ViewStack container
  • Setting the active ViewStack child container
  • Enabling buttons dynamically
  • Using the TabNavigator container
  • Using the Accordion container

Module 10: 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 currentState property
  • Switching between states

Module 11: 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

Module 12: 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 vs 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

Module 13: 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 contentGroup 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

Module 14: 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

Module 15: Accessing Remote Data

  • Using HTTPService to load remote data
  • Using the HTTPService class
  • Process for making HTTP requests
  • Retrieving data with lastResult
  • Understanding the ArrayCollection 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 CallResponder class
  • Creating a master/detail form

Module 16: 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 ActionScript class for typed data
  • Reviewing classpaths and packages
  • Creating class files
  • Defining class access modifiers
  • Creating class constructors
  • Defining class properties
  • Instantiating an ActionScript class
  • Populating an ArrayCollection with value objects
  • Comparing ArrayCollection with ArrayList
  • Understanding data bindings with value objects
  • Making ActionScript class properties bindable
  • Binding the view to the model
  • Binding two-way
  • Refactoring value objects
  • Downcasting object references

Module 17: 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

Module 18: Rendering Content with the DataGroup Container

  • Displaying string data in an item renderer
  • Understanding DataGroup container basics
  • Implementing the DataGroup 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 DataGroup
  • Using the SkinnableDataContainer
  • Implementing the SkinnableDataContainer
  • Creating the skin component

Module 19: 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

Module 20: 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