Permits customization of the way Ant output is displayed.

Permits additions to the default Ant classpath.

Examining cached and introspected data about which tasks and types are known to be defined in the user's Ant scripts, and what their design-time structure is. Used by XML code completion, for example.

Running named targets in specified Ant scripts. Can be used by modules which provide a different UI for initiating Ant execution. ActionUtils provides a more convenient wrapper around this functionality.

API for controlling and configuring dashboard.

SPI for providing dashboard widgets and alternative displayers.

NetBeans Platform specific bindings over standard HTML for Java API.

API for describing and executing intended operations.

SPI for handlers that are able to invoke proper operation for specified intents.

The module contains APIs for creating output panes (e.g. output tabs in Output Window in the IDE) and for writing data into them. It also supports some advanced techniques, e.g. color text, hyperlinks, code folding, scrolling to stored positions.

SPI for providing custom implementations of output window is also included in this module, in package org.netbeans.spi.io

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 ClassPath APIs provides java classpath like ordered collection of (source) roots with ability to listen on changes and helper methods like finding the file under the roots, returning a path from root to given file. It also provides a registry where projects register their classpaths to make them visible to languages infrastructure.

API for registering additional providers that help the HTML editor to offer better code completion for certain HTML files based on the produced description of a JSON-like structure.

The Lanugage Server APIs provides basic facilities for getting or supplying information used by language server implementations.

provides miscellaneous APIs related to operations provided by maven-archetype-plugin. See package description for more details.

Scripting class offers static createManager() method that should be used whenever one needs an instance of ScriptEngineManager inside of NetBeans based application.

Implement EngineProvider and register it into global lookup via ServiceProvider to dynamically discover and offer new ScriptEngines to users of ScriptEngineManager obtained via Scripting factory methods.

Defines abstract classes SearchInfoDefinition, SearchFilterDefinition, SubTreeSearchOptions and a factory class SearchInfoDefinitionFactory

Defines abstract classes that need to be implemented when creating custom providers: SearchProvider, SearchProvider.Presenter, SearchResultsDisplayer, SearchComposition and relative classes.

Classes usually used by search providers. Contains class SearchInfo, that defines which files should be searched (it can be retrieved from methods in SearchInfoUtils, or UI component controller ScopeController), SearchListener that you should inform about events that happen during searching, and helper classes SearchInfoUtils (getting SearchInfo objects for nodes) and FileNameMatcher (filtering files by file name).

Several UI components that can be used in presenters of search providers, and factory method for creating them.

Contains classes for controlling search, passing search criteria, and some helper classes.

The API provides a set of reusable pieces - widgets. By composing them you are creating a visualization. Each widget has various properties including layout, border, assigned actions, ... The library contains a set of pre-defined widgets that can be extended. All pluggable pieces are declared as interfaces or abstract classes - WidgetAction, Anchor, AnchorShape, PointShape, Animator, Border, GraphLayout, LookFeel, Layout, SceneLayout, Router, CollisionsCollector. Also they all have their built-in implementation.

The API part provides access to web module properties and defines constants for use web module projects (such as action commands or source types). The SPI part can be implemented by modules that provide web module "project" support. It can be implemented with project APIs but other implementations are also possible. There is also an SPI which allows implementors to provides support for web frameworks such as Struts and JSF.

To support classification of exceptions and also annotation of exceptions with logging levels and additional localized messages, logged exceptions and their initCause's are searched for implementation of Callable<LogRecord[]>. If an exception implements this interface, the call() method is called and returned LogRecords then scanned for messages, levels, etc.

The heart of NetBeans. It contains basic implementation of all necessary interfaces, takes care of the startup sequence and the whole lifecycle of any NetBeans based application.

The context field is accessed from editor module by reflection from MultiKeymap.

This module exports an API that allows the UI Gestures Collector module to plug and enhance the behaviour of exception dialog by own buttons. The behaviour is like this: If any of Handlers of Logger.getLogger("") implements Callable<JButton> then such button is going to be inserted to the exception dialog and can react and change the behaviour of that dialog. Such a button is going to be a "closing" one - e.g. the dialog will close as soon as the button is pressed.

provides handy ServicesTabNodeRegistration accompanied with few UI elements.

Provides support for creation of editors composed from multiple (independent) elements. One can either specify the elements directly or read them from a declarative registration for a particular mime type.

the heart of NetBeans integration with OSGi with NetBeans module system is contained in this module. This module locates the OSGi framework implmentation and is then responsible for finding, registering and starting OSGi bundles provided by the NetBeans module system.

Library with utilities for UI Gesture Collector module as well as for the server processing the results.

Allows clients to work with local Git repositories and invoke a set of Git commands affecting a Git repository.

This module re-exports all found GraalVM languages under GraalVM:lang name and makes them accessible via NetBeans Scripting API.

This module re-exports org.graalvm.polyglot APIs. Use them to obtain access to the GraalVM directly, if you only want to work with them and generic Scripting wrapper isn't enough.

Enables Bugtracking modules to fully integrate into Bugtracking Issue Management facilities and other IDE workflow.

Provides Bugtracking functionality for other subsystems in the IDE.

SPI for code analysis tools.

Editor defines APIs and SPIs both by

• Providing java classes in public packages for further reuse.
  Most of the classes were created spontaneously (several years ago) without fulfilling of the rules imposed on APIs and SPIs at the present time.
  There is an ongoing work to revisit the existing classes and create stable APIs and SPIs (and possibly extract functionality into a submodule where appropriate). However this is a long-term task spanning several promotions.
• Being sensitive to content of certain directories in xml layer.

OpenIDE Text API

public SPI provided by the Error Stripe.

Private mark provider SPI.

The Guarded Sections module is supposed to operate over the Swing's StyledDocument. It allows clients to manipulate named guarded sections that prevents user to modify the content. So if you like to create, modify or delete guarded sections the GuardedSectionManager is the best place where to start.

The module also allows to implement custom guarded section persistance in various content types like java, xml, ... The easiest way is to subclass AbstractGuardedSectionsProvider.
In order to bind guarded sections to your editor see GuardedSectionsFactory.

Hyperlink SPI in org.netbeans.lib.editor.hyperlink.spi allows the editors for a particular mime-type to respond to the situation when a user hovers over the text with a Ctrl key pressed.

Editor defines APIs and SPIs both by

• Providing java classes in public packages for further reuse.
  Most of the classes were created spontaneously (several years ago) without fulfilling of the rules imposed on APIs and SPIs at the present time.
  There is an ongoing work to revisit the existing classes and create stable APIs and SPIs (and possibly extract functionality into a submodule where appropriate). However this is a long-term task spanning several promotions.
• Being sensitive to content of certain directories in xml layer.

Code Generator SPI

Highlighting SPI

Typing Hooks SPI

Editor Caret API

API

The Gradle Project API provides some miscellaneous friend APIs and SPIs relating to Gradle projects.

The Gradle Java Project API provides some miscellaneous friend APIs and SPIs relating to Gradle Java projects.

The J2EE DD API is based on a bunch of interfaces based on the deployment descriptor xml structure. The names of interfaces correspond to the names of deployment descriptor elements in the J2EE DD files like ejb-jar.xml, web.xml or applicaiton.xml. The DD API interfaces are organized in a hierarchic tree structure and are accassible through the root (Application), (WebApp) or (EjbJar) interfaces. The implementation of DD API interfaces is hidden for clients. It is based on schema2beans infrastructure and is the DD version - specific. (there is always requirement to support at least two successive versions of DD specification). The implementation is located in non-public packages of j2ee/ddapi module. It is expected that interfaces will not be implemented by the client.
The root of the deployment descriptor is accessible through the DDProvider class.

The spi classes are to be subclassed by dev modules and to be provided as cookies on the development nodes. The api classes are to be used to add actions/properties/additional cookies to those nodes.

J2EE Server module serves as an integration point between two kinds of netbeans modules:

• server plugins (or simply plugins) that integrate various J2EE servers in IDE
• devmodules - netbeans modules that provide support for development of J2EE modules (web module, EJB module, J2EE Application, etc.) and need to deploy and debug them on J2EE servers.

API to create tests for the custom Java hints.

API to register a JDK

(service provide interfaces) for JDK sources and JavaDoc

Module provides public package org.netbeans.modules.java.j2seproject.api with interface for resolving values of project properties defined in project.properties and private.properties files.

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.
Note that this module concentrates the part of th API which is independent of the client desktop (and Swing UI library) environment. Its desktop-dependent counterpart is in the org.netbeans.modules.java.platform.ui module.

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.
Note that this module concentrates the UI part of API. Its desktop-independent counterpart is in the org.netbeans.modules.java.platform module.

The Java Project API is actually entirely SPI and supplies useful implementations of Java-related functionality specific to the project system.

Implemented by java/j2seproject and asked for by form. Permits the Form Editor to add JavaBeans archives to the classpath of a J2SE project automatically.

Support class containg helper method for creating ClassPathImplementation based on Ant properties.

The Java Project API is actually entirely SPI and supplies useful implementations of Java-related functionality specific to the project system. This module focuses on Swing UI components.

Templatesui module is using reflection to access JavaTemplates class from this module in order to create Java-like package chooser.

When the ensure.built.source.roots property is set during ant script execution, the javac task will not actually build the classfiles from scratch, but rather copy classfiles produced by the Java infrastructure into the output folder. The content of the property will be interpreted as list of source roots, for which the artifacts should be copied.

APIs for controling visual aspects of processing of Java files.

TypeBrowser Jump To API

service provide interfaces

This SPI describes services provided by the custom JUnit support plugin which are not desribed by the existing public SPI (UnitTestForSourceQuery). This SPI represents an additional source of information for the JUnit module and allows a custom test-skeleton generator to be plugged.

Other modules can access the keyring, or add implementations.

The Maven Project API provides some miscellaneous friend APIs and SPIs relating to Maven projects.

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.

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.

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.

API allows to display standard Swing UI for project library manipulation.

The Project API defines abstract projects. These are 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. Besides the visible Javadoc, this module permits a project to add implementations of org.netbeans.spi.queries.FileBuiltQueryImplementation, org.netbeans.spi.queries.SharabilityQueryImplementation and org.netbeans.spi.queries.FileEncodingQueryImplementation into the project lookup (rather than global lookup). The implementations will be consulted only in the case the relevant file belongs to that project (according to org.netbeans.api.project.FileOwnerQuery). This helps avoid the need to consult irrelevant query implementations.

API can be used to get list of information about recently opened projects in IDE. API provides project display name, icon and URL of project folder location. Listeners can be registered to learn about change of the list.

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.

Callbacks intended to let the Project UI module plug in implementations of APIs defined here. Uses implementation dependencies.

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.

Callbacks intended to let the Project UI module plug in implementations of APIs defined here. Uses implementation dependencies.

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.

This project to allows to easily add syntax highlighting for languages by using the TextMate grammar files.

interfaces from the API of this module

Enables Source Code Management (SCM or Versioning) modules to fully integrate into the IDE workflow.

Enables to fully integrate into the IDE workflow filesystem independent Source Code Management (SCM or Versioning) modules.

This package provides API's for obtaining a wsdl model using the factory pattern as well as reading and writing the wsdl structure. This package is made up mostly of interfaces, which are not expected to be implemented by the client. The entry point is the wsdl model factory. The components are based on the structure of wsdl and the names should reflect element and attribute names from the specification.

Generic visitor pattern support (such as empty and deep visitors) as well as visitors for finding usages.

The SPI package provides the ability to plug-in strongly typed extensibility elements, which are used in every concrete wsdl for bindings.

Strongly typed extensibility elements for the SOAP binding.

Strongly typed extensibility element for Schema. This supports embedding the schema model within the WSDL model to introspect the types section of WSDL.

Represents a domain independent model and associated artifacts such as a factory, source, and the concept of a reference.

Provides entities for working on XML based models. This package depends on org.w3c packages and assumes a mapping between an xml tree and a strongly typed binding. This package also provides the ability to resolve other models

XDM (XML Document Model)

allows to show errors in the editor, with possible fixes.

SPI to create custom Java hints, including code smell warnings, productivity tips, etc. Please see the Use Cases section for a guide on how to use this SPI.

ETable

Outline

API contains classes used only by switchers accessible through main menu in "Window/Documents..." and "Go To/Recent Document". Besides this module the package is used from core/windows too. Classes contained in the package are rather general and therefore this package could be moved in the future. It is placed here only due to current modules dependencies. Consequently the package is not intended for external use.
For more information on SwitcherTable and SwitcherTableItem see a javadoc.

masterfs module is using a reflection to re-associate the lookup after a move operation.

Just an API/SPI for defining the output window.

Option API

In order to speedup, or remove the load of initialization of kit in AWT during startup, there is a special API that allows to ask the kit to pre-initialize. If the kit implements Callable interface from JDK, it is called in non-AWT thread. This works since version 6.18 and can be disabled by property oldInitialization.

used to call the remove method using reflection

allows the discovery

simplifies creation and registration of own lookup objects

calls constructor of registered classes using reflection

There is a static private method Lookup.resetDefaultLookup that is called by NbJUnit's MockServices to properly reset default lookup and fire changes to all registred listeners.

a class that is looked up in Lookup.getDefault() and if registered can provide better UI elements for Actions.

used to instantiate subclasses.

DataFlavor.javaJVMLocalObjectMimeType + "; class=org.openide.windows.TopComponent"

DataFlavor.javaJVMLocalObjectMimeType + "; class=org.openide.windows.TopComponent$Cloneable"

DataFlavor.javaJVMLocalObjectMimeType + "; class=org.netbeans.core.windows.dnd.TopComponentDragSupport$TopComponentArray"

defines interfaces SearchInfo, FileObjectFilter and a factory class SearchInfoFactory