1. Chapter 1 Getting and Installing the IDE

   1. Platforms and Requirements

   2. Getting and Installing a JDK

   3. Which IDE Distribution?

   4. Installing Binary Distributions

   5. Building the IDE from Source (Simple Builds)

   6. Running the IDE

   7. Updating the IDE Automatically

   8. You're Now Running NetBeans

2. Chapter 2 Concepts and Paradigms

   1. NetBeans and the Java Abstract Model of Computing

   2. Explorer

   3. Creating Packages and Classes

   4. Services

   5. Workspaces

   6. Project Management

   7. Object Browser

   8. Summary

3. Chapter 3 Working with the Source Editor

   1. Why Learn a New Editor?

   2. Opening the Source Editor

   3. Context Menus

   4. Closing the Source Editor

   5. Code Completion

   6. Editor Colorings

   7. Shortcuts

   8. Word Matching

   9. Indentation Engines and Code Formatting

   10. Automatic Edits

   11. Other Editor Functionality

   12. A Simple Example

4. Chapter 4 Debugging

   1. Debugger Types

   2. Breakpoint Types

   3. Adding and Removing Breakpoints

   4. Setting Watches

   5. Starting the Debugger

   6. The Debugger Window

   7. The Variables View

   8. Remote Debugging in NetBeans

5. Chapter 5 Compilation and Execution Services

   1. Using Custom Compilation and Execution Services

   2. Associating Services with Java Files

   3. Building with Ant

6. Chapter 6 Customizing the Environment

   1. The Setup Wizard

   2. The Tools→Options Dialog

   3. Configuring Toolbars

   4. Configuring Menus

   5. Configuring Editors

   6. Command Line Options

   7. Modules

7. Chapter 7 Using Source Control (CVS)

   1. What Is CVS?

   2. The How, When, and Why of CVS in NetBeans

   3. Mounting CVS Sources

   4. Exploring Versioned Sources

   5. Common CVS Operations

   6. Unexpected Results

   7. Uncommon CVS Operations

   8. Mounting a Generic Versioning System

   9. One Final Tip

8. Chapter 8 GUI Building

   1. Creating a GUI Frame or Panel

   2. Adding Components to a GUI Container

   3. Configuring Components

   4. Building Menus

   5. Changing a Container's Layout

   6. Working with Borders

   7. Accessibility

   8. Copying a Source Object

   9. The Connection Wizard

   10. The GridBagLayout Customizer

   11. Adding Event Handlers

   12. Using the Code Generation Properties

   13. Working Around Code Generation

   14. Containers Within Containers

   15. Building Complex GUIs

9. Chapter 9 JavaBeans

   1. Why Should I Make Beans?

   2. Creating JavaBeans

   3. Component Palette

10. Chapter 10 Using Javadoc

    1. Javadoc Support in NetBeans

    2. Mounting Javadocs

    3. The Javadoc Search Tool

    4. Creating Javadoc

11. Chapter 11 Working with XML

    1. Installing XML Support

    2. Overview

    3. XML Editors

    4. Beyond Editing XML

    5. Generating Java Classes

12. Chapter 12 Developing Web Applications

    1. Why the IDE Supports Web Application Development

    2. How the IDE Provides Web Application Support

    3. Creating a Web Application

    4. Working with JSP and HTML Files

    5. Advanced Web Applications Features

    6. Packaging and Deploying Web Applications

13. Chapter 13 Extending NetBeans

    1. What's Different About NetBeans?

    2. The Core and the Open APIs

    3. NetBeans for Bean Counters

    4. Getting and Installing the Open APIs Support Module

    5. Life Is Change

    6. Source Code for the Examples

14. Chapter 14 Understanding the NetBeans APIs

    1. Design Philosophy of NetBeans

    2. User-Level Customization

    3. Modules—Overview

    4. Interacting with the IDE

15. Chapter 15 The Open APIs

    1. APIs versus Core versus Modules

    2. Service Provider Interfaces and Client APIs

    3. Overview of the APIs and Their Purposes

    4. Modules, JARs, and Class Loaders

    5. Threading, Deadlocks, andHow to Avoid Them

16. Chapter 16 Developing Modules—the New Module Wizard

    1. The HelloWorld Module

17. Chapter 17 Internals of the Running IDE

    1. The Activated Node(s)

    2. Cookies

    3. A Peek under the Hood

    4. Touring NetBeans with the Bean Browser

    5. Data Objects, Nodes, and Cookies

    6. Filesystems and the Repository

    7. Services

    8. Lookup

    9. Options

    10. UI Components

    11. Localization

    12. Wizards

    13. Jumping-off Places

    14. Special Folders in the System Filesystem

18. Chapter 18 Creating the QuickPanel Module

    1. Abstractions Covered in This Chapter

    2. Creating the Project Files Drop-Down

    3. FilterNode—Filtering Which Children of a Node Are Displayed

    4. Creating the Methods Drop-Down

    5. Improving the Methods Drop-Down

    6. Creating the Module

    7. A Little Homework

19. Chapter 19 A Mail-Based Filesystem

    1. Building a Mail Reader in the NetBeans Paradigm

    2. Implementing MailFileSystem Using AbstractFileSystem and JavaMail

    3. Creating Folder Objects for Attachments

    4. Using FileSystem.Status Annotations to Mark Unread Messages

    5. BeanInfo—Displaying Filesystem Properties

    6. Using the Wizard Framework to Set Up Mail Accounts

20. Chapter 20 Creating the User Interfacefor the Mail Client

    1. Creating a DataLoader for Messages

    2. Creating a Threaded Mail View Using Filter Nodes

    3. Creating a Mail Workspace

21. Chapter 21 Score File Support

    1. Overview—Functionality to be Implemented

    2. Creating the Minicomposer Module

    3. Creating a UniFileLoader and MultiDataObject for *.score Files

    4. Creating an Editor Support for Scores

    5. Creating a Fixed ExecCookie to Play Scores

    6. Creating a Simple Template

22. Chapter 22 Creating a Structural View of the Score

    1. Creating a ScoreCookie to Represent a Sequence of Notes

    2. Creating a ScoreSupport

    3. Lifecycle of the Score

    4. An OpenSupport

    5. Indicating Parse Errors on the Node

23. Chapter 23 Compiling Scores

    1. Creating the Compilers

    2. Creating and Using the Compiler Cookie

    3. Displaying an Out-of-Date Badge on Score Icons

24. Chapter 24 Executing Scores

    1. Creating the .au Player Executor

    2. Creating Player Configuration Support

    3. Creating a SystemOption for the Default Executor

25. Chapter 25 Better Score Support in the Explorer

    1. The Clip Length Property

    2. Representing Notes as Subnodes Using Children.Keys

    3. Permitting Subnodes to Be Renamed or Deleted

    4. Permitting Subnodes to Be Added

    5. Making Read/Write Properties on Subnodes

    6. Reordering Subnodes

    7. Data Transfer—Cut, Copy, and Paste of Notes and Sequences

26. Chapter 26 Tuning Modules for Performance & Memory Footprint

    1. Startup Performance vs. Runtime Performance

    2. Operating Principles

    3. Techniques

27. Chapter 27 Producing Modules (Packaging & Distribution)

    1. Versioning

    2. Upgrading User Settings

    3. Bundling Extension Libraries

    4. Internationalization and Accessibility

    5. JavaHelp—Writing and Distributing

    6. Supporting User-Level Java APIs

    7. Creating the Module JAR File Within the IDE

    8. Creating a Build Script Using Ant

    9. Producing the .nbm File

    10. Publishing Using the Update Center

    11. Using ErrorManager to Log Problems

    12. Testing

28. Chapter 28 Building Your Distribution of NetBeans

    1. Do You Need Your Own Distribution?

    2. Licensing

    3. Selecting a Baseline

    4. Getting the Sources

    5. Customizing the Build Process

    6. Adding Modules to a "Stock" Distribution

    7. Creating Preconfigured Settings

    8. Branding

1. Appendix A A Tour of Existing Modules

   1. Modules That Expose Functionality You Might Need

   2. Incidental APIs, Utilities, and Extensions

   3. Modules That Make Good Examples for Things You May Need to Implement

2. Appendix B Useful Utility Classes

   1. XML Utilities

   2. Visual Components and Extensions to Standard Swing Components

   3. Lookup Implementations

   4. Threading

   5. Miscellaneous Utility Classes inorg.openide.util

   6. Serialization Helpers

3. Appendix C Resources

   1. CVSHome

   2. Java Environments

   3. Java Tools

   4. Secure Shell (SSH) Resources

   5. Cygwin for Windows

   6. Newsgroups and Mailing Lists

   7. Web Sites

   8. NetBeans Open Source Projects with Design Forms in the Distribution

   9. Java-Oriented IDEs Other Than NetBeans

4. Appendix D Future Plans

   1. Declarative Instantiation

   2. Uniform Lookup

   3. Datasystems II

   4. The Looks API

   5. Declarative Actions

   6. Deprecation of IDE-Specific Functionality in the Open APIs

   7. The Metadata Repository

   8. Project Support

5. Appendix E Working with Open Source and NetBeans

   1. Practices

   2. Resources

   3. Interacting Effectively on Mailing Lists

6. Appendix F Additional Modules and Where to Find Them

   1. Open Source Modules Available Via the Update Center

   2. The Modules Marketplace on Flashline

   3. IDEs That Are Distributions of the NetBeans IDE

   4. Open Source Application Projects Based on NetBeans

   5. Commercial Applications Built on the NetBeans Platform

   6. Commercial Modules Available for NetBeans

   7. Should You Create Your Own Update Server?

7. Colophon

Our look is the result of reader comments, our own experimentation, and feedback from distribution channels. Distinctive covers complement our distinctive approach to technical topics, breathing personality and life into potentially dry subjects. The animals on the cover of NetBeans: The Definitive Guide are European tree frogs (Hyla arboria). These tiny amphibians inhabit verdant European forests. Like most tree frogs, they have suction pads on the end of each toe that allow them to cling to plants, but European tree frogs can be distinguished from other species by a whitebordered black line that runs from their nostrils to their hind legs. They are generally green in color, though their shade often changes to match their surroundings and help them hide from predators. Less than two inches long, tree frogs are an attractive snack for snakes, lizards, birds, and large fish. Because they are coldblooded, tree frogs often stay in the sun, snapping up flies and other tiny insects with their long sticky tongues.

The most distinctive feature in the males is a well-developed vocal sac; when calling this sac can expand to be larger than the frog's head. The male's sac is creased and usually darker than the rest of his body, while the female's is smoother, smaller, and lighter in color. European tree frogs usually spawn in ponds during spring or early summer. At dusk, males claim an area from which to call females, who arrive later in the evening and choose a mate if they are ready to spawn. The female lays up to 1,000 eggs, which sink to the bottom of the pond. Tadpoles hatch in 12-14 days, and develop their hind legs a month later. Once the tadpoles become frogs, they will leave the water until they are old enough to spawn. An individual female will spawn only once a season, but males do so throughout the summer. These frogs are notoriously difficult to breed in captivity, but are often kept as pets because of their expressive features, distinctive coloring, and ability to stick to the sides of glass terrariums. Phil Dangler was the production editor for NetBeans: The Definitive Guide. Argosy provided production services and wrote the index. Emily Quill and Jane Ellin provided quality control.

Hanna Dyer designed the cover of this book, based on a series design by Edie Freedman. The cover image is a 19th-century engraving from Animal Creation, Volume 5. Emma Colby produced the cover layout with QuarkXPress 4.1 using Adobe's ITC Garamond font.

David Futato designed the interior layout. This book was converted from XML to FrameMaker 5.5.6 with a format conversion tool created by Erik Ray, Jason McIntosh, Neil Walls, and Mike Sierra that uses Perl and XML technologies. The text font is Linotype Birka; the heading font is Adobe Myriad Condensed; and the code font is LucasFont's TheSans Mono Condensed. The illustrations that appear in the book were produced by Robert Romano and Jessamyn Read using Macromedia FreeHand 9 and Adobe Photoshop 6. The tip and warning icons were drawn by Christopher Bing. This colophon was written by Philip Dangler.