<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML><HEAD><TITLE>Release Notes for NetBeans IDE 3.1</TITLE>
<META http-equiv=Content-Type content="text/html; charset=iso-8859-1"><!--revised 20 July 2000-->
<META content="MSHTML 5.50.4134.600" name=GENERATOR>
<META NAME="description" CONTENT="Release Notes for NetBeans IDE 3.1">
<link rel="stylesheet" type="text/css" href="../../../netbeans.css"></HEAD>
<BODY>
<CENTER>
<h1>Release Notes</h1>
<H3>NetBeans IDE 3.1</H3></CENTER>
<P>
<H2>Contents</H2>
<UL>
  <LI><A href="#features">New Features</A>
  <ul>
  <LI><A href="#ant">Ant Integration Module</A>
  <LI><A href="#script">Scripting Module</A>
  <LI><A href="#xcompiler">Cross-Directory Compiler</A>
  <LI><A href="#form">Form Editor Enhancements</A>
  <LI><A href="#editor">Source Editor Enhancements</A>
  <LI><A href="#cvs">CVS Module Enhancements</A>
  <LI><A href="#jsp">JSP Module Enhancements</A>
  <LI><A href="#i18n">I18n Module Enhancements</A>
  <LI><A href="#properties">Properties Module Enhancements</A>
  <LI><A href="#other">Other Changes</A>
  </ul>
</UL>

<A name=features><H2>New Features</H2></A>
<p>This release incorporates many new features since the NetBeans IDE
3.0 release.</p>

<A name=ant><h3>Ant Integration Module</h3></a>
 <blockquote><p>This module
  makes it very convenient to work with ant buildfiles inside the IDE.
  You can easily and visually create and edit the buildfile and run the
  build.  Using this module, you can even build the whole
  NetBeans IDE from within itself.</p>
  <p>Ant is a Java-based build tool,
  developed by the Jakarta project - see <a href="http://jakarta.apache.org/">http://jakarta.apache.org/</a>.
  Jayme Edwards contributed this module.</p></blockquote>
<a name=script><h3>Scripting Module</h3></a>
 <blockquote>
 <p>Using the scripting module, you can run code written in scripting languages
  directly inside the IDE.  This module is designed in a way that
  allows for plugging in a new scripting engine with very little
  effort.  Several scripting engines with licenses compatible with the Sun
  Public License will be bundled with the IDE.</p></blockquote>

<a name=xcompiler><h3>Cross-Directory Compiler</h3></a>
<blockquote>
<p>A cross-directory compiling functionality has been merged into the Java module to allow you to
direct the compiler to send <code>.class</code> files to a different directory than the source
(replicates javac's -d option).</p>
</blockquote>


<a name=form><h3>Form Editor Enhancements</h3>
<ul><li>Opening a form in non-visual mode. Now it is possible to open only the java
  file without the Form Editor. This feature was requested to enable making changes
  only in non-GUI Java code and prevent needless changes in
  regenerated GUI code (thus avoiding confusing the user and version control
  systems).</li>
  <li>Property editors for JList and JComboBox. These editors allow easy
  editing of content of JList and JComboBox components directly in form
  editor, without writing any code.</li>
<li>The most important and frequently-used properties ("preferred" in the JavaBeans spec)
are now accessible on a new tab in the Component Inspector. You no longer need to go through a
long list of rarely-used properties to find the common properties you want to set.</li>
<li>Many bugs have been fixed, including bugs that inhibited use of some features
(for example, using JSplitPane, JInternalFrame or JTable, installing beans, using events
and event handlers, using Form Connection property editor etc.).</li></ul>

<A name=editor><H3>Source Editor Enhancements</H3></A>
  <UL>
    <LI>HTML and JSP code completion.
    <LI>New Java indentation engine.</LI></UL>


<A name=cvs><H3>CVS Module Enhancements</H3></A>
  <UL>
    <li>Revision Explorer added to make it easier to work with different versions of one
file (diff, merges, open old version, version info).
<LI>New wizard and customizer, added action CVS settings which opens up the
    Customizer.
    <LI>New Import And Checkout command added for convenience.
    <LI>It is now possible to turn on input of additional options to all CVS
    commands by setting "Ask for advanced options" property of the filesystem.
    <LI>Internal caching changed to download files statuses asynchronously,
    which will speedup working with the filesystem and resolve compilation
    problems.
    <LI>Faster refresh after relative mount point change.
    <LI>Export command added.
    <LI>Files get status [Locally Modified] when saved.
    <LI>Commit reasons recorded in a file that contains template from
    rcsinfo.</LI></UL>

<A name=JSP><H3>JSP Module Enhancements</H3></A>
  <UL>
    <LI>Version 1.1 of the JSP specification and 2.2 of the Servlet
    specification now supported, enabling richer syntax and features such as
    support for JSP tag libraries and XML-based configuration files.
    <LI>Jakarta Tomcat is now used for compiling and running JSPs.
    <LI>The JSP editor has code completion (for HTML, JSP code, and Java code).
    <LI>New Content language, Scripting language, and Encoding properties.
    <LI>JSP execution properties have been redesigned (most have disappeared
    since XML-based deployment descriptors are now used).
    <LI>In Tools | Options | JSP, the user interface for setting web
    browsers has changed.
    <LI>In Tools | Options | JSP, new switches for compiling error pages
    and pages referenced by &lt;jsp:include&gt; and
  &lt;jsp:forward&gt;.</LI></UL>


<A name=i18n><H3>I18N Module Enhancements</H3></A>

  <ul>
    <li>the user can customize code which the IDE generates to replace the
        string literals in java source code
  </ul>

<A name=properties><H3>Properties Module Enhancements</H3></A>Properties module:
In table view of bundles:
- Highlighted keys and values of properties according it's editor settings.
- Shadowed value cell for not existing property in the specified locale column.
- Undo/Redo on table view.
- Search capability in editor-like way on table. (Working on keystrokes Ctrl-F, F3, Shift-3,
Alt-Shift-H).

<A name=other>
  <H3>Other Changes</H3></A>
  <UL>
<li>Convert To Text command available on the contextual menu for objects with no extension or no
extension recognized by the IDE, thus allowing text editing of these files in the IDE.</li>
<LI>Menus rearranged and many items renamed; mnemonics added.
    <LI>When creating a Java class from the New From Templates wizard, you can
    customize the superclass and interfaces, override inherited methods, and add new fields.
    <li>An Override Methods command is available on the contextual menu for class nodes.
    <LI>File | Add Filesystem menu item and dialog box added.
    <LI>The JavaHelp viewer now uses the standard viewer implementation, which
    enables printing of help pages.
    <LI>Welcome screen added.
    <LI>Variables tab added to the Debugger Window - shows local/instance/static
    variables for current thread. </LI>
    <LI>New keyboard shortcuts added and the shortcut for
Execute changed to F6.
<li>Renaming a package causes the ide to prompt user whether it should
update package statements in sources in that package</li>
<li>Improvements in code generation (better indentation) and
thread safety</li>
<li> Performance improvements in the parser engine.</li>
<li>Improvements in Java connection detection and firing
events.</li>
    <LI>Improved Copy-Cut/Paste behavior on both Java Elements and Java files.
    <li>The user interface for the Auto Comment Tool has been changed
    to make it easier to edit Javadoc comments (contributed by Mauro Botelho).
    <LI>Explorer notices class &lt;-&gt; interface change in the source text
    (the node was not updated in CE1).
    <LI>Interface synchronization is triggered by changes done in Explorer,
    customizers, or Open API calls from other modules.
    <LI>The popup menu item Generate BeanInfo is now called BeanInfo Editor.
    <LI>The BeanInfo editor now also generates method descriptors (in addition
    to the already existing descriptors for properties and event sources).
    <LI>If you check the option Generate Firing Methods in New Event Source and
    then you decide to delete the event source, a modal dialog appears asking
    you whether to delete the firing methods.
    <LI>Images reloaded when changed externally.
    <LI>Created group objects can be saved as templates (fixed bug).
    <LI>URL can be set when creating web bookmarks (bug fix). </LI></UL>



</body>
</html>
