Introduction

The Kelp add-in makes it easy to use the Enhydra XML Compiler (XMLC) and the Enhydra Application Server (EAS) within an integrated development environment. Kelp 4 supports Borland JBuilder, Sun Forte, and Oracle JDeveloper. Refer to Using Kelp with an IDE for information on how to use a Kelp add-in to develop web applications with XMLC.

This document supplements the Lutris donated documentation for Kelp tools and add-ins. The Lutris documentation covers the feature set supported in the Enhydra Application Server Suite. This document describes modules that part of the Kelp project but are not in the Lutris product line such as the Oracle JDeveloper add-in and the Windows installer. You'll also find an overview of the open source CVS modules at the end of this document.

If you are working with a commercial release of Kelp such as the one bundled with Lutris EAS 4, you may have additional documentation or features that are not described here. You will find the latest version of this document at the Enhydra Kelp project web site along with FAQs (Frequently Asked Questions) and information on checking out the source from the CVS repository. For information on building Kelp, refer to the README.BUILD that is included in the root of the Kelp project source tree.

This documentation assumes a basic understanding of a Java IDE and the servlet programming model. For information on JBuilder, visit the Borland website. You can find out more about Oracle JDeveloper from the Oracle Technology Network. The Sun Microsystems website provides information Forte for Java. If you are new to EAS, be sure to review the Getting Started Guide that can be found at the Lutris Enhydra Evaluation Documentation page.

The add-in provides wizards and tools to help you develop applications for EAS. The add-in will add the Kelp application wizards to your IDE's File menu. You only need to use an application wizard when starting a new project. If you have an existing application that uses the Enhydra 3 make system, you can import it into an IDE project file using the Enhydra Import wizard. Once you have a project, you can use the XML Compiler and Enhydra Deployer to build and deploy your application.

The XML Compiler and Enhydra Deployer are added to the IDE's Tools menu. These tools give you access to EAS features from within your IDE. Using the JBuilder integrated build feature, you can invoke these same processes directly within the project builder without opening either wizard. Each tool also has a set of project and node property pages that you can access from your project navigation tree.

The general usage model for building web applications with the Kelp add-in:

1. Create a new empty project from within your IDE
2. Use a Kelp application wizard to generate a web application.
3. Use the XML Compiler to generate Java source files for DOM classes. The DOM classes represent the dynamic pages of your application.
4. Use the IDE build command to compile all Java source files.
5. Deploy the application with the Enhydra Deployer.
6. Run or debug your application by launching Enhydra from the IDE.
7. Develop your application invoking the XML Compiler whenever you add or change XMLC documents. The documents are any HTML, WML, CHTML and XHTML files that represent dynamic content.
8. Rerun the Enhydra Deployer to rebuild your web application archive (.war) to test any changes you've made to your source, template, or content files.
9. When your application is complete, copy the web archive (.war) to your production server and use an administration console to add and configure the new application.

The general usage model for building Enhydra services with the Kelp add-in:

1. Start a local instance of Lutris EAS.
2. Create a new empty project from within your IDE.
3. Use a Kelp application wizard to generate an Enhydra service.
4. Expand on the generated service classes to provide your desired functionality.
5. Use the IDE build command to compile all Java source files.
6. Use the Kelp Deployer to build and auto-deploy a service archive (.jar) to the locally running instance of EAS.
7. Create and deploy a client application to test your service.
8. When your service is complete, copy the service archive to your production server.

The Kelp Project Web Site

The Kelp project web site, http://kelp.enhydra.org is dedicated to making Enhydra technologies easier to use through the use of tools such as application wizards and Java IDE add-ons.

The site serves as the repository for downloads, documentation and mail list archives. It also acts as a gateway to the CVS repository for the open source modules.

You are invited to participate in the Kelp project. We welcome contributions in many forms, including documentation, patches and additional IDE implementations.

What's new and what's next

Most of the changes since 4.0 have been bug fixes. The other focus has been keeping in sync with EAS 4.0.1. Here are a few new features worth noting:

• The Windows installer now supports for JBuilder 5 and Forte 2.
• There is a new HelloJB5Enterprise sample project that provides an example of creating and deploying EJBs and a Web Applicition using an EAR (Enterprise Archive). You can find enterprise sample project in the <ide_root>/kelp4/samples directory.
• The JBuilder add-in includes support for using the Jonas add-in from Ingenosya (Kelly). Refer to the readme.html in the HelloJB5Enterprise project for information on using Kelly with Kelp.

We hope to reduce the learning curve required to use the Kelp add-ins, better leverage existing Enterprise tools and continue making it easier to develop for EAS. In some cases, we may be providing less support for the free editions of commercial IDEs. Note that the 4.0.1 release may be the last to include support for Enhydra 3.x and the Enhydra Application Framework. For more information, please check out the Kelp roadmap.

Installing the add-in from kelp.enhydra.org

Before installing the add-in, you should already have installed a supported Java IDE and the Enhydra Application Server. Lutris provides an installation guide for EAS at the Lutris Enhydra Evaluation Documentation page.

System Requirements

• OS
  • Windows 2000, NT
  • Linux
  • Solaris
• Java IDE
  • Borland JBuilder 4.0, 5.0
  • Sun Forte for Java 2.0
  • Oracle JDeveloper 3.2
    
• Enhydra Application Server
• Lutris EAS 4.0.1
• Lutris Enhydra 3.5.2
• Enhydra 3.1.1 beta 1

Note:  Kelp 4 will not work with Enhydra 3.1. The Forte add-in does not support Lutris Enhydra 3.5.2, Enhydra 3.1.1, Forte 3, or NetBeans.

Kelp 4 requires the Kelp add-in jar, the Kelp toolbox jar and Enhydra XMLC classes to be in the IDE class path.

Install Options

• Commercial Releases

  Commercial releases may include alternate installers and require additional configuration steps. If you are installing Kelp with a commercial product such as Lutris EAS, refer to the documentation that came with your product.

• Open Source Windows Installer
  

  The kelp.enhydra.org site provides a Windows installer that can automatically configures your IDE. Note that does not provides support for the open source installer. To use, refer to Using the open source Windows installer.

• Zip Archives

  To use a zip archive, extract the contents into your <ide_root> directory. For example, if you have JBuilder installed at: /opt/jbuilder5, extract the Kelp archive so you end up with:

  /opt/jbuilder5/kelp4/dist
/opt/jbuilder5/kelp4/doc
/opt/jbuilder5/kelp4/lib
/opt/jbuilder5/kelp4/samples



  If you install from an archive, you may also need to install the toolbox.jar from the ToolBox zip. The toolbox.jar is also bundled with the Lutris EAS. Kelp will not run correctly if you are not running with a matching version of the toolbox.jar. If you are not sure if your EAS installation contains the correct toolbox.jar, you should install toolbox.jar from the matching archive.

  If you need to install the toolbox.jar, download the zip file and extract the contents into your <eas_root> directory. If your <eas_root> directory is /usr/local/eas4, extract the toolbox.jar into <eas_root>/tool/lib.

  /usr/local/eas4/tool/lib/toolbox.jar



  After installing Kelp from archives, you will need to configure your IDE.

Using the open source Windows installer

If you are running on Windows NT or Windows 2000, you can use the open source Windows installer to install Kelp add-in files and configure your IDE. This installer does not support Linux or Solaris.

This section describes the open source InstallShield setup program that is available from kelp.enhydra.org. Refer to the Lutris documentation if you are installing Kelp from a commercial release of Lutris EAS.

Before running the open source installer, close any open instances of the IDE and note where your IDE and Enhydra files reside. You will need to tell the setup program what version of the IDE you are running. Open the IDE's About box to view the version number that you are currently running.

The setup program will look up your Java IDE home directory in the Windows registry. If you have installed more than one supported IDE, you may need to click on Browse in the Choose IDE directory step to select the location of the IDE you want to use with Enhydra. The sample projects, documentation and libraries will be installed in a kelp4 directory within the Java IDE's home directory.

After selecting the Java IDE root directory to use for installing, you need to tell the setup program where your EAS root directory is located. The setup program will look for a lib directory containing one or more EAS jar files within your EAS root directory. The setup program will check the Windows registry and common locations to determine a default such as:

c:\usr\local\eas4

Enter the correct location or use Browse to navigate to your EAS root directory. The Enhydra XMLC jar files will be added to the IDE class path. The setup program also creates an Enhydra library for use with your projects. The toolbox.jar will also be installed.

Note: If you have previously installed Kelp with a different version of EAS, you may need to modify the IDE class path to ensure that it only references a single installation of EAS. See the section on configuring your IDE for more information.

The setup program provides you with three types of installations: Typical, Compact and Custom. Typical installs the libraries, documentation and the sample projects. Compact installs only the library files. Use custom to select any combination of components.

After selecting the type of installation you want, setup prompts you for the program group and lists all your selections for confirmation. When you confirm the settings, the installer will copy files into a kelp4 directory within the IDE home directory. The installer also copies the toolbox.jar to <eas_root>/tool/lib.

The installer modifies IDE configuration files. Some of the modifications will not be reversed if you uninstall Kelp. To allow you to restore your original configuration, the setup program creates a backup of each of the modified files and copies the backups to the kelp4 directory.

• JBuilder

  The installer will configure JBuilder to open Kelp sample projects the next time you start the IDE. This will overwrite the IDE's most recently used history list. You can restore your history list by overwriting the modified user.properties file with a "Backup of user.properties" file which the installer creates. Under Windows 2000, you'll find these files under your Documents and Settings login directory.

• JDeveloper

  The installer may fail in your jbuilder.ini file contains any lines longer than 1024 characters. Before using the Windows installer to configure JDeveloper, review the JDeveloper section under upgrading.

• Forte

  The Kelp add-in is not compatible with Forte's runide.exe program. To avoid conficts, the installer will rename the runide.exe and runidew.exe files to "Backup of runide.exe" and "Backup of runidew.exe". After installing, you will need to use the runide.bat file to launch Forte. The installer will create a new short-cut for the batch file.

If you want to know more about what the installer does to update your IDE configuration, refer to the section configuring your IDE.

Upgrading from Kelp 2 or Enhydra 3.x

If you have configured your IDE for use with earlier releases of Kelp or the EAS, you should uninstall and remove all references to those releases. This is particularly important if you plan to use a configure script or the Windows installer to configure your IDE. The following items provide steps that should be taken prior to installing Kelp 4.

• JBuilder

  Before running the configure script, remove addpath statements that reference Kelp or Enhydra application server jar files from the <ide_root>/bin/jbuilder.config.

  The configure script for JBuilder will not remove addpath statements that reference earlier releases of the application server or Kelp. If classes are referenced by more than once addpath statement, the classes in the first addpath statement will take precedence. Since the script inserts addpath statements at the end of the jbuilder.config file, these addpath statements will have the least precedence.

• JDeveloper

  Before running the Windows installer, remove all references to Kelp and Enhydra application server jars from the PREBCP entry of <ide_root>/bin/jbuilder.ini.

  Also remove both the [Library_Enhydra] and [Library_SunTools] sections from the <ide_root>/bin/library.ini.

  The Windows installer will add but not remove entries to the PREBCP, causing the line to expand beyond 1024 characters on repeated installs. Running the installer when the PREBCP line exceeds 1024 can cause the file to be corrupted. If your file is corrupted, you may restore it using the "Backup of jbuilder.ini" file.

• Forte

  Before copying an updated KelpAddinForte.jar to your <ide_root>/modules directory, remove the older jar then launch and exit Forte. This will clear references to the previous jar from the module cache.

Configuring your IDE

You will need to modify some IDE configuration files to enable the Kelp add-in. The configuration process depends on what IDE you are running. Refer to the steps for your IDE.

After configuring your IDE, you can to create an Enhydra library to use with your Enhydra projects. The library should include the Enhydra classes required to compile the source files generated by XMLC.

Setting up JBuilder

The add-in includes a configure script that automates the configuration process when installing with Lutris EAS. The script does not support Enhydra 3.1.1. You'll find the configure script in the kelp4 directory. The script will modify the jbuilder.config file and create an Enhydra library. There is a configure batch file for Windows and a configure shell script for Linux/Solaris. For usage information run the configure script without any parameters from the kelp4 directory.

Follow the steps below when running with Enhydra 3.1.1 or if the add-in does not appear to be functioning properly after using the Windows installer or the configure script.

1. Setup the IDE class path.

   Add toolbox.jar, KelpAddin.jar and Enhydra XMLC classes to your IDE class path. JBuilder uses a JBuilder.config file for setting the IDE class path. You can use the addpath setting to add jars to the IDE class path. What jars you need for Enhydra XMLC depends on what release of EAS you are working with as shown below:

   • EAS 4.0.1
     The manifest for toolbox.jar automatically adds the following to your IDE class path: Boot.jar, build.jar, Kernel.jar, Wireless.jar, xmlc.jar, LutrisWireless.jar
      
     
   • Enhydra 3.1.1, Lutris Enhydra 3.5.2
     enhydra.jar
     
     

   With JBuilder closed, edit the JBuilder.config file to add an addpath statement for each of the jar files. Also be sure to remove any addpath statements that refer to older versions of Enhydra, ToolBox or Kelp.

   To avoid conflicts with the Xerces library included with JBuilder 5, be sure to insert your addpath statements before the following config statements:

   addjars ../patch
addjars ../lib
addjars ../lib/ext


   If you have JBuilder installed to /opt/jbuilder5 and EAS 4.0.1 installed in an <eas_root> of /usr/local/eas4, your addpath statements would be:

   addpath /usr/local/eas4/tool/lib/toolbox.jar
addpath /opt/jbuilder5/kelp4/lib/KelpAddin.jar



   If you have JBuilder installed to /opt/jbuilder5 and Enhydra 3.1.1 installed in an <eas_root> of /usr/local/enhydra3.1.1, your addpath statements would be:

   addpath /usr/local/enhydra3.1.1/lib/enhydra.jar
addpath /usr/local/enhydra3.1.1/tool/lib/toolbox.jar
addpath /opt/jbuilder5/kelp4/lib/KelpAddin.jar



2. Create an Enhydra library for defining project class paths

   JBuilder uses libraries to setup the class paths used to build and run your projects. You can create and edit library definitions by selecting Tools | Configure Libraries. Refer to the Defining a project class path for the list of jars required in your Enhydra library.

   Note that if the IDE class path and library entries reference different releases of Enhydra, the XML Compiler may generate java source files that fail to compile.

If you want to use the XML Compiler with non-HTML document types on Linux, you will also need to comment out the vmparam -Xverify:none option in the jdk.config file. Note that commenting out this vmparam setting may prevent access to the project Run properties tab.

You can check to see if you have installed the tools correctly by starting JBuilder and looking for the XML Compiler in the Tools menu. If the menu does not appear, check the IDE class path setting from the Info tab of the JBuilder about box.

Setting up JDeveloper

The add-in does not include a configure script for automating the JDeveloper configuration process. Follow the steps below if the add-in does not appear to be functioning properly after using the Windows installer.

Kelp 4 requires that you run the JDeveloper IDE under JDK 1.2.2 or higher. The Kelp configuration may cause problems when running JDeveloper under JDK 1.1.8. Be sure you shutdown JDeveloper before editing jdeveloper.ini, gallery.ini or jdeveloper.properties.

1. Setup the IDE class path.

   Add toolbox.jar, KelpAddin.jar and Enhydra XMLC classes to your IDE class path. The jdeveloper.ini file specifies the IDE class path. The jdeveloper.ini file is located in the JDeveloper bin directory. Add the jar files to the PREBCP=-Xbootclasspath setting in the Java2 section of the jdeveloper.ini. For example, if are running with Enhydra 3.1.1 and your <eas_root> is d:\usr\local\enhydra3.1.1, your Java 2 section should look similar to the following:

   [Java_2]
JDK=java version "JDK1.2.2_JDeveloper"
Java2VM=OJVM
JLP=-Djava.library.path=.;%JAVA_ROOT%\bin;%JAVA_ROOT%\jre\bin;c:\orant\bin
SLP=-Dsun.boot.library.path=.;%JAVA_ROOT%\bin;%JAVA_ROOT%\jre\bin;c:\orant\bin
IHS=-Xms12m
PREBCP=-Xbootclasspath/p:..\kelp4\lib\KelpAddin.jar;
  d:\usr\local\enhydra3.1.1\lib\enhydra.jar;
  d:\usr\local\enhydra3.1.1\tool\lib\toolbox.jar;
  ..\classes;..\lib\jdeveloper.zip;..\aurora\lib\vbjorb.jar;...
ADDBCP=-Xbootclasspath/a:..\lib\debugger.jar;...
 
What jars you need for Enhydra XMLC depends on what release of Enhydra you are working with as shown below:
   • EAS 4.0.1
     Boot.jar, build.jar, Kernel.jar, Wireless.jar, xmlc.jar, LutrisWireless.jar
      
     
   • Enhydra 3.1.1, Lutris Enhydra 3.5.2
     enhydra.jar
     
     
2. Add a gallery page to the gallery.ini file.

   The gallery defines what appears in the new file dialog. The gallery is divided up into pages. The gallery.ini file resides in the <jdeveloper_root>/bin directory. You need to add the following entries to make the Kelp application wizards appear in the new file dialog. You can add the entries into an existing page or create a new page for them

   wizard=Web Application=org.enhydra.kelp.jdeveloper.wizard.WebAppWizard
wizard=Enhydra Application=org.enhydra.kelp.jdeveloper.wizard.Enhydra3AppWizard
wizard=Enhydra Service=org.enhydra.kelp.jdeveloper.wizard.EnhydraService


3. Add wizard entries to the jdeveloper.properties file.

   The jdeveloper.properties file is located in the <jdeveloper_root>/lib directory. Each add-in has a numbered entry in the properties file. Locate the last jdeveloper.addin entry and add entries for the Kelp wizards. You can assign any numbers to the add-ins as long as they are unique.

   jdeveloper.addin.90=org.enhydra.kelp.jdeveloper.tool.XMLCTool jdeveloper.addin.91=org.enhydra.kelp.jdeveloper.tool.DeployTool jdeveloper.addin.92=org.enhydra.kelp.jdeveloper.wizard.ImportWizard jdeveloper.addin.93=org.enhydra.kelp.jdeveloper.wizard.WebAppWizard jdeveloper.addin.94=org.enhydra.kelp.jdeveloper.wizard.Enhydra3AppWizard jdeveloper.addin.95=org.enhydra.kelp.jdeveloper.wizard.EnhydraService

4. Create an Enhydra library for defining project class paths

   JDeveloper uses libraries to setup the class paths used to build and run your projects. You can create and edit library definitions from the Libraries tab of the Project Properties dialog. Refer to the Defining a project class path for the list of jars required in your Enhydra library.

   Note that if the IDE class path and library entries reference different releases of Enhydra, the XML Compiler may generate java source files that fail to compile.

5. Convert paths in the sample projects

   The KelpWebApp.jpr and KelpWireless.jpr sample projects are delivered in JBuilder format. You can quickly convert these files for use by JDeveloper by modifying the relative path values. JBuilder uses / as the file separator and begins relative paths with the file or directory name. JDeveloper uses \ as the file separator and it uses the .\ prefix for relative paths. For example, the JBuilder entry...

   #12=src/kelp/webapp/resources/Greeting.html

   ...is equivalent to the JDeveloper entry...

   #12=.\src\kelp\webapp\resources\Greeting.html

   If you want to work with a Kelp sample within JDeveloper, open the project file in a text editor and use search and replace to replace all instances of / with \ and then insert .\ before each relative path.

Oracle JDeveloper comes bundled with an older implementation of the org.wc3.dom classes that are not compatible with XMLC. The enhydra.jar file contains updated org.wc3.dom classes. To allow the XMLC to run successfully, the setup program places the enhydra.jar at the start of the IDE class path. Under JDK 1.1.8 the enhydra.jar will cause conflicts with the dacfdtd.zip, jbodt.zip and xmlparserv2.jar files. If you need to run JDeveloper under 1.1.8, you should remove those jar files from the IDE class path. This will disable some of JDeveloper's HTML tag support. If you want to use the HTML tag wizards, you will need to restore the Oracle files back into the IDE class path and remove Kelp.

Setting up Forte

The add-in includes a configure script that automates the configuration process when installing with Lutris EAS and Forte. You'll find the configure script in the kelp4 directory. The script will create a runideForte startup script. It will not modify your existing runide scripts. There is a configure batch file for Windows and a configure shell script for Linux/Solaris. For usage information run the configure script without any parameters from the kelp4 directory.

Follow the steps below if the add-in does not appear to be functioning properly after using the configure script. Note that when manually configuring Forte, you will be modifying your existing runide start script instead of using the Kelp provided runideForte script.

1. Setup the IDE class path.

   Add the toolbox.jar and the EAS jars to your IDE class path. Forte 2 includes a runide start script that you can use to add jars to the IDE class path. The start script is platform dependent. The EAS jars you need to add are listed below.

   Boot.jar, build.jar, Kernel.jar, Wireless.jar, xmlc.jar
 
You can optionally include the LutrisWireless.jar from Lutris EAS 4 for XHTML and CHTML support.

   With Forte closed, edit the runide script to add each enhydra jar into the IDE class path. Note that the Enhhydra XMLC jar files must precede all other jar files in the class path. Be sure not to add the KelpForteAddin.jar file to the IDE class path.

   • Windows
     The runide.exe is not supported by the add-in. To set the IDE class path, you will need to modify the runide.bat file. In the bat file, locate the the SET NB_CLASSPATH statement. Insert add new SET NB_CLASSPATH statements for the EAS jar files to runide.bat file as shown:
     
SET NB_CLASSPATH=%PATCH_PATH%;%_FORTE4J_HOME%\lib;...

SET NB_CLASSPATH=C:\usr\local\eas4\tool\lib\toolbox.jar;%NB_CLASSPATH%
SET NB_CLASSPATH=C:\usr\local\eas4\lib\Boot.jar;%NB_CLASSPATH%
SET NB_CLASSPATH=C:\usr\local\eas4\lib\build.jar;%NB_CLASSPATH%
SET NB_CLASSPATH=C:\usr\local\eas4\lib\eaf.jar;%NB_CLASSPATH%
SET NB_CLASSPATH=C:\usr\local\eas4\lib\Kernel.jar;%NB_CLASSPATH%
SET NB_CLASSPATH=C:\usr\local\eas4\lib\servlet.jar;%NB_CLASSPATH%
SET NB_CLASSPATH=C:\usr\local\eas4\lib\WebService.jar;%NB_CLASSPATH%
SET NB_CLASSPATH=C:\usr\local\eas4\lib\Wireless.jar;%NB_CLASSPATH%
SET NB_CLASSPATH=C:\usr\local\eas4\lib\xmlc.jar;%NB_CLASSPATH%


     After configuring Kelp on Windows, update Forte shortcuts to use the batch file instead of the runide.exe.

   • Linux/Solaris
     Open the start script and locate the prefixcp setting. By default, prefixcp is set to nothing. Use the variable to add the EAS jars as shown:
     
prefixcp="/usr/local/eas4/tool/lib/toolbox.jar:
  /usr/local/eas4/Boot.jar:
  /usr/local/eas4/build.jar:
  /usr/local/eas4/eaf.jar:
  /usr/local/eas4/Kernel.jar:
  /usr/local/eas4/servlet.jar:
  /usr/local/eas4/WebService.jar:
  /usr/local/eas4/Wireless.jar:
  /usr/local/eas4/xmlc.jar"

     
2. Install the KelpAddinForte.jar

   Copy the KelpAddinForte.jar file to the <forte_root>/modules directory. The add-in comes with two add-in jar files under the kelp4/lib directory. The jar files differ only in manifest entries. The manifest in KelpAddin.jar works with JBuilder while the manifest in KelpAddinForte.jar works with Forte. JDeveloper does not rely on manifest entries and be used with either jar.

   Forte automatically loads jars from the modules directory using a separate class loader than is used for the IDE class path. Modules will not function properly if added to the IDE class path directly through the IDE start script.

3. Toggle the Kelp Tools Enabled property

   From the menu, select Tools | Global Options and open the modules section. Locate the Kelp Tools module and set the Enable property to False. Reset the property to True. This will allow Forte to properly recognize the newly installed module.

You should now be able to view Kelp add-in menu items. To check for proper installation, look for the Enhydra Application Wizard in the File menu.

Defining a project class path

Forte projects automatically include all jar files that are in the IDE class path. You can mount individual jar files and add them to your project if they are not already in the IDE class path,

In both JBuilder and JDeveloper, the project class path is independent of the IDE class path. Both IDEs also allow you to define sets of jars as libraries. Libraries may be shared between projects.

The following jars are required to successfully compile and run projects that use the servlet, Enhydra service, Enhydra XMLC or Enhydra Application Framework APIs.

• EAS 4.0.1
  

  <eas_root>/lib/Boot.jar
<eas_root>/lib/build.jar
<eas_root>/lib/ctxrmic.jar
<eas_root>/lib/EAAL.jar
<eas_root>/lib/eaf.jar
<eas_root>/lib/EjbService.jar
<eas_root>/lib/Kernel.jar
<eas_root>/lib/serlvet.jar
<eas_root>/lib/xmlc.jar
<eas_root>/lib/WebService.jar
<eas_root>/lib/Wireless.jar
<eas_root>/lib/LutrisWireless.jar
<eas_root>/tool/lib/toolbox.jar
 


• Enhydra 3.1.1, Lutris Enhydra 3.5.2
  

  <eas_root>/lib/enhydra.jar
<eas_root>/tool/lib/toolbox.jar

ToolBox properties

Using the JDeveloper add-in

This section describes difference between the JDeveloper add-in and what is described in Using Kelp with and IDE.

JDeveloper may lockup if you task switch while the XML Compiler or Kelp Deployer tools are open.

Kelp tools may not work correctly with projects generated through the new Project wizard. Before using Kelp, use the File | New Empty Project option. Once you have an empty project, you can generate a web application, Enhydra application or an Enhydra service with Kelp.

The add-in does not auto-detect the <eas_root> directory. The application wizards uses the <eas_root> to generate command line support files and the Kelp Deployer uses the <eas_root> when determining the default auto-deploy directory. You can set the <eas_root> from the first step of an application wizard or by editing the toolbox properties file.

When you invoke help from a Kelp dialog, the add-in loads help using an external browser instead of using the JDeveloper help system. The first time you open help, you will be asked to select a browser. You can modify your browser selection, by editing the toolbox properties file.

JDeveloper 3.2 runs under JDK 1.2.2. To run projects with Lutris EAS 4, you will need to set the project's Target JDK version to 1.3. You can set the Target JDK through the project's paths property page.

Using Kelp with Enhydra 3.x

• Generating Enhydra Services with the Kelp Application wizard
• Generating or using Ant build files
• Creating Enhydra Service archives (.jar)
• Creating Enterprise JavaBean archives (.jar)
• Creating Enterprise Application archives (.ear)

CVS modules

The source files for the Kelp ToolBox and add-in modules are available from the CVS page of the Kelp project web site. Each module contains an Ant build.xml file. Some of the modules also contain JBuilder projects that you can use to view, debug and build the source.

Kelp includes the following modules.

• AddinConfigure contains configuration templates, scripts and an Ant configure.xml file that you can use to setup your IDE for use with a Kelp add-in.
   
  
• AddinCore contains classes shared by IDE implementation modules. The core classes are used to create property pages, wizards and build tasks for working with XMLC and the Enhydra application server from a Java IDE. It also contains two sample projects.
   
  
• AddinJBuilder contains Borland JBuilder implementations of AddinCore interfaces.
   
  
• AddinJDeveloper contains Oracle JDeveloper implementations of AddinCore interfaces.
   
• AddinForte contains Sun Forte implementations of AddinCore interfaces.
   
  
• Doc contains this document along with Lutris donated documentation for the add-ins, application wizard and archive wizard.
   
  
• Launcher contains a partial implementation of a GUI launcher for EAS. This module is not being worked on at this time.
   
  
• ToolBox contains wizards, templates and command line tools that can be run without an IDE. These tools are built into the toolbox.jar and related scripts that are included with Lutris EAS.
   
  
• Winstall contains an InstallShield project for configuring an IDE for use with the Kelp tool set.

Each module can be built with Jakarta Ant 1.2 provided that you have setup the class paths in each modules lib.properties file. Below is a listing of external dependencies.

• Jar files from Lutris EAS 4.0.1 are required to build AddinCore, AddinJBuilder, AddinJDeveloper, AddinForte and ToolBox.
• Jar files from Borland JBuilder are required to build AddinJBuilder.
• Jar files from Oracle JDeveloper are required to build AddinJDeveloper.
• Jar files from Sun Forte for Java are required to build AddinForte.
• InstallShield Professional is required to build Winstall.

Visit the following news groups for information about the developing add-ins and using the JBuilder OpenTools API:

borland.public.jbuilder.opentools
borland.public.jbuilder.thirdpartytools

Visit the NetBeans site for information about the developing add-ins for Forte using the NetBeans OpenIDE API:

Copyright 2000-2001 Lutris Technologies, Inc.
All rights reserved.