Here are descriptions of some of the more interesting or significant changes made to the Plug-in Development Environment (PDE) for the 3.6 release of Eclipse, grouped into:
|OSGi console||An OSGi console is now available to
interact with the running framework. Use the Open Console drop
down action in the Console View to open a Host OSGi Console.
You can then enter OSGi commands into the console to interact directly with the framework running the IDE.
|XML error reporting in context help and table of contents editors||The context help editor and table of
contents editor now report XML errors.
|Spell checking in context help and table of contents editors||
Spell checking is now available in the Table of Contents (TOC) and Context Help editors.
|Configurable problem severities for build.properties||Severities for problems in
build.properties can now be configured individually via the Preferences
> Plug-in Development > Compilers preference page. Problem
severities can also be configured at the project level via a project's
Properties > Plug-in Development > Plug-in Manifest
Compiler property page.
|Search repositories quickfix||A new quickfix allows you to
conveniently search a set of repositories for a missing imported
package and have a bundle supplying the package added to your target
|API for plug-in project creation||An API is now available to create
and modify plug-in (bundle) projects. The API provides a description
of a project's bundle related attributes and allows them to be
modified declaratively. For example, a bundle's activator, required
bundles, package exports and imports can be queried and defined. As
well, the root of bundle (i.e. the folder containing
|Feature based launch||You can now manage the set of
plug-ins launched in Eclipse Applications, JUnit
Plug-in Tests, and OSGi Framework launch configurations
by selecting a set of features.
Features from both the workspace and the target can be included. Individual plug-ins can be added to the launch to include plug-ins that are not part of a feature. PDE will launch all the selected plug-ins as well as all required plug-ins.
Features in the workspace are used over external features, however, this can be configured by un-checking 'Use features from workspace if available'. Bundles in the workspace are used over external bundles in the target platform. However, this can be configured by modifying the configuration's default bundle resolution policy, or can be configured per feature using the cell editors in the 'Plug-in Location' column.
|Headless launching support||Launching support for Eclipse
Applications, JUnit Plug-in Tests, and OSGi Frameworks is provided by
a new headless plug-in (
|Console log||By popular
|Support software installation while running and debugging||Launched Eclipse Applications can
now support software installation operations. When the new option is
checked (on the Configuration tab of Eclipse Applications), a
p2 profile is generated when running or debugging. The profile
initially contains all bundles in the target and can be modified by
software installation operations. The profile is regenerated on each
subsequent run or debug session, but is maintained across restart
|Import from CVS||The Plug-in Import wizard
allows you to import projects from CVS corresponding to bundles in the
target platform. This feature is available for bundles that define the
Eclipse-SourceReferences header. On the first page of the
import wizard select the Import As > Projects from a repository
The second page allows you to choose from all bundles with source repository information. Select the bundles you want to import and press Next.
The last page of the wizard allows you to import the specific versions of the bundles used in the target platform or from HEAD. Pressing Finish will import the projects into your workspace.
You can also import projects from the Plug-ins view. Use the Import As > Project from a Repository... action to import plug-ins from CVS.
|Export target content||It's now possible to export the
contents of your current target platform into a destination directory
via the export active target definition wizard. In the list of export
wizards (File -> Export...), you'll find the wizard available
under Plug-in Development -> Target definition.
Note: This will copy all features and plug-ins that are part of your currently set target platform to the destination directory.
|Feature based target||You can now manage the set of
bundles in a target platform by selecting a set of features.
Additionally, you can select from bundles that are not contained in
any feature. On a target definition's Content tab select the Manage
using Features radio button. This provides coarse grained management
of bundles in a target. When a feature is selected, all bundles in
that feature are added to the target.
|Add to target platform dialog||The Add Artifact to Target
Platform dialog (Ctrl+Shift+Alt+A) allows you to quickly search a set
of repositories for dependencies (bundle, feature or package) to add
to your current target platform.
|Synchronize Java search with target platform||You can automatically synchronize
Java search operations with the target platform via the Preferences
> Plug-in Development preference page.
Java search operations are scoped to workspace projects and their dependencies. Developers don't typically have the entire target platform in their workspace and thus Java search operations don't locate references from many upstream plug-ins. You can manually add plug-ins to the Java search path using the Add All Plug-ins to Java Search action in the Plug-ins view. However, the new preference automatically keeps the search path in synch with the target platform.
Under the covers a project named External Plug-in Libraries is created with all external plug-ins in the target platform on its build path.
|Compare with baseline now reports deprecations||When performing Compare With
> API Baseline..., deprecation changes are now reported. This
allows you to quickly identify what has been deprecated between two
releases of a project.
|API use reports||
You can generate reports describing what API and internals are being used by other bundles. API use reports have been integrated as an external tool (Run > External Tools > External Tool Configurations...). For example, the following report settings are used to generate a report revealing which internal components of the debug platform are being consumed by JDT.
A report is run against a set of bundles which can be specified as an API baseline, a target definition or a directory of bundles. You can search for API and/or internal references and you can limit the report to specific bundles by using regular expressions. You must specify an output location (directory) for the report and whether to generate HTML.
Package exports in bundle manifests are used to determine package visibility. Any package exports with an x-internal or x-friends modifier will be considered internal. All other packages are considered API. The Patterns tab can be used to augment package visibility information by specifying regular expressions to identify packages, and whether those packages should be considered API or internal. For example, since TPTP specifies all packages as API, the following patterns could be used to identify its internal packages.
|Customize API use scan reports||A new wizard helps you customize API
use reports. From the Patterns tab of an API Use Report
launch configuration (available via External Tools), press the Add
button to open the wizard and create custom pattern filters.
An Archive Pattern allows specific jars within bundles to be omitted from the scan. A Package Pattern allows you to specify which packages should be considered API or non-API (override visibility definitions in bundle manifests). A Report Conversion Pattern allows specific references to be filtered from the final report. You can filter references from or to locations based on regular expressions.
|Enhanced build.properties validation||Redundant entries in source builds
are now flagged with a warning by default.
|API use report filters||You can now add filter patterns to
API use reports to constrain what references are reported. This
feature is available in UI and in API tooling Ant tasks. When you
press Add on the Patterns tab a wizard allows you to
craft a variety of patterns. An archive pattern is used to skip
specific jars. A package pattern is used to define a package as API or
internal (to override a bundle manifest). A report conversion pattern
is used to skip specific references during report creation (by
specifying a regular expression of reference origins to skip).
For example, to use an archive pattern to filter references from specific archives within bundles, select Archive Pattern and press Next. The wizard allows you to easily craft an archive pattern.
When you press Finish the pattern appears in the Patterns table.
|API use report details||You can now provide comments to
accompany an API use report, which will show up in the reports as
additional information along with the scan parameters for reference.
This feature is available in the UI and in API tooling Ant tasks.
The resulting report could look like the following.
|Enhanced compiler error options for PDE build||PDE/Build can now take advantage of
new support from the JDT compiler to specify that certain warnings
should instead be reported as errors.
Set the property javacErrors.<library> in your build.properties. Similar to the javacWarnings.<library> property, specify the warnings that should be reported as errors:
javacErrors.. = forbidden,discouraged, javacErrors.library.jar = deprecation,nullDereference
|Synchronize project settings with PDE build||To ensure PDE will export and build
your project with the same settings as in the workspace there are new
checks to synchronize project specific compiler and build path
|Synchronize project settings with PDE build||It's easier to synchronize your
project specific compiler settings and file encoding settings with PDE
build. Two new options appear in the Build section of the Preferences
> Plug-in Development > Compilers preference page. By default the new
options are set to Ignore.
When set to Warning or Error problem markers will
appear when your project settings are not reflected in
|Plug-in specific compiler arguments||A bundle can now specify custom
compiler arguments to be used in export or releng builds by setting compilerArgs
in its build.properties file..
These arguments will be specified in addition to whatever general compiler arguments are specified by the releng setup.
|Custom compiler adapters||A bundle can now specify a custom
ant compiler adapter to be used during export or releng builds. This
allows for compiling non-java sources such as AspectJ or Groovy
provided a suitable adapter is available.
Set compilerAdapter in the bundle's build.properties file. As well, set sourceFileExtensions to a list of file extensions which should be treated as source and automatically copied to generated source bundles.
|Improved error reporting from PDE build||A new