Kelp Project Documentation


 

Kelp 4

EAS developer tools
and IDE add-ins

    Table of Contents

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 can use the project mail list, kelp@enhydra.org to post questions or suggestions regarding any of the Kelp modules. View the mail list archive to get information on recent releases and tips on how to make the most of Kelp.

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

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

The Forte add-in requires Lutris EAS 4 and Forte for Java 2. The Forte add-in does not support Lutris Enhydra 3.5.2, Enhydra 3.1.1 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. Note that Kelp 4 will not work with Enhydra 3.1 and may not function correctly with the daily builds of Enhydra Enterprise.

It is recommended that you go through each step listed in the installation guide so you can run the Enhydra administration console. If you install your Java IDE prior to installing Enhydra, you can skip the step about downloading Java. You can configure the application server to work with the Java 2 files that come with the IDE.

Install Options

Kelp add-ins are available in the following packages:
  • 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.

  • Zip Archives

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

    /home/toni/jbuilder5/kelp4/dist
    /home/toni/jbuilder5/kelp4/doc
    /home/toni/jbuilder5/kelp4/lib
    /home/toni/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/enhydra4, extract the toolbox.jar into <eas_root>/tool/lib.

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

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

  • Open Source Windows Installer

    The kelp.enhydra.org site provides a Windows installer that automatically configures JBuilder and JDeveloper. The Windows installer does not support Forte. Note that Lutris no longer provides support for the Windows installer. To use, refer to Using the open source Windows installer.

Upgrading from Kelp 2 or Enhydra 3.x

If you have configured your IDE for use with earlier releases of Kelp or the Enhydra application server, 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:

    • Enhydra 3.1.1, Lutris Enhydra 3.5.2
      enhydra.jar

    • Enhydra Enterprise (daily build)
      Boot.jar, build.jar, Kernel.jar, Wireless.jar, xmlc.jar
       
    • Lutris EAS 4
      Boot.jar, build.jar, Kernel.jar, Wireless.jar, xmlc.jar, LutrisWireless.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.

    If you have JBuilder installed to /home/toni/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 /home/toni/jbuilder5/kelp4/lib/KelpAddin.jar

    If you have JBuilder installed to /home/toni/jbuilder5 and Lutris EAS 4 installed in an <eas_root> of /usr/local/enhydra4, your addpath statements would be:

    addpath /usr/local/enhydra4/lib/Boot.jar
    addpath /usr/local/enhydra4/lib/build.jar
    addpath /usr/local/enhydra4/lib/Kernel.jar
    addpath /usr/local/enhydra4/lib/xmlc.jar
    addpath /usr/local/enhydra4/lib/Wireless.jar
    addpath /usr/local/enhydra4/lib/LutrisWireless.jar
    addpath /usr/local/enhydra4/tool/lib/toolbox.jar
    addpath /home/toni/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:

    • Enhydra 3.1.1, Lutris Enhydra 3.5.2
      enhydra.jar

    • Enhydra Enterprise (daily build)
      Boot.jar, build.jar, Kernel.jar, Wireless.jar, xmlc.jar
       
    • Lutris EAS 4
      Boot.jar, build.jar, Kernel.jar, Wireless.jar, xmlc.jar, LutrisWireless.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.

You can check to see if you have installed the Kelp add-in correctly by starting JDeveloper and looking for the XML Compiler in the Wizards menu. If the menu does not appear, double check that you have the KelpAddin.jar, toolbox.jar and Enhydra XMLC classes in the IDE class 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. Modify the SET NB_CLASSPATH statement in the runide.bat file as shown:

      SET NB_CLASSPATH=
        c:\usr\local\enhydra4\tool\lib\toolbox.jar;
        c:\usr\local\enhydra4\Boot.jar;
        c:\usr\local\enhydra4\build.jar;
        c:\usr\local\enhydra4\Kernel.jar;
        c:\usr\local\enhydra4\Wireless.jar;
        c:\usr\local\enhydra4\xmlc.jar;
        c:\usr\local\enhydra4\LutrisWireless.jar;
        %PATCH_PATH%;
        %_FORTE4J_HOME%\lib;
        %_FORTE4J_HOME%\lib\developer.jar;
        %_FORTE4J_HOME%\lib\openide.jar;
        %JAVA_PATH%\jre\lib\i18n.jar;
        %JAVA_PATH%\lib\tools.jar;
        %JAVA_PATH%\lib\dt.jar;
        %EX_PATH%

      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/enhydra4/tool/lib/toolbox.jar:
        /usr/local/enhydra4/Boot.jar:
        /usr/local/enhydra4/build.jar:
        /usr/local/enhydra4/Kernel.jar:
        /usr/local/enhydra4/Wireless.jar:
        /usr/local/enhydra4/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.

The add-in does not come with predefined sample projects for Forte. Refer to Using Kelp with an IDE for information on creating Forte projects for the Kelp samples.

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.

  • Enhydra 3.1.1, Lutris Enhydra 3.5.2

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

  • Enhydra Enterprise (daily build)

    <eas_root>/lib/Boot.jar
    <eas_root>/lib/build.jar
    <eas_root>/lib/eaf.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>/tool/lib/toolbox.jar
     

  • Lutris EAS 4

    <eas_root>/lib/Boot.jar
    <eas_root>/lib/build.jar
    <eas_root>/lib/eaf.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
     

ToolBox properties

The IDE add-in uses wizards within the ToolBox library. The ToolBox persists user settings in a toolbox.properties file. This file is created in an .enhydra directory under your home directory:

/home/toni/.enhydra/toolbox.properties

If you experience any problems using the application wizards, verify that you have rights to create files and directories within your home directory.

There are two properties you may need to modify in the toolbox.properties file. They are browser and eas.root. The browser property refers to the HTML browser that will be used to open help from Kelp tools launched from outside of an IDE or from within JDeveloper. The JBuilder and Forte add-ins use the IDE's native help system.

browser=C\:/Program\ Files/Internet\ Explorer/IEXPLORE.EXE

eas.root=C\:/usr/local/enhydra4

Using the open source Windows installer

If you are running on Windows with JBuilder or JDeveloper, you can use the open source Windows installer to install Kelp add-in files and configure your IDE. This installer does not support Forte, 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\enhydra4

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 automatically detects and loads add-ins from the jar files that are listed in the IDE class path. It checks the manifest of each jar in the IDE class path to see if it contains a loadable add-in. If you want to know more about what the installer does to update your IDE configuration, refer to the section configuring your IDE.

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

Kelp 4 provides limited support for Enhydra 3.1.1 and Lutris Enhydra 3.5.2. It does not support earlier versions including Enhydra 3.1 or Lutris Enhydra 3.5. The following Kelp features will not function properly when running 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.

  • 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. It not being actively 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. It currently supports the JDeveloper and JBuilder add-ins.

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.

Refer to the README.BUILD file for more information on building each module.

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.

JBuilder is a trademark or registered trademark of Borland Software Corporation.
JDeveloper is a trademark or registered trademark of Oracle Corporation.
Forte and NetBeans are trademarks or registered trademarks of Sun Microsystems, Inc.
InstallShield is a registered trademark of InstallShield Corporation.