<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
<html>
<head>
   <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
   <meta name="GENERATOR" content="Mozilla/4.7 [en] (WinNT; I) [Netscape]">
   <title>Eclipse Project SDK R2.0 - SWT Release Notes</title>
</head>
<body>

<table COLS=1 WIDTH="604" HEIGHT="45" >
<tr>
<td BACKGROUND="workbench.gif"><b>Eclipse Project SDK R2.0 - SWT Release
Notes</b></td>
</tr>
</table>

<h3>
Notices</h3>
(c) Copyright IBM Corp. 2000, 2003. All Rights Reserved.
<h3>
Table Of Contents</h3>
&nbsp;1. Known Issues
<h3>
1 Known Issues</h3>
<h4>
1.1 Available Colors on 8-bit Linux</h4>

Typically, in Gnome Linux installs running with 8 bitplain 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 not affected.

<h4>
1.2 Printing Support</h4>

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, <code>Printer.getPrinterList()</code> will always return
an empty array on the Linux platform.</dd>

<h4>
1.3 List and ComboBox on Windows NT</h4>

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.

<h4>
1.4 BiDi Support</h4>

The StyledText widget now provides bidirectional language support for Hebrew and Arabic locales.
Currently, this support is available only on win32, and has several known problems. It should be
considered to be a preliminary implementation only.

<h4>
1.5 Cursor constructor arguments</h4>

In the constructor Cursor(Device device, ImageData source, ImageData mask, int hotspotX, int hotspotY), 
when both a source and mask argument are specified (i.e. 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. For a description of this issue see bugzilla report #4809.

<h4>
1.6  ToolBar on Windows</h4>

On Windows, you must create all tool bars with the FLAT style bit set. If you do not do this,
the "hot" (rollover) images of <em>all</em> toolbars may display incorrectly.
This will be fixed in a future release.

<h4>
1.7  Non ASCII strings on Linux</h4>

On Linux RedHat 6.2 only, you will not be able to display text that contains non
ASCII characters. This limitation is not present on Linux RedHat 7.1 or higher.

<h4>
1.8  Using J9 VM on Photon and AIX</h4>

On Photon and AIX, the SWT library will not be found when running with
the J9 VM (version 1.5). This is a bug in the J9 classes library. You
can workaround this problem by adding the SWT library directory to your
load library path.

<h4>
1.9  Javadoc not consistent across platforms</h4>

Because of a bug in the way we updated the javadoc in our 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. This will be fixed in a future release.

<h4>
1.10 JAWS requires MSAA for List Views to read checkboxes in Tables</h4>

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

<ol>
<li>Open Eclipse and hit INSERT + F2.
<li>In the "Run JAWS Manager" dialog select "Configuration Manager".
<li>In the "Jaws Configuration Manager" that opens up, select "Set Options" and then select "Advanced Options".
<li>Check "Rely on MSAA for List views".
<li>Hit the OK button.
<li>Choose File -> Save from the menu bar.
</ol>

<h4>
1.11 Combo boxes with multi-line items on Linux/Motif</h4>

The Linux implementation of Motif has a bug that causes program execution to terminate
if the value of an editable Combo is set through Combo.setText(String) to a string
that contains five or more newline characters.

<p><a href="hglegal.htm"><img SRC="ngibmcpy.gif" BORDER=0 height=12 width=195></a>
</body>
</html>
