NetBeans Stable API List

NetBeans 5.0

3 May 2007

This document provides a list of
stableNetBeans APIs released as part of NetBeans IDE 5.0 with a short description
of what they are used for, and a table describing different types of interfaces
(see What is
an API? to understand why we list DTDs, file formats, etc.) and with
a stability category (see API
life-cycle for a list of possible API stability
categories and their meaning).
Some of these APIs are part of the
NetBeans Platform
(for example lookup,
loaders, utilities, nodes, explorer, window systems, multiview, etc.), some of them
are specific to
NetBeans IDE
(projects, javacore, diff, etc.) and some
are not included in the release at all and are just provided for download
(usually via autoupdate). Basically when building an application based on
NetBeans one is free to choose the set of modules and their APIs
to satisfy one's needs.

Only APIs considered
stable for NetBeans 5.0 are listed here. There is however a set of
additional ones that are not treated as
stable but can be useful as well. To see them, visit the
documentation for version currently
being developed.

Additional Sources of Information

Content

Actions -
Actions provides system of support and utility classes for 'actions' usage in NetBeans.

ant/project -
Provides the basic infrastructure by which Ant-based projects can be created, read and write configuration parameters and properties from/to disk, satisfy common queries and interfaces, etc.

java-srcmodel -
This module defines JavaHierarchyAPI which allows to inspect Java classes and possibly manipulate with portions of a .java source.

Loaders -
In summary, the LoadersAPI is responsible for scanning files in a directory on disk, weeding out irrelevant files of no interest to the IDE, and grouping the rest into logical chunks, or just determining what type of data each represents.

Modules -
The Modules API lies at the core of NetBeans and describes how plug-in modules are added and managed.

Navigator API -
Navigator module is a base API module which provides:
A place for modules to show structure/outline of their documents
Ability for modules to show their view only when special document(node)
is active in the system
UI for switching between multiple views available for currently active document(node)
Coalescing of fast coming selected node changes to show content for
.

The Java Support APIs provides basic facilities for getting or supplying
information about Java-language source files. It is based on the query pattern
so implementations can be supplied from other modules or projects.

The diff module provides the ability to visualize differencies between source files.
It also has a graphical conflicts resolver tool and built-in patch algorithm.
List of the main features:
Simple APIs, that provide access to registered diff and merge engines and visualizers.
Built in and external diff engines defined.
Graphical diff vizualizer and conflicts resolver.
Extensible with additional diff and merge engines and vizualizers.
Patch algorithm implemented for UNIX-style, unidiff and contextual diff formats.

Code Templates allow to paste various code snippets by using parametrized text.
The parameters of the same name will share the same default value and if that value
gets changed by user's typing the new value gets replicated into all the parameter's
occurrences.
Code Templates replace the original abbreviations functionality.
Code template's example
for (Iterator ${iterator} = ${collection instanceof="java.util.Collection"}.iterator(); ${iterator}.hasNext();) {
${cursor}${iterator}.next();"
}
Each parameter can have additional hints of what values
can be assigned to it.
The hint has a form
${param hint=value}
or just
${param hint}
which translates to
${param hint="true"}
If necessary the value of the hint can be enclosed
in quotes to allow to write whitespace or { or }
into the value. The quote can be written by using \".
Reserved parameter names
${cursor} defines position where the caret will be located
after the editing of the code template default values will finish.
Reserved hint names
${param editable=false} can be used to make the parameter to be skipped
from user's editing. This may be useful e.g. with using java-specific type
hint (described below).
Java:
${ind index} defines that the default value of the parameter
should be an unused variable in the given context named i.
If i is already used then j is attempted
or then k etc. until z.
Then i0, i1 etc. are attempted.
${param type="java.util.Collection"} defines
java type that the parameter must be instance of.
Besides class names there can be array e.g. String[]
or generics java.util.List<String>
${param array} defines parameter of array type (including
arrays of primitive data types).
${param type="java.util.Iterator"} defines
that the parameter has the given java type. The template processing infrastructure
will use short name Iterator and import java.util.Iterator.

Code Completion provides users with a list of suggested completions for partially typed texts in the editor and various dialog input fields.
The Code Completion module was created to replace
the original legacy editor code completion which
lacked several key requirements:
Support for multiple independent code completion content providers.
Implied requirement for ordering and prioritization of the completion items.
Direct support for asynchronous completion result computation.
Missing separation to the API and SPI and implementation parts.

Each editor provides an EditorKit which controls the policy of specific MIME content type.
The policy of content type should be easily registered and found via some lookup mechanism,
that will provide convenient way of using it either for kit provider or base
editor infrastructure. In addition to this, the policy can be inherited, (i.e. in case of embeded
kits like JSP) and the content types need to be merged in this case. MIME Lookup API should
provide all mentioned requierements via easy lookup query, so content type policy
user need not to solve this searching and merging on its own side.

Now editor settings in editor module are maintained by complicated structures and their
initialization processes. It is because of historical reasons and the presence of standalone editor,
where standalone settings layer is supported via openide dependent editor module layer. Each editor
that provides its own settings needs to depend on the whole editor module.
The main purpose of this project is to create editor/settings API, that will contain settings classes,
which will be lookup-able via mimelookup. The aim is NOT to provide physical implementation of
editor settings storage. The module will be just interface between the settings storage and
the settings clients like <mime-type> editors, externaleditor, etc.

Many Java-based project types need to be able to configure the version and
location of Java to be used when building and running the project. This
API/SPI permits these platforms to be registered and queried, and any
customizations made in an appropriate GUI and persisted to disk.

The Java Platform API permits access to installed Java platforms (for example,
the J2SE JDK, or various mobile-device emulators for J2ME). Particular platform
types are registered by modules and can store customized information about the
platform to disk.

The JavaHelp integration API wraps the standard JavaHelp extension
library. It also provides a small additional API for NetBeans modules to
supply help sets to the system, add GUI menu items, and request that
particular help topics be displayed.
JavaHelpIntegrationAPI

Provides the basic infrastructure by which Ant-based projects can be created,
read and write configuration parameters and properties from/to disk, satisfy
common queries and interfaces, etc. See Javadoc and build system design
document.

Mostly an SPI for creating project types centered around the Ant build tool.
Permits Ant-based project types to be registered and supplies various support
implementations to help satisfy the contract of Project and
various optional interfaces.

Permits libraries to be defined, customized, and stored by the user for
reuse in multiple projects. For example, a Java JAR library has a classpath
(usually one JAR), and an optional source path and Javadoc path that may be
used for development-time features.

The Project Libraries API permits definitions of libraries to be
registered and persisted. Library type providers may be registered and can
construct memory objects corresponding to persistent library definitions.

The Project API defines abstract projects, i.e. groupings of files built and
manipulated as units. It is used for Ant-based projects but could support
other scenarios such as makefiles. Modules can plug in project types which can
recognize certain folders as being projects, and define their behaviors.

The Project UI API provides some miscellaneous APIs and SPIs relating to the
appearance and UI behavior of generic projects. Most importantly, it permits
the customizer and logical view of a project to be defined.

General kinds of queries between modules.
Queries are one way of solving the
intermodule communication problem when it is necessary for some modules to
obtain basic information about the system (e.g. whether a particular file is
intended for version control) without needing direct dependencies on the
module providing the answer (e.g. the project type which controls the file).
Details are covered in the Javadoc.

The General Queries API provides generic queries, or sources of
concrete information, useful throughout the build system and perhaps
elsewhere. Each query is split into an API component intended for clients to
find the answer to a particular question without knowledge of the underlying
structure or origin of the answer; and an SPI interface (using lookup)
permitting answers to be provided from any source. These queries currently
pertain to VCS and compilation status and user visibility of files.

Settings are persistent objects with a set of properties, that should be available via lookup.
Properties are expected to be changed. Implementation of setting doesn't care about persistence issues, which
is responsibility of settings infrastructure. XML persistence support is provided in a standalone autoload module core-settings.jar.
But a typical setting is a system option, which uses serialization at the moment. Also service types must be mentioned here.
Service type can be desribed as typed a named settings.
SettingsAPIServicesAPIOptionsAPIXmlSettingsPersistence

Navigator module is a base API module which provides:
A place for modules to show structure/outline of their documents
Ability for modules to show their view only when special document(node)
is active in the system
UI for switching between multiple views available for currently active document(node)
Coalescing of fast coming selected node changes to show content for

The
DialogsAPI
allows creating a user notification, a dialog's description
and also permits it to be displayed. The wizard framework allows create a sequence
of panels which leads a user through the steps to complete any task.
This API is part of package org.openide.

The IDE uses a small interface to describe the execution of Java-based
classes together with arguments. The
ExecutionAPI
controls the execution
of user-level classes. The system may have several different types
of executors simultaneously installed. By default we provide so called
External Execution for running a user code by an external process and
Internal Execution for running the user code in the same virtual machine
as the IDE.

The
ExplorerAPI
is build around Explorer - solely a user-interface device: it has no particular knowledge
of the structure of the IDE. Rather, it provides the physical user interface for
the Node hierarchy, as described in the
NodesAPI.
A given Explorer instance will be some visual component (such as a Swing panel)
displaying some representation of a subtree of the complete Node hierarchy;
the topmost node being displayed is said to be the root of the Explorer.
Be careful not to confuse the root of a particular Explorer instance, which is
selected according to what the user wishes to see, with the root(s) of
the entire Node hierarchy, which generally are fixed.

In summary, the LoadersAPI
is responsible for scanning files in a directory on disk,
weeding out irrelevant files of no interest to the IDE,
and grouping the rest into logical chunks, or just determining
what type of data each represents. It does this scanning by asking each registered
data loader whether or not the given file(s) should be handled. The first
loader to recognize a file takes ownership of it, and creates a matching data object to represent it to the rest of the IDE.

Nodes API serves as the main aparatus for visualisation of objects
in NetBeans. Nodes augment objects with standard aspects used for
visualisation (e.g. name, displayName, icons, set of proerties,
subnodes hierarchy, etc.) Once a Node is defined for given object
it can be visualised using diferent views e.g. trees, lists, tables etc.
Descripion of nodes can be found
here.

This module defines JavaHierarchyAPI which allows to
inspect Java classes and possibly manipulate with portions of a .java source. Other modules,
java and clazz, implement the API on top of source files or .class files respectively.

Window System API is used to display and control application GUI: Main window,
frames, components.

Usage:

Declare dependency on openide module ie. add following line to manifest of your module:
OpenIDE-Module-IDE-Dependencies: IDE/1 > X.XX (it will be defined yet) as window system is part of openide.
And dependeny on implementation:
OpenIDE-Module-Module-Dependencies: org.netbeans.core.windows > X.XX. But since the core-windows.jar does not provide any public API
this should be used only in ui-declaration module (like core-ui.jar).