book

NetBeans: The Definitive Guide

by Tim Boudreau, Jesse Glick, Simeon Greene, Vaughn Spurlin, Jack J. Woehr

October 2002

Intermediate to advanced

672 pages

21h 47m

English

O'Reilly Media, Inc.

Read now

Unlock full access

Is NetBeans for You?Is This Book for You?NetBeans and JavaWhat Is JavaBeans™?The Core Concept of NetBeansNetBeans as the “Visual JDK”All the Usual FeaturesNetBeans as a Tools PlatformNetBeans as an Open Source CommunityDon’t Be Cross that This Book Is Cross-PlatformContents of the Accompanying SourcesLicensing of the Code Examples in This BookWriting Conventions in This BookComments and QuestionsAcknowledgmentsReviewersSimeon GreeneVaughn SpurlinJack WoehrJesse GlickTim Boudreau
Platforms and RequirementsWhat Are the System Requirements to Run NetBeans?Getting and Installing a JDKThe Java Development KitRelationship of JDK to JREObtaining the JDKWhat JVM flavors and version are known to be supported by the IDE?Which IDE Distribution?Installing Binary DistributionsBuilding the IDE from Source (Simple Builds)What You’ll Need to Build the IDESetting Up and Performing the BuildWhere Did Everything Go?How Do I Install a Newly Built Version of NetBeans?Running the IDEMinimal EnvironmentHow to Launch NetBeansSwitches to the runide.sh scriptMultiple NetBeans UsersTroubleshootingLaunchingX Window System issuesAppearance once launchedScreen resolutionX Window SystemSDI vs. MDISummary regarding windowing issuesUpdating the IDE AutomaticallyThe Update CenterConfiguring the Update CenterSetup WizardYou’re Now Running NetBeans
NetBeans and the Java Abstract Model of ComputingExplorerObjects in the User InterfaceData Objects, Nodes, Actions, and PropertiesWhat has NetBeans Explorer got to hide?Other file typesTabs in the ExplorerThe Filesystems viewHow to mount and unmount JARs and directoriesThe Project viewThe Javadoc viewThe Runtime viewNode ParadigmsExplorer views of Java classesBadgesExpanded view of classesCut, copy, and paste subnodesTools actionsSometimes Explorer Gets Behind the TimesDoes a file really need recompilation?Is a version really up to date? Is a file really local or is it already in the repository?SummaryFilesystems and the CLASSPATHHow branches of the host filesystem manifest themselves in NetBeansHow CLASSPATH is handled in the IDEHow to modify the IDE’s CLASSPATHAppending and prepending CLASSPATH to the IDE’s CLASSPATHOther CLASSPATH tricksCreating Packages and ClassesCreating PackagesCreating ClassesTemplatesUsing templatesCreating templatesCreating your own macrosServicesCompiler ServicesCompiling your codeCompiler settingsExecution ServicesDebugging ServicesWorkspacesEditingGUI EditingBrowsingRunningDebuggingPersistence Across SessionsUsing Multiple Instances of ExplorerUsing Multiple Instances of the Source EditorProject ManagementManaging Multiple ProjectsManaging Project Builds Using AntObject BrowserSummary
Why Learn a New Editor?Opening the Source EditorContext MenusClosing the Source EditorCode CompletionUsing Code CompletionTaking advantage of code completionAvoiding code completionUpdating the Parser Database to Include New ClassesAbbreviationsEditor ColoringsShortcutsWord MatchingIndentation Engines and Code FormattingAutomatic EditsOther Editor FunctionalityA Simple Example
Debugger TypesBreakpoint TypesAdding and Removing BreakpointsSetting WatchesStarting the DebuggerThe Debugger WindowThe Variables ViewRemote Debugging in NetBeansDebugging RemotelyCaveatsAdvanced Features
Using Custom Compilation and Execution ServicesCreating and Customizing Internal Compilation ServicesCreating and Customizing External Compilation ServicesCreating a new JDK 1.1 External Compilation ServiceConfiguring the new JDK 1.1 External Compilation ServiceConfiguring the external processThe Internal Execution ServiceCreating and Customizing External Execution ServicesAssociating Services with Java FilesSetting Default Services for Java FilesSetting Services for Specific FilesBuilding with AntCreating a Build ScriptConfiguring the Ant ModuleExecuting and Compiling with Ant ScriptsWhy Use Ant?
The Setup WizardGeneral NetBeans SettingsModule InstallationUpdate CenterThe Tools→Options DialogConfiguring ToolbarsConfiguring MenusConfiguring EditorsObject Type AssociationsEditor SettingsGlobal Key Bindings (shortcut keys)Fonts and colorsMacrosRecording and saving macrosEditing and executing macrosIndentation enginesCommand Line OptionsModulesInstalling ModulesInstalling from the WebInstalling manually downloaded NBM filesEnabling and Disabling Modules
What Is CVS?The How, When, and Why of CVS in NetBeansWhen to Use CVSWhere to Get a ClientNetBeans and CVSUsing Generic VCSUsing Command-Line CVS SupportCVS and NetBeans ProjectsNew Files and PackagesCVS Outside of NetBeansMounting CVS SourcesExploring Versioned SourcesCommon CVS OperationsCheckout/GetCheckin and CommitAdd and ImportLogDiffUpdateUnexpected ResultsSpurious [Local] DesignationAdding DirectoriesAdding Binary FilesUncommon CVS OperationsBranching, Merging, and TaggingNetBeans CVS and the Secure Shell (SSH)Mounting a Generic Versioning SystemOne Final Tip

Creating a GUI Frame or PanelAdding Components to a GUI ContainerConfiguring ComponentsBuilding MenusChanging a Container’s LayoutWorking with BordersAccessibilityCopying a Source ObjectThe Connection WizardThe GridBagLayout CustomizerAdding Event HandlersUsing the Code Generation PropertiesWorking Around Code GenerationContainers Within ContainersBuilding Complex GUIs
Why Should I Make Beans?Creating JavaBeansCreating a GUI ComponentConverting a GUI Component into a BeanAdding an Event Set to a BeanGenerating a BeanInfo ClassAdding a Design-Time IconComponent PaletteAdding a Category to the Component PaletteAdding a Bean to the Component PaletteComponent Palette Problems
Javadoc Support in NetBeansMounting JavadocsThe Javadoc Search ToolCreating JavadocThe Auto Comment ToolJavadoc filteringViewing, editing, and correcting Javadoc commentsJavadoc GenerationJavadoc Search TypesJavadoc ExecutorsDocletsAdding contentAdding linksCustomizing the HTML formatAdditional properties
Installing XML SupportOverviewTemplatesBrowsing and EditingGenerating DocumentationAccessing with JavaXML Schema SupportXML EditorsBeyond Editing XMLChecking and Validating XMLSetting the Node ViewGenerating a DTDGenerating DocumentationGenerating CSSGenerating Java ClassesGenerating a SAX Document HandlerGenerating a DOM Tree Scanner
Why the IDE Supports Web Application DevelopmentHow the IDE Provides Web Application SupportCreating a Web ApplicationThe Filesystems ViewThe Web Project ViewWorking with JSP and HTML FilesAdvanced Web Applications FeaturesExecuting Web ApplicationsWorking with ServletsViewing JSPs as servletsAdding servletsAdding a new servletAdding an existing servletExecuting servletsPassing request parametersPackaging and Deploying Web ApplicationsDeploying Web ApplicationsConfiguring Tomcat
What’s Different About NetBeans?The Core and the Open APIsThe LicenseOpen SourceThe netbeans.org Web SiteRegistrationBug trackingWays to participateThe netbeans.org FAQs and mailing listsNetBeans for Bean CountersGetting and Installing the Open APIs Support ModuleLife Is ChangeSource Code for the Examples
Design Philosophy of NetBeansAbstracting the Abstractions—the Open APIsModularityHierarchy, Files, and NodesEverything Is a File—VirtuallyMapping Files to Java ObjectsThe System FilesystemModule LayersLayers in the System FilesystemExploring the System FilesystemData Objects—Wrappers for Persistent DataNetBeans and JavaBeansNodes—the Application as HierarchyPresenting Nodes to the User—ExplorerUser-Level CustomizationNodes in ActionAdding to the Component Palette using Paste LinkRearranging actions/toolbar contents/menu contentsPasting a compiled class to a menu and executing it from thereModules—OverviewHow Modules Add FunctionalityHow Modules Install Virtual Filesystem LayersWhat Modules Can DoDisabling ModulesAn Illustration—NetBeans with No ModulesInteracting with the IDESetting the Status Bar TextSetting the Current Workspace
APIs versus Core versus ModulesService Provider Interfaces and Client APIsOverview of the APIs and Their PurposesModulesModule manifestsXML layersOrdering files in XML layersLookup and the Services APILookup, .settings files, the system filesystem, and layersCommonly used or interesting classes in this packageServicesNodesCommonly used or interesting classes in this packageDatasystemsExplorerActionsOptionsCompilerEditorWindowing SystemCookiesCookies and supportsExecutionJava HierarchyFilesystemsModules, JARs, and Class LoadersThreading, Deadlocks, andHow to Avoid Them
The HelloWorld ModuleCreating a Module Using the New Module WizardThe Source Files
The Activated Node(s)CookiesA Peek under the HoodTouring NetBeans with the Bean BrowserData Objects, Nodes, and CookiesFilesystems and the RepositoryServicesLookupOptionsUI ComponentsTopComponents, Modes, and WorkspacesBrowsing the window system in the system filesystemXML format for workspaces, modes, and componentsActionsPresentersCustom Property EditorsLocalizationWizardsJumping-off PlacesSpecial Folders in the System Filesystem
Abstractions Covered in This ChapterCreating the Project Files Drop-DownFilterNode—Filtering Which Children of a Node Are DisplayedCreating the Methods Drop-DownImproving the Methods Drop-DownCreating the ModuleCreating a Container GUI ComponentCreating the ShowQuickPanelActionCreating the XML Filesystem LayerCreating and Populating the Module JARBuilding and Testing the ModuleA Little Homework
Building a Mail Reader in the NetBeans ParadigmImplementing MailFileSystem Using AbstractFileSystem and JavaMailCreating a New AbstractFileSystem ImplementationMail Filesystem: AbstractFileSystem.InfoMail Filesystem: AbstractFileSystem.ListMail Filesystem: AbstractFileSystem.ChangeMail Filesystem: AbstractFileSystem.AttrOther Parts of AbstractFileSystemCreating Folder Objects for AttachmentsUsing FileSystem.Status Annotations to Mark Unread MessagesBeanInfo—Displaying Filesystem PropertiesUsing the Wizard Framework to Set Up Mail AccountsCreating Wizard ClassesThe IMAP Mail Server Template Wizard
Creating a DataLoader for MessagesDisplaying and Editing Simple Messages and Unnamed AttachmentsHandling Multipart MessagesCreating a Threaded Mail View Using Filter NodesMaking a Basic Mail ViewMaking a Threaded Mail View as an AlternativeCreating a Mail Workspace
Overview—Functionality to be ImplementedCreating the Minicomposer ModuleCreating the ManifestCreating the LayerCreating a JAR File Using AntCreating a UniFileLoader and MultiDataObject for *.score FilesCreating an Editor Support for ScoresCreating a Fixed ExecCookie to Play ScoresCreating a Simple Template
Creating a ScoreCookie to Represent a Sequence of NotesExamples of State-Based SupportsCreating a ScoreSupportWhy a Document Is UsedImplementation of ScoreSupportLifecycle of the ScoreAn OpenSupportCreating an OpenCookie ImplementationShowing a GUI View of the ScoreCookieIndicating Parse Errors on the Node
Creating the CompilersCreating and Using the Compiler CookieDisplaying an Out-of-Date Badge on Score Icons
Creating the .au Player ExecutorThe Internal PlayerThe External PlayerRegistering the Players as ServicesCreating Player Configuration SupportCreating a SystemOption for the Default Executor
The Clip Length PropertyClearing the Cache and Firing ChangesAdding the Property to the Property SheetRepresenting Notes as Subnodes Using Children.KeysUsing Keys to Model ChildrenBeing Lazy and Cleaning UpCreating the SubnodesAttaching the Children to the ParentPermitting Subnodes to Be Renamed or DeletedDeletion of NotesRenaming of NotesPermitting Subnodes to Be AddedMaking Read/Write Properties on SubnodesReordering SubnodesData Transfer—Cut, Copy, and Paste of Notes and SequencesOverview of the TransferablesCutting and CopyingPastingDrag & DropConverting Score → Text, Text →Score, Several Scores → One
Startup Performance vs. Runtime PerformanceOperating Principles“Nobody Will Ever Use My Module”What Does My Module Really Need to Do on Startup?What Are the Critical Paths?TechniquesLazy InitializationAvoid Static InitializersAvoid ModuleInstall Classes—Use XML Layers Instead.settings filesBatching results of expensive operationsPartial Loading Considerations—InstanceCookie and InstanceDataObjectUse URLs Instead of CDATA Sections in XML LayersReduce the Number of Classes You CreateGUI Components—Wait for addNotify( )Using the addNotify( ) and removeNotify( ) Pattern Where Exposed by Non-GUI ClassesUse Weak and Soft References for ObjectsUtility classes that can helpUse WeakListenerAvoid Excessive Event FiringAvoid Overuse of ThreadsBatching EventsSwing Performance
VersioningVersion Numbers and What They MeanSpecifying DependenciesManaging Inter-Module DependenciesRoutine and compatible upgradesIncompatible upgradesModule dependencies and relative orderUpgrading User SettingsSettings History and Physical FormatUpgrade Scenarios for SettingsSerialized settingsTemplates and saved filesActionsWindow system elements and custom formatsWhat Happens When a Module Is Disabled?User Development DataBundling Extension LibrariesReferencing Libraries with Class-PathUsing Autoload Library ModulesAd-Hoc Resources and Module Installer ValidationInternationalization and AccessibilityI18N and L10NA11YJavaHelp—Writing and DistributingCreating a Help SetAdding a Help Set to NetBeansAdding Context HelpSeparating Help from CodeSupporting User-Level Java APIsSupplying a Parser DatabaseBundling JavadocAdding to the Default ClasspathTemplatesBean InstallationCreating the Module JAR File Within the IDECreating a Build Script Using AntProducing the .nbm FilePublishing Using the Update CenterUsing ErrorManager to Log ProblemsTesting
Do You Need Your Own Distribution?LicensingSelecting a BaselineGetting the SourcesCustomizing the Build ProcessAdding Modules to a “Stock” DistributionCreating Preconfigured SettingsBrandingImplementing Branding on a DistributionSimple Branding: Text Strings and ImagesConfiguration Branding: Menu Bar, Workspaces, and MoreReplacing a fileAdding a fileRemoving (masking) a fileUsing the Open APIs Support to brand layersAdvanced Branding: Patching Behavior
Modules That Expose Functionality You Might NeedThe XML ModulesThe EditorVersion Control—the VCS Core ModuleRemoteFSThe Ant ModuleThe Java ModuleDebugger CoreJ2EE ServerForm EditorHTTP Server ModuleClassfile Reader ModuleThe Metadata Repository—a Whole Host of APIsSocket-Based Editor Support—the External Editor ModuleIncidental APIs, Utilities, and ExtensionsThe Utilities ModuleAPI Extensions (openidex)Modules That Make Good Examples for Things You May Need to ImplementAnnotations and Dynamic Editor Tool Tips—the Ant Module and the Debugger Core ModuleAdding Information to the View of Java Sources—the Beans ModuleAdding a Debugger Type—the Applet ModuleMultiplexing DataObjects and Complex Cut/Copy/Paste Support—the Properties ModuleWorking with Network Protocols to Access Files—JavaCVS and RemoteFSDomain-Specific XML Support—the Tomcat and Ant ModulesStretching the Limits—the Web ModulesComplex Syntax Coloring—the JSP ModuleMulti-Stage Compilation—the JSP, RMI, and CORBA ModulesBridging to an Entirely Different Build System—the Ant and Makefile ModulesUse of the Compiler Infrastructure for Non-Compilation Tasks—the JAR Packager ModuleExecution—the Applet and JSP/Servlet ModulesCustom Hyperlinking in the Output Window—the Ant ModuleSpecifying Windows, Workspaces, and Components Using XML—the Core Window System and the Form Editor ModuleComplex Work with MIMEResolvers and Multi-File DataObjects—the CPP ModuleCut/Copy/Paste—Data Transfer Support for Complex Elements—the Ant and Java ModulesInterconversion between Different Types of Clipboard Contents—JNDI, CORBA, and RMIIntegrating Other Programming Languages—the C++/Fortran, Scripting, and WebL ModulesFancy Footwork with Nodes—the Java ModuleAdding Nodes to the Runtime Tab in the Explorer—the RMI, CORBA, JNDI, and Database Explorer ModulesThe Bare Essentials of Non-Data-Driven Nodes—the System Properties ModuleWizards—the CORBA, Java, and New Module Wizard ModulesEmbedding Property Panels into Wizards—the Java ModuleComplex Explorer Views—the Debugger Core ModuleEnabling/Disabling Sets of Actions Based on Context—the VCS Core Module
XML Utilitiesorg.openide.xml.XMLUtilorg.openide.xml.EntityCatalogVisual Components and Extensions to Standard Swing ComponentsLookup ImplementationsThreadingMiscellaneous Utility Classes inorg.openide.utilSerialization Helpers
CVSHomeGNU/BSD/Other Operating SystemsCVS GUI ClientsJava EnvironmentsJava ToolsApache Software FoundationSecure Shell (SSH) ResourcesCygwin for WindowsNewsgroups and Mailing ListsWeb SitesOrganization of Main NetBeans Web SiteSun SitesNetBeans Open Source Projects with Design Forms in the DistributionJava-Oriented IDEs Other Than NetBeans
Declarative InstantiationUniform LookupDatasystems IIThe Looks APIDeclarative ActionsDeprecation of IDE-Specific Functionality in the Open APIsThe Metadata RepositoryStandards Employed by the MDRProject Support
PracticesGovernanceConsensusThe mechanics of consensusHow to Get InvolvedThe mechanics of contributionThe Lifecycle of Module DevelopmentResourcesCVS (Concurrent Versioning System)ProjectsMailing ListsCVS mailing listsIssue mailing listsIssuezillaInteracting Effectively on Mailing Lists
Open Source Modules Available Via the Update CenterThe Modules Marketplace on FlashlineIDEs That Are Distributions of the NetBeans IDEOpen Source Application Projects Based on NetBeansCommercial Applications Built on the NetBeans PlatformCommercial Modules Available for NetBeansShould You Create Your Own Update Server?

Content preview from NetBeans: The Definitive Guide

Appendix E. Working with Open Source and NetBeans

Many interesting texts are available on the value, philosophy, and practices of open source software development, so we’ll stick to some practical advice and tips for working effectively in the NetBeans project.

Practices

Any community functions according to stated or unstated contracts between its participants. In the case of NetBeans, these “contracts” are relatively lightweight. To participate effectively in a community, it is helpful to know what the typical behavior patterns are. Read on to learn how NetBeans works as an open source project.

Governance

The NetBeans project has a “governance board” that can vote and make decisions if there is some irreconcilable problem. It is composed of two members chosen by the user and developer community on the mailing lists and one member appointed by Sun Microsystems, which donated the initial source code and sponsors the project. The governance board is the choice of last resort. As of this writing, it has never had to decide an issue. It exists to ensure that no party can hijack the project or cause NetBeans to evolve specifically in its private interest at the expense of others or the health of the project and code.

Heavyweight governance, with committees, hierarchies, and chairpeople is notably absent from the NetBeans project. The authors of this book were two of the individuals who set up the initial site and governance process, and we strongly believe that it is far better to evolve ...