<!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]">
   <meta name="Author" content="IBM">
   <title>Eclipse Platform Build Notes - SWT</title>
</head>
<body>

<h1>
Eclipse Platform Build Notes<br>
SWT</h1>
SWT Build 2.0 023 - Tuesday January 22, 2002

<h2>
<a NAME="Problem reports fixed"></a>Problem reports fixed</h2>
<blockquote>
4610: StyledText - DCR - Word wrap (1GABS6C)  
<br>4644: Mouse click on a link displayed in embedded IE5 ActiveX is not reliable (1GD7TT2)
<br>5660: SWT default font's need to honor accesability settings  
<br>6324: SWT.CLOSE implies rendering of Minimize and Maximize buttons  
<br>6997: StyledText - mark new API  
<br>7123: Shell shows the maximize button enabled when SWT.TITLE | SWT.BORDER | SWT.CLOSE style passed
<br>7361: Add getOffsetAtLine API  
<br>7632: Tree widget doesn't select item with focus on right-click  
<br>7849: Labels on WINCE don't use background color of parent when color isn't set
<br>7867: DCR: Delete checkSubclass method from Dialog  
<br>7959: Potential problems when running on big endian machines  
</blockquote>

<h1>
Eclipse Platform Build Notes<br>
SWT</h1>
SWT Build 2.0 022 - Tuesday January 15, 2002

<h2>
<a NAME="Problem reports fixed"></a>Problem reports fixed</h2>
<blockquote>
4663: Fail to tab the views. (1GGYV8T)  
<br>4718: Tool tip is openning when on dragging. (1GF5Z7Z)  
<br>5866: Can't multiselect in Tree using keyboard  
<br>6592: Box for checkbox table items is too large when using large fonts
<br>6770: Only the left mouse button should select in a Table.  
<br>6852: StyledText - verify event character invalid value  
<br>6940: MenuShortcuts only respond to Ctrl-N  
<br>7190: Ctrl-S does not work  
<br>7458: WinCE - top level Shells created through Display.asyncexec can have incorrect Z-order
<br>7459: Caret leaving garbage  
<br>7486: Cannot use keyboard Shift Select in a Tree  
<br>7559: ScrollBar thumb is reset when ScrollBar is hidden, then shown
</blockquote>

<h1>
Eclipse Platform Build Notes<br>
SWT</h1>
SWT Build 2.0 021 - Tuesday January 8, 2002

<h2>
<a NAME="Problem reports fixed"></a>Problem reports fixed</h2>
<blockquote>
4443: Layout: Exceptions when horizontalSpan > remaining columns (1FFC6XZ)
<br>4462: ScrollBar - vbar.setMaximum does not work after hbar is hidden (and vice versa) (1FIG5CG)
<br>4722: First editor tab missing close button (1GF7QIQ)  
<br>4755: Rebuilding launcher from another directory (1GGNRG0)  
<br>6315: Some perspective save confirmation messages cut off  
<br>6352: Editor doesn't get activated when revealing first match  
<br>6908: Menu handle leak in org.eclipse.swt.widgets.Menu.destroyItem(MenuItem)
<br>6945: Child shells not displaying on WinCE  
<br>6982: CheckedTables have no check boxes  
<br>7005: Missing methods in SWT/GTK implementation  
<br>7018: Tree does not honor SWT.CHECK style  
<br>7068: ScrollBar.setVisible(true) does not work after changing values
<br>7150: StyledText - bidi - partial styling of ligatures bug  
<br>7191: Dialogs not big enough for content  
</blockquote>

<h1>
Eclipse Platform Build Notes<br>
SWT</h1>
SWT Build 2.0 020 - Tuesday December 18, 2001

<h2>
<a NAME="Problem reports fixed"></a>Problem reports fixed</h2>
<blockquote>
4715: First help click on a chapter is ignored (1GF5TV9)  
<br>4784: MIF Files sometime fail (1GI7H7V)  
<br>4797: Table does not use System fonts (1GIV4PZ)  
<br>6635: WinCE: decorations.setMenuBar can be set only once  
<br>6685: StyledText - on setFont caret not being positioned correctly  
<br>6773: StyledText.computeSize uses display width to calculate number of visible lines
<br>6790: Touching code assist scrollbar dumps javacore  
<br>6863: Remaining issues in emulated CoolBar and CoolItem  
<br>6933: Switching to help perspective crashes the workbench  
<br>7014: Tree not accepting children  
</blockquote>

<h1>
Eclipse Platform Build Notes<br>
SWT</h1>
SWT Build 2.0 019 - Tuesday December 11, 2001

<h2>
<a NAME="Problem reports fixed"></a>Problem reports fixed</h2>
<blockquote>
4461: SWTException should overwrite printStackTrace(..) (1GLDW6P)  
<br>4493: Check multilingual support on Windows 2000 (1FQFCBQ)  
<br>4611: StyledText - StringIndexOutOfBounds exception inserting text in line break (1GEID8B)
<br>4620: Workbench does not close ActiveX control's file handle (1GB76AZ)
<br>4660: Moving  
<br>4719: Background colour of views/editors (1GF6C8Y)  
<br>4739: DCR: Provide auto-scrolling and expansion by default in the tree during DND (1GFW7NQ)
<br>4767: Tab Folders can not be toggled using keys. (1GHFCZU)  
<br>4780: YAM: Cannot read some JPEG files (1GI6ZEN)  
<br>4783: Can't scroll to the top of the navigator (1GI7GTG)  
<br>5071: Shift-TAB doesn't generate proper event  
<br>5677: Hierarchy outline has empty space  
<br>5857: Image.getImageData needs to support 15 bit color depth  
<br>6472: Table widget has empty entries  
<br>6572: Default background color of Lists and Combos not consistent with Win2K
<br>6651: Text.setSelection() doesn't actually display the selection visually for SWT.SINGLE
<br>6654: Text.getSelection() not returning correct info on WINCE  
</blockquote>

<h1>
Eclipse Platform Build Notes<br>
SWT</h1>
SWT Build 2.0 018 - Tuesday December 4, 2001

<h2>
<a NAME="Problem reports fixed"></a>Problem reports fixed</h2>
<blockquote>
4419: Widgets - Missing features and API on MOTIF (1FBPKCT)  
<br>4494: ColorDialog doesn't open in VA/Java with JDK 1.2 (1FQGM6H)  
<br>4833: Remove focus button from Table (1GK7MK4)  
<br>4860: StyledText - StyledTextBidi, BidiUtil need doc (1GL32C8)  
<br>6204: KeyListener on table does not work.  
<br>6438: StyledText - bidi - isBidi test not working on XP  
</blockquote>

<h1>
Eclipse Platform Build Notes<br>
SWT</h1>
SWT Build 2.0 017 - Tuesday November 27, 2001

<h2>
<a NAME="Problem reports fixed"></a>Problem reports fixed</h2>
<blockquote>
4714: Label draws wrong background when image is set (1GF0IC6)  
<br>5503: Tabbing broken  
<br>5986: BidiUtil handling of WM_INPUTLANGCHANGE needs to be fixed
<br>5992: Changing Java Editor font in Preference Page makes Eclipse hang or crash
<br>6171: NullPointerException in ImageLoader save method with SWT.IMAGE_JPEG
</blockquote>

<h1>
Eclipse Platform Build Notes<br>
SWT</h1>
SWT Build 2.0 015 - Tuesday November 20, 2001

<h2>
<a NAME="Problem reports fixed"></a>Problem reports fixed</h2>
<blockquote>
4791: StyledText does not switch colour (1GILHIW)  
<br>4956: StyledText - change StyledTextBidi.toString to conform with standard SWT format
<br>5599: StyledText - redrawRange does not check range  
<br>5722: Selecting font crashes eclipse with a javacore  
<br>5815: StyledText - setFont refresh problem  
<br>5846: Combo.select does not ignore an out of range index
<br>5990: Printing single page prints entire document  
</blockquote>

<h1>
Eclipse Platform Build Notes<br>
SWT</h1>
SWT Build 2.0 014 - Thursday November 15, 2001

<h2>
<a NAME="Problem reports fixed"></a>Problem reports fixed</h2>
<blockquote>
4542: Menu accelerators CTRL+ / and CTRL + SHIFT + / don't work (1FYAF8V)
<br>4754: Arrow keys not accepted as keyboard accelerators (1GGM4U3)  
<br>5815: StyledText - setFont refresh problem  
</blockquote>

<h1>
Eclipse Platform Build Notes<br>
SWT</h1>
SWT Build 2.0 013 - Tuesday November 13, 2001

<h2>
<a NAME="Problem reports fixed"></a>Problem reports fixed</h2>
<blockquote>
4846: StyledText - bidi - partial styling of ligatures (1GL3AWT)  
<br>4859: StyledText - bidi - provide solution for bidi coloring hack (1GL2UNC)
<br>5491: StyledText - getStyleRangeAtOffset allows offset == getCharCount
<br>5497: StyledText - ExtendedModify event not sent on setText
<br>5602: StyledText - page down causes IllegalArgumentException in invisible/small widget
<br>5615: StyledText - window start does not always work  
<br>5622: StyledText - print causes NPE when invoked on empty widget  
<br>5626: StyledText - print does not check for null Printer argument  
<br>5633: StyledText - replaceTextRange and setText do not check for null argument
<br>5664: StyledText - Single line should not accept tab  
<br>5673: StyledText - SINGLE line mode still allows some multi line cursor navigation
<br>5722: Selecting font crashes eclipse with a javacore
<br>5725: Please rename "Eclipse Launcher"  
<br>5802: EC: ControlExample does not run on Solaris  
</blockquote>

<h1>
Eclipse Platform Build Notes<br>
SWT</h1>
SWT Build 2.0 012 - Monday November 5, 2001

<h2>
<a NAME="Problem reports fixed"></a>Problem reports fixed</h2>
<blockquote>
5470: User is lost when trying to move views around  
<br>5484: Tab no longer traverses between widgets!!!  
</blockquote>

<h1>
Eclipse Platform Build Notes<br>
SWT</h1>
SWT Build 2.0 011 - Thursday November 1, 2001
<h2>
<a NAME="API Changes"></a>API Changes</h2>
<code>FontData.setLocale(Locale)</code> has been changed to <code>FontData.setLocale(String)</code>.
<ul>
<li>
J2SE code can simply create a <code>Locale</code> and invoke <code>toString()</code> to pass it onto the new <code>setLocale</code>.
<li>
CLDC code will have to form a string matching the format specified in the J2SE javadoc of <code>java.util.Locale.toString()</code>.
</ul>
Example:
<blockquote><code><pre>
Locale[] locales = {
	Locale.US, new Locale("iw", "IL"), new Locale("ar", "SA"), new Locale("ru", "RU"),
	Locale.GERMAN, new Locale("ja", "JP"),
	null,
};
// old code: fd.setLocale(locales[i]);
String locale = (locales[i] != null ? locales[i].toString() : null);
fd.setLocale(locale);
</pre></code></blockquote></p>

<h2>
<a NAME="Problem reports fixed"></a>Problem reports fixed</h2>

<blockquote>
4664: StyledText does not compute correct text width (1GELJXD)  
<br>4832: German: Fonts cannot handle German characters (1GKMHHY)  
<br>4961: Preferences dialog disappears when you click on certain pages
<br>5180: Open Motif for Linux shared libraries are duplicated in Eclipse  
<br>5304: StyledText - ArrayIndexOutOfBoundsException in StyledTextBidi.segmentedRangesFor
</blockquote>


<h1>
Eclipse Platform Build Notes<br>
SWT</h1>
SWT Build 2.0 010 - Thursday October 25, 2001

<h2>
<a NAME="Behaviour change"></a>Behaviour change</h2>
<p>
1) The Drag Under effect of scrolling and expanding items as you drag over the <code>Tree</code> or <code>Table</code> has been added.  To enable this drag under effect, in the <code>DragOver</code> event set the <code>event.feedback</code> to have a bitwise combination of <code>DND.FEEDBACK_SCROLL, DND.FEEDBACK_EXPAND</code> and (<code>DND.FEEDBACK_SELECT, DND.FEEDBACK_INSERT_BEFORE, DND.FEEDBACK_INSERT_AFTER</code>) - where the last three items are mutually exclusive.
<blockquote><code><pre>
target.addDropListener (new DropTargetAdapter() {
	public void dragOver(DropTargetEvent event){
		event.feedback = DND.FEEDBACK_SELECT | DND.FEEDBACK_EXPAND | DND.FEEDBACK_SCROLL;
	}
}
</pre></code></blockquote></p>
<p>
2) On some operating systems it is preferred to move files in a drag and drop operation rather than for the drop target to make a copy of the file and the drag source to delete the original file.  The operation of moving the file is preformed by the drop target.  For these cases, the new drop type <code>DND.DROP_TARGET_MOVE</code> has been added.  The Eclipse <code>DropTarget</code> does not support this behaviour but the Eclipse <code>DragSource</code> can recognize this scenario.  If another application has chosen to move the file rather than copy/delete, the <code>DragFinished</code> event on the <code>DragSource</code> will have an <code>event.detail</code> value of <code>DND.DROP_TARGET_MOVE</code>.
<blockquote><code><pre>
source.addDragListener (new DragSourceAdapter () {
	public void dragFinished(DragSourceEvent event) {
		if (event.detail == DND.DROP_TARGET_MOVE) {
			// clean up presentation but do not delete underlying file
		}
	}
}
</pre></code></blockquote></p>

<h2>
<a NAME="Problem reports fixed"></a>Problem reports fixed</h2>

<blockquote>
1767: Display ASCII for values greater than 127 fails (1GLE8I5)  
<br>4725: FontData spec should disallow null name (1GL34H3)  
<br>4844: Tab appears narrower than space (1GL2WTY)  
<br>4852: German: Cannot start Eclipse in Linux 7.2 (1GKYY99)  
<br>4865: TableTreeEditor.getItem returns an item after setting it to null (1GLE0IQ)
<br>4932: StyledTextBidi has equals but no hashCode method  
<br>4957: StyledText - implement StyledTextBidi.isLigated  
<br>5132: StyledText - remove hardcoded margin  
<br>5178: Change BidiUtil calls to handle true Unicode/Windows CE changes
</blockquote>

<h1>
Eclipse Platform Build Notes<br>
SWT</h1>
SWT Build 2.0 009 - Thursday October 18, 2001

<h2>
<a NAME="Problem reports fixed"></a>Problem reports fixed</h2>

<blockquote>
4444: EWT - incorrect selection feedback when the item's text is changed (1FFP3U2)
<br>4446: DCR - GridBagLayout compatible LayoutManager (1FGCPO2)  
<br>4762: StyledText - default lineStyler remove line background color hack (1GHBMUV)
<br>4819: StyledText - bidi - cursor navigation (1GJLKSN)  
<br>4820: StyledText with style SINGLE does not handle CR/LF well (1GJM2Z5)
<br>4855: Severe: Check boxes are black (1GL0XSI)  
<br>4909: EC: Combo.setText doesn't work on Linux  
<br>4910: EC: Combo.select() fires a selected event on Linux only  
<br>5045: Control.moveAbove() throws NPE if argument is null  
</blockquote>


<h1>
Eclipse Platform Build Notes<br>
SWT</h1>
SWT Build 2.0 008 - Thursday October 11, 2001

<h2>
<a NAME="Problem reports fixed"></a>Problem reports fixed</h2>

<blockquote>
1GLDQYB: SWT:WIN - Text widget with DND enabled, MouseDown but no MouseUp
<br>1GLADBK: SWT:ALL - StyledText - getOffsetAtLocation should throw exception
<br>1GL4ZVE: SWT:ALL - StyledText - getOffsetAtLocation(getLocationAtOffset(N)) != N
<br>1GKO6NY: SWT:ALL - Backspacing in StyledText does not fire selection changed
<br>1GKB1OC: ITPJUI:ALL - Error in JavaDoc hover help
<br>1GK9API: SWT:ALL - StyledText - bidi - numbers,mixed LtoR/RtoL text and caret positioning
<br>1GJLQ16: SWT:ALL - StyledText - bidi - backspace and delete behavior
<br>1GIK7D4: SWT:ALL - StyledText - Selection cleared when deletion disallowed by verify listeners
<br>1GDOMBI: SWT:WINNT - StyledText - redrawRange() doesn't checkWidget
<br>1GDKK3R: SWT:WINNT - StyledText - setCaretOffset and line delimiters bug
<br>1FMRQOT: SWT:ALL - No null argument checks in Dialog constructors
</blockquote>


<h1>
Eclipse Platform Build Notes<br>
SWT</h1>
SWT Build 2.0 007 - Thursday October 4, 2001

<h2>
<a NAME="Problem reports fixed"></a>Problem reports fixed</h2>

<blockquote>
1GKZH74: ITPJUI:WIN2000 - Disappearing Stop icon
<br>1GKZ8CV: SWT:WINNT - setSelection triggers SelectionChanged event
<br>1GKU4C5: SWT:ALL - StyledText - bidi - scrolling to show cursor should take cursor direction into account
<br>1GKPYMK: SWT:WINNT - StyledText - bidi - caret moves when switching keyboard from Hebrew to Arabic
<br>1GKOGQO: SWT:ALL - Javadoc: setSelection in Button and ToolItem
<br>1GKM2O5: SWT:WINNT - StyledText - bidi - ArrayIndexOutOfBounds exception in StyledTextBidi.isRightToLeft
<br>1GKM193: SWT:WINNT - StyledText - bidi autoscroll left does not always scroll all the way to the left
<br>1GKKC0U: SWT:ALL - Tracker calls OS.DispatchMessage(msg) on windows but does not on Linux.
<br>1GIVAXX: SWT:ALL - StyledText - Editors should support shift-backspace
<br>1GELQ14: SWT:WINNT - StyledText - DefaultContent - handle weird line delimiter cases
<br>1GE8LG0: SWT:Linux - Toolbar is not showing the separators.
</blockquote>


<h1>
Eclipse Platform Build Notes<br>
SWT</h1>
SWT Build 2.0 006 - Thursday Sept 27, 2001

<h2>
<a NAME="Problem reports fixed"></a>Problem reports fixed</h2>

<blockquote>
1GHWA19: SWT:WINNT - Problem with callbacks from CCombo
<br>1GHFDPV: SWT:WIN2000 - Setting selection in Table does not update focus item
<br>1GF644V: ITPUI:Linux - Unzoom is changing the active editor.
<br>1GKM3XS: SWT:WINNT - StyledText - bidi autoscroll left: selection reset on mouse move
</blockquote>


<h1>
Eclipse Platform Build Notes<br>
SWT</h1>
SWT Build 2.0 005 - Friday Sept 21, 2001

<h2>
<a NAME="Problem reports fixed"></a>Problem reports fixed</h2>

<blockquote>
1GK09Z0: SWT:Linux - setEnabled(false) has no effect on aToolbar
<br>1GJZZS6: SWT:Linux - File Dialog returns a directory
<br>1GF7SMC: ITPUI:Linux - Wrong bg for close button on editor tab
</blockquote>


<h1>
Eclipse Platform Build Notes<br>
SWT</h1>
SWT Build 2.0 004 - Thursday Sept 13, 2001

<h2>
<a NAME="API Behaviour change"></a>API Behaviour change</h2>
The behaviour of dispose for GCs has been modified such that attempting to dispose of
a GC on a control <em>after</em> the control has been disposed will generate an
SWTException.  This fixes an OS resource leak and potential GPF situation.

<h2>
<a NAME="Problem reports fixed"></a>Problem reports fixed</h2>

<blockquote>
1GJUAKL: SWT:Neutrino - Control.internal_new_GC() needs !isValidWidget() check
<br>1GJN52N: SWT:Linux - Text prints system error message for horizontal scrollbar
<br>1GJBOAV: SWT:ALL - ScrolledComposite bugs
<br>1GIXELI: SWT:ALL - Need Caret to allow bitmaps so bidi caret can be created
<br>1GI5O1T: SWT:WINNT - Composite.setFocus takes focus when it should not
<br>1GHOND7: SWT:WIN2000 - Selection problem with single-selection trees
<br>1GHG990: SWT:ALL - Probable bug in Slider page increment setting
<br>1GENJ60: SWT:ALL - ScrolledComposite should include example in its class comment
<br>1GEA7K7: ITPUI:Linux - Default button not working
</blockquote>


<h1>
Eclipse Platform Build Notes<br>
SWT</h1>
SWT Build 2.0 003 - Friday Sept 07, 2001

<h2>
<a NAME="New APIs"></a>New APIs</h2>

<blockquote>
FontData.setLocale(java.util.Locale) added
<br>Caret.getImage() added
<br>Caret.setImage(Image) added
<br>GC.fillGradientRectangle(int, int, int, int, boolean) added
</blockquote>

<h2>
<a NAME="Problem reports fixed"></a>Problem reports fixed</h2>

<blockquote>
1GJM7KM: SWT:Linux - Table and Tree return a different size for every second call to computeSize
<br>1GJLKHE: SWT:SPARC - GP on "Installed JREs" preference page
<br>1GJLK63: SWT:ALL - StyledText - bidi - keyboard switching
<br>1GJLE36: SWT:WINNT - Alpha data redrawing improperly after occlusion
<br>1GJA2L7: SWT:WIN - Different behavior for GC.drawString() args on Win vs. Photon
<br>1GIZ0P6: SWT:WINNT - GC.drawImage() problem with transparent pixels
<br>1GIXELI: SWT:ALL - Need Caret to allow bitmaps so bidi caret can be created
<br>1GI7FQF: SWT:ALL - Can't set focus to Tasks View by Keyboard
<br>1GI7EBL: SWT:Linux - api typo: ToolItem>>getDisabledmage()
<br>1GI3P86: SWT:ALL - Semantic differences between emulated Table and Tree codebase on Motif and Photon
<br>1GI1WEA: SWT:Neutrino - Text selection code not working correctly
<br>1GHWED2: SWT:WINNT - GC.stringExtent() not correct for Windows Arial font
<br>1GHWB7G: SWT:Linux - Linux font dialog doesn't open with given values.
<br>1GHVRFY: SWT:Neutrino - Text#ClearSelection changes the CaretPosition in a SINGLE-line widget
<br>1GHVLV6: SWT:Neutrino - Text#SetTopIndex and getTopIndex inconsistent
<br>1GHOJ6T: SWT:Neutrino - Text#setSelection inconsistent between SINGLE and MULTI
<br>1GHBLRA: SWT:Neutrino - Display.getBounds() returns incorrect info
<br>1GH48UQ: SWT:Neutrino - Enter key does not insert new line with Text.MULTI widget
<br>1GGT0TM: SWT:Neutrino - GC#drawArc inconsistent between NT and NTO
<br>1GG1DBT: SWT:SPARC - Solaris loses input characters
<br>1GG07HW: SWT:Linux - Tree.getItem() modifies its argument on Motif
<br>1GG0069: SWT:Linux - Weird layout issues seen in Control Example
<br>1GFZZLK: SWT:Linux - ToolItems not disabled when containing ToolBar is disabled
<br>1GFZU3X: SWT:ALL - ImageLoader.load(String) not closing file input stream
<br>1GFZPDP: SWT:Linux - Combo box with SWT.SIMPLE style does not respect Disabled flag (visually)
<br>1GFW85H: SWT:ALL - Printer.getPrinterData() has stale comment
<br>1GFW6MQ: SWT:ALL - DCR: Program class needs .equals() and .hashCode()
<br>1GFW4YN: SWT:ALL - Help KevinH add printing to Eclipse
<br>1GFQKDT: SWT:ALL - Image.setBackground() / getBackground() asymmetry
<br>1GFONVW: SWT:Linux - Empty Combo should not fire Selection event
<br>1GFL0HP: SWT:Linux - Remaining items in SWT comments to fix
<br>1GET90D: SWT:Linux - SWTExceptions bring down Eclipse
<br>1GESQBK: ITPJUI:WINNT - How to get access to pop-up menus of the Java editor ?
<br>1GELX4A: ITPUI:ALL - Hover help is not visible if pane is dragged out of workbench
<br>1GEHWAF: ITPUI:WIN2000 - Can't enter text in a Swing TextField or TextArea
<br>1GE5ECJ: ITPUI:WIN2000 - Hover help for title bar buttons appears behind detached view
<br>1GDX7R8: ITPUI:ALL - SWT setText() does NOT have any way to avoid making mnemonics.
<br>1GD5UHA: SWT:WIN2000 - Double-clicking on toolbar item gives double-click event on toolbar
<br>1GBXIEO: SWT:ALL - DCR: Include cursor pos in Tracker move event
<br>1G4IMQ3: SWT:WINNT - Table images incorrect after rapid removal and creation
</blockquote>

<h1>
Eclipse Platform Build Notes<br>
SWT</h1>
SWT Build 2.0 002 - Wednesday July 18, 2001

<h2>
<a NAME="Problem reports fixed"></a>Problem reports fixed</h2>

<blockquote>
1GGZ13T: SWT:Neutrino - invalid mouse state occuring in Photon
<br>1GGRCCS: SWT:Neutrino - Label does not wrap in SWT0125
<br>1GGAON2: SWT:ALL - Scaling image with alphas does not work correctly
<br>1GFZQVQ: SWT:Linux - Vertical ProgressBar grows incorrectly
<br>1GFQA18: SWT:Linux - Cheese with GC drawRoundedRectangle() on Motif
<br>1GFPK6G: SWT:Linux - Motif fillPolygon() specifies improper hint
</blockquote>

<h1>
Eclipse Platform Build Notes<br>
SWT</h1>
SWT Build 2.0 001 - Thursday July 12, 2001

<h2>
<a NAME="Problem reports fixed"></a>Problem reports fixed</h2>

<blockquote>
1GGET76: SWT:Neutrino - Canvas does not respond to setFocus()
<br>1GGAS5P: SWT:Neutrino - Photon on QNX 6.1.x needs SWT native changes
<br>1GG96RO: SWT:Neutrino - drawOval and fillOval not compatible
<br>1GG8ZLV: SWT:WINNT - drawOval behaves differently on Windows vs. other platforms
<br>1GFKYD9: SWT:Linux - -HANG- (Xserver) When perfoming display.wake() in a DND dragStart()
<br>1GFKK37: SWT:Linux - FileViewer examples issues
<br>1GFBHX6: SWT:ALL - CTabItem tool tip flashing
<br>1GF9ZMT: SWT:SPARC - 8-bit Icons are losing colors
<br>1GF9ZJG: SWT:SPARC - Icons are being masked incorrectly on Solaris
<br>1GF9YHD: ITPUI:WIN2000 - SWTException: help view
<br>1GF9Y32: SWT:SPARC - 24-bit MSB Icons are wrong color (greenish)
<br>1GF0D05: SWT:Linux - GPFs when running JUnit TestRunner in J9 AWT
<br>1GEUZZC: SWT:ALL - "Name" of plugin inconsistant with other plugins
<br>1GETDP5: ITPUI:Linux - NPE while closing editor on linux
<br>1GDVRT5: SWT:Neutrino - Alpha channel memory leak
<br>1GDRXZR: ITPJUI:Linux - SWT: Context-Menus issue under Linux 
<br>1GD0OSK: SWT:ALL - API - package javadoc for SWT packages missing
<br>1GCHS75: SWT:WINNT - workbench exits during expand collapse
<br>1GCFUS0: SWT:ALL - CTabFolder "floating" X sticks sometimes
<br>1GAR95O: SWT:ALL - Remove Smalltalk comments from SWT code
<br>1GAQRND: SWT:ALL - DOC: Write good Javadoc comments for all of SWT
<br>1G97I28: SWT:Linux - Tool bar buttons do not always work
<br>1G84AZB: ITPDUI:ALL - Rename truncates name
<br>1G845EZ: SWT:WIN2000 - Spec for Layout.computeSize() is truncated
<br>1G7YXLB: SWT:WIN - StyledText - NLS Support
<br>1G7NSHR: SWT:ALL - Widget.addListener(int, Listener) vs. adding typed listeners
<br>1G4XDJO: SWT:Linux - Tree needs to display an insert marker
<br>1G0Y8NZ: SWT:ALL - Combo box doesn't send key and mouse events 
<br>1FXAVLF: SWT:WINNT - Disabled toolbar icons don't adapt to appearance changes
<br>1FV1S18: SWT:ALL - Need more WM_* messages passed to ActiveX Control
<br>1FTWX55: SWT:ALL - Inconsistant commenting of which SWT objects need to be disposed.
</blockquote>
<a href="hglegal.htm"><img SRC="ngibmcpy.gif" BORDER=0 height=12 width=195></a>
</body>
</html>
