yoshwann volnee zealot

0 views

Skip to first unread message

Sherman Desrosiers

unread,

Aug 3, 2024, 12:22:53 AM8/3/24

to leonegooca

I upgraded netbeans from 8.2 to 9.0-1 on 2018-10-22, then installed the nb-javac library plugin, as well as the groovy and gradle plugins, and everything seemed to work correctly (eg my gradle-based projects were recognized by netbeans).

Apache Incubator seems to be a phrase at Oracle for abandoned stuff? I cannot blame Archlinux for this:
NetBeans 9 gives me a bad impression, just nothing works. Some things due to ugly bugs like that the broken native L&F for Gtk3 with Java 11 (no visible checkboxes, tabs barley visible...). Other through NetBeans itself, the import from NetBeans 8 completely fails, nothing.

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.

The HTML for Java & NetBeans API is a classical NetBeans module. However it depends on other modules provided by the HTML for Java project and those are OSGi bundles. As such, when one decides to use this module, one needs to turn on an OSGi container inside of the NetBeans Platform. It can be either Felix or NetBeans version of Equinox.

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.

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.

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.

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).

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 useweb 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 frameworkssuch 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. If an exception implements this interface, the call() method is called and returned LogRecords then scanned for messages, levels, etc.

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 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 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.

You modules can use the AutoUpdateUI API directly (of course you almost certainly need also Autoudate Services), just be aware that this module comes with a UI. It is not always practical to depend on modules that provide a UI from low level infrastructure modules - if that is your case, consider separating calls to AutoUpdateUI into separate bridge module.

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.

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.

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.

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.

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.

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.

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.