Process Designer provides a way to import Java packages and other custom
code as described in the following sections.
Besides using the standard function blocks that Activity Editor provides,
Process Designer allows you to import your own Java library for use as
function blocks in the Activity Editor. Importing custom Jar libraries
into activity settings will enable any public methods in the Jar library to be
used as function blocks in the Activity Editor.
Before you begin: Export your Java classes into a
.jar file.
To import a Jar library into Activity Editor:
- Open the Activity Settings view in System Manager by clicking Window >
Show View > Other and selecting Activity Settings from the System Manager
category.
- Right-click BuildBlock Libraries and select Add Library. Figure 60 shows the Activity Settings view for adding a custom Jar
library.

Figure 60. Activity Settings view
- In the Open File dialog box, navigate to your custom
.jar files and select Open.
System Manager will try to import your custom .jar file
for use as function blocks in Activity Editor. If the file is imported
properly, the name of your custom .jar file will appear
under BuildBlock Libraries in the Activity Settings view.
- Tip:
- After importing your custom .jar files into Activity
Settings, when your maps and collaboration template compile in the System
Manager, the custom .jar file will automatically be included
into the compile CLASSPATH. To prepare the InterChange
Server for compilation, make sure that its CLASSPATH includes your
custom.jar file. For information on setting up
InterChange Server for importing your custom .jar files, see
Importing third-party classes to InterChange Server.
- Restart the Process Designer.
- Rule:
- After you change any settings in the Activity Settings view, you must restart
the Process Designer for the change to take effect in the Activity
Editor.
- Result:
- When you open the Activity Editor, the custom Jar library will be listed in
the Library window under My Library in Activity Editor. By default,
available custom function blocks are listed according to their package
structure. You can use them in an activity the same way as you use
standard function blocks.
You can customize the display settings of function blocks imported into the
Activity Editor, such as its name and icon, by changing the custom Jar
library's properties. To change the Jar library's
properties:
- Display the Properties window for the custom Jar library by right-clicking
on your custom Jar library listed under BuildBlock Libraries in the Activity
Settings view in System Manager.
- Result:
- When the Properties window for the custom Jar library is opened, it will list
the available function blocks in this custom library in a tree structure on
the right-hand side of the dialog. The available function blocks are
listed as child nodes under the Java class and package that contain
them.
For the Java package and classes, you can customize the display name of the
entry and whether Activity Editor should display this Java package/class in
the My Library tree structure by changing the check box "Hide level in tree
display." If this option is enabled, Activity Editor will not display
this entry in the My Library subtree. This option is usually useful
when the Java methods in your custom Jar library are in a Java class that is
in a package many levels deep. Enabling this option better organizes
your My Library subtree in Activity Editor.
Figure 61 shows the dialog for customizing the Jar library
display.

Figure 61. Properties dialog for customizing Jar library display
For those Java methods used as function blocks in the Activity Editor, you
can specify the function block display name, description, icon, and
parameter's display name in the Properties window. When you import
an icon for the function block, the icon that you select will be copied into
the Activity Settings folder and will be available for other function blocks
in the same package to use.
- Recommendation:
- When importing an icon for your function block to use, the icon should be 32
pixels by 32 pixels in size and should be in .bmp
format. The color depth of the icon can be up to 24-bit.
Figure 62 shows the Properties dialog for customizing the Jar library
function block display.

Figure 62. Properties dialog for customizing Jar library function block display
Rule: After changing any settings in the Activity Settings
view, you must restart Process Designer for the change to take effect in the
Activity Editor.
If the imported classes are in a third-party package rather than in the
JDK, to set up the server compile, you must add them to the path of the
imported classes in the
JCLASSES variable.
- Recommendation:
- Use some mechanism to differentiate those classes in JCLASSES that
are standard from those that are custom.
Example: You can create a new variable to hold only those
custom classes and append this new variable to JCLASSES, by doing
the following:
- Create a new property, such as one called DEPENDENCIES.
- Place the CwMacroUtils.jar in its own directory.
Example: Create a dependencies directory below
the product directory and place the jar file in it.
- Add the dependencies directory to the file used to start
InterChange Server (by default, start_server.bat or
CWSharedEnv.sh), which is located in the bin
directory below the product directory. For example, add the following
entry for UNIX:
set DEPENDENCIES=$ProductDir/
dependencies/CwMacroUtils.jar
Add the following entry for Windows:
set DEPENDENCIES="%ProductDirS%"\dependencies\
CwMacroUtils.jar
- Add DEPENDENCIES to the JCLASSES entry:
For UNIX, add:
set JCLASSES=$JCLASSES:ExistingJarFiles:
$DEPENDENCIES
For Windows, add:
set JCLASSES=ExistingJarFiles
;%DEPENDENCIES%
- In each map that uses the classes, include the
PackageName.ClassName specified in the
CwMacroUtils.jar file.
- Restart InterChange Server to make the methods available to the
maps.
- Note:
- Be sure you have modified the Compiler Classpath preference for compiling the
maps and collaboration templates from System Manager. To modify the
Compiler Classpath preference:
- In System Manager, select Window > Preferences to open the Preference
dialog.
- Expand System Manager Preferences, and select Compiler.
- In the Compiler preference page, click New and select the
.jar file to be included in the compile CLASSPATH
for maps and collaboration templates.
- Guidelines:
- When importing a custom class, you may get an error message indicating that
the software could not find the custom class. If this occurs:
- Check that the custom class is part of a package. It is good
programming practice for custom classes to be placed in a package. Make
sure that the custom class code includes a correct package statement and that
it is placed at the beginning of the source file, prior to any class or
interface declarations.
- Verify that the import statement is correct in the map
definition code. The import statement must reference the
correct package name; it may further specify the name of the custom class
or it may reference all classes in the package.
Example: If your package name is
COM.acme.graphics and the custom class is
Rectangle, you can import the entire package:
import COM.acme.graphics.*;
Or, you can import just the Rectangle custom class:
import COM.acme.graphics.Rectangle;
- Be sure that you have updated the
CLASSPATH environment variable to include the path to the package
containing the custom class, or to the custom class itself if it is not in a
package.
Example: When importing a custom class, you might create a
folder called %ProductDir%\lib\com\<ProductDir>\package,
where package is the name of your package. Then, place your
custom class file under the folder you just created. Finally, in the
CLASSPATH variable in the
start_server.bat file, include the path
%ProductDir%\lib.
