<!-- 
	DO NOT EDIT THIS FILE WITH HTML EDITORS
-->

<!DOCTYPE doctype 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.76 [en] (Windows NT 5.0; U) [Netscape]">
   <title>Eclipse Platform Build Notes - Java Development Tooling UI</title>
</head>

<body>
<h1>
Eclipse Platform Build Notes<br>
Java Development Tooling UI</h1>
To see which bugs have been addressed in one of the builds simply open the <a href="http://bugs.eclipse.org/bugs/query.cgi?short_desc_type=allwordssubstr&amp;product=JDT&amp;component=UI&amp;long_desc_type=allwordssubstr&amp;long_desc=&amp;bug_file_loc_type=allwordssubstr&amp;bug_file_loc=&amp;keywords_type=allwords&amp;keywords=&amp;emailtype1=substring&amp;email1=&amp;emailtype2=substring&amp;email2=&amp;bugidtype=include&amp;bug_id=&amp;votes=&amp;changedin=&amp;chfieldfrom=&amp;chfieldto=Now&amp;chfieldvalue=&amp;namedcmd=Assigned&amp;newqueryname=&amp;field0-0-0=noop&amp;type0-0-0=noop&amp;value0-0-0=">JDT UI bugzilla query page</a>, select status, resolution and the time frame.
<br><br>

========== Eclipse Build Input January 20th 2004 ==========<br>
<pre>
- Code formatter preference page adapted to new API. Conversion layer handles updates of older profiles. Downgrades are not supported.
- Performance improvements related to Java hover installation
</pre>
========== Eclipse Build Input December 16th 2003 ==========<br>
<pre>
- New Java working sets are initialized with the current selection.
</pre>
========== Eclipse Build Input December 9th 2003 ==========<br>
<pre>
- Move Static Members Refactoring now has a MRU ComboBox and CodeAssist for destination type entry.
- New 'Create Constant' quick fix
- Working sets for type hierarchy
- Type filter preference page: Allows to filter types (e.g. java.awt*) from 'All types', code assist and quick fix proposals.
- Configure exception variable name
</pre>
========== Eclipse Build Input December 2nd 2003 ==========<br>
<pre>
- New code formatter preference page added
- New 'Change else/ten/while/for.. statement to block' quick assist
</pre>
========== Eclipse Build Input November 20th 2003 ==========<br>
<pre>
- new refactorings Introduce Factory and Generalize Type
- Type hierarchy outline supports toggling between super- and subhierarchy
</pre>
========== Eclipse Build Input November 18th 2003 ==========<br>
<pre>
- Added encoding support for Java compare (not yet enabled)
</pre>
========== Eclipse Build Input November 11th 2003 ==========<br>
<pre>
- Adapted the code which does the blue-coloring for showing links in the editor
  to use the new ITextPresentationListener
- Added hover support for local variables
</pre>
========== Eclipse Build Input October 28th 2003 ==========<br>
<pre>
- Occurrences of the selected element can be highlighted in the Java editor
  (Java > Work in Progress > Mark occurrences in file). These Search annotations
  can be highlighted (see Annotation preference page) and also quickly removed
  using the Remove Occurrence Annotations source command (default: Alt+Shift+U).
- The "Disable overwrite mode" preference has been promoted from the Work in Progress
  preference page to the Java Editor's Typing preference page.
- Vertical ruler annotations can be disabled via editor's Annotation preference
  page.
</pre>
========== Eclipse Build Input October 21th 2003 ==========<br>
<pre>
- The Java editor now updates the editor status line with problem annotation
  messages while typing.
</pre>
========== Eclipse Build Input October 7th 2003 ==========<br>
<pre>
- The Package Explorer's built-in filters (fields, non-public members and static
  members) have been moved to the filter dialog (View menu > Filters...).
- Formatting has been extended to also format Javadoc if it is specified in the Java
  preferences. The preferences can be found on the Java Code Formatting preference page.
- "Format Element" is a new formatting action which formats the element at the cursor position. This
  is either a Javadoc comment, a method, a type, etc.
- "Correct Indent" bound to Ctrl+I in the default key binding corrects the line indentation
  of the selected lines.
- The Java editors use docment providers which retrieve their documents from the file buffers manager. Thus
  ther is how document updating between Java editors and Default text editors if they have been opened on the
  same file.
- The Java editors update the status line and the problems/tasks view according to the current caret position.
</pre>
========== Eclipse Build Input September 30rd 2003 ==========<br>
<pre>
- View menus which contain a "Filter..." entry now also contain the 3 last recently
  changed filters
- New Refactoring: Introduce Parameter ...
  Moves a selected selected expression to all call sites and reference the expression
  through a new parameter. The current implementation doesn't consider ripple methods
  nor does it recode the selected expression to fix accessibility problems.
</pre>
========== Eclipse Build Input September 23rd 2003 ==========<br>
<pre>
- Improved Change Method Signature refactoring
- Support for reference updates when moving local types
- Improved auto indentation
- "Correct indentation" fixes indentation (select Prefs->Java->Work in Progress->Smart Tab to bind this to the TAB key)
</pre>
========== Eclipse Build Input August 26th 2003 ==========<br>
<pre>
- Improved 'Set Javadoc Location' for JAR dialog
- Split and Join variable declaration quick assist
- Create field from parameter quick assist
- 'Add finally block' and 'Add else block' quick assist
- 'Remove catch clause' quick assist
- Smart cursor positioning on Java names
- Smart home now respects comments
- Syntax highlighting for method names and operators/brackets
- Enabled enclosing project scope for Java and NLS Search page
- Added enclosing project scope Java search actions to context menus
</pre>
========== Eclipse Build Input August 19th 2003 ==========<br>
<pre>
- The JDT Editor and its preference page now use marker annotation preferences
  declared in org.eclipse.ui.workbench.texteditor plug-in. This enables the
  editor to show new markers/annotations if they have a marker annotation
  specification.
- The JDT extends now ExtendedJavaEditor, an additional layer combining features 
  used in rich editors, such as the annotation, line number and overview rulers, 
  the print margin, current text highlighting, and quick diff.
- Fixed Java auto indentation after conditionals / loops without braces (e.g. <code>if</code> 
  statements without block).
- Added block commenting and uncommenting actions.
</pre>
========== Eclipse Build Input August 13th 2003 ==========<br>
<pre>
- Replaced "Go to Next Error" and "Go to Previous Error" with configurable
  "Go to Next Annotation" and "Go to Previous Annotation"
- F2 opportunity is shown in smaller font and can be disabled (preference)
- changed refactoring keybindings for Mac OS X from Alt-Shift-<some char> to Alt-Command-<some char> (#40989)
- changed "Show Outline" and "Show Hierarchy" keybindings for Mac OS X from Ctrl-O/T to Command-O/T (#41452)
- removed references to class MemberEdit in Java compare (#41383)
- several bugs fixed
</pre>
========== Eclipse Build Input August 5th 2003 ==========<br>
<pre>
- Improved context views:
    * contents of Declaration and Javadoc view is computed in the background
    * added context menu showing Copy and F3 (where available)
    * retargeted Select All action (default: Ctrl+A)
    * added preview functionality to Javadoc view
- F2 opportunity is shown in hovers
- Members view now shows types for fields
- several bugs fixed
</pre>
========== Eclipse Build Input July 29nd 2003 ==========<br>
========== Eclipse Build Input July 22nd 2003 ==========<br>
========== Eclipse Build Input July 15th 2003 ==========<br>
- more quick fixes with linked mode
- quick fix and quick assist as extension points now in public API
- compiler preference page restructured

========== Eclipse Build Input July 8th 2003 ==========<br>
<pre>
- Compilation unit editor supports light weight change indicator integrated with the line number ruler. Can be globally enabled on the
   Java Work in Progress preference page. Use the ruler context menu or "Ctrl+Shift+Q" to enable/disabled it for the current editor.
- quick fix and quick assist as extension points
- quick assist light bulb (first cut).
- quick fixes with linked mode
- create constructor from fields
- converted rename refactorings to processor/participant architecture
</pre>
========== Eclipse Build Input July 1st 2003 ==========<br>
<pre>
- AST rewriter supports moves & node markers
</pre>
========== Eclipse Build Input June 24th 2003 ==========<br>
========== Eclipse Build Input June 17th 2003 ==========<br>
========== Eclipse Build Input June 10th 2003 ==========<br>
========== Eclipse Build Input June 10th 2003 ==========<br>
<pre>
- Experimental views which show Javadoc and the Declaration for the element at the current
    cursor position. Use Window > Show View > Other... > Java to open them.
</pre>
========== Eclipse Build Input June 3rd 2003 ==========<br>
<pre>
- JUnit - introduced a JUNIT_HOME class path variable. When creating a new test case 
    with the test case wizard then the user has the option to put JUNIT_HOME on the build
    class path.
- The browsing views now also follow the caret position if "Linking with Editor" is enabled
    in the view menu.
- The range indication in the Java editor is synchronized with the caret position if
    the editor preference is enabled (default for a new workbench).
- The source tool tip is now shown in a source viewer.
- The Outline view no longer synchronizes immediately but after a delay once the caret remains
    at the same position.
- NOTE: The Java editor preference "Synchronize outline selection and range indication on
    caret move" will be removed for M2: it will always be enabled.
</pre>
========== Eclipse Build Input May 27th 2003 ==========<br>
<pre>
- Type hierarchy structured view: CTRL + T in the editor on a type, method or package.
- Improved dialogs for Generate Getter/Setter, Override Method and Delegate method: Insertion point, visibility, and comment generation
- Released first version of rename refactoring participants. The old rename refactoring actions are still
  in place. To enable a second Rename action which uses participants go to Preferences>Java>Work in Progress
  and enable the 'Rename with Participants' refactoring.
- Fixed bug 37846. To do so we had to break the API of the class org.eclipse.jdt.ui.actions.SelectionDispatchAction. 
  See document apichanges_jdt-ui.html for a describtion how to deal with the breakage.
- Editor
	- Introduced "Smart Opening Brace". To enable go Preferences>Java>Work in Progress.
	- Smart typing mode is enabled per default. Ctrl+M toggle the typing mode between "smart" and "raw". The default typing actions
	  such as auto indent, automatic addition of '"', ']', ')', '}', Smart Semicolon, and Smart Opening Brace adhere to the typing mode.
	- The automatic insertion of '}' has been changed to happen on <Enter> rather than on typing '{'.
</pre>
========== Eclipse Build Input May 20th 2003 ==========<br>
<pre>
- JUnit: added support to step through test failures
- Editor: Introduced "Smart Semicolon". To enable go to Preferences>Java>Editor>Work in Progress.
</pre>
========== Eclipse Build Input May 13th 2003 ==========<br>
<pre>
- Quick Fix on missing return type: guess varible to return
- Quick Fix on unneeded variable, parameter and private members: remove corresponding write accesses
</pre>
========== Eclipse Build Input May 6th 2003 ==========<br>
<pre>
- Quick Fix on mismatching parameters: remove/add/swap arguments, remove/add/replace/swap parameters of referenced method or constructor
</pre>
========== Eclipse Build Input April 29th 2003 ==========<br>
<pre>
- several bugs fixed
</pre>
========== Eclipse Build Input April 22nd 2003 ==========<br>
<pre>
- several bugs fixed
</pre>
</body></html>