Rich Client Programming

Tim Boudreau coauthored NetBeans™: The Definitive Guide (O'Reilly), served on the team that open-sourced NetBeans, and continues to develop for the NetBeans project. Jaroslav Tulach cofounded the NetBeans project, and remains a leading guardian of the project API. Geertjan Wielenga is the technical writer responsible for NetBeans documentation relating to module development and rich-client application development.

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