# What's new in JBuilder 2005

JBuilder 2005 contains changes in the following areas:

- IDE usability improvements
- Code productivity
- Build system
- Archiving and deployment
- Web services
- Project management
- Editor enhancements
- Running and debugging
- Team development
- Web development
- Mobile development
- Online help
- J2EE/EJB development
- Visual designer
- XML

## Fortify Software for Borland JBuilder

Fortify Software for Borland JBuilder finds security vulnerabilities in your Java code so you can fix them quickly and easily. Powered by Fortify Software's unique source code security analyzer and secure coding rules for Java and J2EE, security flaws in your code can be located accurately and automatically.

## IDE usability improvements

There are many substantial usability enhancements in the IDE for this release of JBuilder. See the following topics for detailed information.

- IDE panes
- Menu improvements
- Preferences and project settings
- Object gallery wizards
- Import settings

### IDE panes

JBuilder's panes and toolbars offer greater flexibility and usefulness with many new features.

#### Project pane

The project pane includes improvements to the following areas:

- Classes tab — opens the class browser (View|Panes|Classes), where you can browse classes by way of their inheritance structure.
- Toolbar — includes the new Show Decorated Only button. Hides all unmodified, inactive, and read-only files.
- Tool tip — offers a multi-line tool tip that includes the full path and file name and the last modified date and file size in bytes.
- Decorations — appear on files modified in memory, workspace, and repository, as well as files not in the active project or repository, and on read-only files. These icons also appear on the content pane file tabs.
- Delete function — deletes package and directory trees in project and file browser panes. Right-click the item and choose Delete Directory. However, if a tree's open node can't be saved or closed or it includes an open project or project group, it won't allow deletion.

#### Files pane

Clicking the Files tab on the project pane opens the files pane, also known as the file browser. The file browser provides a Delete Directory menu option on the context menu, as well as a multi-line tool tip that includes the full path, file name, last modified date, and file size in bytes

#### Classes pane

The classes pane, also known as the class browser, displays child-parent relationships for any class or interface within the specific inheritance hierarchy. The classes pane is not enabled by default. To display the classes pane in the project pane area, choose View|Panes|Classes. You can also open it to a given file from the structure pane and file tab context menus.

The classes pane provides several toolbar buttons: Find Class, Select in Class Browser, Show Interfaces, and Select An Open Project To Work With. You can change either the class browser view or the content pane view by the following actions:

- Single-clicking on a class or interface in the class browser tree opens the associated file in the editor. The class browser view and the class target don't change.
- Double-clicking on a class or interface selects the class in the editor and makes it the target in the class browser.

#### Structure pane

The structure pane displays dual icons, one showing type, and the other, visibility. The default look and feel for Java structure pane icons is the Classic configuration, but you can also choose from Classic Updated, Geometric, and Letters (Tools|Preferences|Editor|Java Structure). The Classic Updated mainly shows differences for the base icons of static methods.

#### Content pane

The content pane includes comprehensive tool tips, help, and tab configuration.

- Tool tip — right click, then choose Properties to display the file name, path, modification, and size.
- Tab configuration — sets tab location horizontally, vertically on the right or left, in single or multiple rows; sets type and width, sorting, and inserting.
- Help — displays the embedded Help Viewer in the content pane (Tools|Preferences|Help). You can tear off the Help tab to move it to a new location.

#### Message pane

The message pane displays a useful toolbar, depending on the process showing results in the message pane, that includes the following:

- Copy — Copies selected or all of the output content.
- Clear All — Clears all of the output content.
- Search — Searches in the output.
- Search Again — Searches again in the output.
- Auto Scroll — Automatically scrolls down when user operations generate output.
- Word Wrap — Wraps the output by the words and pane size.

#### Workspace panes

Workspace panes (project, structure, content, message), are versatile and can be moved and configured to suit your work environment.

- Pane slide-out — the minimized pane slides-out automatically when you hover your cursor over it.
- Pane minimize/maximize — the undocked panes appear on the desktop taskbar and automatically minimize or maximize when you minimize or maximize the IDE.
- Project pane redocking — drag the project pane by its title bar to redock it to another location.
- Pane location — configures the undocked pane to appear on top (Tools|Preferences|Browser).

### Menu improvements

The menus have been substantially revised, in order to group the commands more coherently and to make them easier to find.

A new top-level menu has been added: the Enterprise menu provides ready access to enterprise-level configuration features such as server configuration and deployment, Cactus setup, and CORBA setup. The Wizards menu has been removed. Commands formerly on it are either in the object gallery (File| New) or added to one of the following menus: Edit, Enterprise, or Project.

The Edit menu includes a context-sensitive Wizards menu for quick access to many of JBuilder's wizards when you are working in Java files. You can also use the keyboard shortcut, `Ctrl+Shift+W` to access a context-sensitive Wizards pop-up menu in the editor.

### Preferences and project settings

> Preferences and project settings vary by JBuilder edition

You can set all your standard preferences in the Preferences dialog box (Tools|Preferences). The Project Properties dialog box (Project|Project Properties), and the Default Project Properties dialog box (Project|Default Project Properties), also contain the following tabs.

- The Global tab allows you to customize the IDE.
- The Project tab allows you to set properties for the active project.

The Global tab provides the following new customizing options for the IDE.

- Browser Page — includes options for customizing pane locations, keeping the undocked workspace pane on top, and choosing the number of file backups to retain.
- Content Pane page — contains choices to automatically close the least recently viewed files and to limit the number of open files per project.
- Status Bar page — contains settings for heap memory reporting and status timeout.
- Fonts page — contains font options for the browser, editor, and message output pane.
- Keymaps page — provides options for importing, exporting, editing, copying, renaming, removing, and making a new keymap.
- Actions page — activates text drag and drop, formats code when pasting, generates closing curly braces, as well as specifies the actions for saving, searching, and "Smart" key behavior (`Tab`, `Enter`, `Home`, `End`).
- Color page — includes a new JSP tab for customizing JSP screen elements and new screen elements to customize for Java and HTML.
- TagInsight page — provides automatic tag completion options for HTML, XML, and JSP tags.
- Java, HTML, JSF, and Common Templates pages — offer options to restore original template settings.
- Java Structure page — provides different styles for Java structure pane icons.
- Markup Editing — specifies editing options for markup languages.
- Markup Formatting — specifies formatting options for markup languages.
- Help — enables an embedded or standalone Help Viewer and enables Dynamic Help that provides task-oriented information.

The Project tab provides the following settings for the active project.

- Basic Formatting page — general settings for indentation and end of line characters.
- Java Formatting page — sets numerous formatting options specifically for Java files.
- Decorations page — enables decoration icons for a variety of files and file states. The icons appear in the project pane and on the content pane file tabs.
- File Information page — provides information about the file name, type, location, size, modified status, and attributes.
- Code Audits page — enables code auditing for performance, style, documentation, design flaws, content, expressions, and branches and loops.

### Object gallery wizards

> Wizards vary by JBuilder edition.

Many wizards previously on the Wizards menu have been added to the object gallery. Choose File|New to open the object gallery and explore the variety of wizards.

### Import settings

You can now import user-specific settings and libraries from JBuilder 9 or JBuilder X to your JBuilder 2005 installation during the install process. Some of the settings you can import include keymaps, color schemes, file types, workspaces, fonts, histories, and code templates.

During installation, you will have the choice to import settings from your previous JBuilder version. Or, if you don't want to import settings during installation, you can access the Import Settings wizard (Tools|Import Settings), later and choose to import the settings and libraries then.

## Code productivity

JBuilder increased code productivity with new additions to many coding features.

- Searching
- Keymaps
- MemberInsight/Smart MemberInsight
- Code templates
- Code folding
- ErrorInsight
- Garbage collection
- Incremental compiling
- Javadoc
- Refactoring

### Searching

The Find In Path and Replace In Path dialog boxes (Search|Find/Replace In Path), support regular expressions in the search string and display the tabulated search results in table format in the message pane. The search results in the message pane provide toolbar buttons for saving, suspending, resuming the search, navigating between results, removing a file from the results table, and canceling the Find In Path action. The Save command saves the search results as an HTML file.

Find In Path offers parallel searching. Moreover, each search is controlled individually. After you begin one search, you can start, stop, or resume another search before the prior search has completed.

The Search|Find menu command provides searching in selected text (including block selections), selected files, from the start of files, or match the whole word.

### Keymaps

Keymapping (Tools|Preferences|Keymaps), now includes importing, exporting, saving, renaming, removing, copying, and creating new keymaps.

- Copy — allows you to copy an existing keymap so you can edit your new copy without changing the original keymap.
- New — allows you to create a new keymap that only includes the most basic and common keystrokes shared by all of the keymapping editors.
- Import — opens Import Keymap Settings dialog box where you can browse to your keymap file. When you click OK, the file is saved as a `.keymap` file to a keymaps folder in the user's home directory.
- Save As — opens a dialog box where you can save the keymap settings as a reference text file or you can export the keymap settings as keymap file.

The Keymap Editor (Tools|Preferences|Keymaps|Edit button), has a new look to it and contains an enhanced selection of keymap actions for key binding. The keymap actions are displayed in a tree/directory format. Open each directory to view the associated actions within the directory. You can choose to change, remove, add, or find, and view a description of each action in the Description text field.

### MemberInsight/Smart MemberInsight

CodeInsight provides support for Java keywords. When you access MemberInsight (press `Ctrl+H`) when working in the editor, matching Java keywords are included in the pop-up list of methods and variables.

Smart MemberInsight makes it easier to find applicable methods and variables from the current source code context. Smart MemberInsight analyzes the expected return type of the code expression (following a return or assignment statement), and displays and highlights the results in a pop-up window.

Invoke MemberInsight or Smart MemberInsight from the Edit menu (Edit|CodeInsight), from a keystroke (a period, `.`), or from a key binding (`Ctrl+H`). You can toggle between the two windows by invoking the MemberInsight action again while the pop-up window is visible. Use `Ctrl+H` (CUA keymap) to toggle the between the windows.

If the Smart MemberInsight pop-up window is empty, Smart MemberInsight populates the window by automatically switching to MemberInsight. Smart MemberInsight also includes type cast choices in the list of code completion selections.

### Code templates

> This is a feature of JBuilder Developer and Enterprise

Code templates now include JSF templates, as well as Java and HTML templates. Open the individual templates pages in the Preferences dialog box (Tools|Preferences|Editor|Templates), to investigate all of the available new template options, such as the `sup` template, that adds a call to the super method.

### Code folding

> Code folding features vary by JBuilder edition

Code folding now includes comment and markup language code folding. Also, code and comment folding now provides you with a quick-viewing tool tip. The code folding tool tip displays the full source code or comment when you move the mouse over the line of folded code.

You can now set a keyboard shortcut to fold code for easier navigation and code visualization in the Keymap Editor dialog box (Tools|Preferences|Keymaps). You can also access code folding options from the editor's gutter context menu.

### ErrorInsight

> ErrorInsight features vary by JBuilder edition

ErrorInsight now provides another way to fix the exception not caught code error. The "Add Catch Clause" is the option to use when your code already contains a try/catch clause, but does not include the specific exception handler.

ErrorInsight now includes menu options for invoking TagInsight for XML, HTML, JSP, and Struts. ErrorInsight is also available for asynchronous refactorings; refactorings where all code is not initially available. For more information, see "Using ErrorInsight for refactorings" in Building Applications with JBuilder.

### Garbage collection

To help your efficiency, you now can use a garbage collection tool. Click the garbage collection icon in the right corner of the status bar (located at the bottom right corner of the IDE) to invoke the action. When you hover the cursor over the icon, you'll see the tool tip, "Force Garbage Collection".

### Incremental compiling

If a file doesn't have any errors and its dependencies have been compiled, it's compiled automatically without having to manually build the file. The advantage to incremental compilation is that many features, such as CodeInsight, are available without having to compile the project. Note, however, that dependency files aren't updated. When you do manually build the file and/or project (Project|Make), the files that were incrementally compiled are rebuilt and the dependency files are updated.

### Javadoc

The following Javadoc features are new in JBuilder 2005:

- JBuilder now provides quick access to Javadoc documentation with Javadoc QuickHelp. Place your cursor on the code element and press `Ctrl+Q` or choose Edit|CodeInsight|Javadoc QuickHelp to display a pop-up window containing the related Javadoc documentation.
- Code folding has been implemented for Javadoc comments. Simply click the downward arrow in the left gutter of the editor adjacent to the Javadoc comment to fold the Javadoc text.
- The Javadoc wizard is now available from the Build page of the object gallery (File|New|Build). The wizard supports the new Javadoc tags implemented in JDK 5.0, `@literal` and `@code.` It also supports the `arg` argument for the `@value` tag. The wizard also let you exclude classes on the Test class path entry. (This is a feature of JBuilder Developer and Enterprise.)

For more information, see "Creating Javadoc from source files" in Building Applications with JBuilder.

### Refactoring

JBuilder 2005 includes many new refactoring features and commands.

In JBuilder 2005, The Refactor|Refactor command displays the refactorings that are available for the selected code. The refactorings displayed are the same as those on the Refactor context menu. When a code symbol is selected in the editor, you can now choose `Ctrl+Shift+R` to display the Refactor context menu. Additionally, when you refactor, the following items are now updated:

- Main class and related items in the runtime configuration (Run|Configuration).
- Main class, filters, and related items in the archive node.

#### Refactoring and use of local labels

All refactorings now support the use of local labels, allowing you to view differences between different versions of the same or renamed files, and to manage, merge, and revert file differences. To view local labels, use Project|Manage Local Labels. The type of refactoring performed on the file is displayed in the Name column of the Manage Local Labels dialog box.

For more information, see "Refactoring and local labels" in the "Refactoring code" chapter of Building Applications with JBuilder.

#### Delegate To Member wizard

Use the Delegate To Member wizard to create delegates for all selected methods. The delegates call the delegated member. Use the Edit|Delegate To Member command to display this wizard. For more information, see "Delegating to a member" in the "Refactoring code" chapter of Building Applications with JBuilder.

#### Inline Method command

You can now inline a method and place the body of a method into the body of its caller. The body of the method is deleted only if it is a private method and there are no other references to the method. The Inline Method refactoring is available from the Refactor context menu. For more information, see "Inlining a method" in the "Refactoring code" chapter of Building Applications with JBuilder.

#### Inline Variable command

You can also inline a variable to place the initialization expression of a variable into all the places where the variable is used. This refactoring is available from the Refactor context menu. For more information, see "Inlining a variable" in the "Refactoring code" chapter of Building Applications with JBuilder.

#### Distributed refactoring

JBuilder now records completed refactorings for the current project. You can add this history to the project archive, making the history available to other projects and libraries that were not available in the initial refactoring. You can use the history to easily update projects that depend on refactored external APIs, SDKs and libraries. This feature is called distributed refactoring.

To use distributed refactoring, you must first add the refactoring history to the depended-upon project or library's archive using the Refactoring History page of the Archive Builder. When you open that depended-upon project or library archive from the dependent project, you can then review all refactorings with the Refactoring History dialog box (Refactoring|Refactoring History). You can then use the Pending Refactorings page of the Distributed Refactorings dialog box (Refactoring|Distributed Refactorings|Pending Refactorings) to apply refactorings globally so that all files in the project are updated to the new code symbols. Use ErrorInsight to refactor any remaining instances of out-of-date code.

For more information, see "Distributed refactorings" in the "Refactoring code" chapter of Building Applications with JBuilder.

#### JDK 5.0 refactorings

JBuilder now supports JDK 5.0 refactorings that update code to use JDK 5.0 language features. The following refactorings for JDK 5.0 code are supported:

- Foreach refactorings — Foreach refactorings refactor existing loops to JDK 5.0-style enhanced loops. You can refactor the following types of loops:
  - Array traversal
  - List traversal
  - Iterator for loops
  - Iterator while loops
- Auto(un)boxing refactorings — The autoboxing and auto-unboxing features in the JDK 5.0 allow you to easily convert between primitive types and their Object-based counterparts.
- Generics refactoring — JDK 5.0 introduces the use of Generics. Generics add compile-time type safety to the Collections API and eliminate casting. In JDK 1.4 and below, an `Object` would need to be cast to the appropriate type before usage. With Generics, the need for casting is eliminated.

To invoke these refactorings, choose the code symbol in the editor, right-click and choose Refactoring|Introduce Foreach, Introduce Auto(un)boxing, or Introduce Generics. For more information, see "JDK 5.0 refactorings" in the "Refactoring code" chapter of Building Applications with JBuilder.

#### Deployment descriptor refactoring

> This is a feature of JBuilder Developer and Enterprise

You can rename refactor class names when working in a deployment descriptor file. To do this, right-click the name of the class you want to refactor, choose Refactor To Class, and enter the new class name. When you complete the refactoring, JBuilder will rename the class in all locations it is used and referred to. For more information, see "Deployment descriptor refactoring" in the "Refactoring code" chapter of Building Applications with JBuilder.

## Build system

Build system modifications include the following changes. For more information, see "Building Java programs" and "Compiling Java programs" in Building Applications with JBuilder.

### Compiling

Although JBuilder is hosted on JDK 1.4.2, Borland Make for Java (bmj) now uses the JDK 5.0 compiler to take advantage of some of the new language features available in JDK 5.0. Provided that the JDK 5.0 method libraries (`rt.jar`) are available to the compiler, you can compile code containing 5.0 language features for an earlier version of the JDK, such as JDK 1.4 or 1.3.

Also, if you specify javac as the compiler for the project on the Java page of the Project Properties dialog box, the new JDK 5.0 javac is used to compile. Switching compilers is a feature of JBuilder Developer and Enterprise.

To compile JDK 5.0 source code and take advantage of the new language features, you must download JDK 5.0 from Sun at `http://java.sun.com/j2se/5.0/` and make these changes to your project:

1. Use the Configure JDKs dialog box (Tools|Configure|JDKs) to configure JDK 5.0 in JBuilder. Click the Help button on this dialog box for more information.
2. Change the JDK for the project to JDK 5.0 on the Paths page of the Project Properties dialog box (Project|Project Properties|Paths).
3. Change the Language Features option to Java 2 JDK, v 5.0 (generics enabled) on the Java page of the Project Properties dialog box (Project|Project Properties|Build|Java).
4. Set the Target VM option to Java 2 SDK, V 5.0 And Later on the Java page.

#### Compiler options

The following changes for JDK 5.0 support have been made to the Java page of the Project Properties dialog box (Project|Project Properties|Build|Java):

- A new Language Features drop-down list has been added and contains these options:
  - Java 2 JDK, v 5.0 (generics enabled)
  - Java 2 JDK, v 1.4 (asserts enabled)
  - Java 2 JDK, v 1.3 and earlier (asserts disabled)
- The Enable Assert Keyword option has been removed. To use the `assert` keyword, select Java 2 JDK, v 5.0 (generics enabled) or Java 2 JDK, v1.4 (asserts enabled) from the Language Features drop-down list.
- The Target VM drop-down list has a new option — Java 2 JDK, 5.0 And Later. If you choose this option, compiled class files will run only on VMs in the Java 2 SDK, v 5.0 and later, but won't run on 1.1, 1.2, 1.3, or 1.4 VMs.

The Java page of the Project Properties dialog box has new compiler options that are related to the new language features provided by the JDK 5.0 compiler and new features added to JBuilder:

- Standard compiler options
  - Incremental Compilation — If a file doesn't have any errors and its dependencies have been compiled, it's compiled automatically without having to manually build the file. The advantage to incremental compilation is that many JBuilder features, such as CodeInsight, are available without having to compile the project.
- Extended compiler options
  - Show Unchecked Generics — The compiler validates generics and reports warnings for unchecked types.
  - Show Case Fallthroughs — Check switch blocks for fall-through cases and provide a warning message for any that are found. Fall-through cases are cases in a switch block, other than the last case in the block, whose code does not include a break statement, allowing code execution to "fall through" from that case to the next case.
  - Show Non-existing Paths — Warn about nonexistent path (classpath, sourcepath, etc) directories.
  - Show Missing Serial UID — Warn about missing serialVersionUID definitions on serializable classes.
  - Show Return Within Finally — Warn about finally clauses that cannot complete normally.

### Build wizards

The Wizards menu has been removed. The Ant wizard, Export To Ant wizard, and External Build Task wizard are still available on the Build page of the object gallery (File|New|Build).

#### External Build Task wizard

> This is a feature of JBuilder Developer and Enterprise

The External Build Task wizard (File|New|Build) has a new check box — Always Run When Building Project. This option is on by default. If you don't want to run an external build task each time you build the project, uncheck this option.

When this option is off, you can run the external build task at any time by right-clicking the node in the project pane and choosing Make. After exiting the wizard, you can change this option on the External Build Task Properties page. Right-click the external build task node in the project pane and choose Properties.

### Building project groups from the command line

> This is a feature of JBuilder Developer and Enterprise

You can now specify project groups, as well as projects, with JBuilder's -build option at the command line. The syntax is to specify the project group file, followed by an optional list of targets. Multiple project group files can be specified and can also be mixed with projects. If you specify a project group and a project that belongs to that project group, then that project will be built twice. Projects within the project group are built in the same order that they are built in the IDE.

When specifying targets for a project group, they are applied to all projects in the project group. If no target is specified, the default Make target is used.

In this example, rebuild is executed on all projects in `mypg.bpgr` and make is executed on `myproject.jpx`:

    jbuilder -build mypg.bpgr rebuild myproject.jpx

### Build page (Tools|Preferences)

The Build page has new options to provide more control over the build tab of the message pane.

- Close After Build With No Errors — closes the Build tab after the build completes if there aren't any errors. If there are warnings, the Build tab remains open.
- Close After Build With No Errors And Warnings — closes the Build tab in the message pane automatically after a build if there aren't any errors or warnings.
- Do Not Close After Build — the Build tab remains open after the build completes.

### Ant

The Ant version that ships with JBuilder has been updated to version 1.6.2.

#### Specify a different version of Ant

If you want to run a different version of Ant, you can specify it in the Ant Home field on the Ant page of the Project Properties dialog box (Project|Project Properties|Build|Ant) or the Default Project Properties dialog box (Project|Default Project Properties|Build|Ant). By default, the Ant home is `<jbuilder>/thirdparty/ant`. This allows you to use a different version of Ant than the version that ships with JBuilder.

#### Ant Help

Ant documentation is now available from the Help menu and the keyboard:

- Help|Reference Documentation|Ant Documentation — this command loads the Ant documentation for the Ant version specified in the Ant Home Directory field (Project|Project Properties|Build|Ant). If no project is open, the command displays Ant documentation for the version of Ant bundled with JBuilder.
- F1 help — position the cursor on an Ant element, such as the `javac` element, in an Ant build file and press `F1` for help. The Ant help that appears is for the version of Ant specified in the Ant Home Directory field (Project|Project Properties|Build|Ant).

#### Debug Ant

> This is a feature of JBuilder Developer and Enterprise

You can now debug Ant build files. For more information, see "Ant debugging."

#### Ant navigation and targets

You can now navigate within an Ant file by double-clicking a target node in the project pane. You can also right-click an Ant target node and select Open to navigate to it in the Ant build file.

You can also remove minor Ant targets from the project pane. Minor targets are targets without a description.

To remove minor Ant targets from the project pane,

1. Right-click the Ant build file in the project pane and choose Properties.
2. Choose Ant in the tree on the left.
3. Uncheck the Display Minor Targets option.
4. Click OK to close the Properties dialog box.

#### Macros and Ant property values

You can use macros in the value portion of an Ant property in the Add New Property dialog box. For example, you might want to use the JBuilder project's source path as the Ant src property.

To add a macro to an Ant property value,

1. Right-click the Ant build file in the project pane and choose Properties.
2. Choose Ant in the tree on the left.
3. Click the Add button next to the Properties list.
4. Position the cursor in the Value field where you want to insert the Macro and/or remove the existing value.
5. Click the Macro button in the Add New Property dialog box.
6. Choose a macro from the list. For example, choose `$Sourcepath` for the value for the `src` property.
7. Click OK to close the Add New Property dialog box.
8. Click OK to close the Properties dialog box.
9. Right-click the Ant build file in the project pane and choose Make to run Ant with the new property value.

### Importing and exporting package filters

> This is a feature of JBuilder Developer and Enterprise

You can now import and export package filters, which is useful if you want to share filters with others. If you're using a version control system, these filter files are checked in and pulled from the project's VCS if you save them to the project. Importing and exporting filters allows you to switch between different filters without having to manually add and remove them. If your filter has the same name as the project, then the package filter will automatically be applied when you open the project. For example, if your project is `myproject.jpx`, then you would name the filter `myproject.packagefilter`.

The Project menu has a new menu item called Manage Filters. Remove All Filters has been moved to this new menu group and two new commands have been added:

- Remove All Filters
- Import Filters
- Export Filters

## Archiving and deployment

The new archiving and deployment features in this field test include Archive Builder enhancements such as JAR signing,, refactoring, and obfuscation of JAR files.

The archive builder now has its own page in the object gallery. Find all of the archive builder wizards easily on the Archive page of the object gallery (File|New).

### Changes to existing steps

The Dependencies step displays dependencies as a table.

The Archive Contents step has a checkbox to Include All Classes And Resources.

### New Steps

#### Obfuscation

An additional step is added to the Archive Builder for archive types that can logically be obfuscated. Set your obfuscation parameters on this page, or choose not to obfuscate and proceed with the rest of the Archive Builder as usual. JBuilder includes RetroGuard in the installation, although obfuscators (such as Zelix KlassMaster) can be configured and used.

#### JAR signing

Archives can now be digitally signed. A new Signature step appears both in the Archive wizards and as one of the Archive node's property pages. You must create the keystore outside of JBuilder.

#### Refactoring

The Archive Builder now contains a step for including refactoring history. You can choose to exclude all refactorings, include only content-related refactorings, or include all refactorings.

## Web services

> This is a feature of JBuilder Enterprise

The following changes have been made to web services. For more information, see Developing Web Services.

### Web Services designer enhancements

The Web Services designer has had numerous performance, usability, and other functionality enhancements for a smoother design experience.

### Web Services wizards

There are four web services configuration wizards on the Web Services page of the object gallery (File|New). Each toolkit has two wizards — Web Services Server Configuration wizard and Web Services Client Configuration wizard. After you configure your project for web services, the Web Services designer is open in the content pane.

#### Server configuration

Use the Web Services Server Configuration wizard when you want full Web Services designer functionality for exporting and importing services.

#### Client configuration

Use the Web Services Client Configuration wizard when you only want to import services.

#### Module Chooser wizard

The Module Chooser wizard allows you to create or choose a web services module (client or server) when using these project pane context menus to export and import web services — Export As A Web Service and Import A Web Service. The Module Chooser wizard might also be launched when importing a WSDL from UDDI using the Web Services Explorer.

### Drag and drop and keyboard accessibility

Context menus have been added to the project pane for keyboard accessibility. In addition, to drag and drop you can now:

- Move focus to the project pane, select a JavaBean to export or a WSDL to import, press `Shift + F10` to access the context menu, and choose the appropriate menu command — Export As A Web Service or Import A Web Service.
- Right-click a JavaBean and choose Export As A Web Service.
- Right-click a WSDL and choose Import A Web Service.

When you use the context menus, if the project isn't configured for web services, the Module Chooser wizard launches, so you can choose a web services configuration.

### Enterprise refactoring

If you rename the exported Java class or a package using refactoring, the Web Services designer output in the WSDU file is also refactored.

### TCP Monitor

The TCP Monitor can now be run in the IDE as part of the server runtime configuration (Run|Configurations|New or Edit|Monitors). When the TCP Monitor is enabled in the runtime configuration, it appears on the server tab of the message pane.

### Web Services Interoperability (WS-I) testing tools

Develop and test your web services for Web Services Interoperability (WS-I) compliance. Download the testing tools from the WS-I web site at `http://www.ws-i.org/implementation.aspx` and configure the tools in JBuilder (Tools|Basic WS-I Profile|Configure).

#### WS-I Analyzer tool

To analyze a WSDL for WS-I compliance, right-click a WSDL in the project pane and choose WS-I Analyze. You can also run the tool standalone from the Tools menu ((Tools|Basic WS-I Profile|WS-I Analyze)

#### WS-I Monitor tool

Monitor the SOAP messages between the client and the web service. The WS-I Monitor generates a log which you can then analyze with the WS-I Analyzer. Enable the WS-I Monitor in the server runtime configuration (Run|Configurations|New or Edit|Monitors) or run it standalone (Tools|Basic WS-I Profile|WS-I Monitor). Then right-click the log file in the project pane and choose WS-I Analyze.

### Apache Axis toolkit

The Apache Axis toolkit has been updated to version 1.2.

Note: JBuilder 2005 is now using the JDK 5.0 compiler, so compiler warnings might be reported in the message pane. These warnings are to assist you in migrating to JDK 5.0 and have no affect on functionality. For example, you might get this warning, because `enum` is a keyword in JDK 5.0:

    "Bean1SoapBindingStub.java": as of release 5.0, 'enum' is a keyword,
          and may not be used as an identifier at line 29, column 39

#### Generated sources

When you build a web services project configured for Axis, the generated sources appear in the project pane in the Generated Sources node of the designer module. When you delete a service from the Web Services designer, the generated sources are also deleted.

#### Creating a local server implementation

The Server field of the WSDL services representation has been removed for Axis and the functionality is now available from a context menu command — Generate Local Server Implementation.

To create a local server implementation from a WSDL,

1. Configure the project for web services with one of the Axis web services server configuration wizards (File|New|Web Services). Note that client configurations don't support the generation of a local server implementation.
2. Import a WSDL into the Web Services designer.
3. Right-click the WSDL services representation in the Web Services designer and choose Generate Local Server Implementation. Server-side classes are generated for a local server implementation of the web service.
4. Implement the service and build the project to generate the WSDL and the client classes.

#### Add WSDL To Project On Build

There's a new option in the Module Settings dialog box in the Web Services designer. For exported services, WSDLs are automatically added to the project by default and appear at the root of the project in the project pane. If you don't want the WSDLs displayed in the project pane, uncheck the Add WSDL To Project On Build option. This has no effect on previously added WSDLs.

#### Axis deployment validation

At build time, Axis validation errors for services and handlers are reported to the WSDD Validation page in the message pane.

### WebLogic toolkit

#### Generating message handler code for an asynchronous web service

After you've exported a message-driven bean (MDB) as a web service and specified the service options in the Web Services designer's inspectors, you can generate the JMS class used to send and/or receive queue messages.

To generate the JMS class,

1. Click the top field of the MDB representation in the Web Services designer and set the JMS send and/or receive options in the Service MDB inspector.
2. Click the Client field of the service and choose the JMS Options tab. Set any options, such as JMS class name and package name, or accept the defaults.
3. Right-click the message-driven bean service in the Web Services designer.
4. Choose Generate Message Handler Code from the context menu.

## Project management

The following areas have changed in project management:

- Code audits
- Switching projects
- JAR manifest files

### Code audits

> This is a feature of JBuilder Developer and Enterprise

Code auditing helps you discover potential problems early in the development cycle, preventing more complex code problems later. Enable code audits and select specific problems to audit in the Project Properties dialog box (Project|Project Properties|Code Audits). Code auditing provides auditing for style, documentation, performance, design, and potential code errors.

The auditing results for each open file appears immediately after you enable code audits. Code auditing is turned off by default. Remember to turn on code audits for each open project. Code audits appear in a Warnings folder in the structure pane.

### Switching projects

When you are working on multiple projects, you can quickly switch between projects with the menu command, Window|Switch Project, using the mouse, or by pressing `Ctrl+F5`, on your keyboard.

### JAR manifest files

Manifest files now support reference links for identifiers of a full class name (only for a file on the project source path). To identify a link in the manifest file, move the mouse over the item with the `Ctrl` key held down, then click on the link to open the file.

## Editor enhancements

> Editor features vary by JBuilder edition

JBuilder's code editor offers improvements in the following areas:

- TagInsight
- Selecting text
- Gutter context menu and icons
- Smart keys
- White space characters
- Accommodating long lines
- Syntax highlighting
- Smart paste

### TagInsight

TagInsight now works with ErrorInsight to provide information about markup language tagging errors. When you have a tagging error, the error appears in a Markup Errors folder in the structure pane. Choose correction options from the ErrorInsight pop-up window in the editor. See "Correcting tag errors" in Getting Started with JBuilder for more information.

#### Tag Inspector

The tag inspector is useful for editing HTML and JSP files. When you click the Source tab to view JSP or HTML file content, the tag inspector is located on the right side. The tag inspector is context-sensitive and displays all of the applicable tag properties for the current cursor locations. When you hover the cursor over a property name, an explanatory tool tip appears. You can quickly edit the tag by entering text in the Value field.

#### Tag component palette

The tag component palette provides a list of components for HTML and JSP files. The component palette is located on the left side of the opened JSP or HTML file in the editor and displays a list of the available tags and tag libraries to add to your file. The component palette includes a Search field that helps you quickly find a particular tag.

A descriptive tool tip appears when you hover the cursor over the tag. You can automatically add the tag to your file by simply clicking the tag name in the component palette, then clicking in the text location in the editor where you want to add the tag. The component palette includes a context menu with options for navigation and for finding tags to add to your text.

### Selecting text

The editor offers more ways than ever to quickly select text for editing.

- To select a whole line of text, including the carriage-return at the end of the line, triple-click. When you copy the line and paste it elsewhere, the text will be pasted on its own separate line no matter how many times you paste it (without having to press `Enter` or `Return`).
- To expand a variety of selections (triple, double, and `Shift+` mouse-click), drag the mouse.
- To select single lines of code, press `Ctrl+L` or drag the mouse in the gutter.
- To select a single word, press `Ctrl+W`.
- To widen a single word selection to include the next larger code context, (only in Java files), press `Ctrl+W` again. Continue to press `Ctrl+W` to expand the selection to include multiple lines and finally the whole file.

#### Selecting text blocks

Select rectangular blocks of text (text blocks), to cut and paste, delete, or drag and drop with the following methods:

- Press `Ctrl`, hold down the left mouse button, and drag the mouse over any size column of text.
- Place the cursor at one end of the text selection, navigate to the other end of the selection (above or below), and press `Shift+Ctrl+` left mouse-click.

Use the `Shift` and arrow keys to expand or contract a block selection.

#### Toggling to block selection mode

When you select text regularly you can toggle to block selection mode by holding down the `Ctrl` key. The Search|Replace menu ("Search only selected text"), SyncEdit mode, and change case actions support block selection.

#### Adding and deleting text

Use the Slide-In Text and Slide-Out Text pop-up windows to quickly add or delete characters from a selected area of text.

- Press `Ctrl+Shift+'` (single quote), to open the Slide-In Text pop-up window which allows you to insert characters, including tabs (\t) or spaces, to the left side of your selection.
- Press `Ctrl+Shift+;` (semi-colon), to open the Slide-Out Text pop-up window which allows you to delete characters in your selection, including tabbed spaces. The slide-out action deletes any matching characters; the characters don't have to be in concurrent lines.

### Gutter context menu and icons

The editor's gutter provides a gutter-relevant context menu to control the editor's appearance and to access bookmark and debugging commands. Right-click in the gutter on the left side of the editor to view the menu options.

The editor's gutter includes several unique icons for various tools and actions. If there is more than one icon at the same gutter location, the icons stack on top of each other. See the "Using the editor's gutter" in Getting Started with JBuilder for more information.

### Smart keys

The "smart" keys, (`Tab`, `Return/Enter`, `Home`, or `End`), now include more customizing options to change the key behavior. Open the Actions page of the Preferences dialog box (Tools|Preferences|Editor|Actions and click the drop-down menus adjacent to the key names to view the choices.

### White space characters

White space characters are hidden by default, but you can choose to display them in the editor. Toggle between displaying and hiding white space characters with one the following actions.

- Right-click in the editor and choose Toggle Visible Whitespace.
- Choose the Show Visible Whitespace option in the Preferences dialog box (Tools|Preferences|Editor).
- Use the keyboard shortcut, `Ctrl+Shift+X`. You can change the key binding in the CUA Keymap Editor dialog box under the Miscellaneous section (Tools|Preferences|Keymaps|Edit).

The characters match the color of your regular text, but can be dimmed by setting the dim color percentage in the Preferences dialog box.

### Editing long lines

The editor now provides unlimited line length editing for your files, adjusting the editor width and scrollbar action to the longest line in your file.

### Syntax highlighting

Find Java code elements faster and easier in the editor with new color highlighting for members, variables, methods, and keywords. The markup languages, HTML and JSP, also contain new screen element entries to highlight. Set specific foreground and background colors for the screen elements on the Color page of the Preferences dialog box (Tools|Preferences|Editor|Color).

### Smart Paste

The editor provides a smart paste feature that does two things:

- Analyzes the file and determines whether import statements are required. If so, the editor provides a Smart Paste pop-up window displaying the import statements required for the pasted text. You can choose to add the imports or cancel the window.
- Pastes text with correct formatting applied. This action is enabled by default, but can be disabled in the Preferences dialog box (Tools|Preferences|Editor|Actions).

## Running and debugging

### Debugger

The following areas have been enhanced in the debugger.

#### Stepping

JBuilder 2005 provides Quick Step Into. Quick Step Into allows you to step directly into the method you are interested in, ignoring method calls in parameters. Quick Step Into can be accessed from the Run menu or by clicking the Quick Step Into button on the debugger toolbar. For more information, see "Quickly stepping into a method call" in the "Debugging Java programs" chapter of Building Applications with JBuilder.

#### ExpressionInsight

When the mouse hovers over a meaningful expression in the editor, the status bar at the bottom of the IDE now displays a message that explains how to invoke ExpressionInsight.

#### Ant debugging

> This is a feature of JBuilder Developer and Enterprise

You can now debug Ant build files. You can set breakpoints inside an Ant build file, inspect Ant properties, and step between tasks. To debug an Ant build file, open your Ant file in the editor, set a breakpoint, right-click the Ant build file in the project pane and choose Debug. The debugger stops execution at the breakpoint. When execution is paused, you can step into a target or task.

For more information, see "Debugging Ant build files" in Building Applications with JBuilder.

#### JSR-45 debugging

> This is a feature of JBuilder Developer and Enterprise

Tomcat 5.0, included with JBuilder 2005, supports JSR-45 debugging. This allows you to debug non-Java source code, including JSP, SQLJ and LegacyJ code. You can debug both locally and remotely. For more information, see "Debugging non-Java source" in the "Debugging Java programs" chapter of Building Applications with JBuilder.

#### Output display options

> This is a feature of JBuilder Developer and Enterprise

The Debug page of the Runtime Configuration dialog box (Run|Configurations) lets you determine how the debugger displays information. You can display `toString()` values for the classes you choose (providing more quickly-understood information about the class). You can also display non-static object fields alphabetically or in declared order.

For more information, see "Setting debugger display options" in the "Debugging Java programs" chapter of Building Applications with JBuilder.

#### Context menu commands and views

The context menus in the Threads, call stack and data view and the Data watches view now contain a new menu command — Show Fields in Alphabetical/Declared Order. This command is a toggle and applies to non-static fields of the selected object. To show fields in alphabetical order, choose the Show Fields In Alphabetical Order command. To show fields in the order they are declared, choose the Show Fields In Declared Order command.

The Restore Default View Order command has been removed. In JBuilder X, this command allowed you to return the debugger views to their default order after you moved one of the views to a floating window. Now, when you close a floating window, the view is automatically restored to its default order.

The Console, input, output and errors view now displays an editing toolbar, with buttons available for standard editing commands: Copy, Clear All, Search, Search Again, Auto Scroll and Word Wrap.

The Toggle Breakpoint, Enable Breakpoint and Breakpoint Properties commands have been removed from the editor context menu. To access these commands, right-click the gutter in the editor.

In the Threads, call stacks, and data view and the Data watches view, you can now multi-select object or primitive nodes and perform the applicable actions on those nodes. To do this, select the objects or primitives you want and right-click. The applicable actions are displayed in the context menu.

#### Custom view for Collection objects

> This is a feature of JBuilder Developer and Enterprise

JBuilder 2005 provides a built-in custom view for `Map` and `Collection` objects that displays the selected object as an array. To use this custom viewer, right-click a `Map` or `Collection` object in the Threads, call stacks and data view or the Data watches view. Choose Show Custom View, then toArray(java.util.Collection). The object is displayed as an array.

For more information, see "Map and Collection objects custom viewer" in the "Debugging Java programs" chapter of Building Applications with JBuilder.

#### Debug Server location

There is a new directory location for the Debug Server: The Debug Server is now located in the `<jbuilder>/debug/remote` directory instead of the `<jbuilder>/remote` directory.

#### Hotspot Serviceability Agent

JBuilder 2005 supports the Hotspot Serviceability Agent: The Java HotSpot Serviceability Agent is a high-level debugger for the HotSpot VM. It allows you to examine the heap as well as access thread stacks. It can help you diagnose memory leaks and deadlocks in Java programs. To use the HotSpot Serviceability Agent in JBuilder, choose Tools|HotSpot Serviceability Agent. For more information, see "Debugging with the HotSpot Serviceability Agent" in the "Debugging Java programs" chapter of Building Applications with JBuilder.

## Team development

New and updated features for JBuilder 2005 include:

- Recursive updates for all integrations
- StarTeam integration improvements
- CaliberRM plugin
- Subversion integration
- History pane

### Recursive updates for all integrations

To update the entire project or project group recursively, type the appropriate command at the command line:

    // For project only:
    jbuilder -update <projectname.jpx>

    // For project group:
    jbuilder -update <projectgroupname.bpgr>

Warning: Updating this way does not perform a merge. If your VCS supports merges and you want to merge local changes with what gets pulled from the repository, use the Commit Browser or menu commands instead of this.

If you have projects in a group which are under different VCSs, JBuilder executes each project's update against its own designated VCS.

### StarTeam integration improvements

This release of JBuilder supports StarTeam versions 5.4 and 6.

The folder tree pane, hosted in the structure pane, provides tabs that let you see the Project, Shortcut, View, or Server tree.

Shortcut support lets you create shortcuts for folders, files, change requests, and other items, and store these shortcuts wherever is most convenient for you; this lets you keep all your shortcuts in the project pane view most convenient to you and still be able to work on your material in any other project. Use the icons in the toolbar at the top of the upper pane in the StarTeam view to create these shortcuts, and use the context menus on the shortcuts themselves to rename, move, and edit them.

### CaliberRM plug-in

> This is a feature of JBuilder Enterprise

A plug-in for CaliberRM is now accessible from JBuilder 2005. The plug-in allows you to:

- Create a connection to a CaliberRM server and login or logout
- View a CaliberRM project and baseline
- Filter requirements, so you only see the ones you want
- Drop requirements into your source code as comments
- Update comments for requirements that have been changed on the server

You can also change to a new server connection, project and baseline as you work. Additionally, you can open the full CaliberRM client from the plug-in. Once a requirement has been traced to a source file, you can open that source file in the editor.

The CaliberRM plug-in is displayed in JBuilder's message pane. The UI is configurable, allowing you to choose what requirements fields are displayed. For more information, see "Managing requirements using CaliberRM" in Managing Application Development.

### Subversion integration

JBuilder 2005 supports Subversion, an open-source tool originally derived from the CVS project. Subversion is considered particularly useful to server administrators and is gaining popularity. JBuilder supports most common Subversion tasks from within the IDE.

### History pane

The history view has an Annotations page that provides line-by-line information on the last change in each line and who made it.

The history view also has a new button, Check Out Selected Revision, which pulls the latest revision into your workspace. Used in conjunction with the decorations in the file tab and project pane indicating when the file's VCS status changes on the server, this makes it very easy to keep your workspace current.

## Web development

> Web development is a feature of JBuilder Developer and JBuilder Enterprise. Applet development is a feature of all editions of JBuilder.

The Web Development area of JBuilder 2005 includes many new and improved features, including new designers for JavaServer Faces.

### JSF Flow designer

The JSF Flow designer is a JSP-centric visual designer for working with JSF navigation rules and navigation cases.

For JSPs in a JSF application there's a new Flow page which displays and allows you to manipulate the relevant navigation rules within the context of that particular JSP.

To get to the JSF Flow designer, click the Flow tab at the bottom of the content pane for a JSP in a JSF-enabled project.

See "JSF Flow designer" in Developing Web Applications.

### Faces Config Editor

The Faces Config editor is a visual editor for the `faces-config.xml` deployment descriptor. To open the Faces Config editor, double-click the `faces-config.xml` file in the `WEB-INF` node of your module directory in the project pane.

See "Editing the faces-config.xml file" in Developing Web Applications.

### JSF Navigation designer

The Navigation designer is a visual tool for designing the navigation rules and navigation cases of a JSF application.

The Navigation designer is available from the Navigation Rules page of the Faces Config editor.

See "Navigation designer" in Developing Web Applications.

### JSF coding wizards

For certain properties of JSF components, such as the `action` property of a Command Button, wizards for setting the property are available from context menus in the tag inspector and from ErrorInsight. For example, the wizard for the `action` property of a Command Button allows you to create the Action's method binding. For more information on each of the individual coding wizards, click the Help button on the wizard.

### Tag palette in editor

A new component palette for HTML and JSP tag library tags is available on the left side of the editor when editing a HTML or JSP file. Tags are grouped by type. HTML tags are in one group. Other tags are grouped by JSP tag library prefix.

To insert a tag from the component palette, click on the tag and then click in the editor at the insertion point to drop the tag. Use `CTRL`+click to drop the same item multiple times. You can surround existing text by selecting a tag on the palette and then selecting the text you would like to surround in the editor.

See "Tag component palette."

### Tag inspector in editor

The editor includes a convenient tag inspector for editing HTML, XML, and JSP files, located to the right of the source pane of the open file.

For certain properties of JSF components, such as the `action` property of a Command Button, wizards for setting the property are available from context menus in the tag inspector and from ErrorInsight.

See "Tag inspector."

### Servlet wizard

The Servlet wizard has been separated into 3 wizards — the Standard Servlet wizard, the Listener Servlet wizard and the Filter Servlet wizard. Use the Standard Servlet wizard to create a standard servlet; the Listener Servlet wizard to create a listener servlet and a Filter Servlet wizard to create a filter servlet. For more information, see "Developing servlets" in Developing Web Applications.

### Tomcat integration

Tomcat 4.1 and 5.0 are integrated with JBuilder 2005. Use the Configure Servers (Enterprise|Configure Servers) dialog box to configure Tomcat. Choose Tomcat as your project's web server on the Project|Project Properties|Servers page. Note that Tomcat 5.0 supports the Servlet 2.4 specification and JSR-45, among other things. For more information, see "Using JBuilder with Tomcat" in Developing Applications for J2EE Servers.

### Changes to Web Run/Debug/Optimize page of the Preferences dialog box

The Web Run/Debug/Optimize page of the Tools|Preferences dialog box dialog box has been simplified. The options now allow you to copy the formulated URL to the clipboard, always start a new server process and use the Web View to view the URL, or always use the internal Web View to display the formulated URL. For more information, see "Configuring the IDE for web run/debug" in the "Working with web applications in JBuilder" chapter of Developing Web Applications.

### TCP Monitor

The TCP Monitor can be used for debugging web applications. It allows you to monitor request and response packets as they're transported between the client and the server. The TCP Monitor actually sits between the client and server. The client sends its request to the TCP Monitor, which then forwards it on to the server. Responses from the server are in turn sent to the TCP Monitor and then to the client. You can monitor these messages locally to test and debug the web application or listen over a connection.

To enable the TCP Monitor, you use the Monitors page of the Runtime Configurations dialog box (Run|Configurations|New/Edit). For more information, see "Using the TCP Monitor" in Developing Web Applications.

## Mobile development

> This is a feature of JBuilder Developer and Enterprise

Mobile development has the following new features and changes:

- J2MEWTK 2.1
- DoJa 3.0 designer
- MIDlet signing
- Adding DoJa profile keys to the Archive Builder
- Micro unit testing

### J2MEWTK 2.1

JBuilder mobile development includes JavaTM 2 Platform, Micro Edition, Wireless Toolkit Version 2.1 with support for MIDP 2.0 and 1.0, and CLDC 1.1. and 1.0.

### DoJa 3.0 designer

JBuilder has added support for designing a DoJa 3.0 UI in the UI designer. When you click on the design tab, the DoJa 3.0 UI components will appear on the component palette in the designer.

### MIDlet signing

The MIDlet Archive Builder now includes a step for digitally signing your MIDlet Suite. This step of the Archive Builder adds `MIDlet-Jar-RSA-SHA1 and MIDlet-Certificate-<n>-<m>` attributes to the JAD file.

For more information, see "Specify whether and how to sign this MIDlet Suite" under the Archive Builder steps in the "Archiving MIDlets" chapter of Developing Mobile Applications for MIDP .

Note: Before you can run your signed MIDlet on the actual device, you must obtain a valid certificate from a certificate authority recognized by your device.

### Adding DoJa profile keys to the Archive Builder

Currently, JBuilder mobile development has built-in support for the DoJa-1.5oe, DoJa-2.5oe, and DoJa-3.0 profiles. But if you want to use a different DoJa SDK than one of those, mobile development now provides a way for users to add new DoJa profile keys/attributes to the i-mode Application Archive Builder wizard.

A sample file for DoJa-1.5oe profile keys/attributes is delivered in the JBuilder `defaults\micro` directory called `DoJa-1.5oe-sample.xml`. Using this as a template, you can modify it and rename it so the Archive Builder will be able to use it.

For more information, see "Adding new DoJa profile support to the Archive Builder" in the "Archiving and deploying i-mode applications" chapter of Developing mobile applications for i-mode.

### Micro Unit Testing

Unit testing had been expanded to include Mobile Development. A new Micro Test runner has been added to the runner type list in the New Runtime Configuration dialog box. Also, two new wizards have been added to the Object Gallery Test page:

Wizard | Description
--- | ---
Micro Test Case | Creates a skeleton test case class for unit testing a class in a mobile project.
Micro Test Builder | Creates a test suite that groups test cases so they can be run as a batch.

These wizards are basically like the Test Case wizard and the Test Suite wizard for J2SE and J2EE development. To access one of these wizards, open a MIDP or i-mode project in JBuilder, choose File|New|Test and double-click the Micro Test Case or Micro Test Builder wizard icon to open it.

For more information, see "Micro Unit Testing" in "Debugging and testing MIDLets" or "Debugging and testing i-mode applications".

## Online help

Using and finding online help documentation is now easier with new usability enhancements.

- Help Viewer tabs
- Embedded or standalone help
- Searching in the Help Viewer
- Tasks in the Help Viewer
- Dynamic Help

### Help Viewer tabs

The Help Viewer now includes two new tabs to help you find information and complete simple tasks: Search and Tasks. See "Using search in the Help Viewer" and "Using the tasks list" in Getting Started with JBuilder for more information about comprehensive searching and using tasks.

### Embedded or standalone help

You can choose to use embedded help or standalone help with a new setting in the Preferences dialog box (Tools|Preferences|Help). Choose embedded help to quickly view documentation in the content pane or choose the standalone Help Viewer to view documentation outside of your workspace. Both include comprehensive navigation and searching, as well as viewing for the full book-set, index, and tasks list.

### Searching in the Help Viewer

The search page of the Help Viewer provides complex searching and result display features. Your options for searching are varied, from choosing an exact match, to using patterns (wildcard or regular expression), and includes the following areas: search for words (exact match and more), results display, and refined search options. You can sort the results or create a new subset of books to limit the search area.

### Tasks in the Help Viewer

The Help Viewer contains a new, helpful Tasks tab. The tasks tab displays task topics in the left pane. When you click on a topic, descriptive task titles appear in the lower pane, with the first task title highlighted and the informational steps for the task displayed in the right pane of the Help Viewer.

### Dynamic Help

Dynamic Help allows you to access task-oriented help information quickly without opening the Help Viewer. The help information is context-sensitive to the cursor location in the editor.

To enable Dynamic Help, choose Tools|Preferences|Help. On the Help page you can enable Dynamic Help and choose how quickly and in what form it appears. Once you have enabled Dynamic Help, you can view the Dynamic Help menu in the bottom area of the IDE by choosing Help|Dynamic Help.

## J2EE/EJB development

> These are features of JBuilder Enterprise

The following sections describe the changes and improvements in features used for J2EE and EJB development.

### Supported servers

JBuilder 2005 now supports J2EE development these using these servers:

- Borland Enterprise Server 5.2.1
- Borland Enterprise Server 6.0.1
- BEA WebLogic Server 7.0 SP 5
- BEA WebLogic Platform 8.1 SP 3
- IBM WebSphere Application Server 4.0.7 Single Server
- IBM WebSphere Application Server 4.0.7 Advanced Edition
- IBM WebSphere Application Server 5.0.2.4, 5.1.0.4
- JBoss Application Server 3.0.8
- JBoss Application Server 3.2.5
- Tomcat 4.1.30
- Tomcat 5.0.27

### Improved WebLogic Server support

JBuilder now allows WebLogic Server 7.x and 8.x EAR, WAR, RAR, and EJB modules to be deployed as an exploded directory. For more information, see "Deploying J2EE modules as an exploded directory."

A few WebLogic Server properties, such as field groups and other CMP WebLogic-specific properties, were previously accessed only through the EJB Designer. You can now access them through the EJB DD Editor as well.

### Configuring servers

The Configure Servers dialog box now validates entries you enter in its fields immediately after you enter them instead of waiting until you click the OK button.

### Menu changes

There is a new Enterprise menu that includes all the items previously on the Tools menu that are server or EJB related. The menu also includes server-specific tools. Each configured server has a separate section on the Enterprise menu.

### DD Editor changes

When a DD Editor page is incomplete or has errors, an errors folder appears in the structure pane that contains error messages. Use these messages to prompt you to fill in required fields and fix any errors.

You can now choose to validate your deployment descriptors during a build. To select this option, right-click the module in the project pane, choose Properties, select Build in the tree, and check the Validate Deployment Descriptors During Build option on the Build page.

### Working with modules

From any of the module wizards (EJB, Web, Application, Connector, or Application Client), you can now create a module node for an existing directory. You still have the option to copy files from a directory to a newly created module directory.

#### Filters

The file type filters for a module are available as File Type filters on the Content page of a module (previously this was on the Classes page.) The Clean property page of the module has also been updated to use File Type filters instead of expression filters.

For more information about using filters to control the content of archives and to set other build properties for modules, see "Building J2EE modules.""

## Visual designer

The component palette of the visual designer now appears on the left edge of the design surface, instead of on top. Irrelevant pages are concealed; for instance, MIDP pages are not visible when working with J2SE components. You can also choose to show or hide labels next to the icons on the palette.

The new component palette includes a search field, allowing you to find components quickly, regardless of which page they're on.

## XML

> This is a feature of JBuilder Developer and Enterprise

Cocoon has been updated to version 2.1.5.1.

### Castor and the Databinding wizard

Castor has been updated to version 0.9.5.3.

There are two new features in the Databinding wizard (File|New|XML) for Castor — the ability to use a custom binding file and to generate sources for imported XML schemas.

#### Binding file

In some cases, you might want to use your own custom binding file instead of Castor's default binding. A custom binding file is an XML document used to control the generation of Java classes. The binding file allows you to solve naming collision problems, modify the default datatype binding, or add validation rules by implementing your own validator. For information on creating a binding file, see "Binding file" at `http://www.castor.org/sourcegen.html#Binding-File`.

#### Generate imported schemas

Generates sources for imported XML schemas.