NetBeans: The Definitive Guide
NetBeans: The Definitive Guide By Tim Boudreau, Jesse Glick, Simeon Greene, Vaughn Spurlin, Jack J. Woehr
October 2002
Pages: 672

| Table of Contents | Index | Sample Chapter | Colophon

Table of Contents

  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

Return to NetBeans: The Definitive Guide