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 eclipse.org downloads page.
- New features in the Platform1. Eclipse on Vista
2. New Eclipse WPF port
3. Quick access
4. Undo support for resource operations
5. Undo support for task and bookmark operations
6. A new look
7. Improved workspace switching
8. Improved resource selection dialog
9. All plug-ins are now signed
10. Working set usability improvements
11. Hiding the window toolbar
12. Working sets for the Project Explorer
13. Patch wizard improvements
14. Compare editor improvements
15. Compare Structure in Outline view
16. Long resource paths on Windows
17. Open files with other editors
18. Forms enhancements
19. Platform level proxy and SSH2 settings
20. Keys preference page improvements
21. Editor area drag and drop
22. Properties view make over
23. Console launcher for Windows
24. Improved detection of Mozilla plug-ins
25. Easier help navigation
26. Help search term highlighting
27. Categorized help search
28. Print multiple help topics
29. Cheat sheet improvements
30. Spell checking in text editors
31. Show invisible whitespace characters
32. Text drag and drop in text editors
33. Scroll by pages using Ctrl + mouse wheel
34. Select by word or line using the mouse
35. Smart Home/End
36. More team annotation options
37. Recenter command
38. Joining lines in text editors
39. Convert tabs to spaces
40. More flexible templates
41. Import CVS projects directly into working sets
42. Export working sets as part of team project set
43. History view search
44. History view now has view history
45. Spell check in Commit dialog
46. Flat presentation in model-based synchronizations
47. Launch selection vs. launch last
48. Run/Debug settings
49. Automatically showing console
- New features for Java developers50. Refactoring without save
51. Rename refactoring in editor
52. Introduce Parameter Object refactoring
53. Sort Members on multiple elements
54. Clean Up profiles
55. New clean ups
56. Code clean up on save
57. Content assist for favorite static imports
58. Content assist for variable with unresolved type
59. Content assist provides declaration proposals for undefined local variables
60. Content assist improvements continued
61. Quick assists
62. Quick fix to create method from @Override
63. Quick fix to create and use getter and setter
64. Template for adding JUnit 4 test methods
65. Syntax coloring for brackets
66. No more "I don't see the full source" questions on the newsgroup
67. Configurable Javadoc font
68. Background color for source hovers
69. Class file editor shows disassembled code
70. Improved handling of duplicate local variables and types
71. Improved null check detection
72. Warning for raw types activated by default
73. Unused parameter warning enhancement
74. Colored labels in Java views
75. Decorations for transient and volatile fields
76. Grouping of JARs and class folders in Package Explorer
77. More Java search options
78. Search filter for references to overridden method
79. Select execution environment when creating Java project
80. Add new Java project to a working set
81. Assign working sets
82. Paste type declaration creates new project
83. Enhanced paste in Package Explorer
84. Undo deletions in Java Views
85. Java drag-and-drop for Project Explorer
86. Export and import JUnit test runs
87. Open Type opens multiple types
88. Package and enclosing type pattern search
89. Double-click and Ctrl+Shift+B for all kinds of breakpoints
90. New code formatter options
91. Deprecated and non-modifiable classpath variables
92. Workspace relative paths for Javadoc location
93. Runtime type generation
94. Java 6 annotation processing
- New APIs in the platform and SWT95. Custom splash screens
96. IDE application moved to new plug-in
97. Advanced tooltips
98. Widget-independent tree and table viewers
99. Per-column label providers, improved editing support
100. Custom tooltips for tree and table cells
101. Data binding
102. Status handling
103. OSGi R4.1
104. New Application Model
105. Equinox launcher
106. Equinox HTTP service
107. Support for Launching Equinox in Application Servers
108. Orbit project created
109. Platform proxy settings
110. JSch SSH2 Client Support
111. Contribute columns to vertical ruler
112. Extensible hyperlink detection
113. Mixed mode launch APIs and more
114. Debug context API
115. Debug command API
116. Pluggable detail panes
117. Remote help content
118. Plug in help in any format
119. Improved dynamic user assistance content
120. Added control of help/welcome content ordering
121. Link to anything from context-sensitive help
122. Compare supports File Buffers
123. Apply Patch API
124. Menu Contribution API
125. Printing support added on GTK+
126. New DateTime control
127. Option to print line numbers added to StyledText
128. Text SEARCH style
129. System tray support added on Mac OS X
130. Writing PNGs now supported
131. Browser profiles on GTK+ and linux-motif
132. Browser support added on PowerPC
133. Native GTK Combo box
134. Faster JPEG/PNG image loading
135. Color cursors on Mac OS X and GTK
136. New graphics line drawing capabilities
137. SWT libraries automatically found
138. Mozilla everywhere
139. DragDetect API
140. Drag over and drag under effects
141. JavaXPCOM support
142. OLEExample and OLE improvements
143. Reparenting support on Mac OSX
144. Advanced graphics supports mirroring
145. SWT graphics showcase
- New features for plug-in developers146. Self-hosting with multiple versions of the same plug-in
147. PDE editors facelift
148. Field assist in Forms
149. Field validation in plug-in and product editors
150. Content assist in plugin.xml
151. Content assist in MANIFEST.MF
152. Quick outline in plug-in editor source pages
153. Hyperlinking and open declarations
154. Hover support in plug-in manifest editors
155. Code folding
156. Code formatting
157. Stronger plugin.xml validation
158. Flag for non-exported packages in the MANIFEST.MF file
159. PDE problem categories
160. State of the plug-ins
161. Plug-in refactoring
162. Plug-in manifest files participate in refactorings
163. Command composer
164. Bundling JREs in your RCP product
165. Custom splash screen templates
166. Target platform provisioning
167. Extensible launch shortcuts
168. Hello, World - 3.3 edition
169. Analyze dependencies for JAR archives
170. Uses directive calculation
171. Multi-version support for build contributions
172. GET fetch support
173. platform.xml handling
|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 is now available on Windows Presentation
Foundation (WPF), a new window system that comes pre-installed on Microsoft Windows Vista.
|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.
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.
Using the initials of the words you are trying to find, you can narrow down your choices using very few letters.
|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.
|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.
|Eclipse has a new default presentation. Some of the key features
of this presentation are:
You can reinstate the old presentation via the General > Appearance preference page.
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.
|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.
|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.org. 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|
|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.
|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
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.
|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!
|The compare editor has a number of significant improvements:
|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.
|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.
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.
|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.
|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.
|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"
the User column.
You can now:
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.
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.
|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.|
|Users of Mozilla-based browsers can now augment
the default set of Mozilla plug-in paths that are searched by defining
|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.
|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.
|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.
|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.
|You can open a cheat sheet from the Web by specifying its URL in the open cheat sheet dialog.
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 is now available in text editors and an American and a British English dictionary are part of the SDK:
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.
|It is now possible to see the invisible whitespace characters in textual editors:
This feature can either be controlled via General > Editors > Text Editors > Show whitespace characters preference, or via the  tool bar button when the Editor Presentation action set is enabled.
|You can now drag and drop text to and from text editors:
You can control this via General > Editors > Text Editors > Enable drag and drop of text preference.
|The mouse wheel scrolls the content of a textual editor by pages while the Ctrl key is pressed.|
|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.|
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.
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.
Below we see the author names, with background colored by date. These options are configurable via the ruler context menu (Ctrl+F10):
|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.|
|You can now use the new command Ctrl+Alt+J in a text editor to join lines.|
|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.
|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:
|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.
|The export wizard can now persist active working sets as part of a Team Project set.
|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.
|The History view now allows you to navigate
back to previously viewed elements.
|The Commit dialog now uses the Eclipse spell
checker to highlight spelling errors in commit messages.
|A flat presentation has been added to model-based
synchronizations. For CVS, model-based synchronizations are the default.
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.
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.
When the same file is launched again, the most recent configuration
in the launch history associated with that file is re-launched.
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.
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).
Java development tools
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.
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.
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 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.
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.
The following code snippet
will be modified to
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.
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.
The following Clean Ups have been implemented:
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:
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
The import preferences from the Java > Editor > Content Assist preference page are honored when inserting such a proposal.
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:
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:
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.
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.
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:
If a getter exists for this field, you can choose to use it.
And if there is no getter for this field, you can choose to create one.
A new Test template has been added to speed up adding JUnit 4 test methods.
Brackets may now be colored separately from operators in the Java editor via the Java > Editor > Syntax Coloring preference page:
The command group that contains the Show Source of Selected Element Only tool bar button is now hidden by default. The setting can be toggled using the Java > Editor > Only show the selected Java element preference.
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.
The background color for all hovers that show source in the Java editor can now be configured on the Java > Editor preference page.
The Java class file editor now shows the disassembled bytecodes when source code is not available.
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.
The existing Null reference option on the Java > Compiler > Errors/Warnings preference page has been split into three options:
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.
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.
To enable colored labels in Java views, open the Java > Appearance preference page and select Use colors in labels.
Transient and volatile fields now have corresponding icon decorations:
The Package Explorer now groups referenced libraries in a new container node.
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.
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
Note: The "References to Overridden" filter is not activated by default.
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.
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.
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.
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.
Like in 3.2, you can, of course, still select an existing project or package as target for the new file.
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:
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 elements dragged and dropped in the Project Explorer now trigger Java refactoring events (like in the Package Explorer).
JUnit test runs can now be exported and imported.
Currently, Eclipse can read its own test run storage XML files, as well as XML files produced by the Ant JUnit task.
The Open Type dialog (Ctrl+Shift+T) now supports opening multiple editors at once.
Patterns with '*' or '?' characters may be specified for packages and enclosing types in the Open Type dialog.
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.
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.
References are displayed in a popup dialog.
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.
Instances are then displayed in a popup dialog.
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,
Use the Force Return action from the Display view to return true instead.
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).
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.
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
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.
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
New options have been added to the Java > Code Style > Formatter preference page:
Access rules for execution environments
Access rules are now assigned to each execution environment
based on its profile. For example, rules prevent access to
System-defined classpath variables can now
be deprecated and/or declared read-only via the
Users should replace deprecated classpath variables by better mechanisms such as Libraries.
For some variables (e.g. JUNIT_HOME), the Problems view even offers quick fixes to migrate existing projects.
Workspace relative paths are now accepted as Javadoc locations for archives and class folders:
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
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.
|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.
|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.|
JFace now supports tooltips that supply a
Composite for more complex tooltips. See
A new abstract class
TreeViewer and TableViewer now support custom
tooltips on a per cell basis. See
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.
|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.|
|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.|
|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 org.eclipse.equinox.app.IApplication 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.
|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.
|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.|
|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.|
|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.|
|The platform now has a common place for configuring HTTP/Socks proxies. The new org.eclipse.core.net plug-in has API for accessing, storing, and monitoring changes to proxy settings.|
|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|
|A new extension point, org.eclipse.ui.workbench.texteditor.rulerColumns
allows the contribution of columns to the vertical ruler of any text editor.
Clients can use the
|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
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
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.
|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
|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
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
|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.
|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.|
|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:
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.
|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.|
|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:
|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|
|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|
|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 has been added to SWT for GTK+. You must be running with GTK+ 2.10 or newer in order to print.|
|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.
|When printing a StyledText widget, line numbers
can now be printed by setting the
|On platforms that have this concept,
|Icons placed on the system tray will now appear in the Mac OS X status bar.
|Images can now be written to disk in PNG format (example snippet).|
|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 has been added for the PowerPC architecture (GTK+).|
|You now get a native combo box when running with GTK+ version 2.4 or newer.
|JPEG images now load from 30 to 70 percent faster, and PNG images load 2 to 3 times faster, depending on the image.|
|You can now create color cursors on Mac OS X and GTK.
This example snippet created the cursor pictured above.
|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
(This example snippet created the above snapshot.)
|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 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
|Custom widget implementers can now use
|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
|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.
|SWT on Mac OSX now supports widget reparenting.|
|Advanced graphics now renders correctly in RTL
mode. The snapshot below shows bidirectional text drawn using transforms
and patterns on a Canvas.
|Try out the new SWT Graphics example, which showcases
some of SWT's graphics capabilities. This example is included with the other
Plug-in Development Environment
|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
Development scenarios where this new support is particularly useful include:
|All PDE form-based editors have acquired a new
look and feel. Visual enhancements include the following:
In addition, all PDE form editor pages comply with the latest UI recommendations for margins and spacing.
|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.
|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.
As with source page validation, the problem severity used by field validation is configurable on the Plug-in Development > Compilers preference page.
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.
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.
|Content assist (Ctrl+Space)
is now available on the MANIFEST.MF source page, including completion proposals
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 (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
Hovering over attribute values on the plugin.xml page and pressing Ctrl+Left can be used to
Hyperlinking provides additional functionality on the MANIFEST.MF source page including:
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.
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.
|Folding is now supported on the plugin.xml and
MANIFEST.MF source pages of the plug-in manifest editor to make large files
The option to turn folding on and off can be found on the Plug-in Development > Editors preference page.
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.
|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.
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.
|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.
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:
| PDE now supports plug-in refactoring by providing
the ability to rename a plug-in ID and update all references to it in downstream
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.
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.
|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 build.properties files.
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.
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.
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.
| PDE now provides three templates for creating
custom splash screens, complete with code, images and XML markup:
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
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:
Additional types of provisioners can be declared via the
|PDE now provides the
Launching OSGi frameworks
PDE now provides the
If more than one OSGi framework is installed, the default can be set on the Plug-in Development > OSGi Frameworks preference page.
Testing against different OSGi frameworks is as easy as selecting that framework in the OSGi Framework launch configuration.
Note that PDE only provides the Equinox OSGi framework extension.
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.
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.
The templates are available when the option to target an OSGi framework is selected on the first page of the wizard.
|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.
|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.
|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.|
|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.|
|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.|