GUI developers have been very successful delivering portable user interfaces based on the JavaTM Foundation Classes (JFC) API ("JFC/Swing") set of components. The model-view architecture of JFC enables the developer to design user interfaces that are loosely coupled to the underlying business data via abstract data models. In theory, the developer only has to design a thin adapter layer that exposes aspects of the business data via standard JFC interfaces. Model-view separation should then allow all portions of a user interface to update and maintain a coordinated representation of the underlying data.

                     However, in many cases the quantity of data far exceeds JFC's ability to handle it efficiently from both a performance and a presentation point of view. In addition, the design of complex JFC components (those made of a collection of other components) presents its own design issues. This session will explore various aspects of the problems developers may face as they scale up JFC user interfaces, and deliver field-tested design approaches and solutions.

                     The session starts by addressing design issues with the JTable and JTree components and how to synchronize them to display row-oriented information in an efficient manner. The session will illustrate the following:

• How to synchronize the JTable and JTree's selection models
• How JTable and JTree scrolling and internal caching architecture affects performance, and what can be done about it
• How to extend the concepts of JavaSoft's TreeTable example to create a truly flexible and reusable component
• JavaSoft has made available code that illustrates how to integrate a JTree as a cell renderer for a JTable column; however, this example has many limitations, including lack of editing support and inconsistent keyboard navigation, among others. We will show how to use this idea as the first step towards creating a truly effective TreeTable component .
• This session will also discuss how the basic concepts of JFC's model-view separation can be scaled to a higher level of abstraction. This enables the developer to create complex composite beans that remain well-factored and do not become 'brittle' as performance analysis and tuning is performed. Also to be discussed:
• How to design an appropriate data model interface to the underlying hierarchical business data being visualized--presenters will show how this data model interface can be adapted to the needs of specific JFC and other visual components.
• How centralized event routing and narrowly focused manager objects within a complex bean create an architecture in which performance improvements can be made easily
• Different approaches to load-on-demand data caching, and the pros and cons of each
• Discuss the use of JavaTM 2 technology SoftReference objects and how they can be an effective tool in this regard
• This session will also show how a deterministic data load/flush policy can be retrofitted into a well-designed, complex user interface bean. Finally, deployment issues and solutions for complex user interface beans will be covered including automated generation of BeanInfo using custom javadoc doclets, runtime versus design time packaging, and IDE integration issues.