Catálogo de publicaciones - libros

In this chapter, you have learned

The next step is to examine the core classes of the component architecture and learn how to use them to create Flash components that belong to this architecture.

In this chapter, you have completed your knowledge of creating a Flash component by learning how to integrate it with the framework provided by the component architecture.

You should have started to appreciate how much time you can save by inheriting features that are already implemented or, at least, already well defined in the framework. Those features are made available by a number of core components that can be used as base classes whenever creating a new component.

The next chapter will introduce the components that are included in the architecture, grouping them into functional categories.

After reading this chapter, you will be aware of which components have been included in the Flash Component Architecture and what functionality they provide.

You have also found a tool (the Reusability Card) that will tell you at a glance how reusable a component actually is.

You may well consult this chapter again when deciding what components to use in your next project.

In the next chapter, we are going to examine the many options offered by the architecture to efficiently integrate different component instances into a robust component-based application.

In this chapter, you have learned that the scope of the component architecture extends far beyond the set of components—it includes application frameworks and application-oriented functionality encapsulated in manager classes.

In particular, you have learned about the screen concept and how it can be conveniently used to model your applications around a screen-based hierarchy.

You have also encountered the really productive features provided by the manager classes, and you now know how and when to use them.

However, soon you will realize that this very rich set of functionality made of components and classes needs substantial experience to be used properly and conveniently.

This chapter ends the first part of the book, in which we focused on introducing the component architecture, its features, and how the most basic object-oriented programming techniques can be applied to such features.

The second part of the book will expose advanced techniques and tools that will allow you to exploit the full potential of the component architecture and be able to design and implement large-scale component-based applications in which any aspect of the architecture’s standard components can be customized.

In this chapter, the focus of the book moved from introducing the component architecture into using it in the scope of a project.

You then learned the key concepts to consider and the best practices to apply in order to successfully exploit the architecture in the context of commercial applications.

You also learned what an XML layout engine is and the many benefits it can provide. And you discovered that this book contains and exposes one of those engines and that, by learning how it has been implemented, you will also capture the knowledge required to customize the appearance and behavior of any GUI component in the architecture, a knowledge that you may also reuse separately in all sorts of projects.

Note that this is by far the most conceptual chapter in the book and, because of that, probably the most important one. You may well find it beneficial to read it again after having explored the concrete examples in the rest of the book, because every time you come back to this chapter, it will probably show you those same examples in a different, richer light.

In this chapter, you learned how convenient XML can be when it comes to describing a user interface that is generated dynamically.

You also played with a couple of examples that concretely demonstrated benefits that were firstly introduced as abstract ideas in the previous chapter.

The next chapter shows you how easily you can implement intercomponent event handlers and, in doing so, build component-based applications whose user interfaces are generated dynamically.

This chapter covered a topic that has a very wide scope, since component-based applications can be designed for almost any purpose one may think of.

You have learned how a good organization of several different aspects can act synergically, eventually increasing a developer’s efficiency and productivity dramatically.

Although some of the aspects in completing an application are too specific to be treated in a book, you have been given guidelines and techniques that allow you to integrate those aspects with the features that are to some extent present in the design and development of every component-based application.

By reading this chapter, you ended up with a set of best practices and a component-based template that encapsulates them. In particular, you have learned how to

In the second part of the chapter, you learned the basics of developing an application based on an XML layout engine and the benefits that come with it. Many of those benefits depend on mastering the use of XML within a component-based application framework.

The next chapter will show you how to take full control over XML parsing in order to be able to extend the framework by adding new features to existing components or even expand it by adding support for brand new components.

In this chapter, you learned how to save a lot of time when it comes to writing XML parsing code.

Such a result is achieved by realizing that most of the time spent writing code to access the content of XML documents goes into translating the generic XML DOM supported by the XML class into an object model that is specific to your application.

You also learned how to use the XModel class—a huge time-saver since

The next chapter will complete the second part of the book dedicated to mastering the techniques for exploiting the component architecture by introducing the customization process.

In this chapter, you have learned how the component architecture implements styles and skins.

You have also learned that there are three different kind of skins, and that for some of them the separation of code from representation cannot be achieved, because in several cases a skin’s appearance is defined also, or exclusively, by ActionScript code.

You became aware of a set of different techniques that allow you to overcome any limitation you may encounter when customizing a component.

The approaches presented here can be applied in many different situations. The third part of the book, starting next, exploits the application of these techniques in the context of each standard component, providing plenty of concrete and different examples.

In this chapter, you learned how to save a lot of time when it comes to writing XML parsing code.

Such a result is achieved by realizing that most of the time spent writing code to access the content of XML documents goes into translating the generic XML DOM supported by the XML class into an object model that is specific to your application.

You also learned how to use the XModel class—a huge time-saver since

The next chapter will complete the second part of the book dedicated to mastering the techniques for exploiting the component architecture by introducing the customization process.