The open-source NetBeans Platform is an extraordinarily powerful framework for building "write once, run anywhere" rich client applications. Now, for the first time since the release of NetBeans IDE 5.0, there's a comprehensive guide to rich client development on the NetBeans Platform. Written for Java developers and architects who have discovered that basic Swing components are not enough for them, this book will help you get started with NetBeans module development, master NetBeans' key APIs, and learn proven techniques for building reliable desktop software. Each chapter is filled with practical, step-by-step instructions for creating complete rich client applications on top of the NetBeans Platform and plugins for NetBeans IDE. Rich Client Programming's wide-ranging content covers Why modular development makes sense for small, medium, and large applications Using NetBeans to accelerate development and improve efficiency Leveraging NetBeans productivity features, from the Component Palette to Code Completion Leveraging NetBeans' modular architecture in your own applications Implementing loosely coupled communication to improve code maintainability and robustness Managing user- and system-configuration data Building reloadable components with solid threading models Constructing sophisticated multiwindow applications and presenting rich data structures to users Adding user-configurable options Integrating Web services with NetBeans desktop applications Automating module updates and providing user help Foreword by Jonathan Schwartz      Foreword by Jan Chalupa        Preface        About the Authors and Contributors        Acknowledgments        Chapter 1: Getting Started with the NetBeans Platform        Chapter 2: The Benefits of Modular Programming         Chapter 3: Modular Architecture        Chapter 4: Loosely Coupled Communication         Chapter 5: Lookup        Chapter 6: Filesystems        Chapter 7: Threading, Listener Patterns, and MIME Lookup        Chapter 8: The Window System        Chapter 9: Nodes, Explorer Views, Actions, and Presenters        Chapter 10: DataObjects and DataLoaders        Chapter 11: Graphical User Interfaces         Chapter 12: Multiview Editors        Chapter 13: Syntax Highlighting        Chapter 14: Code Completion        Chapter 15: Component Palettes        Chapter 16: Hyperlinks        Chapter 17: Annotations        Chapter 18: Options Windows        Chapter 19: Web Frameworks        Chapter 20: Web Services         Chapter 21: JavaHelp Documentation        Chapter 22  Update Centers        Chapter 23: Use Case 1: NetBeans Module Development        Chapter 24: Use Case 2: Rich Unger on Application Development     Chapter A: Advanced Module System Techniques        Chapter B: Common Idioms and Code Patterns in NetBeans        Chapter C: Performance        Index       

Table of Contents:
Foreword by Jonathan Schwartz        xv Foreword by Jan Chalupa        xvii Preface        xix About the Authors and Contributors        xxvii Acknowledgments        xxxiChapter 1: Getting Started with the NetBeans Platform        11.1  Setting Up the IDE        1 1.2  NetBeans IDE Basics        3 Chapter 2: The Benefits of Modular Programming         112.1  Distributed Development        11 2.2  Modular Applications         13 2.3  A Modular Programming Manifesto        15 2.4  Using NetBeans to Do Modular Programming        19 Chapter 3: Modular Architecture        233.1  Modules—The Assembly Units of a Modular Application         23 3.2  Types of Modules        24 3.3  Module Lifecycle        29 3.4  Groups of Modules        33 Chapter 4: Loosely Coupled Communication         394.1  Registration and Discovery        39 4.2  MetaInf Services        41 4.3  The Global Lookup        43 4.4  Writing an Extension Point        46 Chapter 5: Lookup        495.1  Objects That Own Lookups        53 5.2  Lookup as a Communication Mechanism        55 5.3  Lookups and Proxying        58 5.4  Lookup and Selection        62 5.5  Writing Lookup-Sensitive Actions        63 5.6  Tracking the Global Selection        64 5.7  Legacy Variants of the Lookup Pattern in NetBeans APIs        65 5.8  Common Lookup Patterns        66 Chapter 6: Filesystems        696.1  FileSystems and FileObjects        70 6.2  What Kinds of FileSystems Will I Be Dealing With?        71 6.3  Layering        72 6.4  XML Filesystems        73 6.5  Declarative Registration II: The System Filesystem        74 6.6  Getting from FileObjects to Java Objects        88 6.7  Browsing the System Filesystem        96 6.8  Conclusions        96 Chapter 7: Threading, Listener Patterns, and MIME Lookup        1037.1  Creating the Modules and SPI        104 7.2  Implementing ListModelProvider        107 7.3  Providing a UI Component        123 7.4  Using the Pseudo Navigator        132 7.5  Conclusion: PseudoNavigator—What's Wrong with This Picture?        132 Chapter 8: The Window System        1358.1  What the Window System Does        137 8.2  Classes in the Window System API        139 8.3  Using TopComponent        141 8.4  Persisting State across Sessions        145 8.5  Window System Persistence Data        147 8.6  Creating Editor-Style (Nondeclarative) TopComponents        152 8.7  Advanced Window System Configuration: Defining Your Own Modes        153 8.8  Using TopComponent Groups        158 Chapter 9: Nodes, Explorer Views, Actions, and Presenters        1639.1  The Nodes API        164 9.2  The Explorer API        177 9.3  Actions        190 9.4  Node Properties        199 9.5  Nodes and DataObjects: Creating a System Filesystem Browser        203 9.6  Epilogue: Of Nodes, Property Sheets, and User Interface Design        205 Chapter 10: DataObjects and DataLoaders        20710.1  DataObjects: Where Do They Come From?        210 10.2  Adding Support for a New File Type        212 10.3  Using Custom File Types Internally        234 10.4  Serialized Objects and the System Filesystem        235 Chapter 11: Graphical User Interfaces        23711.1  Introduction        237 11.2  Creating a New GUI Form        240 11.3  Placing and Aligning a Component in a Form        240 11.4  Setting Component Size and Resizability        242 11.5  Specifying Component Behavior and Appearance        244 11.6  Generating Event Listening and Handling Methods        244 11.7  Customizing Generated Code        247 11.8  Building an Explorer View Visually         249 11.9  Previewing a Form        250 11.10  Using Custom Beans in the Form Editor        250 11.11  Using Different Layout Managers        251 Chapter 12: Multiview Editors        25312.1  Introduction        253 12.2  Getting Started        255 12.3  Understanding Multiview Editors        256 12.4  Creating the Editor’s Infrastructure        257 12.5  Creating the Source View        261 12.6  Creating the Visual View        269 12.7  Finishing the Sample        271 Chapter 13: Syntax Highlighting        27313.1  Introduction        273 13.2  Preparing to Create Syntax Highlighting        274 13.3  Creating Token IDs        275 13.4  Creating a Lexical Analyzer        277 13.5  Extending the Options Window        281 13.6  Registering the Syntax Highlighting in the Layer File        284 13.7  Finishing Up        286 Chapter 14: Code Completion        28714.1  Introduction        287 14.2  Understanding Code Completion        289 14.3  Code Completion Query Types        291 14.4  Preparing to Work with the CompletionProvider Interface        291 14.5  Implementing a CompletionProvider        293 14.6  Implementing a CompletionItem        296 14.7  Adding a Filter to the CompletionProvider        300 14.8  Adding Documentation to the Code Completion Box        304 14.9  Adding a Tooltip to the Code Completion Box        305 Chapter 15: Component Palettes        30715.1  Introduction        307 15.2  Adding Items to a Palette        313 15.3  Dragging and Dropping Palette Items        323 15.4  Adding Supporting Features to a Palette        331 15.5  Creating a Palette for a Text-Based Editor        344 Chapter 16: Hyperlinks        35516.1  Introduction        355 16.2  Preparing to Work with the HyperlinkProvider Class        357 16.3  Hyperlinks in Manifest Files        359 Chapter 17: Annotations        36717.1  Introduction        367 17.2  Preparing to Create an Error Annotation        368 17.3  Creating an Error Annotation        368 17.4  Preparing to Use an Error Annotation        376 17.5  Using an Error Annotation        377 17.6  Finishing Up        383 Chapter 18: Options Windows        38518.1  Introduction        385 18.2  Looking at the Options Window Extension Files        389 18.3  Creating a Primary Panel        393 18.4  Adding Settings to the Options Window        396 Chapter 19: Web Frameworks        39919.1  Introduction        399 19.2  Preparing to Work with the WebFrameworkProvider Class        404 19.3  Providing a Framework Configuration Panel        406 19.4  Creating a Source Structure        413 19.5  Letting the User Select a Library in the Frameworks Panel        423 19.6  Project Properties Dialog Box and Web Frameworks        424 19.7  Finishing Up        427 Chapter 20: Web Services        42920.1  Introduction        429 20.2  Creating and Testing a Web Service Client        430 20.3  Integrating the Web Service Client        435 Chapter 21: JavaHelp Documentation        44121.1  Creating a Help Set        442 21.2  Removing the IDE's Help Sets        446 21.3  Branding the Help Set's Default Texts        449 Chapter 22  Update Centers        45322.1  Introduction        453 22.2  Adding the IDE's Update Center Functionality        454 22.3  Creating and Distributing an Autoupdate Descriptor        456 22.4  Distributing the URL to the Autoupdate Descriptor        458 22.5  Downloading NBM Files from an Update Center        461 22.6  Publishing Updates to Existing Modules        462 Chapter 23: Use Case 1: NetBeans Module Development        46323.1  Introduction        463 23.2  Calling the External Tool        465 23.3  Handling the Output        476 23.4  Configuring the Tool        491 23.5  Formatting and Converting Files        496 23.6  Controlling the Conversion        505 Chapter 24: Use Case 2: Rich Unger on Application Development        52124.1  Introduction        521 24.2  Getting Started        522 24.3  Creating Support for the audio/wav MIME Type        526 24.4  Encapsulating Audio Data in the WavDataObject        530 24.5  Creating a Component for Viewing WAV Files        533 24.6  Converting WAV Editor to Multiview        535 24.7  Creating an API for Plugging in Additional Views        542 24.8  Implementing Your Own API to Provide a New View        544 Chapter A: Advanced Module System Techniques        551A.1  Hiding Implementation Details        551 A.2  Design for Extensibility        553 A.3  Splitting API and Implementation        555 A.4  Do I Really Need Cyclic Dependency?        559 A.5  Crossing the Informational Divide        563 A.6  Restricting Access to Friends        565 A.7  Having Public as Well as Friend API        566 A.8  A Final Word on Modularity        568 Chapter B: Common Idioms and Code Patterns in NetBeans        569B.1  Things You Do Differently in NetBeans Than in Plain Swing Code        569 B.2  Things That Represent Files        571 B.3  Working with Lookup        573 B.4  Projects        573 Chapter C: Performance        575C.1  Responsiveness versus Performance        577 C.2  Performance Tips for Module Authors        578 C.3  Writing Modules That Are Good Citizens        579 Index        583