false
Professional Adobe Flex 2 by Renaun Erickson, Simon Barber, Rich Tretola
BUY IT NEW
- $49.99 Online Price$44.99 Member price(Save 10%)Limited Time Offer! Everyone receives the Member Price on books.
See Details
- Add To List uiAction=GetAllLists&page=List&pageType=list&ean=9780470102671&productCode=BK&maxCount=100&threshold=3
DELIVERY & GIFT DETAILS:
Usually ships within 24 hours
Delivery Time and Shipping Rates
Eligible for gift wrap & gift message.
Customers who bought this also bought
Product Details
- Pub. Date: May 2007
- Publisher: Wiley, John & Sons, Incorporated
- Format: Paperback, 600pp
- Series: Programmer to Programmer Series
- ISBN-13: 9780470102671
- ISBN: 0470102675
Synopsis
Wrox's Professional Flex 2 is one of the first guides to Adobe's (Macromedia's) new web application development platform. Flex experts Simon Barber, Rich Tretola and John Bennett share their experience with Flex 2, and teach readers how to leverage the platform to build rich internet applications. Professional Flex 2 relies heavy on practical examples, making this a hands-on guide that will get readers up and running with Flex 2 quickly.
Topics include:
- Building applications with Flex Builder
- Flex programming model
- Using Actionscript 3.0
- Developing applications in MXML
- Creating UIs with Flex controls and containers
- Data access and interconnectivity
- Creating custom flex components
- Charting
- Testing, debugging and deploying Flex applications
- and more
Biography
Rich Tretola (Indianapolis, IN) is a programmer who specializes in developing rich internet applications using Flash and Flex with Java (Hibernate) for data persistence and the Cairngorm framework. He has written a number of articles on Flex, and his most recent thoughts can be found on his Flex website, EverythingFlex.com.
Simon Barber (Cape Town, South Africa) is a web developer and founder of ThoughtFaqtory, where they develop rich internet applications for clients large and small. Simon is well-known in the Flex community and has been working with the technology since its earliest alphas.
Renaun Erickson (Las Vegas, NV) is a RIA developer specializing in Flex, ColdFusion and PHP. He is an Adobe Community Expert and active in the community through his popular blog and the Las Vegas Adobe User Group.
From the Publisher
Wrox's Professional Flex 2 is one of the first guides to Adobe's (Macromedia's) new web application development platform. Flex experts Simon Barber, Rich Tretola and John Bennett share their experience with Flex 2, and teach readers how to leverage the platform to build rich internet applications. Professional Flex 2 relies heavy on practical examples, making this a hands-on guide that will get readers up and running with Flex 2 quickly.
Topics include:
- Building applications with Flex Builder
- Flex programming model
- Using Actionscript 3.0
- Developing applications in MXML
- Creating UIs with Flex controls and containers
- Data access and interconnectivity
- Creating custom flex components
- Charting
- Testing, debugging and deploying Flex applications
- and more
Product Details
- Pub. Date: May 2007
- Publisher: Wiley, John & Sons, Incorporated
- Format: Paperback, 600pp
- Series: Programmer to Programmer Series
- ISBN-13: 9780470102671
- ISBN: 0470102675
Table of Contents
Acknowledgments ix
Introduction xxvii
Getting Started 1
Introducing Flex 2.0 3
Rich Internet Applications 3
OpenLaszIo 3
Ajax 4
XUL 4
Windows Presentation Foundation 4
History of RIA 4
Benefits of RIA 4
Overview of Flex 5
Flex 2 5
Flash Player 9 5
Flex Builder 2 6
Flex Free SDK 2 6
Flex Data Services (FDS) 7
Flex Charting 8
Summary 8
Introducing Flex Builder 2.0 9
Flex Builder 2.0 Eclipse Standalone and Plugin 10
Creating a Flex Project 10
Flex Builder Perspectives 14
The Development Perspective Source Mode 14
The Development Perspective Design Mode 15
The Debugging Perspective 19
Debugging Your Application 19
Starting the Debugger 22
Compiling Your Application 23
Running Your Application 24
Summary 24
Flex 2.0Basics 25
Flex 2 Programming Model 25
MXML 25
ActionScript 27
Flex Class Library 30
Flex Charting Components 31
Charting Types 31
Flex Data Services 32
Data Management Service 32
Messaging Service 33
Publish-Subscribe Messaging 33
Data Push 34
RPC Services 34
FDS Alternatives 34
Summary 34
Using Flex Builder 2.0 35
Getting Started with Flex Builder 35
Learning Flex Builder 36
Flex Builder Workbench Basics 40
Flex Builder Basics 44
Working with Projects 44
Running Applications 50
Navigating and Customizing the Flex Builder Workbench 52
Developing with Design Mode 54
Building a Flex User Interface 54
Adding View States and Transitions 56
Adding Interactivity with Behaviors 56
Programming Flex Applications 57
Code Editing in Flex Builder 57
Summary 58
Developing in Flex 2.0 59
Programming Languages 61
Developing MXML Applications 61
UI Layout Using Containers 61
UI Controls 63
XML Namespaces 63
Data Binding with Components 64
RPC Services 65
Data Validation 67
Data Formatting 68
Cascading Style Sheet (CSS) 69
Skins 70
Adding Effects 72
Custom MXML Components 73
MXML 74
Basic MXML Syntax 74
MXML Naming Conventions 74
ActionScript 75
Flex Components 75
Separating ActionScript from MXML 78
Developing ActionScript Components 79
Performing Reflection 80
Handling Events 84
Event Flow 84
Event Class 85
EventDispatcher Class 85
Event Usage 86
Propagation 88
Priorities 90
Subclassing Events 91
Keyboard Events 92
Summary 93
Building User Interfaces 95
Visual Components 95
Class Hierarchy 95
UIComponent Class 96
Component Sizing 97
Event Handling 98
Styling Components 101
Adding Behaviors 103
Applying Skins 104
Modifying Components at Run-time 104
Extending Components 105
Data Providers and Collections 106
Data Providers 106
Collections 109
IList interface 111
ICollectionView 112
Collection Change Events 115
Hierarchical Data Providers 117
Remote Data Providers 119
Positioning and Sizing Components 120
Layout of Components 120
Component Sizing 121
Component Positioning and Layout 122
Constraint-based Layout 123
Getting Familiar with Flex Controls 124
Summary 125
Customizing the User Interface 127
Applying Behaviors 127
Using Behaviors 128
Applying Styles 131
Using Styles 132
Using Local, Application, and Global Selectors 133
Applying Fonts 134
Device Fonts 134
Embedded Fonts 135
FlashType Fonts 136
Skinning the Application 140
Graphical Skins 140
Programmatic Skins 141
Item Renderers 143
Building Custom Item Renderers and Item Editors 144
Item Editors 147
Overview of Cell Editing Process 147
Editable Cell 147
Returning Data from an Item Editor 148
Sizing and Positioning an Item Editor 148
Cell Editing Events 149
Tooltips 152
Creating Tooltips 153
ToolTipManager Class 155
Cursor Manager 157
Adding and Removing Cursors 157
Busy Cursor 158
Summary 159
Flex UI Topics 161
Repeaters and Containers 161
Using the Repeater Component 161
Repeater Component Execution Process 162
Using View States 165
Using Transitions 167
Transitions Applied to View States 167
Transition Event Handling 169
Transition Action Effects 170
Effects and Filters 170
Using the Drag-and-Drop Manager 171
List Control Drag-and-Drop Functions 171
Adding Drag-and-Drop Support to Other Components 172
Embedding Assets 175
Images 175
Fonts 176
SWF and Sound Files 176
Using the History Manager 177
Components with Built-in History Management 177
Adding History Management to Components 177
Flex Printing 180
Basic Printing 181
Printing Multiple Pages 181
Printing Grid Data 182
Communicating with the Wrapper 183
Flex to JavaScript, JavaScript to Flex 183
Verifying that JavaScript Has Loaded 185
Working with Shared Objects 187
Saving and Reloading Data from Shared Objects 187
Designing Accessible Applications 189
Enabling Accessibility in Your Application 189
Components with Built-in Accessibility 189
Customizing Your Components for Accessibility 189
Summary 190
Flex Data 191
Data Binding 191
Using [left angle bracket]mx:Binding[right angle bracket] 191
Binding to Variables with [Bindable] 192
Binding Directly to Component Properties 193
Data Modeling with Flex 194
A Basic Data Model 194
Using an External XML File 195
Binding a Data Model to a Custom Component 196
Binding Data to a Data Model 198
Validating Data 200
Flex Built-in Validators 200
Validating a Data Model 201
Simple Data Validation Using errorString 203
Testing Validation Events 204
Validating with ActionScript 207
Formatting Data 208
Flex Built-in Formatters 208
Formatter Errors 210
Summary 211
Flex Charting 213
Flex Chart Examples 213
Area Chart 215
Bar Chart 216
Bubble Chart 218
Column Chart 220
Line Chart 222
Pie Chart 223
Plot Chart 225
Candlestick Chart 226
HighLowOpenClose (HLOC) Chart 228
Charting Classes 229
Axis Label 229
Axis Title 230
Axis Renderer 230
Grid Lines 231
Axis Types 231
ChartItem 232
ChartItemEvent 232
Hit Data 232
Legend 232
Advanced Charting 232
Chart Events 232
Drill-Down Charts 234
Mixed Series Types 236
Multiple-Axis Charts 237
Axis Rotation 239
Charting Effects 240
SeriesInterpolate 240
SeriesSlide 240
SeriesZoom 240
Chart Style Examples 241
Summary 244
Data Access 245
Server-side Data 245
Flex Data Access 245
RPC Services 246
Data Management Service 247
Messaging Service 248
Data Services Configuration 248
Service Configuration Files 248
Message Channels 249
Data Serialization 250
Destinations and Security 258
Configuring Logging 259
Software Clustering 261
Custom Error Handling 262
RPC Service Components 263
Defining RPC Components 263
Calling a Service and Handling Results 264
RPC Services Configuration 265
Destination Configuration 265
Destination Properties 266
Flex Messaging 267
The Basics of Flex Messaging 267
Flex Messaging Architecture 268
Producer Components 269
Consumer Components 272
Message Service Configuration 274
Message Service Configuration 274
Message Service Destination Configuration 275
Building a Custom Message Service Adapter 277
Data Management Services 278
Data Management Service vs. RPC Features 278
Data Management Service Data Flow 279
Data Synchronization Conflicts 279
Distributed Data 280
Distributed Data Application 280
Class Mappings 281
Data Synchronization Handling 283
Data Management Service Configuration 284
Data Management Service Destination Configuration 284
Data Push from Servers to Client 286
Summary 286
Creating and Extending Flex Components 287
Creating MXML Components 289
Creating Simple MXML Components 289
Scoping Your Components 291
Styling Your Components 292
Advanced MXML Components 293
Adding Custom Properties and Methods to a Component 293
Creating Composite Components 295
Template Components 297
Creating a Template Component 297
Using a Template Component 298
MXML Interfaces 302
Creating Interfaces 302
Using Interfaces 302
Using IMXMLObject 303
Summary 304
Flex Component Properties 305
Elements of a Component 305
The package Statement 305
Import Statements 306
Defining the Class Name 306
The Default Constructor 306
Defining Properties 307
Defining Methods 309
Overriding Methods Using super 311
Creating a Simple ActionScript Component 313
Implementing and Overriding UIComponent Methods 314
Creating Advanced Components in ActionScript 315
Summary 318
Flex Components 319
Custom Events in Components 319
Dispatching Custom Events 319
Using Metadata Tags in Components 321
[ArrayElementType] 321
[Bindable] 321
[DefaultProperty] 324
[Embed] 324
[Event] 325
[Effect] 326
[IconFile] 327
[Inspectable] 327
[InstanceType] 328
[NonCommittingChangeEvent] 328
[RemoteClass] 330
[Style] 330
Compiling Components 332
Compiling Components with Flex SDK 332
Compiling Components with Flex Builder 332
Deploying Components 338
Summary 340
Custom Formatter, Validator, and Effect Components 341
Custom Formatters 341
Customizing the SwitchSymbolFormatter Class 341
Extending the Formatter Class 344
Custom Formatter Example 345
Formatter Errors 346
Custom Validators 347
Creating Effects 349
Extending the Effect Class 349
Extending the EffectInstance Class 350
Custom Effect Example 350
Extending the TweenEffect Class 353
Extending the TweenEffectInstance Class 353
Custom TweenEffect Example 354
Custom Effect Triggers 357
Summary 359
Programming ActionScript 3.0 361
Overview of ActionScript Programming 363
Introduction to ActionScript 363
What's New in ActionScript 3.0 364
Compatibility with Previous Versions 366
Getting Started with ActionScript 367
ActionScript 3.0 Is More than Flex 367
ActionScript 3.0 Coding Considerations 372
Running ActionScript Applications 373
Display Programming 374
Understanding the Display Architecture 374
Working with Display Objects 376
Using the Core Display Classes 381
Summary 387
Data Types and Classes 389
Value Types 389
Primitive Data Types 390
Complex Data Types 390
Dates and Times 391
Creating Calendar Dates and Times 391
Retrieving Time Values by Unit 392
Date Manipulation 393
Strings 395
Length Property 395
Characters in Strings 395
String Comparison 396
Obtaining String Representations of Objects 396
Concatenation 397
Patterns and Substrings 397
Uppercase and Lowercase Conversion 399
Arrays 399
Index Arrays 399
Associative Arrays 403
Multidimensional Arrays 407
Cloning Arrays 408
Error Handling 408
Error Types 408
Custom Error Classes 411
Exception Handling 414
Regular Expressions 415
Regular Expressions and Strings 415
Using the RegExp Class 416
Using Groups 417
XML 418
Introduction to XML 418
E4X Introduction 420
E4X Classes 420
Summary 426
Building and Deploying Flex 2.0 Applications 427
Building and Deploying Flex Applications 429
Flex Framework and Application Directory Structure 429
Flex and Flash Player Security and Technology Concerns 432
Network Security Concerns 432
Open Technology Concerns 433
Flash Player Security Features 434
Building and Deploying Applications 435
Building for Flex 2 SDK 436
Building for Flex Data Services 2 437
Compiling an Application 439
Deployment Directory Structure 442
Applying Flex Security 445
Flex Security Features 445
Improving Startup Performance 447
Startup Order 447
Using Deferred Creation 449
Deferring Component Creation 452
Using Ordered Creation 455
Using the callLater() Method 458
Summary 460
Debugging and Testing 461
Logging Overview 461
Flash Debug Player 462
Logging API 463
Compiler Logging 464
Web-tier Logging 464
Client-side Logging 464
Using the Logging API 465
Custom Logger 465
Flex Builder Debugging Tools 471
Invoking 472
Configuring 472
Breakpoints and Stepping 475
Command-line Debugger 475
Invoking 475
Configuring 476
Debugger Commands 477
Summary 478
Deploying Flex Applications 479
Deployment Considerations 479
Server-side and Client-side Caching 481
Deployment Options 485
RSL Deployment 485
Flash Player Sandbox and Cross-Domain Consideration 487
Deploying a Flex 2 SDK Application that Uses RSL 488
Compiling for Deployment 493
Troubleshooting Tips and Common Deployment Problems 497
Asset and Dependent Files 497
Run-time Data Access 498
Proxy Server 498
Accessing Server-side Resources from Different Domains 499
Deploying a Flex Data Service Application Under Tomcat 500
Configuring for FDS 506
Creating a Wrapper 508
Migrating and Transferring Files 509
Defining Features 510
mxmlc Compiler 511
Adding Features to the Wrapper 512
Creating a Wrapper that Supports Web Standards 514
[left angle bracket]object[right angle bracket] and [left angle bracket]embed[right angle bracket] 518
Using Express Install 520
Editing Your Wrapper 521
Configuring Express Install on Flex Data Services 525
Upgrading Without Express Install 526
Summary 527
Advanced Flex 2.0 529
Using the Cairngorm Framework 531
The Cairngorm Framework 531
Understanding Frameworks 532
Application Frameworks 532
Architectural Frameworks 532
Building an Application Using the Cairngorm Framework 533
Value Object and Model Locator Pattern 534
The View 537
The Front Controller, Cairngorm Event Broadcaster, and Command Patterns 541
Business Delegate and Service Locator 545
Summary 547
Using the Flex-Ajax Bridge 549
Why Use Flex with JavaScript? 549
Requirements for the FA Bridge 550
Memory-Consumption Issues 551
Flex-Ajax Bridge Samples 551
Using Flex Validators from JavaScript 551
Create Flex Components Using JavaScript 555
Summary 559
Using the ActionScript 3.0 Libraries 561
Types of Libraries 562
How to Include the SWC in Your Application 562
Building a Simple Application Using One of the Libraries 565
Summary 571
Using ColdFusion/Flex Connectivity 573
Using the Flash Remoting Update 573
Using the Flex Messaging Event Gateway 583
The Structure of Messages 585
Using the ColdFusion Event Gateway Adapter 587
Using the Flex Data Service Assembler 591
Configuring ColdFusion 591
Value Object CFC 594
EmployeeAssembler.cfc 595
The DAO.cfc 596
ColdFusion Extensions for Flex Builder 2 597
Eclipse RDS Support Plugin 597
Installation 601
Create CFC Wizard 604
ActionScript to CFC Wizard 605
CFC to ActionScript Wizard 605
Services Browser 606
Summary 606
Integration Techniques 607
Rich Media Integration 609
Integration 610
Audio 610
Video 610
Using the Camera 612
Building an Application with Rich Media Integration 613
The Inner Workings of the Application 617
Summary 620
Integration with External Applications 621
Using the External API 621
AVM1 and AVM2 SWF Communication 622
ExternalInterface and LocalConnection 625
Building Custom Tracing Utility 626
Flash Player Process Structure 626
Using LocalConnection and C# .NET Windows Application 627
Summary 641
Flex 2.0.1 643
Run-time CSS Support 643
ASDoc Tool 647
ASDoc Tags and Syntax 647
Documenting the Logger Classes 648
Using the ASDoc Compiler 649
Documenting the Logger Classes - Continued 650
Building Modular Flex Applications 657
Summary 663
Index 665
Introduction xxvii
Getting Started 1
Introducing Flex 2.0 3
Rich Internet Applications 3
OpenLaszIo 3
Ajax 4
XUL 4
Windows Presentation Foundation 4
History of RIA 4
Benefits of RIA 4
Overview of Flex 5
Flex 2 5
Flash Player 9 5
Flex Builder 2 6
Flex Free SDK 2 6
Flex Data Services (FDS) 7
Flex Charting 8
Summary 8
Introducing Flex Builder 2.0 9
Flex Builder 2.0 Eclipse Standalone and Plugin 10
Creating a Flex Project 10
Flex Builder Perspectives 14
The Development Perspective Source Mode 14
The Development Perspective Design Mode 15
The Debugging Perspective 19
Debugging Your Application 19
Starting the Debugger 22
Compiling Your Application 23
Running Your Application 24
Summary 24
Flex 2.0Basics 25
Flex 2 Programming Model 25
MXML 25
ActionScript 27
Flex Class Library 30
Flex Charting Components 31
Charting Types 31
Flex Data Services 32
Data Management Service 32
Messaging Service 33
Publish-Subscribe Messaging 33
Data Push 34
RPC Services 34
FDS Alternatives 34
Summary 34
Using Flex Builder 2.0 35
Getting Started with Flex Builder 35
Learning Flex Builder 36
Flex Builder Workbench Basics 40
Flex Builder Basics 44
Working with Projects 44
Running Applications 50
Navigating and Customizing the Flex Builder Workbench 52
Developing with Design Mode 54
Building a Flex User Interface 54
Adding View States and Transitions 56
Adding Interactivity with Behaviors 56
Programming Flex Applications 57
Code Editing in Flex Builder 57
Summary 58
Developing in Flex 2.0 59
Programming Languages 61
Developing MXML Applications 61
UI Layout Using Containers 61
UI Controls 63
XML Namespaces 63
Data Binding with Components 64
RPC Services 65
Data Validation 67
Data Formatting 68
Cascading Style Sheet (CSS) 69
Skins 70
Adding Effects 72
Custom MXML Components 73
MXML 74
Basic MXML Syntax 74
MXML Naming Conventions 74
ActionScript 75
Flex Components 75
Separating ActionScript from MXML 78
Developing ActionScript Components 79
Performing Reflection 80
Handling Events 84
Event Flow 84
Event Class 85
EventDispatcher Class 85
Event Usage 86
Propagation 88
Priorities 90
Subclassing Events 91
Keyboard Events 92
Summary 93
Building User Interfaces 95
Visual Components 95
Class Hierarchy 95
UIComponent Class 96
Component Sizing 97
Event Handling 98
Styling Components 101
Adding Behaviors 103
Applying Skins 104
Modifying Components at Run-time 104
Extending Components 105
Data Providers and Collections 106
Data Providers 106
Collections 109
IList interface 111
ICollectionView 112
Collection Change Events 115
Hierarchical Data Providers 117
Remote Data Providers 119
Positioning and Sizing Components 120
Layout of Components 120
Component Sizing 121
Component Positioning and Layout 122
Constraint-based Layout 123
Getting Familiar with Flex Controls 124
Summary 125
Customizing the User Interface 127
Applying Behaviors 127
Using Behaviors 128
Applying Styles 131
Using Styles 132
Using Local, Application, and Global Selectors 133
Applying Fonts 134
Device Fonts 134
Embedded Fonts 135
FlashType Fonts 136
Skinning the Application 140
Graphical Skins 140
Programmatic Skins 141
Item Renderers 143
Building Custom Item Renderers and Item Editors 144
Item Editors 147
Overview of Cell Editing Process 147
Editable Cell 147
Returning Data from an Item Editor 148
Sizing and Positioning an Item Editor 148
Cell Editing Events 149
Tooltips 152
Creating Tooltips 153
ToolTipManager Class 155
Cursor Manager 157
Adding and Removing Cursors 157
Busy Cursor 158
Summary 159
Flex UI Topics 161
Repeaters and Containers 161
Using the Repeater Component 161
Repeater Component Execution Process 162
Using View States 165
Using Transitions 167
Transitions Applied to View States 167
Transition Event Handling 169
Transition Action Effects 170
Effects and Filters 170
Using the Drag-and-Drop Manager 171
List Control Drag-and-Drop Functions 171
Adding Drag-and-Drop Support to Other Components 172
Embedding Assets 175
Images 175
Fonts 176
SWF and Sound Files 176
Using the History Manager 177
Components with Built-in History Management 177
Adding History Management to Components 177
Flex Printing 180
Basic Printing 181
Printing Multiple Pages 181
Printing Grid Data 182
Communicating with the Wrapper 183
Flex to JavaScript, JavaScript to Flex 183
Verifying that JavaScript Has Loaded 185
Working with Shared Objects 187
Saving and Reloading Data from Shared Objects 187
Designing Accessible Applications 189
Enabling Accessibility in Your Application 189
Components with Built-in Accessibility 189
Customizing Your Components for Accessibility 189
Summary 190
Flex Data 191
Data Binding 191
Using [left angle bracket]mx:Binding[right angle bracket] 191
Binding to Variables with [Bindable] 192
Binding Directly to Component Properties 193
Data Modeling with Flex 194
A Basic Data Model 194
Using an External XML File 195
Binding a Data Model to a Custom Component 196
Binding Data to a Data Model 198
Validating Data 200
Flex Built-in Validators 200
Validating a Data Model 201
Simple Data Validation Using errorString 203
Testing Validation Events 204
Validating with ActionScript 207
Formatting Data 208
Flex Built-in Formatters 208
Formatter Errors 210
Summary 211
Flex Charting 213
Flex Chart Examples 213
Area Chart 215
Bar Chart 216
Bubble Chart 218
Column Chart 220
Line Chart 222
Pie Chart 223
Plot Chart 225
Candlestick Chart 226
HighLowOpenClose (HLOC) Chart 228
Charting Classes 229
Axis Label 229
Axis Title 230
Axis Renderer 230
Grid Lines 231
Axis Types 231
ChartItem 232
ChartItemEvent 232
Hit Data 232
Legend 232
Advanced Charting 232
Chart Events 232
Drill-Down Charts 234
Mixed Series Types 236
Multiple-Axis Charts 237
Axis Rotation 239
Charting Effects 240
SeriesInterpolate 240
SeriesSlide 240
SeriesZoom 240
Chart Style Examples 241
Summary 244
Data Access 245
Server-side Data 245
Flex Data Access 245
RPC Services 246
Data Management Service 247
Messaging Service 248
Data Services Configuration 248
Service Configuration Files 248
Message Channels 249
Data Serialization 250
Destinations and Security 258
Configuring Logging 259
Software Clustering 261
Custom Error Handling 262
RPC Service Components 263
Defining RPC Components 263
Calling a Service and Handling Results 264
RPC Services Configuration 265
Destination Configuration 265
Destination Properties 266
Flex Messaging 267
The Basics of Flex Messaging 267
Flex Messaging Architecture 268
Producer Components 269
Consumer Components 272
Message Service Configuration 274
Message Service Configuration 274
Message Service Destination Configuration 275
Building a Custom Message Service Adapter 277
Data Management Services 278
Data Management Service vs. RPC Features 278
Data Management Service Data Flow 279
Data Synchronization Conflicts 279
Distributed Data 280
Distributed Data Application 280
Class Mappings 281
Data Synchronization Handling 283
Data Management Service Configuration 284
Data Management Service Destination Configuration 284
Data Push from Servers to Client 286
Summary 286
Creating and Extending Flex Components 287
Creating MXML Components 289
Creating Simple MXML Components 289
Scoping Your Components 291
Styling Your Components 292
Advanced MXML Components 293
Adding Custom Properties and Methods to a Component 293
Creating Composite Components 295
Template Components 297
Creating a Template Component 297
Using a Template Component 298
MXML Interfaces 302
Creating Interfaces 302
Using Interfaces 302
Using IMXMLObject 303
Summary 304
Flex Component Properties 305
Elements of a Component 305
The package Statement 305
Import Statements 306
Defining the Class Name 306
The Default Constructor 306
Defining Properties 307
Defining Methods 309
Overriding Methods Using super 311
Creating a Simple ActionScript Component 313
Implementing and Overriding UIComponent Methods 314
Creating Advanced Components in ActionScript 315
Summary 318
Flex Components 319
Custom Events in Components 319
Dispatching Custom Events 319
Using Metadata Tags in Components 321
[ArrayElementType] 321
[Bindable] 321
[DefaultProperty] 324
[Embed] 324
[Event] 325
[Effect] 326
[IconFile] 327
[Inspectable] 327
[InstanceType] 328
[NonCommittingChangeEvent] 328
[RemoteClass] 330
[Style] 330
Compiling Components 332
Compiling Components with Flex SDK 332
Compiling Components with Flex Builder 332
Deploying Components 338
Summary 340
Custom Formatter, Validator, and Effect Components 341
Custom Formatters 341
Customizing the SwitchSymbolFormatter Class 341
Extending the Formatter Class 344
Custom Formatter Example 345
Formatter Errors 346
Custom Validators 347
Creating Effects 349
Extending the Effect Class 349
Extending the EffectInstance Class 350
Custom Effect Example 350
Extending the TweenEffect Class 353
Extending the TweenEffectInstance Class 353
Custom TweenEffect Example 354
Custom Effect Triggers 357
Summary 359
Programming ActionScript 3.0 361
Overview of ActionScript Programming 363
Introduction to ActionScript 363
What's New in ActionScript 3.0 364
Compatibility with Previous Versions 366
Getting Started with ActionScript 367
ActionScript 3.0 Is More than Flex 367
ActionScript 3.0 Coding Considerations 372
Running ActionScript Applications 373
Display Programming 374
Understanding the Display Architecture 374
Working with Display Objects 376
Using the Core Display Classes 381
Summary 387
Data Types and Classes 389
Value Types 389
Primitive Data Types 390
Complex Data Types 390
Dates and Times 391
Creating Calendar Dates and Times 391
Retrieving Time Values by Unit 392
Date Manipulation 393
Strings 395
Length Property 395
Characters in Strings 395
String Comparison 396
Obtaining String Representations of Objects 396
Concatenation 397
Patterns and Substrings 397
Uppercase and Lowercase Conversion 399
Arrays 399
Index Arrays 399
Associative Arrays 403
Multidimensional Arrays 407
Cloning Arrays 408
Error Handling 408
Error Types 408
Custom Error Classes 411
Exception Handling 414
Regular Expressions 415
Regular Expressions and Strings 415
Using the RegExp Class 416
Using Groups 417
XML 418
Introduction to XML 418
E4X Introduction 420
E4X Classes 420
Summary 426
Building and Deploying Flex 2.0 Applications 427
Building and Deploying Flex Applications 429
Flex Framework and Application Directory Structure 429
Flex and Flash Player Security and Technology Concerns 432
Network Security Concerns 432
Open Technology Concerns 433
Flash Player Security Features 434
Building and Deploying Applications 435
Building for Flex 2 SDK 436
Building for Flex Data Services 2 437
Compiling an Application 439
Deployment Directory Structure 442
Applying Flex Security 445
Flex Security Features 445
Improving Startup Performance 447
Startup Order 447
Using Deferred Creation 449
Deferring Component Creation 452
Using Ordered Creation 455
Using the callLater() Method 458
Summary 460
Debugging and Testing 461
Logging Overview 461
Flash Debug Player 462
Logging API 463
Compiler Logging 464
Web-tier Logging 464
Client-side Logging 464
Using the Logging API 465
Custom Logger 465
Flex Builder Debugging Tools 471
Invoking 472
Configuring 472
Breakpoints and Stepping 475
Command-line Debugger 475
Invoking 475
Configuring 476
Debugger Commands 477
Summary 478
Deploying Flex Applications 479
Deployment Considerations 479
Server-side and Client-side Caching 481
Deployment Options 485
RSL Deployment 485
Flash Player Sandbox and Cross-Domain Consideration 487
Deploying a Flex 2 SDK Application that Uses RSL 488
Compiling for Deployment 493
Troubleshooting Tips and Common Deployment Problems 497
Asset and Dependent Files 497
Run-time Data Access 498
Proxy Server 498
Accessing Server-side Resources from Different Domains 499
Deploying a Flex Data Service Application Under Tomcat 500
Configuring for FDS 506
Creating a Wrapper 508
Migrating and Transferring Files 509
Defining Features 510
mxmlc Compiler 511
Adding Features to the Wrapper 512
Creating a Wrapper that Supports Web Standards 514
[left angle bracket]object[right angle bracket] and [left angle bracket]embed[right angle bracket] 518
Using Express Install 520
Editing Your Wrapper 521
Configuring Express Install on Flex Data Services 525
Upgrading Without Express Install 526
Summary 527
Advanced Flex 2.0 529
Using the Cairngorm Framework 531
The Cairngorm Framework 531
Understanding Frameworks 532
Application Frameworks 532
Architectural Frameworks 532
Building an Application Using the Cairngorm Framework 533
Value Object and Model Locator Pattern 534
The View 537
The Front Controller, Cairngorm Event Broadcaster, and Command Patterns 541
Business Delegate and Service Locator 545
Summary 547
Using the Flex-Ajax Bridge 549
Why Use Flex with JavaScript? 549
Requirements for the FA Bridge 550
Memory-Consumption Issues 551
Flex-Ajax Bridge Samples 551
Using Flex Validators from JavaScript 551
Create Flex Components Using JavaScript 555
Summary 559
Using the ActionScript 3.0 Libraries 561
Types of Libraries 562
How to Include the SWC in Your Application 562
Building a Simple Application Using One of the Libraries 565
Summary 571
Using ColdFusion/Flex Connectivity 573
Using the Flash Remoting Update 573
Using the Flex Messaging Event Gateway 583
The Structure of Messages 585
Using the ColdFusion Event Gateway Adapter 587
Using the Flex Data Service Assembler 591
Configuring ColdFusion 591
Value Object CFC 594
EmployeeAssembler.cfc 595
The DAO.cfc 596
ColdFusion Extensions for Flex Builder 2 597
Eclipse RDS Support Plugin 597
Installation 601
Create CFC Wizard 604
ActionScript to CFC Wizard 605
CFC to ActionScript Wizard 605
Services Browser 606
Summary 606
Integration Techniques 607
Rich Media Integration 609
Integration 610
Audio 610
Video 610
Using the Camera 612
Building an Application with Rich Media Integration 613
The Inner Workings of the Application 617
Summary 620
Integration with External Applications 621
Using the External API 621
AVM1 and AVM2 SWF Communication 622
ExternalInterface and LocalConnection 625
Building Custom Tracing Utility 626
Flash Player Process Structure 626
Using LocalConnection and C# .NET Windows Application 627
Summary 641
Flex 2.0.1 643
Run-time CSS Support 643
ASDoc Tool 647
ASDoc Tags and Syntax 647
Documenting the Logger Classes 648
Using the ASDoc Compiler 649
Documenting the Logger Classes - Continued 650
Building Modular Flex Applications 657
Summary 663
Index 665
Read a Sample Chapter
Professional Adobe Flex 2
By Rich Tretola Simon Barber Renaun Erickson
John Wiley & Sons
Copyright © 2007 John Wiley & Sons, LtdAll right reserved.
ISBN: 978-0-470-10267-1
Chapter One
Introducing Flex 2.0
Flex 2.0 is arguably the most important new Internet development tool set released to date. It will help speed the migration of the Internet to the Web 2.0 that we have been promised for so long now. Not only has Adobe introduced an extremely easy-to-use development environment in Flex Builder 2.0, but it has also released an SDK allowing for Flex Rich Internet Applications to be developed with absolutely no fees. So what are Rich Internet Applications? Let's start with a definition.
Rich Internet Applications
A Rich Internet Application (RIA) is an application that runs in the traditional browser but utilizes an intermediate layer that can bypass the traditional page refresh that has been a standard of most current Web applications. The most common tools that can achieve this intermediate layer include JavaScript used in Asynchronous JavaScript and XML (Ajax) applications, as well as Flex or Flash using the Flash Player. Other RIA solutions include OpenLaszlo (which utilizes the Flash Player as well as Ajax), XUL (which is dependent on a Mozilla-compatible browser), and the Windows PresentationFoundation (which is part of the Microsoft .NET Framework 3.0).
OpenLaszlo
Like Flex, OpenLaszlo can compile to SWF and, because it is open source, it is also free for developers to use. OpenLaszlo applications are built using JavaScript, as well as an Extensible Markup Language (XML) based programming language named LZX, and compiled to SWF. It is very similar to Flex, and because it was available for free, it garnered a larger amount of attention during the days of Flex 1.5. Because OpenLaszlo compiles to SWF, it enjoys the same write-once-run-anywhere feature that is synonymous with Flex and Flash applications. The one advantage to OpenLaszlo over Flex is that the next version of OpenLaszlo (code-named legals) will allow write-once-and-compile to either an SWF or a dynamic HTML (DHTML), or Ajax, application. The major disadvantages of OpenLaszlo are that it has a smaller set of built-in components than Flex, and it has always been at least one full version behind in optimization for the most current Flash Player.
Ajax
Ajax is a combination of HTML or Extensible HTML (XHTML), Cascading Style Sheets (CSS), and JavaScript to create an application-type feel from a standard Web page request. CSS and JavaScript can be used to trigger updates to the visual aspect of the page, and XMLHttpRequests can be used to fetch data in the background of the page. The combination of these techniques allows a single Web page to change its appearance and update its data without any additional page requests from the server. There are many limitations to this type of RIA, including compatibility issues with browser versions, as well as differences in (or lack of) JavaScript support necessary for the RIA to perform as expected.
XUL
XML User Interface Language (XUL) is an XML-based language developed by the Mozilla project. It is a tag-based language that contains many predefined widgets (buttons, radio buttons, and so on) that will be rendered only by a Mozilla-compatible browser such as Firefox. Although it can also be used in the creation of RIAs, XUL has been most widely used in the creation of Mozilla applications and extensions.
Windows Presentation Foundation
Windows Presentation Foundation (WPF) consists of an engine and a framework that will be preinstalled in Windows Vista, and introduces Extensible Application Markup Language (XAML) as a new tag-based language. XAML is very similar to MXML because it is a tag-based XML language with attributes whereby each tag creates an object model class. XAML tags are fully extendable, allowing developers to create custom classes. XAML, along with C# (which is the programming language), would correspond to MXML and ActionScript 3 in Adobe Flex.
WPF is used for both traditional desktop applications and browser-based RIAs. With Microsoft's backing, WPF and XAML are sure to make a large contribution to Web 2.0 and RIA. Microsoft has stated that it will also introduce Windows Presentation Server Everywhere (WPF/E), which will provide support for other browsers and platforms. One major advantage of WPF is that it will support three dimensions out of the box, which is something that has been lacking in the Flash Player. A disadvantage of WPF is that it does not run within the Flash Player, and it will be a long time before Microsoft can expect the same penetration of its runtime as the Flash Player.
History of RIA
Although the concept of a Web application that performs more in line with the traditional desktop application has been around for years, RIAs were first introduced by Macromedia in March 2002.
Benefits of RIA
RIAs offer many benefits over traditional Web applications. Following are a few of the many advantages of RIAs:
RIAs offer a richer interface that provides a more engaging user experience without the need for page reloads.
RIAs offer real-time feedback and validation to the user, triggered by user events.
The look and feel of a traditional desktop application can be accomplished with an RIA.
RIAs also can include a full multimedia experience, including audio and video.
RIAs have capabilities such as real-time chat and collaboration that are either very difficult or simply impossible with traditional Web applications.
Overview of Flex
Flex was developed to create a development environment that more closely resembled the traditional development environment utilized by other programming languages. The goal was to take the already tremendously successful Flash visual development environment and open it up to programmers who are more comfortable with a code-based model.
In 2004, Macromedia released Flex 1.0, which caused a buzz in the world of RIAs because it was the first time that it was possible to compile Flash SWF files from code. In 2005, Flex 1.5 was released, which was a big improvement over Flex 1.0 and included many new features. A few of the notable new features included new charting components, updates to the datagrid component, and new component-skinning techniques for more control over the look and feel of Flex 1.5 applications.
Flex 1.5 was very successful, but was still targeted to the mid- to large-size company, and it was priced that way. For smaller companies and developers, Flex 1.5 was simply out of reach because of Macromedia's pricing model. In 2006, Adobe released Flex 2.0 and announced that it was now possible to create and distribute Flex 2.0 applications absolutely free. This has created a large influx of developers into the Flex community, and shows tremendous growth potential.
Flex 2
Flex 2 is a tremendous upgrade over its predecessor. It includes a new version of the MXML tag-based language, as well as a new version of ActionScript. Adobe has built the Flex 2 Framework to be fully extendable, allowing developers to create custom components that extend or combine base components using either MXML or ActionScript 3.
Flex 2 is built to run within the all-new Flash 9 Player, which in itself includes huge performance increases over previous versions. Flex 2 includes a new development environment built on the Open Source Eclipse integrated development environment (IDE) named Flex Builder 2, the free Flex 2 SDK, as well as the new Flex Data Services (FDS) application server. Flex 2 also offers a new set of charting components that are not part of the basic free versions of the Flex SDK but can be purchased separately or as part of a Flex Builder package.
Flash Player 9
In May 1996, a small company named FutureWave Software released a product that it called FutureSplash Animator. FutureSplash was released as a browser extension using the new plug-in API from Netscape. Ironically, FutureWave attempted to sell its technology to Adobe, but at the time, Adobe wasn't interested. Macromedia was interested in FutureSplash, and, in December 1996, acquired FutureWave Software. Macromedia renamed FutureSplash as Flash Player 1.0.
Following is a timeline of key events in this history of the Flash player:
1997 - FutureSplash is renamed and released as Macromedia Flash 1.0.
1997 - Flash 2 adds buttons, the Library, sound support, and color tweens.
1998 - Flash 3 adds new animations and alpha transparency.
1999 - Flash 4 adds MP3 audion streaming and motion tweens.
1999 - 100-millionth download of the Flash Player.
2000 - Flash 5 adds ActionScript 1.
2000 - Flash Player installs reach the 92 percent penetration mark.
2002 - Flash Player 6 adds support for Flash remoting, Web services, video, shared libraries, and components.
2003 - Flash Player 7 introduces ActionScript 2.0 and streaming audio and video.
2005 - Flash Player 8 adds filter effects, GIF and PNG images, bitmap caching, new video codec (On2 VP6), file upload and downloading, and FlashType.
2006 - Flash Player 9 is released and introduces ActionScript 3, E4X XML parsing, regular expressions, and binary sockets.
The introduction of Flash Player 9 in 2006 represents the most significant release of any Flash Player to date. The incorporation of ActionScript 3 brings true object-oriented programming to Flex 2 and the upcoming Flash 9 authoring tool. Flash Player 9 boasts performance increases of up to ten times over Flash Player 8. Flash Player 9 is based on the ECMAScript standard and adds new features, including ECMAScript for XML (E4X), regular expressions, a standardized event model, and binary sockets.
Flash Player 9 also includes better memory utilization, improved application initiation speed, as well as improvements in the debugger and error reporting.
Flex Builder 2
Flex Builder 2 is the new development tool that (although it is not necessary for Flex development because any text editor can be used) offers the most complete development environment for rapidly creating Flex applications. Because Flex Builder 2 has been built on top of the mature Eclipse IDE, it will be very familiar to developers who have already been developing software in other languages using Eclipse as their tool of choice. Eclipse is a development environment that was built with extendability in mind, and this can also work to the benefit of Flex developers because it can be customized to suit the needs of the Flex developer. Chapter 2 provides a more comprehensive look into Flex Builder 2.
Flex Free SDK 2
The Flex Software Development Kit (SDK) is a free download from Adobe and includes the Flex framework (component class library), compiler, and debugger. Using the text editor of your choice, you can create the ActionScript and MXML files for your application, and then compile to SWF using the SDK. The SDK allows for data communication via Web services, HTTP services, and Flash remoting with ColdFusion as the back-end server.
Flex Data Services (FDS)
FDS is the server version of Flex that must be installed under any Java 2 Enterprise Edition (J2EE) server. FDS is essentially the next generation of Flex 1.5, which was sold only as a server.
As well as a full commercial edition, the FDS server is available in an Express edition, which is free and available for commercial use (but is limited to one CPU without clustering).
FDS is made up of several components and capabilities, including the following:
Flex Messaging Services (FMS)
Publish-subscribe messaging
Data push
RPC services
Flex Messaging Services
FMS is one of the pieces that make up FDS, and it allows for the creation of applications that support real-time messaging, as well as collaboration. The messaging service has support for Java Message Service (JMS), as well as other existing messaging services, allowing for the creation of cross-platform chat applications.
Publish-Subscribe Messaging
FMS uses the producer/consumer publish-subscribe metaphor, which allows for the creation of co-browsing applications. To understand what is meant by a co-browser application, imagine a company's customer service representative being able to make edits to a form on the user's screen in real time while the user watches.
Data Push
Data push is the capability for the server to push data changes to the client without any user interaction or polling of the servers. This can be critical when an application has hundreds or thousands of users connected, and they can all see changes to business-critical data in real time. This is a feature that is available only when using the FDS server.
RPC Services
Remote procedure call (RPC) services are the suite of services used to connect to external data. They include the following:
WebService - The WebService component can be used to access any Web service that complies with the WSDL 1.1 standard and returns data formatted as Simple Object Access Protocol (SOAP) messages over HTTP.
HTTPService - The HTTPService component can send HTTP GET, POST, HEAD, OPTIONS, PUT, TRACE, or DELETE requests. It does not support multipart requests.
RemoteObjects - The RemoteObject component uses Action Message Format (AMF) to transfer data that is a binary format and is the fastest of the RPC services. It is an ideal way to interact with server-side Java objects that are within the FDS server's source path. It can also be used to connect to local or even remote ColdFusion servers. Both Java objects and ColdFusion components can be mapped to ActionScript objects, allowing for seamless integration between the server-side and client-side objects.
The WebService and HTTPService components are included for free with the Flex SDK, whereas the RemoteObject component is available only for use with the FDS server (Commercial or Free Express Edition) or ColdFusion 7.02.
Flex Charting
The Flex charting components are a set of rich charting components that enable easy development of professional dashboard and business intelligence (BI) systems. The charting components are sold as a stand-alone product or bundled with Flex Builder 2. A free trial of the charting components is available from Adobe. You can learn more about the charting components in Chapter 10.
Summary
This chapter defined RIA and gave some examples of the benefits of RIA, as well as the software options available for creating RIAs. It also provided an overview of Flex and its history, as well as the pieces that make up Flex. Most of the information on Flex covered in this chapter is covered in more depth later in this book.
Chapter 2 introduces the all-new Flex Builder 2 built on top of Eclipse.
(Continues...)
Excerpted from Professional Adobe Flex 2 by Rich Tretola Simon Barber Renaun Erickson Copyright © 2007 by John Wiley & Sons, Ltd. Excerpted by permission.
All rights reserved. No part of this excerpt may be reproduced or reprinted without permission in writing from the publisher.
Excerpts are provided by Dial-A-Book Inc. solely for the personal use of visitors to this web site.
loading...
Related EssentiaListsuiAction=GetRelatedListsByEanFromProductPage&page=List&pageType=list&ean=9780470102671&productCode=BK&maxCount=5&threshold=10
loading...
Fans of this BookuiAction=GetProfileBlurbsWithEANinFavorites&page=UserProfile&pageType=profile&eanInput=9780470102671
loading...