<!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, 2002. 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>
