HATS gives you the ability to transform access to your existing host applications using rich client GUI applications that run in Eclipse Rich Client Platform (Eclipse RCP), Lotus Notes®, or Lotus® Expeditor Client environments.
The Eclipse RCP is a subset of plug-ins provided by the Eclipse platform, which is best known as an open source tooling platform. The introduction of Eclipse RCP enables you to use the core functionality provided by Eclipse to build native client applications targeted for a user's desktop. More information about the Eclipse RCP can be found at http://www.eclipse.org/home/categories/rcp.php.
Lotus Notes is powerful, multifaceted software that gives you instant access to all the information that is important to you. You can use Lotus Notes to send and receive Internet mail, schedule appointments, browse the Web, contribute to Internet newsgroups, and take advantage of the Home Page for tracking all your important daily information. For more information see the Lotus Notes Knowledge Center at http://www.ibm.com/support/knowledgecenter/SSKTMJ.
Lotus Expeditor Client provides a rich client runtime environment and integrated middleware components for extending many enterprise applications to server-managed laptop and desktop systems. For more information about developing and deploying applications for Lotus Expeditor Client, see the Lotus Expeditor Knowledge Center at http://www.ibm.com/support/knowledgecenter/SSVHEW.
Unless otherwise noted, the instructions documented here apply to developing and deploying HATS rich client applications in Eclipse RCP V3.7, Lotus Notes V8.5.3, and Lotus Expeditor Client V6.2.3 environments. For instructions that apply to earlier versions of Eclipse RCP and Lotus Expeditor Client, see earlier versions of the appropriate Knowledge Centers.
A rich client environment offers capabilities not available in a traditional Web environment, including:
Additional information and help about developing rich client applications can be found in the Rational® SDP Help Contents. Select Help > Help Contents on the menu bar and search for rich client.
When creating HATS rich client applications, the distinction between Eclipse RCP, Lotus Notes, and Lotus Expeditor Client environments is minimal. Differences are documented throughout this chapter.
The primary architectural difference between a HATS rich client application and a HATS Web application is in where the Telnet socket connection initiates. With a rich client application, the socket connection initiates from a user's workstation, not from the WebSphere Application Server, as it does with a traditional HATS Web application. Because rich client applications will require a client on a user's workstation, these applications are primarily targeted for internal users, who are accustomed to using a traditional, fat client terminal emulator.
The steps for building and testing a HATS rich client application are essentially the same as those for a HATS Web application. You use HATS Toolkit with tools provided in the HATS perspective to develop a HATS rich client project from which a HATS rich client application is generated. The same wizards, editors and views are provided to support the various activities required during development.
As with HATS for the Web environment, you develop the appearance and operation of the application, including customizing default rendering settings, screen navigation (by way of skip screen macros), and the fonts and colors used to render screens.
The majority of features available in a HATS Web application are also available in a HATS rich client application. These include, but are not limited to:
Features available in HATS Web applications that are not available in HATS rich client applications include:
A HATS rich client project is an Eclipse plug-in project. As a project, it exists in a workspace and is developed by a HATS application developer. Once developed and tested, the project is exported as a HATS rich client application, which is an Eclipse plug-in that can be installed into an Eclipse environment. An Eclipse plug-in is a component that provides a certain type of service within the context of an Eclipse environment. In the case with HATS, the plug-in provides the service required to transform a host application.
Each HATS rich client application plug-in depends on several runtime plug-ins. The dependencies are referred to in the rich client project's manifest file, MANIFEST.MF. You must ensure these required plug-ins are included in your local test environment and in the deployed production environment for your HATS rich client plug-in to run properly. For more information see HATS RCP Runtime Extension project, Testing HATS rich client applications, and Deploying HATS rich client applications.
When you create a HATS rich client project, you are prompted to select a target platform. This selection indicates where you plan to deploy the application. The differences between a project targeted for deployment to Eclipse RCP and Lotus Notes or Lotus Expeditor Client are minor. The following characteristics are common to every HATS rich client project:
Addition for projects targeted for deployment to Eclipse RCP:
Additions for projects targeted for deployment to Lotus Notes and Lotus Expeditor Client:
The Java runtime environment (JRE) of both your Rational SDP workspace and your intended runtime environment must be the same. For example, if you are developing a HATS rich client plug-in to run on an Eclipse environment that is running a 1.6 Java runtime environment (JRE), you must set the compiler compliance level of your workspace to 1.6. To do this, from the Rational SDP menu bar, select Window > Preferences > Java > Compiler and set the Compiler compliance level to 1.6.
If you have other Java or plug-in projects in your workspace that require other compliance levels, you can set the compiler compliance level for individual Java or plug-in projects. To do this, right-click on the project and select Properties. In the Properties panel select Java Compiler on the left. Then select the Enable project specific settings box and set the Compiler compliance level to the appropriate level.
When you create a HATS rich client project, a project for the HATS RCP Runtime Extension plug-in (from here on referred to as the runtime extension plug-in), is automatically created if one does not already exist in the workspace. The runtime extension plug-in has a name and plug-in ID of com.ibm.hats.rcp.runtime.extension and an initial version of 1.0.0.
The runtime extension plug-in is an extension of the HATS RCP Runtime (com.ibm.hats.rcp.runtime) plug-in. The HATS RCP Runtime plug-in contains the HATS runtime classes, and it must be in the environment for HATS rich client applications to function. The runtime extension plug-in provides you the ability to configure settings related to the runtime environment.
This plug-in project contains the following configurable artifacts:
This project is similar to a HATS EAR project in the Web environment, but there is only one of these plug-ins per runtime environment. That is, there is only one runtime extension plug-in running in the user's environment. Every HATS rich client project plugin.xml file declares a dependency on this plug-in. The runtime extension plug-in does not refer to individual HATS application plug-ins.
Because only one copy of the runtime extension plug-in can run in the runtime environment, you must ensure only one copy of the plug-in exists in a user's environment. If more than one runtime extension plug-in exists in the environment, the plug-in with the highest version number is used by the environment. This ensures that the newest code is always used.
The runtime extension project is not visible in the HATS Projects view but is visible in the Navigator view. It is included as part of the feature project generated during export time. For more information see Deploying HATS rich client applications.
As with a HATS Web project, when you create a new HATS rich client project, a set of folders is created to help you organize your HATS files. An example of a default project is shown below. The highest level folder has the same name as the name you give to your project when you create it. In that folder are other high-level folders that contain objects defined in your HATS project. Some folders do not appear until you create certain objects.
Depending on how you set up your project, some or all of these folders appear in the HATS Projects view. You can also specify which folders appear in your HATS Projects view as well as hide file extensions. For more information, see Using HATS preferences.
You can create subfolders within these high-level folders to help organize your project. For instance, as you create screen captures for your project, you might want to create folders under the Screen Captures folder to organize and group the captured screens. To create a folder, right-click on one of the high-level folders in the tree and click New HATS > Folder. To move a file into a different folder, right-click on the file and select Move, or you can use the drag-and-drop method.
HATS projects can be shared in a team environment by going to the Navigator View of the HATS perspective. Right-click the project and select Team > Share Project. Select the repository type from the list and click Next. Rational SDP supports several repositories. For more information, refer to the Rational SDP documentation and search on repository.
To exclude the file from version control, open Window -> Preferences -> Team -> Ignored Resources and click Add Pattern to add a new pattern. Enter resourceUpdate.sts and click OK. Make sure the new pattern is selected in the list of ignored patterns, and click OK to save the settings.
You can copy, paste, delete, move, and rename rich client resources using the pop-up menu in the HATS Projects view. The following resources can be copied or moved between HATS Web and HATS rich client projects:
Some resources copied from projects of different types will need modification. For example, a macro copied from a HATS Web project to a HATS rich client project will need to be updated to refer to a valid SWT Java macro handler (for HATS Web projects, macros refer to a JSP macro handler). Screen customizations will also need to be updated because of references to JSP transformations specified in the apply action and because of URLs specified in the forward action. A warning message will appear in the Problems view to help you find and fix these problems. The following scenarios will be flagged:
There is no built-in function to migrate a HATS Web application to a HATS RCP application. Some artifacts, such as screen customizations, macros, connections, screen captures, images, business logic source files, and custom component source files can be manually migrated, with minimal changes, from one project type to another. Other artifacts, such as transformations, custom widgets, templates, and custom macro handlers require more extensive changes to work in a project of a different type.
To move a HATS rich client project to another system with Rational SDP installed, or to save and restore a project for any other reason, you can use the export and import capabilities of Rational SDP.
Export a project and its dependent projects as a zipped file using the Rational SDP archive file function. This function has multiple benefits. It allows you to export multiple projects and the required runtime extension project (com.ibm.hats.rcp.runtime.extension) all at once. In addition, you do not have to create a project on the destination HATS Toolkit before you import the archive file. To export the project(s) from HATS Toolkit as an archive file:
To import an archive file (or a project interchange file from an older release of Rational SDP) into HATS Toolkit:
To test a HATS rich client application plug-in in a local test environment, you launch the plug-in, and required runtime plug-ins, in an instance of the target platform.
The target platform refers to the Eclipse product (for example, Eclipse RCP, Lotus Notes, or Lotus Expeditor Client) against which the plug-in you are developing will be compiled and tested.
By default the target platform is Rational SDP itself, therefore no configuration is necessary for Eclipse RCP.
To configure the target platform for Lotus Notes (or Lotus Expeditor), perform the following steps.
In order for a HATS rich client application plug-in to run in the target platform's local test environment, the required runtime plug-ins must be installed in the target platform.
The Eclipse RCP target platform is Rational SDP itself. Because the HATS Toolkit is installed in Rational SDP, the HATS runtime plug-ins are already installed for the Eclipse RCP target platform. The remainder of this section pertains to installing runtime plug-ins when using the Lotus Notes (or Lotus Expeditor) target platform.
When you create a new project and select the Lotus Notes (or Lotus Expeditor) target platform, or later change the target platform, the HATS Toolkit will detect if the required runtime plug-ins are installed and at the latest level in the selected target platform. If not, the toolkit will prompt you to have the latest runtime plug-ins installed. You can enable or disable this prompt using HATS Preferences. See Using HATS preferences for more information. Following are the required runtime plug-ins that are installed:
After you configure a new target platform for Lotus Notes (or Lotus Expeditor) and install the latest HATS runtime plug-ins in the target platform, see Configuring the target platform, you must reload the new plug-ins. To do this, perform the following steps .
In addition to configuring the target platform and installing the runtime plug-ins, you may need to set the default JRE for your workspace in Rational SDP.
When testing on an Eclipse RCP target platform, set the default JRE to jdk. To do this perform the following steps:
Ensure your JRE's match. For example, if you are testing on an Eclipse environment that will be running Java 1.6, you should update the JRE of the workspace to match the JRE of the runtime environment.
When testing on a Lotus Notes target platform, perform the following steps:
When testing on a Lotus Expeditor target platform, perform the following steps:
To launch your project, a launch configuration is required. HATS creates a default launch configuration for you when you click either Run or Debug for your project (see the instructions in the sections below). A launch configuration is not created when the Run or Debug dialog is opened from another view, for example, the Package Explorer view. The default launch configuration is based on the target platform of the project, which is set in the New Project wizard or in the Project Settings editor. If you modify the default launch configuration to the point where it can no longer launch a runtime workbench, you can delete the launch configuration, and HATS will re-create it when Run or Debug is clicked again. To launch your project, follow the instructions in the sections below for your target platform.
To launch your project in the local test environment for Eclipse RCP, perform the following steps:
Lotus Notes must be installed on the same development workstation as Rational SDP in order to locally test a HATS plug-in targeted for Lotus Notes. Lotus Notes must not already be running when you attempt to test your project because only one instance of Lotus Notes can be running at any given time. See Configuring the target platform.
To launch your project in the local test environment for Lotus Notes, perform the following steps:
Lotus Expeditor Client for Desktop must be installed on the same development workstation as Rational SDP in order to locally test a HATS plug-in targeted for Lotus Expeditor. See Configuring the target platform.
To launch your project in the local test environment for Lotus Expeditor Client, perform the following steps:
Regardless of where you obtain the HATS package (HATS CD, Web, or packaged with another product), you install the same version of the HATS Toolkit. This is a limited-use version that you can use to evaluate HATS. To fully enable the runtimes for production in accordance with your licensed proof of entitlement, you must specify your license settings using the License Settings wizard included in the HATS Toolkit. For more information see the section, Enabling HATS runtime and license settings, in HATS Getting Started.
This section describes two different methods for deploying HATS rich client applications. The first method can be used to package a complete Eclipse client environment for distribution that has everything necessary to run your HATS rich client application. The second method can be used to package your HATS rich client application for clients that already have an Eclipse environment installed.
The Eclipse SDK, on which the Rational SDP is based, provides the ability to generate a complete Eclipse client which includes your HATS application plug-ins and all other required plug-ins. This client can be distributed to individual client systems and run as a stand-alone application.
To create the client package, perform the following steps:
A complete Eclipse client environment is created. To test your application, use Windows Explorer to navigate to the c:\hostaccess directory. From the eclipse folder double-click eclipse.exe. This directory can be zipped up and downloaded to individual client machines. All that is required on the client system is a compatible Java Runtime Environment (JRE).
To deploy your HATS rich client application in an existing Eclipse client runtime environment you must:
The following sections describe how to perform each of these tasks.
To deploy your HATS rich client application plug-in to a runtime environment, you must first package it into an Eclipse feature. An Eclipse feature is a deployment artifact used to package associated plug-ins. To package your plug-in into an Eclipse feature, perform the following steps.
If you have not specified your license settings, you will see a message that this application is not runtime enabled and cannot be run in a production environment.
HATS rich client applications can be tested in a local test environment (Eclipse, Lotus Notes, or Lotus Expeditor Client), but cannot be run in a runtime (non-development) environment without first specifying license settings. This means that you can create and fully test an application in the HATS Toolkit development environment. You can also export the application, and a user can install it, but the user will not be able to connect with the application. That is, the runtime will be locked down and will not allow for any connections. For information about specifying license settings, see Enabling HATS runtime and license settings in HATS Getting Started.
If licenses have been purchased, click Enable Runtime to runtime enable your application. Otherwise, click Continue to continue the export process.
Your exported HATS rich client application feature automatically includes the runtime extension plug-in and automatically includes a dependency on the HATS runtime features. The feature project is not displayed in the HATS Projects view, but is displayed in the Navigator view.
If you want to perform more advanced configuration of your HATS rich client application feature, instead of using the Create a HATS Feature Project wizard, you can use the standard Eclipse New Feature wizard provided by Eclipse. To launch this wizard, from the Rational SDP toolbar select File > New > Other > Plug-in Development > Feature Project. This wizard performs basically the same functions as the Create a HATS Feature Project wizard except it does not automatically include the runtime extension plug-in, and it does not include the necessary dependencies on the HATS runtime features.
In a production environment, a HATS rich client application feature depends on the HATS runtime features being installed on the client. When you create a HATS rich client application feature using the Create a HATS Feature Project wizard, it automatically includes a dependency on the HATS runtime features. This dependency is what causes the feature install and update process to automatically pull down the HATS runtime features from the update site when a HATS rich client application feature is installed or updated. The HATS runtime features include the following features and plug-ins:
To export the HATS runtime features, perform the following steps:
After exporting both your HATS application feature and the HATS runtime features, you must create an update site that can be used by the feature install and update process to deploy your application. To create an update site, perform the following steps:
You have now created an update site, in this example c:\myHATS, including the site.xml file that indicates what features, and versions of those features, are available from the site for download by a client. You can now move this update site directory to a Web server that can be accessed by clients. For instructions on how to define an update site on the client system and install your HATS rich client applications in a runtime environment, see Installing your application in a runtime environment.
HATS rich client applications can run in Eclipse RCP, Lotus Notes, and Lotus Expeditor Client environments. The following sections describe how to install your HATS rich client application in each of these environments.
To download and install your HATS rich client application in an Eclipse rich client environment, the client environment must be configured to access the update site containing the application. By default, since automatic install and update is disabled, the user or administrator must manually install the new features or updates using the standard Eclipse Software Update functions. To do this perform the following steps on the client system.
For more information about the Eclipse RCP environment see http://www.eclipse.org/home/categories/rcp.php.
In the Lotus Notes environment, a widget is used to install applications that are provided as features and plug-ins. The widget can later be published to a Widget catalog for others to use. For more information about widgets, see the Widgets and Live Text section in the Lotus Notes Knowledge Center at http://publib.boulder.ibm.com/infocenter/domhelp/v8r0/index.jsp?topic=/com.ibm.notes85.help.doc/wid_app_overview_c.html .
To download and install your HATS rich client application in a Lotus Notes environment, perform the following steps on the client system:
The My Widgets Sidebar panel will look similar to this:
You can run your application by selecting Open > Host Access. Your HATS application is listed in the Applications view. To start your application, either double-click it or right-click and select Open.
To uninstall the HATS application, right-click the HATS Provisioning Widget (or whatever name you gave it) and select Remove. Restart Lotus Notes when asked.
In the Lotus Expeditor Client environment application management and deployment can be controlled in a number of ways:
For the Lotus Expeditor Client, the following features must be added to the default installation:
From the Lotus Expeditor Client, select File > Application > Install > Search for new features to install > Add folder location. Browse to the following folder in the Lotus Expeditor Client product files: desktop\updates\platform and select Finish. Expand updates/platform and Development. Put a check mark beside Lotus Expeditor Desktop Development Utilities. Select Next and complete the wizard.
For Lotus Expeditor Client versions 6.2.0 and earlier, to install the Core JVM Feature - J2SE, from the Lotus Expeditor Client, select File > Application > Install > Search for new features to install > Add folder location. Browse to the Desktop Runtime Environment site location, which is the update.site.dre.client directory and select OK. Accept the default site name and select OK and Finish. Expand the site and Runtime Components. Put a check mark beside Core JVM Feature - J2SE. Select Next and finish the wizard.
For more information, see the Assembling and Deploying Lotus Expeditor Applications section in the Lotus Expeditor Knowledge Center at http://publib.boulder.ibm.com/infocenter/ledoc/v6r2/index.jsp.
To download and install your HATS rich client application in a Lotus Expeditor Client environment, the client must be configured to access the update site containing the application. To do this perform the following steps on the client system.
The rich client environment allows for the automatic update of installed applications. Preferences are available for controlling how often the server is checked for updates. Once you upload an update to an application, the rich client will download and install the update. Version checking is performed to make sure only new updates are downloaded and installed. In most cases, the user will need to restart the environment to activate the updated application. For more information, see the appropriate Eclipse RCP, Lotus Notes, or Lotus Expeditor documentation.
Before you can update a plug-in that is already installed, you must update the plug-in's version because Eclipse uses the version to determine if a plug-in has changed. For example, if you add a screen customization or modify a macro in your project, you must update your plug-in's version before re-exporting it.
To update your plug-in's version, in the Project Settings editor for your project, on the Overview tab, click the open the plug-in manifest link. On the Overview tab, under General Information, update the version. An Eclipse version is in the form major.minor.service. When making a minor change to the project, update the service segment of the version. For example, before exporting your plug-in a second time, set your plug-in's version to 1.0.1.
Because the License Settings wizard updates the runtime extension project (com.ibm.hats.rcp.runtime.extension), after running the wizard you must update the version of this plug-in. To do this, in the Navigator view, open the plugin.xml file located at the root of the project. On the Overview tab, under General Information, update the version.
Also, because features are made up of plug-ins (and features also have versions), you must update the version of your feature whenever you update the version of one of the included plug-ins. To do this, switch to the Navigator view and open the feature.xml file located in your feature project. By default the name of your feature project is hostaccess. On the Overview tab, under General Information, update the version. In addition, ensure that your feature correctly lists the new versions of your plug-ins by clicking the Versions button on the Plug-ins tab and selecting Copy versions from plug-in and fragment manifests.
After your feature's version has been updated, you must update your site.xml file (if applicable) to ensure that it lists the new version of your feature.
For HATS rich client applications, runtime settings, such as log and trace settings, are specified in two files in the runtime extension plug-in (com.ibm.hats.rcp.runtime.extension):
For more information about running in different test modes see Testing modes for rich client projects in HATS Getting Started.
While in the HATS Toolkit, you can edit these files to change settings, for example trace and trace level settings. The files are located in the root of the runtime extension plug-in project. Be aware that any changes made to the runtime.properties file in the HATS Toolkit are retained and become effective when you deploy the HATS application to a runtime environment. In the runtime environment, the runtime.properties file is located in the runtime extension plug-in directory, for example, <eclipse_install_dir>/eclipse/plugins/com.ibm.hats.rcp.runtime.extension_1.0.0. The runtime-debug.properties file is ignored in the runtime environment. For more information about log and trace settings in these files, see Appendix A. Runtime properties files.
For information about how the user can configure log and trace settings and gather problem determination data in the runtime environment, see Preferences.
There is just one runtime extension plug-in project in the workspace, and just one version of the plug-in in the runtime environment. Therefore, in any single HATS rich client runtime environment, log and trace settings are the same for all HATS rich client applications.
License settings are also stored in the runtime.properties file of the runtime extension plug-in (com.ibm.hats.rcp.runtime.extension). Therefore license tracking is performed at the rich client environment level and not at the level of an individual HATS rich client application. Warning messages will appear in the log if the user goes over the number of licenses purchased. For information about specifying license settings, see Enabling HATS runtime and license settings in HATS Getting Started
The Applications view displays for the user all active HATS rich client applications installed in the runtime environment. The view is sorted by application display name. By default, this view is displayed the first time the user opens the Host Access perspective. The user starts a new instance of a HATS application by double-clicking the application in the Applications view, or by right-clicking on the application name and selecting Open.
After starting a new instance of a HATS application, its transformation view is displayed. See Transformation view for more information. By default, the name of the newly opened transformation view is the name of the application. If more than one instance of the application is started, the name of the transformation view will be a combination of the name of the application plus a number indicating the instance of the session. For example, the title of the second instance of the application named Order Entry will be titled Order entry : 2.
By default, a user can launch multiple instances of the same application. You can modify the plugin.xml file to disallow launching multiple instances. Also, you can decide not to show the Applications view and instead control what views are available to the user. This can also restrict the number of instances of an application. For more information see the HATS Rich Client Platform Programmer's Guide.
If the application is running in the local test environment and if you have selected to see the display terminal, a display terminal window will be displayed when the connection is made to the system. The window will close when the session has ended, or if the client is shut down.
A pop-up menu is provided to enable the user to perform actions on one or more applications in the view. Select one or more application names and right-click to show the menu. The following menu items are available:
If you allow overrides, this page allows the user to override connection parameters. This function is equivalent to the HATS function for Web applications that allows a user to override connection parameters using the URL when the application is first accessed. An example of using connection parameter overriding might be where the user needs to override a workstation ID or LU name.
The user sets an override by clicking the Add button, selecting a parameter from drop-down list for the Name field, and setting a value in the Value field. No validation within the dialog is performed to alert the user whether the supplied connection parameter name can be overridden. By default, the override setting is enabled when first added. It can be disabled by clearing the check box next to the parameter name.
When the user overrides a connection parameter, the settings are saved on the local workspace. Overridden parameter values are used when an instance of the session is started.
For information about programmatically starting a rich client application instance using connection parameter overrides, see the HATS Rich Client Platform Programmer's Guide.
If you allow overrides, this page allows the user to override global variables. This function is equivalent to the HATS function for Web applications that allows a user to override global and shared global variables using the URL when the application is first accessed.
This capability allows user-specific variable data to be used in the application. For example, you can record a macro that prompts for a user name and password supplied from the values of global variables. The user can supply these values in the variables override page. These values are then used when the macro is run when the sign on screen is recognized.
The user sets an override by clicking the Add button, selecting a variable name from drop-down list for the Name field, setting a value in the Value field, and specifying whether the global variable is Shared. No validation within the dialog is performed to alert the user whether the supplied global variable name can be overridden. By default, the override setting is enabled when first added. It can be disabled by clearing the check box next to the variable name.
When the user overrides a global variable, the settings are stored in the data directory of the environment. Overridden global variable values are used when an instance of the session is started.
For information about programmatically starting a rich client application instance using global variable overrides, see the HATS Rich Client Platform Programmer's Guide.
In the rich client environment, the user has the ability to print the current screen transformation by selecting Print from the File menu. By default, Eclipse displays the Print dialog where the user can select the printer and also configure other options. After the user clicks OK, the transformation area of the transformation view is sent to the selected printer.
The transformation view is the main area for transformation in the rich client environment. Each HATS rich client project has one transformation view associated with it. The view is registered in the plugin.xml file of the project when the project is created. The view is composed of four areas:
The transformation view toolbar contains buttons for application-level actions as well as buttons for actions contributed by the Toolbar widget, during screen rendering. By default, the toolbar is displayed, and the buttons display with text-only captions. You can change these settings in the project settings. See Toolbar RCP-only for more information.
The toolbar is divided into two sections. The right side of the toolbar is equivalent to the application keypad in a HATS Web application and contains application keypad buttons. See Application keypad for how to configure which buttons to display. The left side displays buttons contributed by the Toolbar widget. See Toolbar RCP-only for more information.
Tooltip text that provides a description of the button's function is available on all application keypad buttons. You can set tooltip text on buttons you add using the Toolbar widget.
Above the application keypad buttons on the toolbar, next to the Minimize and Maximize icons is a Menu icon. Clicking this icon displays a menu with the following menu items:
The template and transformation area is the main part of the transformation view and is where all screen transformations are displayed. It is also the area where error messages, disconnect messages, and macro handler panels, are displayed.
The host keypad displays the host keys you select to display in the project settings. See Host keypad for how to configure your host keypad. By default, no host keypad is displayed.
The OIA status area displays the information about the state of the session that you configure in the project settings. See Operator information area for how to configure your OIA status area.
The connection to the host system is closed when the view is closed. This occurs if the user explicitly closes the view or closes the rich client environment. When closed, the set of actions defined in the disconnect and stop events are processed.
When you create or edit a host connection, you can specify that the user be prompted to enter a workstation ID for connecting to a 5250 host. See Creating a connection for more information. If you specify prompting for the workstation ID, the user is presented a prompt dialog when first connecting to the host. The user can then enter a workstation ID in the Workstation ID field.
A check box is provided that, if selected, causes the workstation ID to be saved and prevents future prompting. If the check box is selected, prompting can later be restored by disabling the workstationID connection parameter override in the application's properties. See Connection Parameters for more information.
When you create or edit a host connection, you can specify that the user be prompted to enter an LU name for connecting to a 3270E host. See Creating a connection for more information. If you specify prompting for the LU name, the user is presented a prompt dialog when first connecting to the host. The user must enter an LU name in the LU Name field.
A check box is provided that, if selected, causes the LU name to be saved and prevents future prompting. If the check box is selected, prompting can later be restored by disabling the LUName connection parameter override in the application's properties. See Connection Parameters for more information.
By default, users can access preferences by selecting File > Preferences > Host Access from the runtime platform menu bar. The pages displayed are registered in the runtime extension plug-in. If you do not want to provide these functions to the user, you can remove the applicable declarations in the plugin.xml file of the runtime extension plug-in. For more information about how to do this, refer to the description of the org.eclipse.ui.preferencePages extension point ID in the HATS runtime extension plug-in section of the HATS Rich Client Platform Programmer's Guide. The following preference settings can be selected:
The following print preferences can be set by the user for applications that support 3270 printing:
A message is displayed indicating to the user that a print job has started.
The message, Print job {0} has completed., is displayed. Where {0} is the print job name.
The message, Print job {0} has encountered an error., is displayed. Where {0} is the print job name.
The following troubleshooting preferences can be set by the user. For more information about log and trace settings, see Administering HATS rich client applications.
The trace file is saved in the host simulations folder in the rich client environment. For example, in the Eclipse RCP environment on Windows it is saved in, <Eclipse installation directory>\plugins\<ApplicationName_version>\profiles\hostsimulations\. In the Lotus Notes environment on Windows it is saved in, <Lotus Notes installation directory>\Data\workspace\applications\eclipse\plugins\<ApplicationName_version>\profiles\hostsimulations\. In the Lotus Expeditor Client environment on Windows it is saved in, <Lotus Expeditor Client installation directory>\shared\eclipse\plugins\<ApplicationName_version>\profiles\hostsimulations\. In the Lotus Expeditor Client environment on Linux it is saved in, /opt/IBM/Lotus/Expeditor/shared/eclipse/plugins/<ApplicationName_version>/profiles/hostsimulations/.
Trace files are named using the following template, ApplicationName_ConnectionName_Date(yyyymmdd)_Time(hhmmss)_Number, for example, MyApplication_main_20060101_134543_1.
Following is a list of considerations and limitations when using HATS rich client applications: