Eclipse 3.3 - New and Noteworthy

And hitherward the shore, where thou, Europa!
Mad'st thee a joyful burden: and yet more
- Dante Alighieri, The Divine Comedy

The party keeps getting bigger! This year twenty one Eclipse projects join the Europa simultaneous release. Here are some of the more noteworthy things available in the seventh annual release of the Eclipse platform SDK available for download from the downloads page.


Eclipse on Vista

The win32 version of Eclipse now runs beautifully on Windows Vista. SWT now exploits native features of the Vista platform, such as native double-buffering to make painting in double-buffered canvases twice as fast.

Eclipse on Vista (win32)

New Eclipse WPF port

Eclipse is now available on Windows Presentation Foundation (WPF), a new window system that comes pre-installed on Microsoft Windows Vista.

This port is in early access form for 3.3. While this port is stable enough for exploration and development, it has not yet matured to the level of stability and performance you have come to expect from the Eclipse platform. Stay tuned for more improvements on this platform in future releases.

Eclipse on Vista (WPF)

Quick access

To quickly access UI elements such as views, commands, preference pages, and others, use the new Quick Access dialog, available under Window > Navigation and bound to Ctrl+3 by default. Start typing in the filter field to see matches. For example, to open the console view, type Ctrl+3 followed by "con". One of the first matches will be to open the console view. You can use the arrow keys to select a different match for a given filter string. Press Enter to select the highlighted entry. This will execute the command, or open the view, perspective, or wizard etc.

Ctrl+3 shot 1

Your previous choices will be remembered and shown the next time the dialog opens. If you enter the same filter string again, the entry you picked last time will be selected automatically.

Ctrl+3 shot 2

Using the initials of the words you are trying to find, you can narrow down your choices using very few letters.

Ctrl+3 shot 3

Undo support for resource operations

Undo and redo are now available for most resource changes. When you manipulate projects, folders, or files, you now have the ability to undo and redo the changes you have made. This includes resource creation, deletion, move, copy, and rename. Use the Edit menu from the Navigator view to undo the operation. Note that operations from other views (such as the Java Package Explorer or Project Explorer) may not support undo.

Screenshot showing the undo available after deleting resources from the Navigator

Undo support for task and bookmark operations

Undo is now available for many task and bookmark operations. When you create, update, add, or delete a task or bookmark, you now have the ability to undo that change. Use the Edit menu from the Navigator, Package Explorer, Tasks, or Bookmarks views to undo the operation.

Screenshot showing the undo available after adding a task to the tasks view

A new look

Eclipse has a new default presentation. Some of the key features of this presentation are:
  • New Minimize/Maximize behavior. The new 'Minimize' behavior is to move the view stack to the nearest trim area, showing a 'Restore' button along with the icons for the views in the stack. When in the trim, clicking on a view icon will show the view as a fast view. Minimized stacks can be drag and dropped to new locations along the workbench trim. Maximization of any stack triggers minimization of all others. Maximizing an editor now maximizes the entire editor area, allowing you to view multiple editors side-by-side while maximized.
  • New workbench tab treatments. Workbench tabs have a new color scheme based on your system title background color, and unselected tabs now also have rounded corners to match the appearance of selected tabs. When tabs become crowded, they now maintain their icon and no longer show an ellipsis in order to maximize the amount of useful information.


You can reinstate the old presentation via the General > Appearance preference page.

Improved workspace switching

When you switch workspaces you can now transfer some of your current settings with you. The most recently used workspaces now appear on the file menu under the Switch Workspace item for quick access.

Setting transfer while switching workspaces

Improved resource selection dialog

The resource selection dialog (Navigate > Open Resource) now allows you to filter based on working set, and supports camel-case search. For example, searching with the string "TIMF" will match a file called "ThisIsMyFile".

The dialog also now shows the history of recently opened items, and allows multi-selection to open several resources at once.

Resource selection dialog

All plug-ins are now signed

All plug-ins in Eclipse project builds are now signed using a cryptographic signature provided by the Eclipse Foundation. This allows you to authenticate that the content you receive from the download server matches the content on Eclipse update manager will also authenticate the signatures on these plug-ins when they are provided from an update site. You can see information about plug-in signatures under Help > About Eclipse > Plug-in Details

Working set usability improvements

You can now add and remove selected elements to and from working sets in your workspace. This functionality is found in the Edit menu as well as in the toolbar. You can also create a new working set directly from the Add to working set toolbar dropdown. To access this functionality, you may need to add the Working Set Manipulation command group to your perspective via Window > Customize Perspective.

Add to working set

Hiding the window toolbar

You can now hide the window toolbar by clicking Hide Toolbar in the context menu of the toolbar. You can restore the toolbar by clicking Window > Show Toolbar

Hide window toolbar

Working sets for the Project Explorer

The Project Explorer can now group and filter elements by working set. You can display working sets as top-level groupings or aggregated into a flat list. The window working sets can also be selected and grouped or aggregated based on a preference.

Working Sets top level groupings submenu in Project Explorer

Patch wizard improvements

The Apply Patch wizard now allows you to preview the patch changes against the contents of the local workspace. When applying CVS patches, you can also now manually apply unmatched patch segments to the local file. No more digging through *.rej files!

Apply Patch wizard

Compare editor improvements

The compare editor has a number of significant improvements:
  • The contents of compare editors are now kept in sync with other editors currently open on the same file.
  • Comparisons that used to take a long time now take a matter of seconds, thanks to a new text differencing algorithm.
  • Compare editors are now initialized in the background so that the UI remains responsive while the files are being fetched and compared.
  • Many of your favorite editor commands are now available in compare editors, including find/replace, show whitespace characters, show line numbers, and the Show In sub-menu.
  • Compare editors now highlight individual changes within a block of changes.

Highlighting of changes in compare editors

Compare Structure in Outline view

You can now view the structure pane of a compare editor in the Outline view. To enable this, go to the General > Compare/Patch preference page and check Show structure compare in Outline view when possible. Selecting structure elements in the Outline view will scroll the content pane in the Compare editor to reveal the change in the selected element.

Structure compare pane in Outline view

Long resource paths on Windows

Where the underlying file system allows it, you can now create resources with paths longer than 260 characters on Windows. This requires a Java 1.5 VM or greater.

Navigator view showing long resource path names

Open files with other editors

You can now open files with editors that are not registered for the specific file extension. Right-click on your file and select Open With > Other. You will be presented with a list of editors to choose from.

Open With->Other...

Forms enhancements

UI forms have many visual and functional enhancements, including rendering and layout of the heading area, with drop-down menu, drag and drop, and shared-header support. Form validation now supports multiple messages, and shows which field the error occurred in.

Sample forms editor

Platform level proxy and SSH2 settings

A new General > Network Connections preference page has been added for managing proxy settings.

In addition, the JSch SSH2 client used by the Eclipse CVS client has been pushed down to the Eclipse Platform so that it can be used by other clients as well. Use the new General > Network Connections > SSH2 preference page to configure it.

Network Connections preference page

Keys preference page improvements

The Keys preference page displays your key bindings and can optionally display all available commands that can be bound to keys. Customized key bindings are marked by the "delta" icon delta in the User column.

You can now:

  • Update a selected binding immediately by modifying the Binding or When fields
  • Create a binding from a command by modifying the Binding field
  • Create a command from a binding using the Copy Command button
  • Remove all changes from the system with Restore Defaults

keys preference

Editor area drag and drop

Dragging external files (i.e., from the Windows file explorer) on to the editor area of a workbench window has the same effect as Open File. Also, you can now drag an editor between workbench windows associated with the same workspace.

Properties view make over

The Properties view has adapted to the new look and feel of UI forms. Visual enhancements include new title bar layout, colors and gradient, and new tab design and colors.

tabbed properties view

Console launcher for Windows

There is now a second launcher "eclipsec.exe" on Windows that behaves as expected for a console application. This allows piping the output from Eclipse, sending the Ctrl+Break signal to the VM to generate a stack dump, and better behavior in general for the standard -console, -consoleLog and -debug options.

Improved detection of Mozilla plug-ins

Users of Mozilla-based browsers can now augment the default set of Mozilla plug-in paths that are searched by defining environment variable MOZ_PLUGIN_PATH. For example:

export MOZ_PLUGIN_PATH=/usr/lib/browser-plugins

Easier help navigation

The help window now has a Home button in the navigation toolbar, which brings you back to the initial home page. You can also find your way home by following the bread crumbs at the top of each document. These links allow for easier navigation and provide more information about the context of the document being viewed.

Help breadcrumbs

Help search term highlighting

If you open a help document as a result of a search, a new toggle button will appear in the toolbar allowing you to toggle the search term highlighting on and off, making the document easier to read.

Search highlighting toogle button

Categorized help search

You can now categorize help search hits by book in the help window via the new toolbar toggle button. Similarly, you can also toggle the search descriptions.

Categorized help search

Print multiple help topics

You can now print multiple topics in the help window with a single action. The new print drop-down button above the table of contents allows you to print a complete topic sub-tree at any level, and will automatically generate a table of contents in the printed document.

Print drop-down menu

Cheat sheet improvements

You can open a cheat sheet from the Web by specifying its URL in the open cheat sheet dialog.

Opening a cheat sheet from a URL

Sub steps in a cheat sheet are now clearly separated using horizontal lines. Sub steps can now be previewed. The background colors in the cheat sheet view have been adjusted to make the active step stand out more.

Spell checking in text editors

Spell checking is now available in text editors and an American and a British English dictionary are part of the SDK:

Picture showing the dictionary section from the Spelling preference page

Spell checking is now enabled per default. If you're already a spelling whiz, you can disable this feature with the new Disable Spell Checking quick assist.

Show invisible whitespace characters

It is now possible to see the invisible whitespace characters in textual editors:

Screenshot showing whitespace characters in the editor

This feature can either be controlled via General > Editors > Text Editors > Show whitespace characters preference, or via the [Screenshot of the Show Whitespace tool bar button] tool bar button when the Editor Presentation action set is enabled.

Text drag and drop in text editors

You can now drag and drop text to and from text editors:

Screenshot showing text drag and drop in the editor

You can control this via General > Editors > Text Editors > Enable drag and drop of text preference.

Scroll by pages using Ctrl + mouse wheel

The mouse wheel scrolls the content of a textual editor by pages while the Ctrl key is pressed.

Select by word or line using the mouse

Double-click and drag now grows or shrinks the selection by a word at a time. Triple click will select a whole line, and those with nimble fingers can triple-click and drag to grow or shrink the selection by a line at a time.

Smart Home/End

Pressing Home and End keys now ignores whitespace at the start and end of a line. Pressing the key a second time goes to the real start and end. Pressing the key again toggles between the two start/end positions. Home/End inside a linked area jumps to the beginning or end of the linked area, e.g. when filling in a template.

This feature can be controlled via General > Editors > Text Editors > Smart caret positioning at line start and end preference.

More team annotation options

Team annotations in text editor ruler can now be configured in a number of ways: you can select from three different coloring schemes and choose whether author and revision information should be displayed as text in addition to the coloring. The following screen shot shows the revision numbers, background colored by author, and additional information in the hover and it also emphasizes the changes belonging to the same revision. This is achieved by clicking on a revision in the live annotate ruler. A second click removes the stickiness again.

Screenshot of an annotated Java editor - the ruler shows revision numbers, while its background is colored by committer

Below we see the author names, with background colored by date. These options are configurable via the ruler context menu (Ctrl+F10):

Screenshot of an annotated Java editor - the ruler shows revision numbers, while its background is colored by committer

Recenter command

A new command has been added that allows recentering the line that contains the caret. By default, this command is only bound to a key binding (Ctrl+L) when using the Emacs scheme. To bind it in the Default scheme, simply assign a key sequence to the Recenter command which can be found in the Text Editing category.

Joining lines in text editors

You can now use the new command Ctrl+Alt+J in a text editor to join lines.

Convert tabs to spaces

Text editors now allow you to convert tabs to spaces when typing.

This feature can be enabled via General > Editors > Text Editors > Insert spaces for tabs preference.

More flexible templates

The syntax for templates has evolved to allow typed and parameterized template variables. This allows the same variable type to be used multiple times in the same template. As an example, consider the following template for generating a doubly nested for loop:

Screenshot showing a template for a double loop over two different arrays

Import CVS projects directly into working sets

You can now assign CVS projects to a working set during import. This is available from both the CVS Repository View (via Check Out As) and through the CVS Import Wizard.

Checkout As

Export working sets as part of team project set

The export wizard can now persist active working sets as part of a Team Project set.

Export Project Set

History view search

The History view has a new search field that allows you to filter the history based on text in the author, comment, revision, and tags. The field is not visible by default but can be enabled from the view menu.

History Search Field

History view now has view history

The History view now allows you to navigate back to previously viewed elements.

History view has view history

Spell check in Commit dialog

The Commit dialog now uses the Eclipse spell checker to highlight spelling errors in commit messages.

Commit dialog

Flat presentation in model-based synchronizations

A flat presentation has been added to model-based synchronizations. For CVS, model-based synchronizations are the default.

Flat presentation in Synchronize view

Launch selection vs. launch last

Running and debugging applications has been simplified to run or debug the selected file or active editor. Use the Launch the selected resource or active editor preference to enable this behavior on the Run/Debug > Launching preference page. When the selected resource (or active editor) is not executable, you can opt to launch the associated project or launch the previously launched application.

Launch selection vs. launch last preference settings

Pressing the Run or Debug toolbar button will launch the selected resource (as will the Run or Debug action in the top level Run menu). When a launch configuration does not exist for a file and there is only one way to launch it, the file will simply be launched in the mode you selected. When there is more than one way to launch a file you will be prompted to select how to run or debug the application. For example, when running a JUnit test you can run as a Java application or JUnit test. A launch configuration will be created and an entry will be added to the launch history for the application.

Dialog used to select how to debug a Java program

When the same file is launched again, the most recent configuration in the launch history associated with that file is re-launched.

Run/Debug settings

A new properties page has been added to manage launch configurations associated with a resource. For example, selecting the Run/Debug Settings property page for a project will display all launch configurations associated with that project. Configurations can be created, deleted, and edited from this page.

Run/Debug settings property page showing launch configurations associated with the selected resource

Automatically showing console

Toggle buttons have been added to the console toolbar controlling when the console is automatically displayed. The buttons provide quick access to the workspace preferences to show the console when output is written to standard out or standard error (also available from the Run/Debug > Console preference page).

Toggle buttons in console toolbar

Java development tools

Refactoring without save

Refactorings don't require all editors to be saved any more. They can now operate even if Java or text editors still have unsaved changes. If you don't like unsaved editors after refactorings, you can still choose to always save modified resources on the Javapreference page.

Rename refactoring in editor

The Java Rename refactoring can now be performed directly in the editor, without showing a dialog.

When using Refactor > Rename (Alt+Shift+R) in the Java editor, the editor enters linked mode instead of opening a modal dialog. Changes stay local until Enter is pressed, which will perform the change in the whole workspace.

In-place rename mode

To see and configure refactoring options, press Alt+Shift+R again, or click the menu button and choose Open Rename Dialog....

If you prefer the old modal dialog, you can disable Rename in editor without dialog on the Java preference page.

Introduce Parameter Object refactoring

Introduce Parameter Object is a new refactoring that replaces a set of method parameters with a new container object. All calls to the method are updated to pass the new parameter object class.

Use cases:

  • group parameters which logically belong together; e.g., Date start, Date end, String newValue, String oldValue
  • reduce number of parameters
  • provide useful defaults in the parameter object
  • pass the parameter down the call chain

To execute the Introduce Parameter Object refactoring, select a method, invoke Refactor > Introduce Parameter Object, select the parameters that should be used as fields, and give meaningful names.

Screenshot showing the the Introduce Parameter Object refactoring dialog

The following code snippet

Method before refactoring

will be modified to

Method after refactoring

Sort Members on multiple elements

The Sort Members action can now sort multiple elements at once. Select a package, a project, or a set of Java elements in the Package Explorer and invoke Source > Sort Members.

Screenshot showing the sort member action

Clean Up profiles

A preference page has replaced the Source > Clean Up wizard. Clean Up profiles can be defined on this preference page. A profile can be attached to the workspace or to individual projects. Project settings can be shared in a team through a version control system. It is also possible to export and import each profile.

Clean Up preference page

New clean ups

The following Clean Ups have been implemented:

  • Format source code: The formatting settings can be configured on the Formatter preference page.
  • Remove trailing whitespace: You can choose to remove trailing whitespace on all lines or to ignore empty lines.
  • Organize imports: Imports are organized according to the settings for the project or workspace.
  • Sort members: You can sort either all members of a compilation unit, or ignore fields, enum constants, and initializers (because sorting such members may result in semantic changes).

Code clean up on save

It is now possible to automatically invoke code clean up whenever the Java editor is saved. This feature can be enabled globally on the Java > Editor > Save Actions preference page. The save actions can also be configured per project, which makes it easy to enforce a project-wide standard by sharing the settings across a team:

Save Action property page

Content assist for favorite static imports

The Content Assistant (Ctrl+Space) can now propose completions for static members from a list of favorite imports that can be configured on the Java > Editor > Content Assist > Favorites preference page.

For example, if you have added java.util.Arrays.* to this list, then all static methods of this type matching the completion prefix will be added to the proposals list:

Content Assist proposals

The import preferences from the Java > Editor > Content Assist preference page are honored when inserting such a proposal.

Content assist for variable with unresolved type

The Java editor now supports the new member proposals with unresolved types: depending on the Java > Editor > Content Assist > Add import instead of qualified name preference the editor will either automatically add imports or fully qualify the types for such proposals.

Pressing ; in the following scenario:

Screenshot showing Content Assist for variables with unresolved types

results in:

Screenshot showing the content assist result when pressing ';'

Content assist provides declaration proposals for undefined local variables

Code assist can now infer the name of a declared local variable by detecting the presence of unresolved names in subsequent code, as shown in the example below:

Unresolved Names Proposals example

Content assist improvements continued

  • Content Assist (Ctrl+Space) inside a try-catch clause can now infer exception type names based on exceptions detected to be thrown in the corresponding try block. These exceptions are now listed before other possible exceptions.
  • When completing a name reference, Content Assist now proposes unresolved names found in other parts of the code.
  • Code completions in the empty statement now include the local types of the current compilation unit in the list of proposals.
  • Code completion after an at sign "@" proposes all visible annotation types.
  • Completing in an annotation member proposes all possible attributes which are not already specified.

Quick assists

Functionality that was previously only available in the Refactoring menu is now also offered as quick assists (Ctrl+1). As always, quick assists don't show a dialog, but enter the linked mode where you can change names or types that have been introduced.

  • Extract to local variable and Extract to constant: select an expression in the code
  • Inline local variable: available on a variable name
  • Convert local variable to field: available on a variable name
    Screenshot of the Extract Local Quick Assist
  • Convert anonymous to local type: available on the type name of an anonymous class
    Convert anonymous to nested class example - before
    When applied, use the Tab key to navigate through the generated code and to modify the new type name and choose from the offered field and parameter names.
    Convert anonymous to nested class example - after

Quick fix to create method from @Override

When you add an @Override annotation to a method that does not override yet, quick fix (Ctrl+1) will offer you to create the method in one of the super types.

Quick fix to create and use getter and setter

A new quick fix is available for a field not accessible due to visibility restrictions. In the following scenario, use Ctrl+1 to invoke quick fix:

Invisible field

If a getter exists for this field, you can choose to use it.

Use getter

And if there is no getter for this field, you can choose to create one.

Create getter

Template for adding JUnit 4 test methods

A new Test template has been added to speed up adding JUnit 4 test methods.

Syntax coloring for brackets

Brackets may now be colored separately from operators in the Java editor via the Java > Editor > Syntax Coloring preference page:

Screenshot of the Java editor showing bracket highlighting

No more "I don't see the full source" questions on the newsgroup

The command group that contains the Show Source of Selected Element Only tool bar button Picture of the tool bar button is now hidden by default. The setting can be toggled using the Java > Editor > Only show the selected Java element preference.

Configurable Javadoc font

The font for displaying Javadoc is now configurable on the General > Appearance > Colors and Fonts preference page. The Javadoc display font is used by the Javadoc view and hover, and for the additional information shown during content assist.

Screenshot of the Javadoc view displaying a non-standard font

Background color for source hovers

The background color for all hovers that show source in the Java editor can now be configured on the Java > Editor preference page.

Screenshot showing a source hover with custom background Color

Class file editor shows disassembled code

The Java class file editor now shows the disassembled bytecodes when source code is not available.

Screenshot showing the Class File Editor with disassembled code

Improved handling of duplicate local variables and types

JDT now does a better job of handling invalid code with duplicate local variables and types; in particular it will minimize secondary errors. This allows the Java tools to perform in offending code, so as to offer quick fixes.

  • Local rename (Ctrl+2,R) can now operate even in faulty nested loops, allowing you to quickly fix the name of the duplicate variable in all the places it appears.

    Local rename with duplicate locate variables

  • Method invocation or field access through a duplicate variable now refers to nearest definition of the local variable, thus reducing the number of secondary errors reported.

    Method invocation with duplicate locate variables

Improved null check detection

The existing Null reference option on the Java > Compiler > Errors/Warnings preference page has been split into three options:

  • Null reference (in 'Potential programming problems')
    When this option is enabled, the compiler will issue an error or warning whenever a variable that is statically known to hold a null value is used to access a field or method, as shown in the example below:

    Null reference example

  • Potential null reference (in 'Potential programming problems')
    When this option is enabled, the compiler will issue an error or a warning whenever a variable is statically known to potentially hold a null value, as shown in the example below:

    Potential null reference example

  • Redundant null check (in 'Unnecessary code')
    When enabled, the compiler will issue an error or a warning whenever a variable that is statically known to hold a null or a non-null value is tested against null, as shown in the examples below:

    Redundant null check example (instanceof always false)

    Redundant null check example

Warning for raw types activated by default

The optional compiler diagnostic for detecting any usage of a raw type is now activated by default.

This diagnosis can be configured on the Java > Compiler > Errors/Warnings preference page, using the Generic types > Usage of a raw type preference.

Raw Type Warning example

Unused parameter warning enhancement

The Unused Parameter warning was improved with a new option that helps avoiding false positives. You can give the compiler a hint that a parameter is not really unused by commenting it with a @param tag.

The option is located on the Java > Compiler > Errors/Warnings preference page in the Unnecessary code section.

Screenshot of the Error/Warning preference page

Colored labels in Java views

To enable colored labels in Java views, open the Java > Appearance preference page and select Use colors in labels.

Screenshot showing the Package explorer with colored labels

Decorations for transient and volatile fields

Transient and volatile fields now have corresponding icon decorations:

Screenshot showing a transient and a volatile field

Grouping of JARs and class folders in Package Explorer

The Package Explorer now groups referenced libraries in a new container node.

Screenshot of the package explorer with grouped libraries

More Java search options

The Java search dialog has been extended to offer finer control to limit the scope to search in sources, required projects, JRE libraries, and application libraries.

Screenshot showing the search dialog with the new 'Search In' options

Search filter for references to overridden method

The Java search engine has introduced a new criterion for categorizing method reference matches. It can now distinguish an invocation via a type or one of its subtypes from an invocation via a supertype, which is usually a weaker match. The Search view now includes a filter for further narrowing references to the searched method.

In the following example, the user searched for references to the A.toString() method and got 3 matches. Since o.toString() denotes an invocation of a method that is overridden by the search target A.toString(), it can be filtered out from the Search view by activating the "References to Overridden" filter as shown below:

Filter References to Overridden example

Note: The "References to Overridden" filter is not activated by default.

Select execution environment when creating Java project

When you create a Java project that you want to share with a team, it is a good idea to use an execution environment instead of a specific JRE.

Execution environments are symbolic representations of JREs with standardized entries like 'J2SE-1.4', 'J2SE-1.5'. That means no file system path will go into the shared build path.

JREs can be assigned to the environments on the Java > Installed JREs > Execution Environments preference page.

Screenshot of the 'New Java Project' wizard

Add new Java project to a working set

The New Java Project wizard got additional input fields to specify the working sets to which the new project gets added. The fields are initialized from the current selection or the active working set filter in the Package Explorer.

Screenshot showing the New Java Project wizard

Assign working sets

It's easier now to reorganize Java elements or resources in working sets. To assign an element to a different working set, select the element in the Package Explorer and choose Assign Working Sets... from the context menu.

Screenshot showing the working set assignment dialog

Paste type declaration creates new project

Ever wanted to quickly try out a code snippet somebody sent to you? Copy the snippet to the clipboard, go to the Package Explorer, make sure nothing is selected, and choose Edit > Paste (Ctrl+V).

Eclipse will try to parse the text in the clipboard, and if it looks like contents for a *.java file, it will create a new Java project and create the *.java file.

after paste (*.java file created and opened)

Like in 3.2, you can, of course, still select an existing project or package as target for the new file.

Enhanced paste in Package Explorer

Pasting Java source text with multiple package declarations to the Package Explorer now automatically creates all the necessary packages and compilation units. The structure on the right is created when you paste the snippet on the left into the Package Explorer while nothing is selected:

package a;
public class Target {

package b;
import a.Target;
public class Test {
  void reference() {
    new Target();
Package Explorer showing created project and package structure

Undo deletions in Java Views

Edit > Undo is now also available for deletions of Java elements in Java views. Accidentally deleted packages, compilation units, etc. can easily be restored by pressing Ctrl+Z.

Java drag-and-drop for Project Explorer

Java elements dragged and dropped in the Project Explorer now trigger Java refactoring events (like in the Package Explorer).

Java DND in action

Export and import JUnit test runs

JUnit test runs can now be exported and imported.

JUnit view menu with Import and Export actions

Currently, Eclipse can read its own test run storage XML files, as well as XML files produced by the Ant JUnit task.

Open Type opens multiple types

The Open Type dialog (Ctrl+Shift+T) now supports opening multiple editors at once.

Open Type dialog with multi-selection

Package and enclosing type pattern search

Patterns with '*' or '?' characters may be specified for packages and enclosing types in the Open Type dialog.

Open Type dialog example: java.*.ChangeHandler

Follow references (Java SE 6 only)

You can display all references to an object (only available when debugging on a Java SE 6 virtual machine). Object references can be displayed in the variables view by toggling the Show References setting in the view menu. References to each object are grouped in a collection.

Show References toggle in view menu

References can also be displayed in a popup dialog by selecting an object in the variables view and choosing All References from the context menu.

All References action in context menu

References are displayed in a popup dialog.

Popup dialog displaying references

Display instances (Java SE 6 only)

You can display all instances of a Java type (only available when debugging on a Java SE 6 virtual machine). Instances are displayed in a popup dialog by selecting a type in the editor outline, a type name in the Java editor, or a variable in the Variables view and choosing All Instances from the context menu.

All Instances action in context menu

Instances are then displayed in a popup dialog.

Popup dialog displaying instances

Force return (Java SE 6 only)

You can force an early return from a method (only available when debugging on a Java SE 6 virtual machine). This returns a value from the current stack frame without executing any more instructions in the method and releases any locks obtained by synchronized blocks. A return value is created by selecting an expression and Force Return (Alt+Shift+F). This action is available from the Java editor's context menu, top level Run menu, in the Display view, and in the detail pane of the Variables view.

Forcing an early return from a non-void method requires an expression to be evaluated. For example, if a method was going to return false you could return a value of true by selecting an expression in the Display view and invoking Force Return. In the following example, elementCount is not equal to zero, and would return false (see debug hover showing the value of elementCount).

Method that would return false since elementCount != 0

Use the Force Return action from the Display view to return true instead.

Select expression and Force Return from context menu

Hyperlink stepping

When debugging you can use hyperlinks to step into a method. Use Ctrl+Alt+Click to step into a method (rather than Ctrl+Click which will navigate to the source code).

Step into using hyperlink (Ctrl+Alt)

Double-click and Ctrl+Shift+B for all kinds of breakpoints

Double-clicking in the vertical ruler, or invoking Toggle Breakpoint (Ctrl+Shift+B), now creates an appropriate kind of breakpoint based on the cursor location - line breakpoint, watchpoint, method breakpoint, or class load breakpoint. To create a class load breakpoint, double click on the class declaration line.

Class load breakpoint

Step through filters vs. step return

You can configure step filters to always return from a filtered location or step through to a non-filtered location. For example, if java.util is a filtered location, stepping into code in HashMap could result in a call-back to your application code to check the equality of an object. If you choose to Step through filters a step into would end up in your application code. However, when the Step through filters option is disabled, a step into HashMap would behave like a step over.

Use the Step though filters preferences setting on the Java > Debug > Step Filtering preference page to toggle the feature.

Auto format stack traces

Stack traces can be formatted automatically as you paste them into the Java stack trace console. An Auto Format toggle is available on the console tool bar.

Auto Format button in stack trace console toolbar

Export logical structures

You can now export and import Java logical structure preferences separate from other workspace preferences. Java logical structures are defined on the Java > Debug > Logical Structures preference page. Logical structures are used to define alternate presentations for complex data structures and are displayed when examining objects in the Variables view. For example, displaying a java.util.Collection as an array rather than revealing the internal data structure that implements the collection.

Exporting logical structures

New code formatter options

New options have been added to the Java > Code Style > Formatter preference page:

  • Comment formatting can now be enabled and disabled for each comment type individually (Javadoc, block, single line, and header comments). Block and line comments on the first column can be excluded from indentation.

    Screenshot showing the formatter preferences modify dialog

  • The number of blank lines that Organize Imports (Ctrl+Shift+O) inserts between import groups can be configured on the Blank Lines tab. When formatting, this setting will take precedence over the number of blank lines to preserve.

    Screenshot of the formatter preference page showing 'Blank lines between import groups'

  • Binary expressions can now be wrapped before or after the operator.

    Screenshot showing the formatter preferences modify dialog

  • For return statements, you can now add or remove whitespace before the parenthesized expression of the throw statement. This option is available on White Space tab.

    Screenshot of the formatter preference page showing 'Space before expression throws'

Access rules for execution environments

Access rules are now assigned to each execution environment based on its profile. For example, rules prevent access to com.sun.* packages that are not guaranteed to be present at runtime. The rules are only applied to projects that are bound to execution environments. Projects bound to a specific JRE still have access to all of their libraries.

Access rules for system libraries

Deprecated and non-modifiable classpath variables

System-defined classpath variables can now be deprecated and/or declared read-only via the org.eclipse.jdt.core.classpathVariableInitializer extension point.

Users should replace deprecated classpath variables by better mechanisms such as Libraries.

Java build path dialog with deprecated variables

For some variables (e.g. JUNIT_HOME), the Problems view even offers quick fixes to migrate existing projects.

Workspace relative paths for Javadoc location

Workspace relative paths are now accepted as Javadoc locations for archives and class folders:

Screenshot of the Javadoc location configuration dialog

Runtime type generation

Java 5 annotation processing (APT) was introduced in Eclipse 3.2, but until now, new types could only be generated by doing a build. Java 5 Annotation processors can now generate new types on the fly, as you edit the annotations. This feature is disabled by default, for performance reasons; to enable it, a processor should include "enableTypeGenerationInEditor" in the set of strings returned from AnnotationProcessorFactory.supportedOptions().

Java 6 annotation processing

Eclipse 3.3 fully supports Java 6 annotation processing in the Eclipse Java batch compiler. Java 6 annotation processing is also minimally supported in the IDE, with more support to come in the future.

Platform API

Custom splash screens

API is now in place to provide custom splash screens using SWT. You can use the new org.eclipse.osgi.service.runnable.StartupMonitor API to update the splash screen as the platform is being started.

Custom splash screens

IDE application moved to new plug-in

The portion of the org.eclipse.ui.ide plug-in that defines the application has been moved into a new plug-in: org.eclipse.ui.ide.application. This allows people writing their own RCP application to use existing views or APIs defined by org.eclipse.ui.ide without having a dependency on the application.

Advanced tooltips

JFace now supports tooltips that supply a Composite for more complex tooltips. See org.eclipse.jface.window.Tooltip.

Tool tip


Widget-independent tree and table viewers

A new abstract class AbstractTableViewer has been introduced, making it possible to create subclasses that work on table widgets other than SWT's Table. More methods on AbstractTreeViewer have been made accessible to subclasses for the same reason.

Per-column label providers, improved editing support

AbstractTableViewer and AbstractTreeViewer now inherit from a new base class ColumnViewer. A new abstraction for columns in viewers has been introduced, making it possible to use a separate label provider for each column. After creating a viewer, create appropriate viewer column objects (TableViewerColumn or TreeViewerColumn) and call setLabelProvider on the column object rather than the viewer itself. The new column abstraction also makes it easier to set up an editable table or tree - see ViewerColumn.setEditingSupport(), and to add keyboard navigation to editable tables or trees - see TableViewerEditor.create() and TreeViewerEditor.create(). Code examples can be found on the JFace snippets page.

Custom tooltips for tree and table cells

TreeViewer and TableViewer now support custom tooltips on a per cell basis. See org.eclipse.jface.viewers.CellLabelProvider.

Tool tip on cell of table

Data binding

Data binding supports automatic synchronization between UI state and model state and drastically reduces the amount of listener code required to implement common UIs. The data binding API was made public in 3.3, and the existing single plug-in was split into three to separate the core framework (org.eclipse.core.databinding) from code that implements binding to SWT and JFace (org.eclipse.jface.databinding) and code that binds to JavaBeans-style models (org.eclipse.core.databinding.beans). See the data binding wiki page for more information.

Status handling

The new org.eclipse.ui.statushandlers package introduces a mechanism for reporting and handling problems in the UI. Plug-ins can report their problems through StatusManager, along with a hint about how the problem should be handled. Eclipse applications and products can configure how problems reported via this API are displayed to the end user.

OSGi R4.1

The Equinox Framework implements all the new features defined in the OSGi R4.1 specification. The most noteworthy change is the standardization of the lazy activation policy.

New Application Model

The Eclipse application model now implements the Application Admin Service from the OSGi specification. The net result is a more flexible application container. For example, applications can now be specified to allow more than one to run at a time. The lifecycle of an application has also been improved to allow applications to be properly shut down if the framework is shut down unexpectedly.

Eclipse applications can now implement to take full advantage of the new application model. See the org.eclipse.core.runtime.applications extension point for more details on the options that can be specified for application extensions.

Equinox launcher

The native Eclipse launcher has been rewritten to use JNI calls as much as possible. The Java VM will be started in-process using the JNI Invocation API unless the -vm argument points directly to a Java launcher.

Among other advantages, this change allows for SWT widgets to be used in the splash screen. As well, the splash screen can appear much earlier if the product is set up properly.

Equinox HTTP service

The Jetty-based implementation of the OSGi HTTP service has been added to the Platform SDK along with the bundles that provide JSP and extension registry support. Help is now using this service instead of Apache Tomcat.

Support for Launching Equinox in Application Servers

The Equinox servlet bridge allows the launching of OSGi based web applications in existing applications servers.This support provides full integration with other Equinox services and existing bundles and is tested for compatibility with major server implementations.

Orbit project created

The Eclipse Orbit project was created to be a home for third party libraries being consumed and bundled by Eclipse projects. Application developers can find many useful Apache and other libraries in Orbit, ready to use. Note that Orbit can only host libraries that have been IP reviewed and approved by the Eclipse Foundation.

Platform proxy settings

The platform now has a common place for configuring HTTP/Socks proxies. The new plug-in has API for accessing, storing, and monitoring changes to proxy settings.

JSch SSH2 Client Support

The platform provides API which allows SSH2 related preference settings to be forwarded to the JSch SSH2 library (com.jcraft.jsch) when making SSH2 connections. The new org.eclipse.jsch.core plug-in provides this API

Contribute columns to vertical ruler

A new extension point, org.eclipse.ui.workbench.texteditor.rulerColumns allows the contribution of columns to the vertical ruler of any text editor.

Screenshot showing a ruler to display photos along the Java editor

Extensible hyperlink detection

Clients can use the org.eclipse.ui.workbench.texteditor.hyperlinkDetectors extension point to add their own hyperlink detectors and can enable their viewers using the corresponding methods in the source viewer configuration along with the org.eclipse.ui.workbench.texteditor.hyperlinkDetectorTargets extension point.

Screenshot showing the hyperlinking preference page

Mixed mode launch APIs and more

The debug platform's launch API now supports mixed mode launching. For example, an ISV could contribute a launcher to profile and debug an application at the same time. See enhancements to the launchDelegates and launchConfgurationTypes extension points.

ISVs can also contribute one or more tabs to existing tab groups in the launch dialog to extend existing launch types with new function. For example, a profiling tool could provide a tab to configure profile options for Java applications. See the new extension point launchConfigurationTabs.

The platform also allows more than one toolset to exist for launching the same kind of application. For example, two profilers could exist for Java applications and the user would be prompted to choose which profiler to use.

Debug context API

The debug platform has new API to access the active debug context. A debug context represents the active state of a program being debugged and drives the enabled state of debug actions (step, terminate, etc.), as well as source lookup, visible variables, and watch expression values. A set of classes and interfaces have been added to the new package org.eclipse.debug.ui.contexts allowing clients to listen to and drive the active debug context.

Debug command API

Debug commands represent common operations implemented by debuggers - for example, step over, suspend, resume, and terminate. The debug platform has added API allowing debuggers to provide custom implementations of the operations by implementing the debug command interfaces. See the new package org.eclipse.debug.ui.commands.

Pluggable detail panes

API has been added to the debug platform allowing custom detail panes to be contributed to the Variables view. Clients may use any SWT control to render custom details for their variables. A context menu allows users to choose between available detail panes for each variable. See the new extension point org.eclipse.debug.ui.detailPaneFactories.

Remote help content

Packaging a comprehensive set of help documentation with a product can often significantly increase its download size. To alleviate this, Help now allows you to host your documentation remotely on an infocenter, and will display the remote contents alongside any locally installed content you may have, giving you significant savings on initial download size.

Remote help preference page

Plug in help in any format

Teams are no longer restricted to the specific XML formats defined by the Help system, such as table of contents XML, keyword index XML, etc. A new set of API has been added to enable Java code to generate the content at runtime. This allows teams who work with other formats, such as DITA, to write an adapter plug-in that will perform the conversion, thus avoiding a build-time conversion and allowing them to ship documentation in the format of their choice.

Improved dynamic user assistance content

Dynamic content is now fully supported for all user assistance XML documents, which means you can filter, include, extend or replace sections of documents for any of the user assistance document types. These include:
  • Welcome pages (XML or XHTML) and contributions
  • Help XHTML topics, table of contents, keyword index, and context-sensitive help
  • Cheat sheets, both simple and composite

You can also define your own filter criteria and use boolean operators to achieve greater flexibility with filtering by using XML expressions in any of the documents listed above.

Added control of help/welcome content ordering

The help table of contents and welcome items will now be arranged in a more meaningful order when multiple products and documentation sets are installed. All available products' preferences will be taken into consideration, and products may now use an external XML file similar to welcome's to specify their preferred order and visibility of entries in the table of contents.

Link to anything from context-sensitive help

You can now add arbitrary command links in context-sensitive help, allowing applications to perform any operation. For example, you can link to a related cheat sheet:

Linking to a cheat sheet

Compare supports File Buffers

Compare now has support for file buffers which means that a Compare editor can share the underlying file buffer with other types of editors (e.g. Java editor) such that changes made in one editor will be immediately reflected in the other. More information on this can be found in the Implementing a Content Viewer, Implementing a structure viewer and Advanced compare techniques sections

Apply Patch API

Compare now has support for opening the Apply Patch wizard programmatically and also provides a low level API for manipulating patches. More information on this can be found in the Advanced compare techniques section

Menu Contribution API

Commands can now be contributed directly to menus and toolbars. The menu contribution API allows you to place commands in the main menu or toolbar, in the view dropdown menu or view toolbar, in editor or view context menus, and in the workbench window trim areas (like the status line). See the Basic workbench extension points using commands and org.eclipse.ui.menus sections. We will also be building more complex examples on the Menu Contribution wiki page.

Printing support added on GTK+

Printing support has been added to SWT for GTK+. You must be running with GTK+ 2.10 or newer in order to print.

New DateTime control

Your users can now enter dates or times using the new DateTime control. You can see the DateTime control in action on the DateTime tab of the SWT control example.

DateTime control with SWT.DATE | SWT.SHORT style on Windows

DateTime control with SWT.TIME style

DateTime control with SWT.CALENDAR style on Windows

Option to print line numbers added to StyledText

When printing a StyledText widget, line numbers can now be printed by setting the StyledTextPrintOptions.printLineNumbers field to true.

Text SEARCH style

On platforms that have this concept, Text controls can now have the look and feel of a search field with the SWT.SEARCH style. Adding the SWT.CANCEL style gives the user a way to cancel the search. This example snippet created the Text control shown in the snapshot below.

A search Text on the Mac

System tray support added on Mac OS X

Icons placed on the system tray will now appear in the Mac OS X status bar.

System tray on Mac OS X

Writing PNGs now supported

Images can now be written to disk in PNG format (example snippet).

Browser profiles on GTK+ and linux-motif

The Browser widget now uses profiles on GTK+ and linux-motif. This fixes many previous shortcomings, including the inability to display https pages, not rendering visited links properly, and not caching visited pages.

Browser support added on PowerPC

Browser support has been added for the PowerPC architecture (GTK+).

Native GTK Combo box

You now get a native combo box when running with GTK+ version 2.4 or newer.


Faster JPEG/PNG image loading

JPEG images now load from 30 to 70 percent faster, and PNG images load 2 to 3 times faster, depending on the image.

Color cursors on Mac OS X and GTK

You can now create color cursors on Mac OS X and GTK.

A Color Cursor on the Mac

This example snippet created the cursor pictured above.

New graphics line drawing capabilities

SWT graphics now supports much finer control of line attributes, including fractional line widths, dashed line offsets, and miter limits. These capabilities are provided by the new LineAttributes class and the new GC methods get/setLineAttributes.


(This example snippet created the above snapshot.)

SWT libraries automatically found

The SWT libraries are now loaded from the SWT jar when an SWT application is launched. Within Eclipse, you can just use the Run As > Java Application menu item and the libraries will be found. When launching from the command line, you no longer need to specify the SWT library path.

Mozilla everywhere

Mozilla can now be used as the underlying browser control on Windows and OS X, providing that you have XULRunner installed and registered. To use this just create your Browser with the SWT.MOZILLA style. This example snippet created the snapshot below.

Mozilla on Windows

DragDetect API

Custom widget implementers can now use Control.setDragDetect() to disable the default drag detection and Control.dragDetect() to implement their own. For example, a custom list control could start dragging only when an item is selected. Typed events for drag detection are now available (see DragDetectListener and DragDetectEvent). This example snippet created the snapshot shown below.

Drag detect in a custom control

Drag over and drag under effects

Custom drag over and drag under effects can now be implemented for any control. Custom widget implementers can provide feedback that is appropriate for their control by subclassing DragSourceEffect and DropTargetEffect. The default effects for the Table, Tree and StyledText controls have been changed to use these classes (see TreeDragSourceEffect, TreeDropTargetEffect and the corresponding classes for these controls). This StyledText example snippet created the snapshot shown below.

StyledText dragging selected text to show 'insert cursor' drag under effect

JavaXPCOM support

SWT.MOZILLA-style Browsers can now be programmed to via JavaXPCOM. This requires that XULRunner or newer be installed. This example snippet created the snapshot below.

Browser JavaXPCOM

OLEExample and OLE improvements

The new OLEExample showcases SWT OLE (win32) support. We now do a better job of hosting OLE documents in SWT. For example, OleClientSite in-place activation scrollbars work correctly.


Reparenting support on Mac OSX

SWT on Mac OSX now supports widget reparenting.

Advanced graphics supports mirroring

Advanced graphics now renders correctly in RTL mode. The snapshot below shows bidirectional text drawn using transforms and patterns on a Canvas.

Advanced graphics in RTL mode

SWT graphics showcase

Try out the new SWT Graphics example, which showcases some of SWT's graphics capabilities. This example is included with the other example plug-ins.


Plug-in Development Environment

Self-hosting with multiple versions of the same plug-in

PDE now supports self-hosting scenarios that will allow you to develop and run with multiple versions of the same plug-in in the workspace or target platform.

Development scenarios where this new support is particularly useful include:

  • Workflows that require different plug-ins to compile against different versions of the same plug-in
  • Building an update site where you are constantly managing multiple versions of the same plug-in in the workspace

PDE editors facelift

All PDE form-based editors have acquired a new look and feel. Visual enhancements include the following:
  • Gradient form headers
  • Form title icons
  • New section title bar design and colors
  • Section header tool items using standard size icons
  • Form header help icons

In addition, all PDE form editor pages comply with the latest UI recommendations for margins and spacing.

PDE Editor Facelift

Field assist in Forms

All fields denoting classes in the plug-in manifest editor now support a field assist feature to help you complete the name of a partially entered class name.

This feature works in a similar way to the content assist in the Java editor, and supports package names and CamelCase.

Field Assist

Field validation in plug-in and product editors

PDE now validates plug-in and product editor form fields while input is being entered.

During validation, form fields are decorated according to problem severity and provide status messages via tool tips.

All status messages are qualified with a field label and rolled up into the form title header where they are available on mouse over.

Field Validation

As with source page validation, the problem severity used by field validation is configurable on the Plug-in Development > Compilers preference page.

Content assist in plugin.xml

Content assist (Ctrl+Space) is now available on the plugin.xml source page to give you context-sensitive information as you create extensions and extension points.

Features include:

  • completion proposals for extensions, extension points, attributes, and elements
  • auto-generation of required elements and attributes

Note that the content assist can be activated without the need for a partial string. PDE uses extension point schemas to determine which elements and attributes are suitable for the current context.

XML Content Assist

Content assist in MANIFEST.MF

Content assist (Ctrl+Space) is now available on the MANIFEST.MF source page, including completion proposals for:
  • header names, attributes, and directives
  • header values such as plug-in IDs, package names, and Java class names
  • boolean and enumerated values for attributes and directives

MANIFEST.MF content assist

Quick outline in plug-in editor source pages

When editing a source in the plug-in manifest editor, pressing Ctrl+O or selecting Navigate > Quick Outline from the top level menu shows you a quick outline.

The quick outline has many of the sizing and filtering options that are available in the Java editor's quick outline.


Hyperlinking and open declarations

Hyperlinking (i.e. the use of Ctrl+Left to navigate from one editor to another) is now supported on the plug-in manifest editor source page. The usage of the F3 key to open declarations is also supported and provides the same functionality as hyperlinking.

Hovering over attribute values on the plugin.xml page and pressing Ctrl+Left can be used to

  • open resources and Java type declarations
  • open extension point schema descriptions
  • navigate from a translated key reference to that key in the properties file

plugin.xml hyperlink

Hyperlinking provides additional functionality on the MANIFEST.MF source page including:

  • opening manifest editors for referenced plug-ins
  • opening referenced packages

MANIFEST.MF hyperlink

Hover support in plug-in manifest editors

The source pages in the plug-in manifest editors now provide a number of useful hovers. Hovering over an attribute in the plugin.xml shows the schema description for that attribute, while hovering over a manifest header shows the Javadoc for that header.

Source Hover

The hover support has also improved on the Extensions page of the plug-in manifest editor. Hovering over a translated attribute now shows the actual substituted value for that attribute.

Forms Hover

Code folding

Folding is now supported on the plugin.xml and MANIFEST.MF source pages of the plug-in manifest editor to make large files more manageable.

The option to turn folding on and off can be found on the Plug-in Development > Editors preference page.

Code Folding

Code formatting

Line wrapping introduced by some packaging tools make the plug-in MANIFEST.MF file hard to read.

PDE now provides a Format action in the context menu of the MANIFEST.MF source page to format the contents of the file into something more human-readable.

MANIFEST.MF formatting

Stronger plugin.xml validation

PDE now flags warnings when the number of elements in an extension's XML markup is at odds with the arity specified in the extension point schema.

The severity for this type of problem is set to Warning by default, and can be customized via the Plug-in Development > Compilers > Plug-ins > Illegal elements preference.

Element Occurrence Validation

Flag for non-exported packages in the MANIFEST.MF file

PDE now provides a flag on the MANIFEST.MF file when the list of exported packages of the plug-in is incomplete. This feature is a useful reminder when you wish to expose all your plug-in code to downstream clients.

By default, the severity of this flag is set to IGNORE, but it can be raised to WARNING or ERROR at a global level via the Plug-in Development > Compilers > Plug-ins > Non-exported Packages preference. It can also be set on a per-project basis on the Plug-in Development > Compilers property page of a plug-in project.

Non-Exported Packages

PDE problem categories

Problems in plug-in manifest files can now be categorized, allowing you to easily spot fatal issues such as unsatisfied constraints which may prevent your plug-in from compiling and running properly.

You can turn this feature on via Group by > PDE Problem Type from the drop down menu of the Problems view.

PDE Problem Category

State of the plug-ins

The Plug-in Dependencies view, available under Window > Show View > Other > PDE > Plug-in Dependencies, has been enhanced to show you the state of every plug-in you have in your development environment.

For each plug-in, you get to see all its dependencies and the plug-ins supplying each of its imported packages.

The view now also serves as a valuable diagnostic tool that shows you the unsatisfied constraints that may prevent your plug-in from running and which may cause a chain reaction affecting other plug-ins.

New filtering capabilities include:

  • focusing on unresolved plug-ins only
  • showing leaf plug-ins only therefore helping you prune unnecessary plug-ins when assembling a product

State of the State

Plug-in refactoring

PDE now supports plug-in refactoring by providing the ability to rename a plug-in ID and update all references to it in downstream plug-ins.

The Rename function is available in the context menu of the Plug-ins view, the Plug-in Dependencies view and the MANIFEST.MF source page.

Rename in Plug-ins view

Plug-in refactoring may also take place as part of the regular project renaming action in the Package Explorer view (Refactor > Rename from the context menu) if the project name matches the plug-in ID.

Plug-in manifest files participate in refactorings

When you rename or move files and folders in your plug-in project, PDE will now update references to these resources in the plugin.xml and files.

Resource Refactoring

Cheat sheet authoring

Cheat sheets guide users through a series of steps to achieve an overall task. PDE now provides a cheat sheet editor to let you compose cheat sheets, complete with embedded workbench commands and links to the Help documentation.

The editor also provides a Preview function that allows you to preview your work on the fly directly in the Cheat Sheets view.

You can create a cheat sheet via File > New > Other... > User Assistance > Cheat Sheets.

Cheatsheet Editor

Command composer

Cheat sheets support the embedding of workbench commands allowing you to execute commands such as opening a particular perspective or a wizard in a script-like fashion.

The Command Composer dialog shows you a categorized list of available commands and their parameters, making it easy to compose, test, serialize, and embed commands into your cheat sheet.

The Command Composer can be invoked from the Command section of the cheat sheet editor.

Command Composer

Bundling JREs in your RCP product

The Product editor now gives you the option to bundle a JRE with your exported Eclipse product. JREs can be specified on a per-platform basis.

The JRE will be bundled in a jre/ subdirectory inside the product, and it will be the default JRE used when the product runs.

This feature is useful if you want your product with a specific JRE or if the end user of your product does not have a JRE installed on their system.


Custom splash screen templates

PDE now provides three templates for creating custom splash screens, complete with code, images and XML markup:
  1. Interactive: A simulated log-in session
  2. Browser: An embedded HTML browser
  3. Extensible: A dynamic set of image contributions

This feature is available in the Templates section on the Splash page of the product configuration editor.

Splash screen templates are also available in the New Extension wizard when generating a new org.eclipse.ui.splashHandlers extension on the Extensions page in the plug-in manifest editor.

Splash templates

Target platform provisioning

PDE now allows the dynamic addition of plug-in locations to the target platform by simply pressing Add on the Plug-in Development > Target Platform preference page.

PDE provides two provisioners:

  1. a file system provisioner to augment the content of the target platform with plug-ins located in the file system.
  2. an update site provisioner that downloads and installs plug-ins into your target platform with a single click by simply pointing at an update site.

Target Provisioning

Additional types of provisioners can be declared via the org.eclipse.pde.ui.targetProvisioners extension point.

Extensible launch shortcuts

PDE now provides the org.eclipse.pde.ui.launchShortcuts extension point to enable custom launch shortcuts and additional launch modes (e.g. profile) to be integrated into the Testing section of the plug-in manifest editor.

Launch Shortcuts

Launching OSGi frameworks

PDE now provides the org.eclipse.pde.ui.osgiFrameworks extension point to enable the integration of additional OSGi frameworks into the PDE bundle tooling.

If more than one OSGi framework is installed, the default can be set on the Plug-in Development > OSGi Frameworks preference page.

OSGi Frameworks Preference Page

Testing against different OSGi frameworks is as easy as selecting that framework in the OSGi Framework launch configuration.

OSGi Framework Launcher

Note that PDE only provides the Equinox OSGi framework extension.

Hello, World - 3.3 edition

In Eclipse 3.3, the Platform introduced a new way to contribute menu and toolbar items to the workbench. See this new support in action by selecting the Hello, World Command template in the New Plug-in Project wizard, available under File > New > Project... > Plug-in Development > Plug-in Project.

Hello World 3.3

OSGi Services Templates

The New Plug-in Project wizard, available under File > New > Project... > Plug-in Development > Plug-in Project, provides new templates demonstrating the usage and implementation of programmatic OSGi services.

OSGi Services Templates

The templates are available when the option to target an OSGi framework is selected on the first page of the wizard.

OSGi Option

Analyze dependencies for JAR archives

When creating a plug-in from existing JAR archives (File > New > Project... > Plug-in Development > Plug-in from existing JAR archives), PDE now computes the dependencies required to run the code in the archive.

Plug-ins targeted to run with an OSGi framework will have their dependencies specified with Import-Package statements, while plug-ins targeted to run with Eclipse will have theirs specified with Require-Bundle statements.

Analyze dependencies

Uses directive calculation

PDE is now able to calculate the OSGi uses directive for exported packages.

The uses directive is important because it models inter-package dependencies to ensure that consistent class spaces are calculated for each bundle. This helps prevent ClassCastExceptions when multiple versions of a package or bundle are installed in the Framework.

The calculation can be initiated from the Organize Manifests wizard (PDE Tools > Organize Manifests... from the context menu of plug-in projects) or the Calculate Uses button in the Exported Packages section on the Runtime page of the plug-in manifest editor.

Uses Directive

Multi-version support for build contributions

Support has been added to allow for multiple versions of the same bundle to appear in a client's map file contribution to the build and therefore retrieved to be part of the same build. Clients wishing to take advantage of this functionality should specify a version in the map file as well as in the referencing feature.

GET fetch support

A new GET fetch factory was added to PDE Build which allows clients to specify URLs in their map files contributions to a build. The factory generates a call to the Ant Get task, and clients are able to specify whether or not the fetched file should be unzipped, which is especially useful for clients who are retrieving build input from an HTTP server.

platform.xml handling

In order to handle linked directories and extension locations while building, PDE Build now constructs its state by consulting the platform.xml file contained in the base location, if available.