Eclipse Project Release Notes

DRAFT Pre-release 2.1.0
Last revised March 6, 2003

This software is OSI Certified Open Source Software.
OSI Certified is a certification mark of the Open Source Initiative. 

1. Target Operating Environments
2. Compatibility with Previous Releases
3. Known Issues
4. Defects Fixed
5. Interoperability with Previous Releases

1. Target Operating Environments

Most of the Eclipse SDK is "pure" Java™ code and has no direct dependence on the underlying operating system. The chief dependence is therefore on the Java 2 Platform itself. Like the 2.0 release, the 2.1 release of the Eclipse Project is written and compiled against version 1.3 of the Java 2 Platform APIs, and targeted to run on either version 1.3 or 1.4 of the Java 2 Runtime Environment, Standard Edition.

Eclipse SDK 2.1 has been tested and validated on the following Java 2 Platform implementations:

Operating system Processor architecture Java 2 Platforms
Microsoft®
Windows®
Intel x86 Sun Java 2 SDK, Standard Edition, version 1.3.1_06 for Microsoft Windows
Sun Java 2 SDK, Standard Edition, version 1.4.1_01 for Microsoft Windows
IBM Developer Kit for Windows, Java 2 Technology Edition, version 1.3.1 SR-2
IBM 32-bit SDK for Windows, Java 2 Technology Edition, version 1.4.0
Linux Intel x86 Sun Java 2 SDK, Standard Edition, version 1.3.1_06 for Linux x86
Sun Java 2 SDK, Standard Edition, version 1.4.1_01 for Linux x86
IBM Developer Kit for Linux, Java 2 Technology Edition, version 1.3.1 SR-2
Sun Solaris SPARC Sun Java 2 SDK, Standard Edition, version 1.3.1_06 for Solaris SPARC
Sun Java 2 SDK, Standard Edition, version 1.4.1_01 for Solaris SPARC
HP HP-UX hp9000 PA-RISC HP-UX SDK for the Java 2 platform, version 1.3.1 for hp9000 PA-RISC
IBM® AIX PowerPC IBM Developer Kit for AIX, Java 2 Technology Edition, version 1.3.1
Apple® Mac® OS PowerPC Java 2 Standard Edition 1.3.1 for Mac OS X 10.2
Java 2 Standard Edition 1.4.1 for Mac OS X 10.2 (pre-release)
QNX® Neutrino® RTOS Intel x86 IBM J9 VM for QNX, version 2.0

The following table describes the combinations of operating system and Java 2 Platform used when testing the Eclipse SDK configurations. The status column indicates the level of testing: "Primary" means a full tested configuration; "Secondary" means a configuration which is only lightly tested; "Untested" means a configuration that has received no testing, but which should work. Note that the Mac OS X configuration is considered early access for the 2.1 release; it has been tested, but is not product quality in this release.

Window system Java 2 Platform
(see above table)
Operating Environment Testing Status
Win32 Windows on Intel x86 Windows XP Primary
Windows 2000 Primary
Windows ME Secondary
Windows 98SE Secondary
Windows NT Secondary
Motif  

Linux on Intel x86

 

RedHat Linux 8.0 x86 Primary
SuSE Linux 8.1 x86 Primary
Other Linux; kernel version 2.4.7, and XFree86 version 4.1.0 Untested
Solaris on SPARC  Sun Solaris 8 SPARC Primary
HP-UX on hp9000 PA-RISC HP-UX 11i hp9000 Primary
AIX on PowerPC IBM AIX 5.1 on PowerPC Primary
GTK Linux on Intel x86
RedHat Linux 8.0 x86 (GTK 2.2 required for DBCS) Primary
SuSE Linux 8.1 x86 (GTK 2.2 required for DBCS) Primary
Other Linux; GTK 2.0.6 (GTK 2.2 required for DBCS) Untested
Carbon Mac OS X on PowerPC Mac OS X 10.2 Early access
Photon® IBM J9 VM for QNX QNX Neutrino RTOS 6.2.1  Primary

Internationalization

The Eclipse Platform is designed as the basis for internationalized products. The user interface elements provided by the Eclipse SDK components, including dialogs and error messages, are externalized. The English strings are provided as the default resource bundles.

Latin-1 locales are supported by the Eclipse SDK on all of the above operating environments; DBCS locales are supported by the Eclipse SDK on the Windows, GTK, and Motif window systems; BIDI locales are supported by the Eclipse SDK only on Windows operating environments.

The Eclipse SDK supports GB 18030, the new Chinese code page standard, on Windows 2000 and XP, and Linux. Note, however, that GB 18030 also requires locale and character encoding support from the Java 2 Runtime Environment; this support is standard in version 1.4, and also available in some 1.3 JREs.

German and Japanese locales have been tested.

BIDI support

The Eclipse SDK is a development environment targeted at technical professionals - not an end user application. However, the Eclipse SDK tools will permit technical professionals who are working in English to build Hebrew/Arabic end user Java programs which are themselves not based on the Eclipse SDK. The BIDI support in the Eclipse SDK allows a Java programmer to work with BIDI strings, code comments, etc. but the Eclipse SDK itself is not designed to be localized for BIDI locales and its widget orientation cannot be changed.

IMPORTANT: The above BIDI support is available only for Windows operating environments.

2. Compatibility with Previous Releases

Compatibility of Release 2.1 with 2.0

Eclipse SDK 2.1 is intended to be upwards compatible with Eclipse SDK 2.0. We have made exceptions only in areas where slavishly maintaining compatibility would not be in the best interests of Eclipse or its clients. The exceptions are noted in the next section.

API Contract Compatibility: Eclipse SDK 2.1 is upwards contract-compatible with Eclipse SDK 2.0 except as noted in the next section. This means that programs in full compliance with contracts specified in Eclipse SDK 2.0 APIs is automatically in full compliance with Eclipse SDK 2.1 APIs. (API is construed broadly to include such things as plug-in extension points.) Downward contract compatibility is not supported. There is no guarantee that compliance with Eclipse SDK 2.1 APIs ensures compliance with Eclipse SDK 2.0 APIs. Refer to Evolving Java-based APIs for a discussion of the kinds of API changes that maintain contract compatibility.

Binary (plug-in) Compatibility: Eclipse SDK 2.1 is upwards binary-compatible with Eclipse SDK 2.0 except as noted in the next section. This means that plug-ins built for Eclipse SDK 2.0 will continue to work correctly in Eclipse SDK 2.1 without change. Downward plug-in compatibility is not supported. Plug-ins for Eclipse SDK 2.1 are unlikely to be usable in Eclipse SDK 2.0. Plug-ins with hard-coded references in their plug-in manifest file to 2.0 versions of prerequisite Eclipse Project plug-ins will work in 2.1 provided the version match rule is "greaterOrEqual" or "compatible" (the default); references using "perfect" or "equivalent" match rules will be broken. Refer to Evolving Java-based APIs for a discussion of the kinds of API changes that maintain binary compatibility.

Source Compatibility: Eclipse SDK 2.1 is upwards source-compatible with Eclipse SDK 2.0 except as noted in the next section. This means that source files written to use Eclipse SDK 2.0 APIs can be successfully compiled and run against Eclipse SDK 2.1 APIs. Since source incompatibilities are easy to deal with, maintaining source compatibility is considered much less important than maintaining contract and binary compatibility. Downward source compatibility is not supported. If source files use new Eclipse SDK APIs, they will not be usable with an earlier version of Eclipse SDK.

Workspace Compatibility: Eclipse SDK 2.1 is upwards workspace-compatible with Eclipse SDK 2.0 except as noted in the next section. This means that workspaces and projects created with Eclipse SDK 2.0 can be successfully opened by Eclipse SDK 2.1 and upgraded to a 2.1 workspace.  This includes both hidden metadata, which is localized to a particular workspace, as well as metadata files found within a workspace project (e.g., the .project file), which may propagate between workspaces via file copying or team repositories. Individual plug-ins developed for Eclipse SDK 2.1 should provide similar upwards compatibility for their hidden and visible workspace metadata created by earlier versions; 2.1 plug-in developers are responsible for ensuring that their plug-ins recognize both 2.1 and 2.0 metadata and process it appropriately. User interface session state may be discarded when a workspace is upgraded. Downward workspace compatibility is not supported. A workspace created (or opened) by Eclipse SDK 2.1 will be unusable with an earlier version of Eclipse SDK. Visible metadata files created (or overwritten) by Eclipse SDK 2.1 will generally be unusable with earlier versions of Eclipse SDK. 

Non-compliant usage of API's: All non-API methods and classes, and certainly everything in a package with "internal" in its name, are considered implementation details which may vary between operating environment and are subject to change without notice. Client plug-ins that directly depend on anything other than what is specified in the Eclipse SDK API are inherently unsupportable and receive no guarantees about compatibility within a single release much less with an earlier release. Refer to How to Use the Eclipse API for information about how to write compliant plug-ins.

2.1 Incompatibilities between release 2.1 and 2.0

Eclipse 2.1 breaks compatibility with Eclipse 2.0 in the following areas.

Platform - Core

Linked resources

Eclipse 2.1 allows a project in the workspace to bring together contents from several different directories on disk using what are termed linked folders and files. The presence of linked resources changes a fundamental assumption true for earlier versions of Eclipse, namely, that all of a project's files are located under the project's root directory in the local file system. Furthermore, the target of a linked resource is allowed to overlap that of another linked resource, or overlap the root directory of any project. This new potential for overlap means that several distinct files in the workspace might map to the same file in the local file system. In 2.0, there was no way for overlap to happen (project root directories are not allowed to overlap).

These changes have several ramifications at the API:

Since linked resources and their children appear in the workspace as normal files and folders, client code that works exclusively with the workspace resource tree is not affected. The clients most likely to be impacted are ones that assume that all of a project's files are located together in the local file system under the project's root directory. For example, an export utility that works directly on the local file system might miss some of a project's files if it only looks within the project's root directory.

This change was made to give certain kinds of users greater flexibility in laying out their projects on disk. The behavior of existing plug-ins is unchanged from 2.0 for projects that do not use linked resources. Depending on the assumptions made, existing plug-ins might misbehave or fail for projects containing linked resources. A plug-in can prohibit linked resources for a project via a project nature (IProjectNatureDescriptor.isLinkingAllowed()), but this should only be done where there is a good reason to deny the user this additional flexibility in laying out a project. (bug 6664)

Project build order

The default order in which projects get built was changed in Eclipse 2.1 to improve the handling of mutually-dependent projects. The old method IWorkspace.computePrerequisiteOrder was deprecated and replaced by IWorkspace.computeProjectOrder. Since there are few potential clients of either method beyond the Eclipse Platform itself, it's unlikely that clients will be affected. (bugs 10262, 25952)

Platform - UI

Restructuring of UI plug-ins

In Eclipse 2.1, the API and code for the org.eclipse.ui plug-in was partitioned and parceled out to several new plug-ins (org.eclipse.jface, org.eclipse.text, and org.eclipse.ui.workbench, etc.). Although this looks on the surface to be a breaking change, it is not. These new plug-ins are internal and should not be referenced explicitly. As they always have, plug-ins requiring the Eclipse Platform UI (API found in the org.eclipse.swt.*, org.eclipse.jface.*, and org.eclipse.ui.* packages) should continue to state a dependency on the org.eclipse.ui plug-in.

Platform - Help

Pluggable app server

Eclipse 2.0 provided interim support for pluggable app servers via an undocumented org.eclipse.help.app-server extension point, with interim APIs in the org.eclipse.help package. For 2.1, this support has been made internal, along with the former interim API classes. Because this support was marked as interim for 2.0, this is not really a breaking API change. Nevertheless, existing clients using the interim support will be broken. Even though the mechanism is not officially supported, clients that are adamant about plugging in a different app server can do so (with all the usual risks of depending on unsupported Eclipse internals).

Pluggable web browser

Eclipse 2.0 provided interim support for pluggable web browsers via the org.eclipse.help.ui.browser extension point, with API in the org.eclipse.help.ui.browser package. For 2.1, this support appears in finished form in different location: the org.eclipse.help.browser extension point, with API in the org.eclipse.help.browser package. Because this support was marked as interim for 2.0, this is not really a breaking change. Nevertheless, existing clients using the interim support will need to update the extension point and package names.

Platform - Team

Validate edit/save

[Describe additional new restrictions on repository providers re: validate edit/save not bringing up progress monitors on pain of deadlock, etc.] (bug MISSING)

Linked resources

[Describe additional new responsibilities of repository providers re: linked resources (RepositoryProvider.canHandleLinkedResources())] (bug MISSING)

Platform - SWT

Character field in key event

The specification of the Event.character field now makes it clear that the character reflects the outcome after any modifier keys are taken into account (for example, CTRL+A is reduced to the ASCII equivalent character with integer value 1). Since the treatment of modifier keys was completely unspecified before, this change affects clients that make assumptions about how modifiers were handled. (bug 33592)

New key modifier: command

In order to properly support the Mac for Eclipse 2.1, a new SWT.COMMAND key modifier constant was added to represent the Apple command key. On the Mac, the command key plays the same role as the control key plays elsewhere, whereas the control key is used mainly as an additional mouse click modifier. Clients that merely want to check for the appropriate primary modifier for the OS should instead use the new bit mask SWT.MOD1 in favor of either SWT.CONTROL or SWT.COMMAND. The advent of the Mac port of Eclipse affects existing clients that explicitly check for the SWT.CONTROL modifier. In most cases, they should instead check for SWT.MOD1 so that they work appropriately on both Macs and non-Macs. (bug 24393)

OLE variant type exceptions

SWTError exceptions are now thrown when a Java type is requested from an empty variant type (VT_EMPTY). Since existing clients should already be handling SWTError exceptions as per the spec for Variant.getInt(), etc., this change should not affect existing clients. (bug 24402)

Platform - Install/Update

None.

Platform - Ant

None.

Platform - Debug

None.

Platform - Text

[TBD]

Platform - Search

[TBD]

Platform - Compare

[TBD]

JDT - Core

Multiple output folders

In Eclipse 2.0, all generated class files (and copied resource files) for a Java project get written to the project's single output folder. As of 2.1, the generated class files (and copied resource files) can be partitioned across several output folders, with each source build path entry specifying which output folder its generated files get written to. This change was made to give certain kinds of users greater flexibility in laying out their Java projects on disk. Clients used to be able to assume that a Java project's output files were in the project's output folder (IProject.getOutputLocation()); now they need to take into account the possibility of other output locations (IClasspathEntry.getOutputLocation() != null). Existing code appears to work fine until the user exercises the additional flexibility. This change is most likely to affect client code that deploys code directly from the project's output folder (e.g., creates a JAR; launches a Java VM with the output folder on the runtime class path). (bug 24123)

Source folder exclusion patterns

In Eclipse 2.0, all Java source files under a source folder on a project's build class path were compiled and included in the Java model. The notion of exclusion patterns were added in 2.1 to give certain kinds of users greater flexibility in laying out their Java projects on disk  Exclusion patterns associated with a source entry on the build class path (IClasspathEntry.getExclusionPatterns()) cause matching files or subdirectories to be ignored for the purposes of compilation and inclusion in the Java model. Most existing clients traverse the Java model and will continue to work fine. However, clients that directly traverse the corresponding source folder in the local file system need to take into account the possibility that some of the files found there may have been excluded with this new mechanism. (bug 22039)

Code formatter positions

The specification for ICodeFormatter.format was changed to specify that the positions array passed in must be in non-decreasing order. The implementation had always been making this assumption, and there would have been serious performance consequences to specify the method as working with unordered positions. Existing clients are unlikely to be affected. (bug 30417)

Leading comments on AST Statement nodes

Statement.getLeadingComment and setLeadingComment have been deprecated because they were not a particularly good way to deal with the general issue of comments and significant whitespace. Since the implementations of AST.parseCompilationUnit never set the leading comment for any AST nodes they create, the change is moot for most clients. (bug 29176)

Empty array passed to Java model operation

In Eclipse 2.0, certain Java model API operations (IJavaModel.delete, copy, move, and rename) threw an ArrayIndexOutOfBoundsException if passed an empty array. The behavior in this case was completely unspecified. For 2.1, the specification and implementation of these operations have been changed to throw JavaModelException in such cases. Clients need to be aware that the empty array case does indeed trigger an exception. (bug 32219)

Non-Java projects included in Java model 

In Eclipse 2.0, non-Java projects and closed projects were excluded from the Java model. In 2.1, non-Java projects and closed projects are available from the Java model via IJavaModel.getNonJavaResources. Their inclusion in the Java model means that they appear in Java model deltas, under IJavaElementDelta.getResourceDeltas. This change may affect clients that listen for Java element deltas (via JavaCore.addElementChangedListener) if they make overly strong assumptions about triggering conditions and contents. (bug 29274)

Java element changed events for full working copy lifecycle

In Eclipse 2.0, Java element changed events were reported for changes to shared working copies, but not when they were created or destroyed. In 2.1, Java element changed events are uniformly issued for the full lifecycle of working copies and apply equally to non-shared as well as shared working copies. This change may affect clients that listen for Java element deltas (via JavaCore.addElementChangedListener) if they make overly strong assumptions about triggering conditions and contents. (bug 32981)

IJavaProject.isOnClasspath

For Eclipse 2.1, the API predicate IJavaProject.isOnClasspath (both forms) was changed to do the more standard thing of returning false rather than throwing JavaModelException in some cases. While this change is within the original spirit of the original API  contract, it breaks source compatibility because JavaModelException is a checked exception; code that invokes this method and catches JavaModelException may need to be rewritten. (bug 33754)

JDT - UI

None.

PDE

None.

2.2 Incompatibilities between release 2.0 and 1.0

(This section from the 2.0 release notes is included for the benefit of customers migrating to 2.1 from 1.0.)

The Eclipse SDK 2.0 is upwards compatible with the Eclipse SDK 1.0 to the greatest extent possible. We made exceptions in areas where slavishly maintaining compatibility would not be in the best interests of the Platform or its clients. The exceptions noted in the 2.0 release notes are repeated here for the benefit of customers migrating from 1.0 to 2.1 directly.

Platform - UI

The public client API has been kept stable with the exception of ITextViewer interface which changed in an incompatible way:

Platform - Debug

The debug API has been completely reworked for 2.0. The new APIs are not compatible with the 1.0 APIs, which were all considered "interim".

The high level API differences between the new and old debug platforms are:

As well, the Java debug model API has been enhanced and changed to reflect changes in the debug platform.

Platform - Core

Eclipse 1.0 Core Target Management was provisional. For 2.0, Core Target Management has been withdrawn and replaced by team target management providers. These new target management facilities are early access, and are contained in the Eclipse FTP and WebDAV Support feature (separately installable).

Platform - Help

Help APIs and extension points were marked as interim in Eclipse 1.0. Based on the initial feedback, the Help APIs and extension points have changed significantly in Eclipse 2.0 and are not compatible with those in Eclipse 1.0.

Platform - Scripting

Eclipse 1.0 Scripting support was provisional and incomplete. For 2.0, the Scripting component has been withdrawn completely from the Eclipse Platform.

Platform - Install/Update

The Install/Update component API has been completely reworked for 2.0. The 1.0 notion of component has been replaced in 2.0 by the notion of a feature. The new APIs are not compatible with the 1.0 APIs, which were all considered "interim".

Platform - Team

Workspace compatibility from VCM CVS 1.0 to Team CVS 2.0: the meta information for CVS providers has considerably changed from 1.0 to 2.0, and the meta information is not being preserved. To ease migration, some automation of migrating CVS repository locations is provided, and some helpful steps have been included. These are described in the Team CVS FAQ.

PDE

Extension point schema file extension changed

Extension point schema file extension has been changed from *.xsd to *.exsd to avoid conflicts with XML schema editors and/or non-PDE schema files. PDE will still detect files with the old extension and will issue a warning about the change.

Support for components removed

Eclipse 2.0 Install/Update has discontinued the use of components in favor of features. Consequently, PDE 2.0 supports feature-related development while component support has been removed. Features are described in the Eclipse Platform Plug-in Developer Guide.

3. Known Issues

3.1 Platform
     3.1.1 Core
     3.1.2 Ant
     3.1.3 Help
     3.1.4 UI
     3.1.5 SWT
     3.1.6 Team
     3.1.7 Install/Update
3.2 Java Development Tools (JDT)

3.3 Plug-in Development Environment (PDE)

3.4 Other
     3.4.1 FTP and WebDAV support

Note: Bug numbers refer to the Eclipse project bug database at http://dev.eclipse.org/bugs/

As a reminder of past problems, items carried over from the most recent release notes (2.0.1) are shown in green. Many of these can be expected to go away, although some will remain.

3.1 Platform

Eclipse process does not exit (HP-UX only)

On HP-UX, the HP JVM process that runs the Eclipse Workbench does not terminate upon closing the workbench. The remedy is to always pass the -XdoCloseWithReadPending to the VM via the Eclipse launcher command line; that is, launch Eclipse with the command line:

eclipse -vmargs -XdoCloseWithReadPending

(bug 18321)

3.1.1 Platform - Core

Declaring package name prefixes improves plug-in class loading speed

A significant (10-15%) speed increase in the time to load a plug-in's classes can be obtained simply by declaring the package name prefixes found in that plug-in's runtime library JARs. This is done in the new Package Prefixes section of the Runtime page in the PDE plug-in manifest editor. (Further information here.)

Invalid characters in install directory prevents Eclipse from starting

Eclipse will fail to launch if installed in a directory whose path contains certain invalid characters, including :%#<>"!. The workaround is to install Eclipse in a directory whose path does contain invalid characters. (bugs 3109, 17281)

Problems with classloaders in created threads

There is a known issue with trying to load classes from a newly created thread using a class loader different from the plug-in class loader. The result will be a ClassNotFoundException. As a workaround, do the following:

  1. Create a thread in which to run your code.
  2. Send yourThread.setContextClassLoader(yourClassLoader); // you can find your classloader by grabbing a class it loaded (YourPluginClass.class.getClassLoader())
  3. Run your code in the newly created thread.

If you set the context class loader for the current thread, you are competing with other users of the thread (all of Eclipse), so the results will be unpredictable. However, there should be no problem in practice provided you reset the context class loader back to its original value when your use in the current thread is 
complete. (bug 8907)

Deadlock creating executable extension in Plugin.startup

If Plugin.startup code is too complex and performs tasks such as creating an executable extension, a deadlock situation can be created. Only simple bookkeeping tasks should be performed in Plugin.startup code. (bugs 12827, 5875, 16141)

3.1.2 Platform - Ant

Xerces JARs no longer required on runtime Ant classpath

Explicitly adding the Xerces JARs to the runtime Ant classpath is no longer required and can cause problems. The Xerces classes are loaded from the org.apache.xerces plug-in provided with Eclipse. (bugs 33664, 33117)

[TBD]

3.1.3 Platform - Help

Help documents not displayed in a browser or very slow document loading (Windows only)

If your LAN settings are not properly configured for local host access, your Help browser might open to a blank page or display an HTTP error instead of a help page, or you may experience long delays when loading help documents. Your system administrator can configure your LAN settings so that help documents can be accessed from the local help server.
  1. In the Control Panel, open Internet Options, select the Connections tab and choose LAN Settings.
  2. If your host was configured to use DHCP for IP assignment, make sure that the "Automatically detect settings" check box is cleared.
  3. If you use proxy server, ensure that the "Bypass proxy server for local addresses" is selected.
  4. In "Advanced" settings for proxies, add "127.0.0.1;localhost" to the "Exceptions" if these addresses are not listed.
  5. If you are using an automatic configuration script for proxy settings, and are not sure that the script is correct, clear the "Use automatic configuration script" check box.

If the above steps do not fix your problem, try changing the port and host properties in org.eclipse.tomcat\preferences.ini. In general, setting host=localhost or host=127.0.0.1 should work. Also, especially when running a firewall, you may want to set port=80 or some other firewall-friendly value. (bugs 7036, 9418, 11394)

Working disconnected from the network (Windows only)

If you are experiencing problems when not connected to the network you must install the loopback adapter from the Windows installation CD. (bug 831)

Using Internet Explorer in offline mode (Windows only)

If you have been using Internet Explorer in Offline mode, when you access the help system, you will get a message indicating that the web page you requested is not available offline. Click Connect to return the system behavior to normal.

Opening and navigating Help produces clicking sound (Windows only)

Internet Explorer has a sound event associated with navigate events. To turn this sound off, go to Control Panel -> Sounds ->Windows Explorer and change the sound for "Start Navigation" to "none" in the menu box. (bug 16081)

Keyboard navigation in help using Mozilla

Accessibility support is limited in pre-1.0 releases of the Mozilla browser. If you need to navigate help using the keyboard, you must upgrade to Mozilla version 1.0. (bug 15018)

Searching help produces unexpected results and highlights incomplete words

For some languages, a stemming algorithm is used to enhance the chance of a search hit. For these languages, the word roots are searched for; exact searches are not supported.  As such, the result set contains documents with variations of the search query words, and only the common roots are highlighted in the document. Stemming and stop word removal also applies to search query terms enclosed in quotation marks ("), so the search results will not be an exact match of the quoted string. (bug 17030)

3.1.4 Platform - UI

Manual refresh required when files modified outside Eclipse

When files within a project are added or removed outside of Eclipse, or when an external editor is used to modify a file within a project, a manual refresh must be done in order for the changes to show up in the Workbench. To do this, select the project in the Navigator view and choose Refresh from the pop-up menu. This refreshes only the selected project. Alternatively, activate the Navigator view and press F5, which refreshes all projects.

Dirty state not tracked properly for OLE documents (Windows only)

The dirty state for an OLE document is not updated properly. This causes it to prompt to save the contents when the document is closed, even if the contents have already been saved.

OLE document crashes can cause Eclipse to also crash (Windows only)

If an OLE document crashes, this can cause Eclipse to either crash, or to have workbench menus become inconsistent.

Minimum display resolution

A number of dialogs in Eclipse, such as the Preferences dialog, require a minimum display resolution of at least 800 x 600. (bug 5549)

External Tools will automatically quote path variables containing spaces

When an external tool is launched, expanded path variables that contain spaces will be enclosed in double quotes ( " ). While it is typical for Windows executables to expect paths containing spaces to be quoted, this is known to cause problems on platforms such as Linux which do not expect these quotes. A workaround is to make the external tool a script which strips off the quotes before launching the executable with those parameters. (bug 20599)

Default text file encoding may be detected incorrectly (Windows XP/2000 only)

The "Text file encoding" value displayed in the Preferences dialog under "Editors" may be wrong on platforms running Windows XP (or 2000) when the user locale and system locale differ. 

Example of the manifestation of the bug: A Japanese user using Japanese Windows 2000 works in New York, United States. The user has selected English (United States) as the user locale. The "Text file encoding" value displayed by Eclipse is incorrect: "Cp1252" (English). It should display the system locale "MS932" (Japanese).

Workaround: The user can modify the user locale so that user locale and system locale are identical. In the example above, this means the user should set Japanese as the user locale. Then restart Eclipse. The "Text file encoding" value will then be correct: "MS932" (Japanese).

For Windows XP:

For Windows 2000:

(bug 20641)

Preferred Output Level on External Tools preferences page has no effect

In Window > Preferences > External Tools, there is a group of radio buttons under the heading "Preferred Output Level" with possible options of "Information", "Verbose" and "Debug". Changing these values does not affect Eclipse in any way. Workaround: when running an Ant script, use the Ant command line arguments -verbose or -debug to get an output level other than the default ("Information"). (bug 20817)

Updating the toolbar in multi-page editors

Clients of action bars may create a number of SubToolBarManagers on their IToolBarManager (e.g., multipage editor). The client will typically make one SubToolBarManager visible, the rest invisible, and call updateActionBars. The visibility of the items may not update correctly.

A workaround is for the client to explicitly update the toolbar:

actionBars.updateActionBars();
actionBars.getToolBarManager().update(false);

(bug 20988)

3.1.5 Platform - SWT

Printing and drag and drop not available on Mac (Mac OS X Carbon only)

The Mac OS X Carbon implementation of SWT does not yet support printing or drag and drop. (bug MISSING)

Unable to drag data between applications in simplified Chinese locale (Motif only)

When configured for the simplified Chinese locale, it is not possible to drag data between applications running on the Motif window system. This is a known limitation of the Open Motif library. (bug 29777)

Hang opening font or color dialogs (Mac OS X Carbon only)

There are reports of hangs opening a font or color dialog on early access 1.4.1 Mac OS X Java VMs. These problems do not occur with the officially released J2SE 1.3.1 for Mac OS X 10.2. (bug 30021)

Available colors on 8-bit Linux (Linux only)

Typically, in Gnome Linux installs running with 8-bit visuals (i.e. 256 color mode), before the Eclipse application is started you already do not have any free colors. This may mean that Eclipse is unable to allocate the default widget background color, causing it to display a white background. The functionality, however, is otherwise unaffected.

Printing support (Linux only)

The X printing extension implementation on Linux is currently disabled because it can take up to 7 seconds to determine that the X print server is not running. Until this is rectified, Printer.getPrinterList() will always return an empty array on Linux. (bug 8821)

Disposing in a focus event

Applications should not dispose widgets in focus changing events. Doing so on Motif may cause Eclipse to terminate, since Motif accesses the disposed widget within their internal focus change event handler. A similar (but less serious) issue exists on Windows and occasionally results in an SWT exception being thrown.

List and ComboBox on Windows NT (Windows NT only)

On Windows NT only, you should avoid creating items in a List or ComboBox with strings longer than 1000 characters. Doing so may result in a General Protection Fault. This has been fixed in more recent versions of Windows.

BiDi support

The StyledText widget provides bidirectional language support for Hebrew and Arabic locales. Currently this support is available only on Windows and has several known problems.

Cursor constructor arguments

In the constructor Cursor(Device device, ImageData source, ImageData mask, int hotspotX, int hotspotY), when both a source and mask argument are specified (that is, the mask is not null), the meaning of the two arguments is reversed. That is, the "mask" argument should be the source image and the "source" argument should be the mask image. (bug 4809)

Using IBM J9 VM (Photon and AIX)

On QNX Photon and IBM AIX, the SWT library will not be found when running with an IBM J9 1.5 VM. This is a bug in the IBM J9 class library in version 1.5. You can workaround this problem by adding the SWT library directory to your LD_LIBRARY_PATH environment variable.

Missing permissions for SWT native libraries in workspace (HP-UX only)

When retrieving the SWT Motif fragment into an Eclipse workspace, the permissions of the native libraries are reset. This creates a problem on HP-UX because shared libraries need to have execute permission. Attempting to self-host with this fragment throws an UnsatisfiedLinkError...Permission Denied error. You must manually change the permissions to make these libraries accessible (assume the workspace is at /workspace):

cd /workspace/org.eclipse.swt.motif/os/hpux/PA_RISC
chmod 555 *.sl

(bug 20305 describes a related problem)

Javadoc not consistent across platforms

Because of a bug in the way we updated the javadoc in SWT source code, the javadoc for protected methods is not consistent across platforms. The javadoc for the Windows platform, which is used to generate the documentation that appears in the Platform Plug-in Developer guide, is the definitive source. The javadoc for the other window systems will be brought into line in a future release. (bug 20968)

JAWS requires MSAA for List Views to read checkboxes in Tables (Windows only)

In order for JAWS to detect the checkbox information in Tables, MSAA support for List Views must be activated as follows:

  1. Open Eclipse and hit INSERT + F2.
  2. In the Run JAWS Manager dialog select Configuration Manager.
  3. In the Jaws Configuration Manager that opens up, select Set Options and then select Advanced Options.
  4. Check "Rely on MSAA for List views".
  5. Hit the OK button.
  6. Choose File > Save from the menu bar.

No accelerators or mnemonics on Solaris (Solaris only)

The Solaris implementation of Motif has a long-standing bug with respect to adding and removing accelerators and mnemonics. The behavior is such that the time to do so becomes increasingly longer each time it occurs, to the point that, in Eclipse's case, it can take more than a minute to switch between editors and views! Because of this, accelerators and mnemonics are explicitly ignored on Solaris.

3.1.6 Platform - Team - CVS

Note: Additional information on how to use CVS from Eclipse can be found in the Eclipse CVS FAQ.

"extssh" is not a supported command line method

Since the "extssh" connection method is not a supported command line method, you cannot use the command line tool when a project uses this method. Instead, use the Eclipse supported "ext" method and set the appropriate environment variables so that the command line tool will work. (bug 7943)

Connection cannot be found after initially missing

If a connection initially fails due to a network problem, the connection may continue to fail even when the network problem is fixed. In order to establish the connection you must exit and restart Eclipse. (bug 9295)

CVS meta-folders appear in some cases

There are some cases where CVS folders are not hidden from the UI as the user would expect. For instance, CVS folders will appear if a user imports a CVS project into Eclipse before the CVS plug-in is loaded. To avoid this, open the CVS Repositories view (thus loading the CVS plug-in) before importing CVS projects into Eclipse. (bug 12386)

"Received broken pipe signal" error from server

Eclipse sometime performs multiple commands within a single connection to the server. This may cause problems with CVS servers that are running server scripts in response to certain commands. (bug 15490)

"Terminated with fatal signal 10" error from server

There is a bug in the CVS server related to some compression levels. If you get this error, changing the compression level on the CVS preference page may help. (bug 15724)

Team > Update does not indicate that there are outgoing changes

The Team > Update command will load all remote changes into your local working copy. If you are using Team > Update and you want to see which files have outgoing changes, open the CVS console before performing the update. The console will show the results of the update (which files had mergeable conflicts, which ones had unmergeable conflicts and which ones had outgoing changes). Warning: Only use Team > Update if you know CVS. If there are "real" conflicts (i.e., those that affect the same line of a file) then CVS will add markup to the file during the update. Resolving these conflicts in this manner is not pleasant. (bug 16750)

Synchronize view "Mark as Merged" has surprising behavior with respect to modes

When you Mark as Merged, if its your only incoming change and you are in the incoming mode, the sync view becomes empty. On the surface it looks like the change is gone. However, your change will appear in outgoing mode. (bug 18513)

Team > Commit on an unchanged file does not update decorator

If you perform a Team > Commit on a file that has been modified but whose contents match the contents of the file on the server, the file will remain on outgoing change. To correct the problem, either perform a Team > Update or use the Synchronize view to commit. (bug 18647)

Change ASCII/Binary Properties not available for unadded files

The Change ASCII/Binary Properties menu item is only enabled for files and folders that are under CVS control. If you want to set the keyword substitution mode for a new file, you will need to add it to version control first. (bug 19183)

Error updating incoming directory additions with pruning turned off

If pruning is turned off and a project has incoming nested folder additions that do not contain any files, performing an update in the Synchronize view will result in an error (cannot create folder). The workaround is to perform a Team > Update which will bring in the directories. (bug 19442)

"Remove from View" in Synchronize view does not exclude resources from view actions

If you remove one or more resources from the Synchronize view using the Remove from View menu item, these resources will no longer appear but they will still be included in any performed operations (Update, Commit, etc.) (bug 19538)

Ctrl-S does not save in Synchronize view and CVS compare views

Ctrl-S does not perform a save in the workspace resource editor in the Synchronize view. Instead, use the popup menu and choose Save. (bug 20327)

CVS automatically prunes empty directories

By default, empty directories will be pruned on checkout and update. This is desirable in most cases as directories on a CVS server are never deleted. However, if this causes problems, there is a CVS preference to disable auto-pruning. (bug 20463)

ClassCastException on attempt to replace directory with file

Performing the following steps will result in the above exception:

  1. Create a new project & share it with a CVS repository.
  2. Create a directory in the project root and a file inside this directory.
  3. Synchronize the project using Team > Synchronize with Repository.
  4. Locally delete the directory (and contained file) that was just created
  5. Create a file in the project root with the same name as the directory that was just deleted.
  6. Synchronize again using Team > Synchronize with Repository.

The workaround is to commit the folder deletion before creating the new file. (bug 20906)

Still prompted if delete unmanaged preference turned off

If the "delete unmanaged resources on replace" preference has been disabled on the Team > CVS preference page and a Team > Replace With operation is performed on a project that has one unmanaged resource and no other outgoing changes, the user is prompted to overwrite local changes even though the operation will not overwrite the unmanaged resource. (bug 18834)

Hidden CVS/ folders get copied when copying folders from one project to another

If you copy a folder that is under CVS control to a folder that is not, the CVS/ folders (usually not shown) will be copied as well. This can cause problems if the target project is under CVS control and you try to add the moved folder to CVS control. The workaround is to manually delete the CVS/ subdirectories using the file system browser, or disconnect the source project from CVS control before copying the folders. (bug 20621)

Update with incoming deletion and addition involving file with different case fails (Windows only)

On update, if there are incoming deletions for one or more files and incoming additions for files of the same name with a different case, then the operation may fail on Windows depending on what order the server sends the files in. Workaround is to update the deletions first and then the additions using the Synchronize view. (bug 21001)

Cached authorization information lost when workspace is upgraded

The Platform's internal authorization database file format has changed for 2.1. Because of this, authorization information cached with a workspace created with an earlier version of Eclipse will be unusable, and the user will need to reauthenticate. (bug 32899)

3.1.7 Platform - Install/Update

Migrating 2.0 pre-release workspaces

When migrating an existing workspace that was used with a 2.0 pre-release version of Eclipse (e.g., created with development drops obtained directly from eclipse.org, or updated via the Eclipse update manager prior to 2.0 release), it is strongly recommended that you start with a fresh install of Eclipse 2.0, and delete the .config/ subdirectory of the .metadata/ directory located in the workspace you are migrating (<workspace>/.metadata/.config/) before reopening the workspace. (bug 16456)

Not enough space for temporary files

If you get the error "java.io.IOException: There is not enough space in the file system." but still have plenty of space in the selected install location, check to make sure that you also have sufficient space in the standard location where temporary files are created. (bug 17787)

Workbench non-responsive while attempting to connect

If the connection to an update site does not respond (the site does not exist or is down), the workbench becomes non-responsive until the connection request times out. Once the time out is reported, you will be able to continue. (bugs 18598, 19775)

Processing pending "downgrades"

Natively-installed feature changes are automatically detected on workbench startup. If this change is a downgrade (that is, the newly detected version of a feature is older that one already configured), you will be prompted whether you'd like the change applied; even when you say Yes, the change will not actually be applied, and the currently configured newer feature will remain configured. If the downgrade was intentional, open Help > Software Updates > Update Manager, and from the Install Configuration view, choose Show Disabled Features, explicitly enable the lower version and explicitly disable the newer version. (bug 16502)

Local JAR files are locked

While processing update sites in the local file system (for example, by exploring My Computer), some of the feature JAR files may be left open while the workbench is active, and will not be available to other applications. Exit and restart the Eclipse to correct this condition. (bug 15594)

Wrong status being reported for unconfigured or missing features

If you select Show Status for a feature that is unconfigured or missing, the resulting dialog erroneously claims "The feature is configured properly". (bug 19932)

Accessing update sites through a proxy

To access an update site through a proxy, you will need to start the workbench with the following command line options:

eclipse -vmargs -DproxySet=true -DproxyHost=<proxy_name> -DproxyPort=<proxy_port>

as documented in JavaWorld Tip 42. Proxies requiring user authentication are currently not supported. (bug 19717)

URL validity checking on input

URL syntax is currently not completely checked on input. Ensure that any entered URLs use the correct separators (eg. forward  slash '/') and do not contain invalid characters. (bugs 19685, 20247)

Running "headless" applications that do not handle restart

When install changes are detected, the changes are automatically processed and the workbench restarts. The executable launcher supplied with the application correctly handles the restart. However, if you have applications that directly call the platform (eg. by calling the BootLoader APIs) and do not handle restart, the startup reconciliation processing can be suppressed by specifying -noupdate command line option. In this case, the application will start with the set of features and plug-ins that were processed and configured on the previous start. If prior configuration cannot be found, the application will start with the full set of plug-ins found in the installation location.

3.2 Java Development Tools (JDT)

Running Java programs with non-Latin-1 characters in package or class names

You get a java.lang.NoClassDefFoundError when running Java programs with non-Latin characters in the package or class names. The workaround is to package the class files as a JAR file and run the program out of the JAR and not from the file system directly. (bug 4181)

Missing debug attributes

The debugger requires that class files be compiled with debug attributes if it is to be able to display line numbers and local variables. Quite often, class libraries (for example, "rt.jar") are compiled without complete debug attributes, and thus local variables and method arguments for those classes are not visible in the debugger.

Setting breakpoints

In general the debugger will not allow you to place breakpoints on lines of code that are not executable (comments, blank lines, etc.). However, there are some cases where the debugger will allow breakpoints on lines of code that are not executable. For example, the debugger will allow a breakpoint to be placed on a variable declaration that does not contain an initializer ("int x;"). Note that enabled breakpoints which are successfully installed on an executable line in a running (debuggable) VM are displayed with a checkmark. Breakpoints that are displayed without a checkmark are not installed in a running (debuggable) VM.

Using Hot Code Replace

Hot code replace is supported on JDK 1.4.x VMs, and IBM J9 VMs. Hot code replace is limited to changes which do not effect the shape of a class. That is, changes within existing methods are supported, but the addition or removal of members is not supported.

Hot code replace and stepping on JDK 1.4.0 VMs is unreliable. This appears to be a VM issue that should be fixed in later releases of the JDK.

Scrapbook

Setting a breakpoint inside a scrapbook page is not supported.

When a snippet is run in the scrapbook which directly or indirectly calls System.exit(int), the evaluation cannot be completed, and will result in a stack trace for a com.sun.jdi.VMDisconnectedException being displayed in the scrapbook editor.

Terminating a scrapbook page while it is performing an evaluation results in a com.sun.jdi.VMDisconnectedException being displayed in the scrapbook editor.

Debugging over slow connections

A global Java debug preference specifies the debugger timeout, which is the maximum amount of time the debugger waits for a response from the target VM after making a request of that VM. Slow connections may require that this value be increased. The timeout value can be edited from the Java > Debug preference page. Changing the timeout value only effects subsequently launched VM, not VMs that are already running.

Updating of inspected values

When inspecting the result of an evaluated expression in the debugger, it is important to note that the result displayed is the result of that expression at the time it was evaluated. For example, when inspecting a simple integer counter (primitive data type), the value displayed in the Expressions view is the value when the expression was evaluated. As the counter is changed in the running program, the inspected result will not change (since the view is not displaying the value bound to a variable - it is displaying the value of an expression, and the value of a primitive data type cannot change). However, if an expression results in an object, fields of that object will be updated in the inspector as they change in the running program (since the value bound to fields in an object can change).

Stepping over native methods that perform I/O

When the debugger steps over native methods that perform I/O to System.out or System.err, the output may not appear immediately unless the native performs a flush on the output buffer.

VM and process termination running on IBM 1.3 JVM on Linux (Linux only)

Terminating a launch, debug target, or system process associated with a debug target running on the IBM 1.3 JVM on the Linux platform does not work when the associated debug target has a suspended thread. To remove such debug targets from the debug UI, select Terminate and Remove from the debug view's pop-up menu (or use the shortcut "delete" key). Associated system processes in the OS may not be properly cleaned up. If a debug target has no suspended threads, termination works properly.

Searching for constant field references

Search does not find references to constant fields inside binaries because the Java Language Specification mandates that constant field values be inlined in the class file's bytecodes, leaving no trace of a field reference. (bug 12044)

Java compilation units outside of the build class path

When a compilation unit with compilation problems is moved outside the Java build class path, it retains its Java problems forever (its compilation problem list does not get refreshed because it will never be compiled again). Renaming a *.java file to one with another a different file extension suffix causes the same problem. (bug 13008)

Refactoring operations update references in the entire workspace

Refactoring operations always update references in the entire workspace. This can be more than what is needed and expected. For example, when you have the same project twice in your workspace and you perform a rename refactoring in one of the projects, then the references in the other project will be updated as well.

Actions to modify read-only files

Actions on the Source menu (e.g., Generate Getter and Setter) are always disabled when the file is read-only. This is currently true even when the repository provider supports automatically checking out files on modification. (bug 17600)

Java code templates

You cannot use ${CURSOR} inside of a comment in a Java code template (Window > Preferences > Java > Templates). (bug 19556)

Organize import and imports from default packages

Organize import does not handle imports from default packages. Note that importing from a default package is no longer supported in JDK 1.4. (bug 19487)

Add Javadoc action for fields

The Add Javadoc action does not work for fields. (bug 20259)

Javadoc hover in the Java editor

The Javadoc hover help shown when hovering over identifiers in the Java editor does not handle links inside of Javadoc comments properly. (bug 20644)

3.3 Plug-in Development Environment (PDE)

Comments in source pages of PDE XML editors

PDE provides a number of multi-page editors that include a raw source page. Editors that handle XML files (plug-in, fragment and feature manifests) will preserve comments in most cases. However, comments will not be preserved if added before the root XML element, or if added after the last child element contained in the parent element. (bug 8000)

Clipboard operations in the property view

Clipboard shortcuts (Ctrl+X, Ctrl+C, Ctrl+V etc.) do not work in cell editors of properties that belong to the PDE Plug-in Manifest Editor. Use pop-up menu to activate these operations. (bug 13776)

Problem while importing fragments

If a workspace contains binary projects for a plug-in and a fragment that references that plug-in, fragment libraries are added to the class path of the referenced plug-in project. When an attempt is made to overwrite the plug-in and the fragment with versions from another build, deletion of the old fragment may fail. If that happens, repeat the operation to repair the workspace. Only the affected plug-in and fragment need to be re-imported. (bug 16921)

Assumption that output is in bin/ folder

PDE assumes that all plug-in and fragment projects that contain Java code have one or more source folders and build output in the bin/ folder. Although it is possible to change the name of the output folder in Properties dialog, the PDE run-time workbench launcher does not work correctly for those plug-ins. (bug 17444)

Preferences not working with import/export

Preferences set in PDE preference page called Target Platform are not preserved the same way as other preferences. Consequently, they are not subject to Import/Export operations in the Preferences dialog. (bug 19688)

Clipboard operations do not work in the Feature Manifest Editor

GUI pages of the Feature Manifest Editor support pop-up menus that contain standard clipboard operations (Cut, Copy, Paste). However, none of these operations work for structural widgets (trees and lists). The only place where these operations do work is in text widgets in Information and Source page (bug 20460)

Choosing Compute Build Path causes Java project to no longer build

PDE computes the build class path of a plug-in project by looking up source mappings in the build.properties file. This file defines how source folders are compiled into runtime libraries. In the absence of this file, PDE will compute the class path that contains no source folders, resulting in compilation errors. The required build.properties file is generated by PDE when a new plug-in project is created. If the plug-in project is created in some other way, a build.properties file must be added manually. See the PDE Guide for details on the format of build.properties files. (bug 9765)

ECLIPSE_HOME produces fragile class paths due to version numbers in plug-in directory paths

Eclipse products are typically built so that plug-ins are located in the same directory and each plug-in is in the directory whose name includes both a plug-in id and a version id (e.g., "org.eclipse.ui_2.0.0"). If external plug-ins are used while self-hosting, these plug-in directory names show up in PDE-generated class paths. These class path are sensitive to plug-in version changes and must be recomputed if the target platform uses different version numbers. (bug 15199)

Plug-in import wizard does not allow plug-ins of different versions to be imported

The Eclipse platform allows two plug-ins with the same ID but different versions to coexist if the only thing they contribute is run-time libraries. However, PDE cannot handle these plug-ins because it creates project names using plug-in IDs during binary project import. (bug 18500)

PDE nature required for plug-in manifest syntax checking

PDE will only be able to provide syntax checking and error/warning markers for plug-in manifests if the plug-in project has the PDE plug-in nature. A plug-in project automatically gets this nature when created by a PDE wizard. This situation can only occur if a regular Java project has been used to host a plug-in. The problem can be fixed by converting it into a PDE project. (bug 19248)

PDE does not preserve original manifest file layout

When non-Source page of a PDE manifest editor is used, PDE will convert changes back into XML by regenerating the file. Although the overall content and the comments are preserved, the actual file layout is not. This may cause problems by showing false changes during file compare. If file layout is important, perform all editing in the Source page. Alternatively, avoid using Source pages altogether. Since XML files are generated in a way that respects and preserves the relative order of major elements (extensions, extension points etc.), changes made in a non-Source page of a PDE manifest editor do not result in false deltas during file compare. (bug 19251)

Go To Line in manifest editor causes Outline view to go blank

When the Source > Go To Line command is invoked in the Source page of a PDE manifest editor, the Outline view will become gray. Since the Source page does not have a functional outline, there is no actual loss of function. (bug 19361)

New Feature wizard does not generate build.properties file

When creating a new feature project, the PDE wizard does not automatically generate a build.properties file. As a result, building the feature will create a feature JAR without any content. To work around this, create a build.properties manually using the instructions provided in the PDE Guide. (bug 20118)

Update Classpath attaches source from the wrong Eclipse install

Java libraries are associated with source code according to source code locations specified in a PDE preference. By default, these locations are registered by plug-ins of the design-time Eclipse instance. If the target platform is not the same as the design instance, the source code provided by these plug-ins will not be in sync with the libraries. The workaround is to uncheck the default locations and define new source code locations that point to the source-bearing plug-ins in the target Eclipse installation. (bug 20578)

No way to specify plug-in library type

PDE manifest editors do not provide widgets for specifying run-time library types as being either "code" or "resource". The only way to specify this attribute is to add it manually in the source page. (bug 20757)

Run-time libraries exported through more than 2 plug-ins not in classpath

If a plug-in requires a runtime library exported through more than two plug-ins, it is not automatically added to the compile class path when generating the build.xml file. Example: Plug-in A export its libraries, plug-in B requires plug-in A and re-exports A, plug-in C requires plug-in B and re-exports B. If plug-in D requires plug-in C, when generating the build.xml file, plug-in A libraries will not be added to the compile path even though they will be available at runtime. The problem can be worked around as follows::

  1. Generate a build.xml using PDE (select the plugin.xml file and click Create Plug-in JARs)
  2. Edit the build.properties and add the following line:
    custom = true
  3. Add the missing JARs to the classpath of the javac task in build.xml.

(bug 20119)

3.4 Other

3.4.1 FTP and WebDAV support

When mapped to a target, the project folder is ignored

Ignoring the project folder is by design. Normally with target management you put/get the contents of the project, not the actual project. The place you pick in the site explorer is where the project contents will go. This allows your local project to have a different name than the container in the WebDAV/FTP server. If you want to map several projects to the same site location, you create a new folder for each one. This is why "New Folder" is in the mapping page. (bug 17657)

FTP messages cause an exception

With some servers, the FTP client may receive messages that it did not anticipate. These will cause an exception. Trying the operation again usually works. (bug 18108)

FTP problems with spaces in resource names

FTP does not work properly when file or folder name contains spaces. (bug 20220)

FTP problems retrieving remote timestamps with NT server

Problems have occurred with some servers (NT server Serv-U FTP-Server v2.5k ) when trying to obtain the timestamp of a newly uploaded file. This causes a "file does not exist" error. The workaround is to Synchronize again and continue. (bug 19715)

4. Defects fixed

4.1 Release 2.1 over 2.0

Release 2.1 improves on release 2.0. The various features and plug-in in this release have version id "2.1.0" (the exceptions are the org.apache.*, org.junit, and org.eclipse.tomcat plug-ins).

Release 2.1 fixes the following defects present in release 2.0. (Note that this list includes defects fixed in the 2.0.* service releases up to and including 2.0.3.)

ID Summary

[TBD]

5. Interoperability with Previous Releases

Interoperability of Release 2.1 and 2.0

Sharing projects between heterogeneous Eclipse 2.0 and 2.1

Special care is required when a project in a team repository is being loaded and operated on by developers using Eclipse-based products based on different feature or plug-in versions. The general problem is that the existence, contents, and interpretation of metadata files in the workspaces may be specific to a particular feature or plug-in version, and differ between versions. The workspace compatibility guarantees only cover cases where all developers upgrade their Eclipse workspaces in lock step. In those cases there should be no problem with shared metadata. However, when some developers are working in Eclipse 2.1 while others are working in Eclipse 2.0, there are no such guarantees. This section provides advice for what to do and to not do. It addresses the specific issues with the Eclipse SDK.

Things to watch out for when the project is to be shared with 2.0:

  1. Linked folders and files. This support was added in 2.1. Information about linked resources is recorded in the project's .project file. Recommendation: do not use. Better still, disable linked resources via the Workbench / Linked Resources preference page.
  2. External tool (Ant) builders. Information about external tool builder is recorded in the project's .project file. The format of the information changed between 2.0 and 2.1. Builders created or changed in 2.1 use the new format, which is not understood by a 2.0 workspace. Builders created in 2.0 use the old format and continue to work in 2.1. Recommendation: Always create or edit external tools builders from a 2.0 workspace.
  3. Optional exclusion patterns on Java source entries on the build class path. This support was added in 2.1. This information is recorded in the project's .classpath file. Recommendation: do not specify exclusion patterns.
  4. Output folders associated with Java source entries on the build class path. This support was added in 2.1. This information is recorded in the project's .classpath file. Recommendation: do not specify anything other than the default (project-wide) output folder.
  5. PDE classpath containers for dependent plug-ins. PDE's use of classpath containers was added in 2.1. Classpath containers are recorded in the project's .classpath file. Recommendation: Ensure that the setting on the Plug-in Development / Java Build Path Control preference page for using classpath containers is disabled before creating any plug-in (or fragment) projects.
  6. PDE extension point schemas. This support was added in 2.1. This information is recorded in the plug-in project's plugin.xml (or fragment.xml) file. Recommendation: do not use extension point schemas; explicitly document extension points as you would in 2.0.

Using Eclipse 2.1 to develop plug-ins that work in Eclipse 2.0

It is also possible (and reasonable) to use Eclipse 2.1 to develop a plug-in intended to work in Eclipse 2.0. Use the Plug-in Development / Target Platform preference page to locate non-workspace plug-ins in an 2.0 Eclipse install. This ensures that the code for your plug-in is being compiled and tested against Eclipse 2.0 APIs, extension points, and plug-ins. (The above list of concerns do not apply since they affect the layout and interpretation of files in the plug-in project but none affect the actual deployed form of the plug-in.)


Java and all Java-based trademarks are trademarks of Sun Microsystems, Inc. in the United States, other countries, or both.

IBM is a trademark of International Business Machines Corporation in the United States, other countries, or both.

Microsoft, Windows, Windows NT, and the Windows logo are trademarks of Microsoft Corporation in the United States, other countries, or both.

Other company, product, and service names may be trademarks or service marks of others.

(c) Copyright IBM Corp. and others 2003