Added SourcesHelper.registerExternalRoots with additional parameter
minimalSubfolders controlling how the roots having an explicit include
list are registered. When true only those subfolders which are included
(or folders directly containing included files) will be registered, otherwise the
whole source root is registered.
Classes JavaRunner and JavaRunnerImplementation added.
setSelectedNodes()
.
does partial selection
of valid nodes instead of throwing IllegalArgumentException.
Added a new Utilities.OS_OPENBSD and OS_UNIX_OTHER
fields. Deprecated OS_WINDOWS_MASK and OS_UNIX_MASK.
ActionFactory.createContiguousSelectAction
creates contiguous selection action.
ContiguousSelectProvider
provides logic for selection action.
ContiguousSelectEvent
is an event for ContiguousSelectProvider.
To speed up MIME type recognition it is added an extra parameter
to method FileUtil.getMIMEType(FileObject, String...).
We can supply one or more MIME types which we are only interested in.
Module writers have to override
MIMEResolver
default constructor and call super(String...), e.g.:
public MyResolver() {
super("text/plain", "text/sh");
}
Adding new constant SimpleValueNames.JAVADOC_POPUP_NEXT_TO_CC.
AntProjectHelper.createSimpleAntArtifact enhanced
with new parameter: property name holding project relative location
and name of Ant build script to use.
InplaceEditorProvider.TypedEditorController
contains getEditorInvocationType() which returns invocation type
(MOUSE, KEY, CODE).
If you are interested just in the Class of an attribute, but
without creating its instance, use fileObject.getAttribute("class:attrName").
This instructs the XMLFileSystem
to scan its XML files for definition of attrName
attribute and guess its class. The guessing is
usually easy, just for methodvalue types, the system
needs to use some kind of heuristic: it locates the
appropriate factory method and returns its return type. This may
not be the actual type of the returned object at the end, but
it seems as the best guess without instantiating it.
CodeStyle.getDefault(FileObject), CodeStyle.getDefault(Document).
Deprecated CodeStyle.getDefault(Project).
Added a new Utilities.OS_WINVISTA field to be able
to recognize Windows Vista operating system.
Children.Keys(boolean lazy).
Children.getNodesCount(boolean optimalResult) can be
used instead of Children.getNodes(boolean optimalResult)
for children "initialization". While keeping same behavior as
Children.getNodes(boolean optimalResult) for "default"
(non-lazy) implementation it allows full initialization without need to
create all nodes. Children.snapshot() creates an immutable snapshot representing
the current view of the nodes in this children object. Such snapshots are available in
NodeMemberEvent and
NodeReorderEvent
via getSnapshot() and provide information about state of nodes
in time when events were emited.
Class JavadocAndSourceRootDetection added with couple of
helper methods to detect Javadoc and/or sources root.
META-INF/netbeans/translate.names. If class name
maps to empty string, it is ignored. E.g.:org.mypackage.OldClass=
XML schemas may now be registered in ProjectXMLCatalog/**/*.xsd.
Any attempts to read or write project.xml or private.xml
will first try to validate against the registered schemas.
Added a new method to validate XML documents against schemas.
Declaratively registered MIME resolvers using the XML file syntax
(rather than Java classes implementing MIMEResolver)
are now used even when you run an application with just the Filesystems API in the classpath.
In particular, this makes declarative resolvers be honored in unit tests.
Formerly, declarative resolvers were only loaded when you used org-netbeans-core.jar
and started the full module system.
Added class SingleMethod,
which represents identification of a single method/function
in a file. The new class also contains new constants
(COMMAND_RUN_SINGLE_TEST_METHOD and
COMMAND_DEBUG_SINGLE_TEST_METHOD) corresponding
to commands for running debugging test methods.
It is possible to declare a value in layer.xml
files with <attr name="..." bundlevalue="org.yourpkg.Bundle#key"/>.
TopComponent.
Improve Line.show to have better control over its open/visibility behavior. Previous version of Line.show mixes open and visibility behavior into one parameter. New version separates this into 2 parameters. It is possible to use any combination of these 2 parameters without need to add new constants for previous version. 2 enum types ShowOpenType and ShowVisibilityType are added.
JDBCDriver that was added.
Changes found in FolderLookup are delivered in their own
thread. This is a change to previous behaviour which used the
Folder recognizer
thread for event delivery. That could
cause deadlocks, if malicious code decided to do something wild
in the resultChanged method.
All modification methods in AbstractLookup and ProxyLookup
were extended to accept an
Executor.
If not null, it is used to dispatch events to listeners sometime
"later". Also the AbstractLookup.Content
and InstanceContent constructors
have been extended to accept such Executors.
In order to align RequestProcessor closer to standard
Java 5 concurrency utilities, the class now implements
Executor
interfaces and its execute(Runnable) method.
Initial version of the Print API
Added a new convenience class for getting some common information from Ant scripts.
FileChooser enhanced with "Use Variable Path" option. Following
methods were added:
FileChooser.getSelectedPathVariables and
FileChooser.enableVariableBasedSelection.
For backward compatibility "Use Variable Path" option is by default
switched off and has to be enabled. Existing getSelectedPaths()
method will keep returning either absolute
or relative paths. If "Use Variable Path" option was selected it will
return absolute path. Variable based paths are returned via new
getSelectedPathVariables method.
Support class added for showing variables manager.
Added methods for adding/copying global libraries that are needed
for Ant build script. Added methods:
AntBuildExtender.addLibrary,
AntBuildExtender.removeLibrary
There is new method to register new DataObject types without the need to write own DataLoader. Use DataLoaderPool.factory method.
A new API method AntProjectHelper.createAuxiliaryProperties.
A new API method was introduced to match the AuxiliaryConfiguration
SPI interface. The change simplifies caller code, provides a path for future
changes in the SPI, and allows project types to avoid providing an explicit
implementation of this SPI if the fallback implementation suffices for their needs.
Added new API method ProjectUtils.getPreferences and new SPI interface AuxiliaryProperties.
Project root nodes will now automatically be badged according to VCS status of contained files.
Image methods were separated to ImageUtilities (renamed IconManager) as replacement for methods in Utilities. There are some additional methods for image tool tips manipulation.
New methods for tool tips manipulation:
Image assignToolTipToImage(Image image, String text);
String getImageToolTip(Image image);
Image addToolTipToImage(Image image, String text);
New method for conversion from Image to Icon:
Icon image2Icon(Image image);
"Moved" methods from Utilities:
Image icon2Image(Icon icon);
Image loadImage(String resourceID);
Image loadImage(String resource, boolean localized);
Image mergeImages(Image image1, Image image2, int x, int y);
There is a set of new properties defined in resource bundle which platform developers can use to customize the behavior of NetBeans' window system:
The features above can be turned on/off simply by branding of core.windows module.
The copy of the ClassPath API was used by generic scripting framework, which cannot depend on the java cluster. To remove this copy of the ClassPath API the java API needs to be splitted into the ClassPath API (IDE cluster) and the rest of the java API (java cluster).
The copy of the ClassPath API was used by generic scripting framework, which cannot depend on the java cluster. To remove this copy of the ClassPath API the java API needs to be splitted into the ClassPath API (IDE cluster) and the rest of the java API (java cluster).
Adding new constant SimpleValueNames.THICK_CARET_WIDTH.
Added classes:
org.netbeans.api.debugger.jpda.DeadlockDetector,
org.netbeans.api.debugger.jpda.MonitorInfo,
org.netbeans.api.debugger.jpda.ThreadsCollector
Added methods:
CallStackFrame.getFrameDepth(),
CallStackFrame.getOwnedMonitors(),
JPDADebugger.getThreadsCollector(),
JPDADebugger.getDeadlockDetector(),
JPDAThread.getCurrentBreakpoint(),
JPDAThread.getContendedMonitorAndOwner(),
JPDAThread.getOwnedMonitorsAndFrames(),
EditorContext.annotate() with thread argument,
AttachingDICookie.getProcessID()
Added fields:
JPDADebugger.PROP_THREAD_STARTED,
JPDADebugger.PROP_THREAD_DIED,
JPDADebugger.PROP_THREAD_GROUP_ADDED,
JPDAThread.PROP_SUSPENDED,
JPDAThread.PROP_BREAKPOINT,
EditorContext.OTHER_THREAD_ANNOTATION_TYPE
Added classes:
org.netbeans.spi.viewmodel.TreeExpansionModelFilter
Changed classes:
Models.TreeFeatures - final class with a private
constructor changed to an abstract class.
Added methods:
Models.createNodes(),
Added fields:
ModelEvent.EXPANSION_MASK
Embeddings that request input sections to be joined before lexing
are now lexed as a single section.
Token.isRemoved() was added to check whether a particular token
is still present in token hierarchy or whether it was removed as part of a modification.
Adding new constant EditorStyleConstants.RenderingHints.
Adding new constant to SimpleValueNames for code folding
related settings.
There is new
registration
scheme for DataLoaders.
LookupMergerSupport.createClassPathProviderMerger(ClassPathProvider)
can be used to allow composing the project's classpath from multiple sources (modules).
CloneableEditorSupport.saveDocument() checks document's "beforeSaveDocument" property for a Runnable to be executed before the actual save will be done.
Adding new constant to SimpleValueNames as the name
of an editor setting that determins if pair characters should be
autocompleted or not.
If the Common Palette is associated with a text editor then it's desired to allow users dragging and dropping text into the palette to create new custom code clips that can be dropped into editor later on.
That can be achieved simply by subclassing the default DragAndDropHandler class which manages all DragAndDrop-related operations in the Common Palette and turning the text dnd support in superclasses's constructor on. The default implementation pops up a dialog window when some text is dropped into the palette where user enters code clip name and tooltip and optionally selects appropriate icons.