<!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>Java Tooling Release Notes</title></head><body>

<h1>
Eclipse Platform Build Notes<br>
Java Development Tooling UI</h1>

Eclipse Build Input March 14<sup>th</sup> 2003
<h2>
What's new in this drop</h2>

<h2>
Problem Reports</h2>

<a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;chfield=bug_status&amp;chfieldfrom=2003%2F03%2F06&amp;chfieldto=2003%2F03%2F14&amp;product=JDT&amp;component=UI&amp;cmdtype=doit&amp;&amp;order=Bug+Number">Click
here</a> to see PRs which have been marked as RESOLVED or CLOSED between
between 2003/03/06 and 2003/03/14<br>



<br>
Eclipse Build Input March 6<sup>th</sup> 2003
<h2>
What's new in this drop</h2>

<h2>
Problem Reports</h2>

<a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;chfield=bug_status&amp;chfieldfrom=2003%2F03%2F04&amp;chfieldto=2003%2F03%2F06&amp;product=JDT&amp;component=UI&amp;cmdtype=doit&amp;&amp;order=Bug+Number">Click
here</a> to see PRs which have been marked as RESOLVED or CLOSED between
between 2003/03/04 and 2003/03/06<br>



<br>
Eclipse Build Input March 4<sup>th</sup> 2003
<h2>
What's new in this drop</h2>

<h2>
Problem Reports</h2>

<a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;chfield=bug_status&amp;chfieldfrom=2003%2F02%2F27&amp;chfieldto=2003%2F03%2F04&amp;product=JDT&amp;component=UI&amp;cmdtype=doit&amp;&amp;order=Bug+Number">Click
here</a> to see PRs which have been marked as RESOLVED or CLOSED between
between 2003/02/27 and 2003/03/04<br>



<br>
<br>
Eclipse Build Input February 27<sup>th</sup> 2003
<h2>
What's new in this drop</h2>

<ul>
<li><br>
</li>
</ul>

<h2>
Problem Reports</h2>

<a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;chfield=bug_status&amp;chfieldfrom=2003%2F02%2F20&amp;chfieldto=2003%2F02%2F27&amp;product=JDT&amp;component=UI&amp;cmdtype=doit&amp;&amp;order=Bug+Number">Click
here</a> to see PRs which have been marked as RESOLVED or CLOSED between
between 2003/02/20 and 2003/02/27<br>



<br>
<br>
Eclipse Build Input February 20<sup>th</sup> 2003
<h2>
What's new in this drop</h2>






<ul>
<li><br>
</li>
</ul>






<h2>
Problem Reports</h2>





<a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;chfield=bug_status&amp;chfieldfrom=2003%2F02%2F18&amp;chfieldto=2003%2F02%2F20&amp;product=JDT&amp;component=UI&amp;cmdtype=doit&amp;&amp;order=Bug+Number">Click
here</a> to see PRs which have been marked as RESOLVED or CLOSED between
between 2003/02/18 and 2003/02/20<br>



<br>
<br>
Eclipse Build Input February 18<sup>th</sup> 2003
<h2>
What's new in this drop</h2>





<ul>
<li><br>
</li>
</ul>





<h2>
Problem Reports</h2>




<a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;chfield=bug_status&amp;chfieldfrom=2003%2F02%2F13&amp;chfieldto=2003%2F02%2F18&amp;product=JDT&amp;component=UI&amp;cmdtype=doit&amp;&amp;order=Bug+Number">Click
here</a> to see PRs which have been marked as RESOLVED or CLOSED between
between 2003/02/13 and 2003/02/18
<br>



<br>
<br>
Eclipse Build Input February 13<sup>th</sup> 2003
<h2>
What's new in this drop</h2>




<ul>
<li><br>
</li>
</ul>




<h2>
Problem Reports</h2>



<a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;chfield=bug_status&amp;chfieldfrom=2003%2F02%2F11&amp;chfieldto=2003%2F02%2F13&amp;product=JDT&amp;component=UI&amp;cmdtype=doit&amp;&amp;order=Bug+Number">Click
here</a> to see PRs which have been marked as RESOLVED or CLOSED between
between 2003/02/11 and 2003/02/13
<br>


<br>
<br>
Eclipse Build Input February 11<sup>th</sup> 2003
<h2>
What's new in this drop</h2>



<ul>
<li><br>
</li>
</ul>



<h2>
Problem Reports</h2>


<a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;chfield=bug_status&amp;chfieldfrom=2003%2F02%2F07&amp;chfieldto=2003%2F02%2F11&amp;product=JDT&amp;component=UI&amp;cmdtype=doit&amp;&amp;order=Bug+Number">Click
here</a> to see PRs which have been marked as RESOLVED or CLOSED between
between 2003/02/07 and 2003/02/11
<br>

<br>
<br>
Eclipse Build Input February 6<sup>th</sup> 2003
<h2>
What's new in this drop</h2>


<ul>
<li>
The JUnit plugin provides an extension point to register additional test run listeners.<br>
</li>
</ul>


<h2>
Problem Reports</h2>

<a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;chfield=bug_status&amp;chfieldfrom=2003%2F02%2F05&amp;chfieldto=2003%2F02%2F06&amp;product=JDT&amp;component=UI&amp;cmdtype=doit&amp;&amp;order=Bug+Number">Click
here</a> to see PRs which have been marked as RESOLVED or CLOSED between
between 2003/02/05 and 2003/02/06
<br>
<br>
Eclipse Build Input February 5<sup>th</sup> 2003
<h2>
What's new in this drop</h2>

<ul>
<li>
Package Explorer and Projects view offer to filter non-shared projects.</li>

<li>
Show in Package Explorer/Show in Navigator was replaced with the new Show
In.., support.</li>

<li>
Package Explorer: a class path container/library is no presented as a single
node with children.</li>

<li>
Problem annotations in the editor's vertical ruler become gray when the
problems have gone during editing.</li>

<li>
Rework of Edit and Navigate menu</li>

<li>
Presentation of&nbsp; task tags in the editor can be configured</li>

<li>
The hyper link style navigation can be switched off.</li>

<li>
Automatically inserted ')' and '}' can be deleted with "Del".</li>
</ul>

<h2>
Problem Reports</h2>
<a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;chfield=bug_status&amp;chfieldfrom=2003%2F01%2F28&amp;chfieldto=2003%2F02%2F04&amp;product=JDT&amp;component=UI&amp;cmdtype=doit&amp;&amp;order=Bug+Number">Click
here</a> to see PRs which have been marked as RESOLVED or CLOSED between
between 2003/01/28 and 2003/02/04
<p>Eclipse Build Input January 28<sup>th</sup> 2003
</p><h2>
What's new in this drop</h2>

<ul>
<li>
New Non-Java projects are now shown in the Package Explorer. Added a filter
to hide non-Java projects.</li>

<li>
Open Type Dialog no support the special end of type name character &lt;.
If you want to see all types that end with factory you have to use the
pattern *factory&lt;. If a pattern doesn't end with &lt; then a star is
automatically added to the pattern.</li>

<li>
The Project menu now contains two actions to quickly open the Generate
Javadoc and the Java Build Path dialog.</li>

<li>
The Java editor preference pages have been reworked. Java editor text hovers
are now fully user configurable.</li>

<li>
New <i>Push Down</i> refactoring. To use it, select set of non-static methods
and fields (declared in a class) and choose 'Push Down' from the menu.
You can then, for each of the class methods and fields choose if you want
to either</li>

<ul>
<li>
push it down to subclasses or</li>

<li>
(in the case of methods) push down to subclasses and declare abstract in
the class that currently declares the method or</li>

<li>
leave as is</li>
</ul>

<li>
Class file editor and compilation unit editor have been unified. Both are
supporting now: current line highlighting, line numbers, overview rulers,
bracket matching (painting + navigation), squiggly lines, print margin
indication, error navigation, goto previous and next member, and expand
to selection.</li>
</ul>

<h2>
Problem Reports</h2>
<a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;chfield=bug_status&amp;chfieldfrom=2003%2F01%2F21&amp;chfieldto=2003%2F01%2F28&amp;product=JDT&amp;component=UI&amp;cmdtype=doit&amp;&amp;order=Bug+Number">Click
here</a> to see PRs which have been marked as RESOLVED or CLOSED between
between 2003/01/21 and 2003/01/28
<p>Eclipse Build Input January 21<sup>th</sup> 2003
</p><h2>
What's new in this drop</h2>

<ul>
<li>
<i>Pull Up</i> refactoring is more powerful now. Additional functionality
includes:</li>

<ul>
<li>
You can add new members to pull up after the refactoring dialog appears.</li>

<li>
Members can be pulled up more than 1 level in the class hierarchy.</li>

<li>
Instead of pulling methods up you can choose to declare them abstract in
the destination class. Refactoring will then add method stubs to all non-abstract
subclasses of the destination class (only those that require such additions).</li>

<li>
By pressing 'Pull Up Required Members' you can compute the set of all members
that are required to be pulled up together with those already selected.</li>
</ul>

<li>
<i>Move</i> refactoring now supports updating qualified names in non Java
files as well.</li>
</ul>

<h2>
Problem Reports</h2>
<a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;chfield=bug_status&amp;chfieldfrom=2003%2F01%2F14&amp;chfieldto=2003%2F01%2F21&amp;product=JDT&amp;component=UI&amp;cmdtype=doit&amp;&amp;order=Bug+Number">Click
here</a> to see PRs which have been marked as RESOLVED or CLOSED between
between 2003/01/14 and 2003/01/21
<br>&nbsp;
<h1>
Eclipse Platform Build Notes<br>
Java Development Tooling UI</h1>
Eclipse Build Input January 14<sup>th</sup> 2003
<h2>
What's new in this drop</h2>

<ul>
<li>
New <i>Move instance method refactoring</i>: you can select a virtual method
and select Move from the context menu. It allows you to move the method
to the declared class of a field of the class or the declared class of
one of the method's parameters. The refactoring will creat the new method
and convert the old method into a delegate (passing 'this' if necessary).</li>
</ul>

<h2>
Problem Reports</h2>
<a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;chfield=bug_status&amp;chfieldfrom=2003%2F01%2F07&amp;chfieldto=2003%2F01%2F14&amp;product=JDT&amp;component=UI&amp;cmdtype=doit&amp;&amp;order=Bug+Number">Click
here</a> to see PRs which have been marked as RESOLVED or CLOSED between
between 2003/01/07 and 2003/01/14
<br>&nbsp;
<h1>
Eclipse Platform Build Notes<br>
Java Development Tooling UI</h1>
Eclipse Build Input January 7<sup>th</sup> 2003
<h2>
What's new in this drop</h2>

<ul>
<li>
A new font definition for Java editors has been added. As a consequence,
the Java editor font preference has moved from the Java Editor preference
page to the&nbsp;<span style="font-style: italic;">Workbench's&nbsp;</span><span style="font-style: italic;">Font</span><span style="font-style: italic;">
preference page</span>.</li>

<li>
Run the currently selected method as a JUnit test.</li>

<li>
New search action: Occurrences in File - the action finds all the occurrences
of the selected element in a Java editor. For variables the read or write
access is indicated in the search results.</li>
</ul>

<h2>
Problem Reports</h2>
<a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;chfield=bug_status&amp;chfieldfrom=2002%2F12%2F16&amp;chfieldto=2003%2F01%2F07&amp;product=JDT&amp;component=UI&amp;cmdtype=doit&amp;&amp;order=Bug+Number">Click
here</a> to see PRs which have been marked as RESOLVED or CLOSED between
between 2002/12/16 and 2003/01/07
<br>&nbsp;
<h1>
Eclipse Platform Build Notes<br>
Java Development Tooling UI</h1>
Eclipse Build Input December 16<sup>th</sup> 2002
<h2>
What's new in this drop</h2>

<ul>
<li>
    <br>
</li>
</ul>

<h2>
Problem Reports</h2>
<a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;chfield=bug_status&amp;chfieldfrom=2002%2F12%2F13&amp;chfieldto=2002%2F12%2F16&amp;product=JDT&amp;component=UI&amp;cmdtype=doit&amp;&amp;order=Bug+Number">Click
here</a> to see PRs which have been marked as RESOLVED or CLOSED between
between 2002/12/13 and 2002/12/16
<br>&nbsp;
<h1>
Eclipse Platform Build Notes<br>
Java Development Tooling UI</h1>
Eclipse Build Input December 13<sup>th</sup> 2002
<h2>
What's new in this drop</h2>

<ul>
<li>
Hovers in overview ruler</li>
</ul>

<h2>
Problem Reports</h2>
<a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;chfield=bug_status&amp;chfieldfrom=2002%2F12%2F10&amp;chfieldto=2002%2F12%2F13&amp;product=JDT&amp;component=UI&amp;cmdtype=doit&amp;&amp;order=Bug+Number">Click
here</a> to see PRs which have been marked as RESOLVED or CLOSED between
between 2002/11/27 and 2002/12/13
<br>&nbsp;
<h1>
Eclipse Platform Build Notes<br>
Java Development Tooling UI</h1>
Eclipse Build Input December 10<sup>th</sup> 2002
<h2>
What's new in this drop</h2>

<ul>
<li>
New lightweight refactoring user interface implemented. It is enabled per
default, but if you expierence any problems you can disable the new UI
and switch back to the old wizard based UI using the preferences Java-&gt;Refactoring-&gt;User
Interface mode.</li>

<li>
Package Explorer now retargets action Navigate-&gt;Go To-&gt;Resource.</li>
</ul>

<h2>
Problem Reports</h2>
<a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;chfield=bug_status&amp;chfieldfrom=2002%2F11%2F27&amp;chfieldto=2002%2F12%2F10&amp;product=JDT&amp;component=UI&amp;cmdtype=doit&amp;&amp;order=Bug+Number">Click
here</a> to see PRs which have been marked as RESOLVED or CLOSED between
between 2002/11/27 and 2002/12/10
<br>&nbsp;
<h1>
Eclipse Platform Build Notes&nbsp;<br>
Java Development Tooling UI</h1>
Eclipse Build Input December 3<sup>rd</sup> 2002
<h2>
What's new in this drop</h2>

<ul>
<ul>
<li>
Added automatic closing of braces to Java editor (can be turned off in
behaviour tab of Java editor preference page)</li>
</ul>
</ul>

<h2>
Problem Reports</h2>
<a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;chfield=bug_status&amp;chfieldfrom=2002%2F12%2F03&amp;chfieldto=2002%2F12%2F10&amp;product=JDT&amp;component=UI&amp;cmdtype=doit&amp;&amp;order=Bug+Number">Click
here</a> to see PRs which have been marked as RESOLVED or CLOSED between
between 2002/12/03 and 2002/12/10
<br>&nbsp;
<h1>
Eclipse Platform Build Notes&nbsp;<br>
Java Development Tooling UI</h1>
Eclipse Build Input November 26<sup>th</sup> 2002
<h2>
What's new in this drop</h2>

<ul>
<li>
outline of compilation unit in a content assist like lightweight window
available inside the editor:</li>

<ul>
<li>
<i>Show Outline</i> (Ctrl+O) shows the outline for the editor's input</li>

<li>
<i>Open Structure</i> (Ctrl+F3) shows the outline for the element at caret
position</li>
</ul>
</ul>

<h2>
Problem Reports</h2>
<a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;chfield=bug_status&amp;chfieldfrom=2002%2F11%2F19&amp;chfieldto=2002%2F11%2F26&amp;product=JDT&amp;component=UI&amp;cmdtype=doit&amp;&amp;order=Bug+Number">Click
here</a> to see PRs which have been marked as RESOLVED or CLOSED between
between 2002/11/19 and 2002/11/26
<br>&nbsp;
<h1>
Eclipse Platform Build Notes&nbsp;<br>
Java Development Tooling UI</h1>
Eclipse Build Input November 19<sup>th</sup> 2002
<h2>
What's new in this drop</h2>

<h2>
Problem Reports</h2>
<a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;chfield=bug_status&amp;chfieldfrom=2002%2F11%2F16&amp;chfieldto=2002%2F11%2F19&amp;product=JDT&amp;component=UI&amp;cmdtype=doit&amp;&amp;order=Bug+Number">Click
here</a> to see PRs which have been marked as RESOLVED or CLOSED between
between 2002/11/16 and 2002/11/19
<h1>
Eclipse Platform Build Notes&nbsp;<br>
Java Development Tooling UI</h1>
Eclipse Build Input November 12<sup>th</sup> 2002
<h2>
What's new in this drop</h2>

<ul>
<li>
JUnit 3.8.1 support.</li>

<li>
Overloaded F2 key to make a text hover sticky in the Java editor.</li>

<li>
Added smart pasting for correct indentation in Java source code. The feature
can be turned off in the Java Editor behavior preferences.</li>

<li>
Java Editor hover configuration now allows to configure default hovers.</li>

<br><i>Note: Existing current hover preferences in an old/existing workspace
will be reset to default.</i></ul>

<h2>
Problem Reports</h2>
<a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;chfield=bug_status&amp;chfieldfrom=2002%2F11%2F05&amp;chfieldto=2002%2F11%2F12&amp;product=JDT&amp;component=UI&amp;cmdtype=doit&amp;&amp;order=Bug+Number">Click
here</a> to see PRs which have been marked as RESOLVED or CLOSED between
between 2002/11/05 and 2002/11/12
<h1>
Eclipse Platform Build Notes&nbsp;<br>
Java Development Tooling UI</h1>
Eclipse Build Input November 06<sup>th</sup> 2002
<h2>
What's new in this drop</h2>

<ul>
<li>
Added link-like navigation for declarations to Java editor. While the Control
key is pressed, text over which the mouse hovers and which have a declaration
turn into links which can be clicked. The link color can be changed on
the Java Editor Appearance Preference page.</li>

<li>
Applied patch submitted by Scott Rutledge to go into top level type in
Java outliner.</li>

<li>
Added new view menu option in the Package Explorer called "Layout" which
allows to switch between "Flat" and "Hierarchical" (default is flat). The
"Hierarchical" layout displays the package structure in a tree. There is
also a preference (Java -&gt; Appearance)</li>

<br>which allows to set if empty package fragments are folded together
when in hierarchical view (default is folded).
<li>
<i>Work in progress:</i> Java Editor hovers can now be configured per modifier
(Window -&gt; Preferences -&gt; Java -&gt; Editor -&gt; Hovers). The enable/disable
button in the workbench toolbar affects all configured hovers.</li>

<li>
Applied patch submitted by Sebastian Davids. It adds the new template variable
${year}.</li>

<li>
Added a new refactoring, Inline Constant. This refactoring operates on
multiple compilation files, and lets the user automatically replace references
to a static final field with expressions equivalent to the field's initializer
(provided the static final field is not blank). The action can be invoked
when a reference to, or declaration of, such a constant is selected, either
in the editor, or in an outline. The user can choose to only inline the
selected reference (if a reference is selected), inline all references
(anywhere in the workspace), or inline only some references, selecting
only the desired changes from the preview page. If all references are to
be replaced, the user can choose to have the constant declaration removed.
When the initializer expression refers to entities not visible from a particular
inline site, the initializer will be adapted to that inline site by qualifying
the names of some of the entities (by prepending multiple levels of enclosing
class names). If the initializer refers to non-static or non-final fields,
the user will be unobtrusively warned.</li>
</ul>

<h2>
Problem Reports</h2>
<a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;chfield=bug_status&amp;chfieldfrom=2002%2F10%2F31&amp;chfieldto=2002%2F11%2F05&amp;product=JDT&amp;component=UI&amp;cmdtype=doit&amp;&amp;order=Bug+Number">Click
here</a> to see PRs which have been marked as RESOLVED or CLOSED between
between 2002/10/31 and 2002/11/05
<h1>
Eclipse Platform Build Notes&nbsp;<br>
Java Development Tooling UI</h1>
Eclipse Build Input October 29<sup>th</sup> 2002
<h2>
What's new in this drop</h2>

<ul>
<li>
Added new 'Promote Local Variable to Field' refactoring - to perform, select
a local variable in the editor and choose 'Promote Local Variable to Field'.
You can then select the field's visibility and other modifiers (if applicable).
If the variable is initialized on creation, then the refactoring allows
moving the initialization to the class' constructors or the new field's
declaration.</li>

<li>
Added new 'Convert Anonymous Class to Nested Class' refactoring - to perform,
select an anonymous class delcaration and choose 'Convert Anonymous to
Inner'. You can then choose a name and visibility for the new class. The
refactoring then also passes accessed local variables to the new class
via added constructor variables. This refactoring is useful for instance
when you realize that your inner class has grown too big to be anonymous.
Btw, you can then (if it ever grows even more or proves to be more generally
useful) move it to top level by using the 'Move Nested to Top Level' refactoring.</li>

<li>
Added new shortcut to Java Editor: "Open Declaration" can now be triggered
with Ctrl-Left Mouse Button as well.</li>

<li>
Added first batch of Mac OS X keybindings.</li>

<li>
A new icon is used for an empty package that contains resources.</li>

<li>
New property page on Java projects to define project specific compiler
settings.</li>

<li>
New UI to define special tasks tag. Task tags can be used in comments and
the compiler will generate a marker when detected. Example usage of a task
tag is 'TODO' to mark code that has to be revisited.</li>

<li>
Added name guessing for the Extract Constant refactoring.</li>

<li>
JUnit: added support to find and navigate to tests that reference a particular
type or method. The action is in "Navigate&gt;Go To&gt;Referring Tests".</li>
</ul>

<h2>
Problem Reports</h2>
<a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;chfield=bug_status&amp;chfieldfrom=2002%2F10%2F22&amp;chfieldto=2002%2F10%2F29&amp;product=JDT&amp;component=UI&amp;cmdtype=doit&amp;&amp;order=Bug+Number">Click
here</a> to see PRs which have been marked as RESOLVED or CLOSED between
between 2002/10/22 and 2002/10/29
<h1>
Eclipse Platform Build Notes&nbsp;<br>
Java Development Tooling UI</h1>
Eclipse Build Input October 16<sup>th</sup> 2002
<h2>
What's new in this drop</h2>

<ul>
<li>
Added "Goto Matching Bracket" action to Java editor (Ctrl+Shift+P)</li>
</ul>

<h2>
Problem Reports</h2>
<a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;chfield=bug_status&amp;chfieldfrom=2002%2F10%2F09&amp;chfieldto=2002%2F10%2F16&amp;product=JDT&amp;component=UI&amp;cmdtype=doit&amp;&amp;order=Bug+Number">Click
here</a> to see PRs which have been marked as RESOLVED or CLOSED between
between 2002/10/09 and 2002/10/16
<p>Eclipse Build Input October 9<sup>th</sup> 2002
</p><h2>
What's new in this drop</h2>

<ul>
<li>
Added "Edit Working Set..." to JDT view menus</li>

<li>
Inline Method - new refactoring. To activate the refactoring, select a
method invocation in a compilation unit editor and select <i>Inline Method</i>
from the refactoring menu. Alternatively, select a method declaration in
the editor.</li>

<br>You can choose between inlining only the selected method call or inlining
all calls (in which case you can also delete the method).
<br>Note that currently no checking is done if method to be inlined is
reimplemented in subclasses.
<li>
Change Signature refactoring: Modify Parameters refactoring has been enhanced
to add and remove parameters. Also, the parameter types and the method
return type can be changed. The declaration of the method, declarations
of methods overriding/implementing it and all invocations are updated accordingly.</li>

<br>Currently, to change the method's name Rename refactoring should be
used. This will change in a future release - Change Signature will allow
renaming the method too.
<br>To activate - select a method or constructor and choose <i>Change Signature..</i>
from the <i>Refactor</i> menu.
<li>
Use Supertype Where Possible refactoring: new refactoring that replaces
usages of a type with one of its supertypes.</li>

<br>It computes the largest set of references that can be updated.
<br>To activate, select a type and choose <i>Use Supertype Where Possible...</i>.
<li>
Extract Constant refactoring: new refactoring to create a constant (a static
final field) out of a selected expression. To activate, select an expression
in the editor and choose <i>Extract Constant</i> from the context or global
<i>Refactor</i>
menu. You can replace all matching or only the selected expression.</li>

<li>
New Quick fixes</li>

<ul>
<li>
Fix usage of non visible methods/ fields, types and imports</li>

<li>
Fix access of instance variables in static contexts</li>

<li>
Fix for abstract methods in non-abstact types</li>

<li>
Fix type has unimplemented abstract methods</li>

<li>
Fix to add additional catch clauses for uncaught exceptions</li>
</ul>

<li>
New API class: <tt>IClasspathContainerPageExtension</tt>: Classpath container
pages that implement <tt>IClasspathContainerPage</tt> can optionally implement
<tt>IClasspathContainerPageExtension</tt>
to get additional information about the context when the page is opened.</li>

<li>
JUnit Plugin Tests (not part of the SDK, but available as an optional plugin).
The launching was changed to be more compatible with PDE. This avoids plugin
version conflicts and supports running tests with references to external
plug-ins (not all referenced plugins have to be available as binary projects).</li>
</ul>

<h2>
Problem Reports</h2>
<a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;chfield=bug_status&amp;chfieldfrom=2002%2F10%2F01&amp;chfieldto=2002%2F10%2F08&amp;product=JDT&amp;component=UI&amp;cmdtype=doit&amp;&amp;order=Bug+Number">Click
here</a> to see PRs which have been marked as RESOLVED or CLOSED between
between 2002/10/01 and 2002/10/08
<p>Eclipse Build Input October 1<sup>st</sup> 2002
</p><h2>
Problem Reports</h2>
<a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;chfield=bug_status&amp;chfieldfrom=2002%2F09%2F24&amp;chfieldto=2002%2F10%2F01&amp;product=JDT&amp;component=UI&amp;cmdtype=doit&amp;&amp;order=Bug+Number">Click
here</a> to see PRs which have been marked as RESOLVED or CLOSED between
between 2002/09/24 and 2002/10/01
<p>Eclipse Build Input September 24<sup>th</sup> 2002
</p><h2>
What's new in this drop</h2>

<ul>
<li>
JUnit launch configuration - support for creating a config that runs all
tests inside a package, source folder or projects.</li>

<li>
Different icon for empty package</li>
</ul>

<h2>
Problem Reports</h2>
<a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;chfield=bug_status&amp;chfieldfrom=2002%2F09%2F18&amp;chfieldto=2002%2F09%2F24&amp;product=JDT&amp;component=UI&amp;cmdtype=doit&amp;&amp;order=Bug+Number">Click
here</a> to see PRs which have been marked as RESOLVED or CLOSED between
between 2002/09/18 and 2002/09/24
<br>Eclipse Build Input September 17<sup>th</sup> 2002
<h2>
What's new in this drop</h2>

<ul>
<li>
Added Behavior tab to Java Editor Preference Page for smart insertion/skipping
of parenthesis and brackets, smart wrapping of strings</li>

<li>
Compiler preference page contains new options; new tab created</li>

<ul>
<li>
Task markers: Compiler generates markers when special keywords are detected</li>

<li>
Deprecated in deprecated: Select if the usage of deprecated API&nbsp; is
shown if the method is already deprecated.</li>
</ul>

<li>
New preference page to specify the sort order of members in Java views</li>

<li>
<b>Move to Previous/Next Member</b> - use Ctrl+Shift+Down/Ctrl+Shift+Up
to quickly navigate between methods, types, fields and initializers</li>

<br>The action is also available from the <i>Edit</i> menu
<li>
<b>Extract Interface</b> refactoring - creates a new interface with a set
of method and makes the selected class implement the interface.</li>

<br>Also, an option is provided to change references to the class into
references to the new interface (where possible).
<br>The refactoring can be activated by selecting a class and choosing
the appropriate entry from the context or global <i>Refactor</i> menu.
<li>
<b>Move Inner Class to Top Level</b> refactoring - select an inner class
and choose the appropriate action from</li>

<br>the context or or global <i>Refactor</i> menu. A new compilation unit
will be created and the inner class will be moved to that compilation unit.
<br>Where necessary, references will be updated. If the class is not static,
then a field is created to access the enclosing instance.</ul>

<h2>
Problem Reports</h2>
<a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;chfield=bug_status&amp;chfieldfrom=2002%2F09%2F11&amp;chfieldto=2002%2F09%2F17&amp;product=JDT&amp;component=UI&amp;cmdtype=doit&amp;&amp;order=Bug+Number">Click
here</a> to see PRs which have been marked as RESOLVED or CLOSED between
between 2002/09/11 and 2002/09/17
<p>Eclipse Build Input September 10<sup>th</sup> 2002
</p><h2>
What's new in this drop</h2>

<h2>
Problem Reports</h2>
<a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;chfield=bug_status&amp;chfieldfrom=2002%2F09%2F04&amp;chfieldto=2002%2F09%2F10&amp;product=JDT&amp;component=UI&amp;cmdtype=doit&amp;&amp;order=Bug+Number">Click
here</a> to see PRs which have been marked as RESOLVED or CLOSED between
between 2002/09/04 and 2002/09/10
<p>Eclipse Build Input September 3<sup>rd</sup> 2002
</p><h2>
What's new in this drop</h2>

<h2>
Problem Reports</h2>
<a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;chfield=bug_status&amp;chfieldfrom=2002%2F08%2F28&amp;chfieldto=2002%2F09%2F03&amp;product=JDT&amp;component=UI&amp;cmdtype=doit&amp;&amp;order=Bug+Number">Click
here</a> to see PRs which have been marked as RESOLVED or CLOSED between
between 2002/08/28 and 2002/09/03
<p>Eclipse Build Input August 27<sup>th</sup> 2002
</p><h2>
What's new in this drop</h2>

<h2>
Problem Reports</h2>
<a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;chfield=bug_status&amp;chfieldfrom=2002%2F08%2F21&amp;chfieldto=2002%2F08%2F27&amp;product=JDT&amp;component=UI&amp;cmdtype=doit&amp;&amp;order=Bug+Number">Click
here</a> to see PRs which have been marked as RESOLVED or CLOSED between
between 2002/08/21 and 2002/08/27
<p>Eclipse Build Input August 20<sup>th</sup> 2002
</p><h2>
What's new in this drop</h2>

<ul>
<li>
added feature to guess arguments in method completion</li>

<li>
added feature to wrap a selection with a template</li>
</ul>

<h2>
Problem Reports</h2>
<a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;chfield=bug_status&amp;chfieldfrom=2002%2F08%2F14&amp;chfieldto=2002%2F08%2F20&amp;product=JDT&amp;component=UI&amp;cmdtype=doit&amp;&amp;order=Bug+Number">Click
here</a> to see PRs which have been marked as RESOLVED or CLOSED between
between 2002/08/14 and 2002/08/20
<p>Eclipse Build Input August 13<sup>th</sup> 2002
</p><h2>
What's new in this drop</h2>

<h2>
Problem Reports</h2>
<a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;chfield=bug_status&amp;chfieldfrom=2002%2F08%2F07&amp;chfieldto=2002%2F08%2F13&amp;product=JDT&amp;component=UI&amp;cmdtype=doit&amp;&amp;order=Bug+Number">Click
here</a> to see PRs which have been marked as RESOLVED or CLOSED between
between 2002/08/07 and 2002/08/13
<p>Eclipse Build Input August 6<sup>th</sup> 2002
</p><h2>
What's new in this drop</h2>

<h2>
Problem Reports</h2>
<a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;chfield=bug_status&amp;chfieldfrom=2002%2F07%2F31&amp;chfieldto=2002%2F08%2F06&amp;product=JDT&amp;component=UI&amp;cmdtype=doit&amp;&amp;order=Bug+Number">Click
here</a> to see PRs which have been marked as RESOLVED or CLOSED between
between 2002/07/31 and 2002/08/06
<p>Eclipse Build Input July 30<sup>th</sup> 2002
</p><h2>
What's new in this drop</h2>

<h2>
Problem Reports</h2>
<a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;chfield=bug_status&amp;chfieldfrom=2002%2F07%2F24&amp;chfieldto=2002%2F07%2F30&amp;product=JDT&amp;component=UI&amp;cmdtype=doit&amp;&amp;order=Bug+Number">Click
here</a> to see PRs which have been marked as RESOLVED or CLOSED between
between 2002/07/24 and 2002/07/30
<p>Eclipse Build Input July 23<sup>rd</sup> 2002
</p><h2>
What's new in this drop</h2>

<ul>
<li>
Removed all 2.0 build notes. They can be found in <a href="buildnotes_jdt-ui_2_0.html">buildnotes_jdt-ui_2_0.html</a></li>
</ul>

<h2>
Problem Reports</h2>
<a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;chfield=bug_status&amp;chfieldfrom=2002%2F06%2F29&amp;chfieldto=2002%2F07%2F23&amp;product=JDT&amp;component=UI&amp;cmdtype=doit&amp;&amp;order=Bug+Number">Click
here</a> to see PRs which have been marked as RESOLVED or CLOSED between
between 2002/06/29 and 2002/07/23
<br>&nbsp;
<p><a href="hglegal2003.htm"><img src="ngibmcpy2003.gif" alt="Copyright IBM Corporation and others 2000, 2003." border="0" height="14" width="324"></a>
<br>&nbsp;
<br>&nbsp;
<br>&nbsp;
<br>&nbsp;
</p></body></html>
