Rational® Rose® Release Notes

Version 2003.06.00

UNIX/Linux

© 2003 Rational Software Corporation. All Rights Reserved.

Any reproduction or distribution of this work is expressly prohibited without the prior written consent of Rational.

Legal Notices Information

Scope

These Rational Rose release notes provide:

• System and software requirements
• New features and enhancements
• Any defects fixed since the last release
• Current known defects and defect workarounds

Updated versions of the release notes will periodically be posted on the World Wide Web. Please check the Rational Web site at http://www.rational.com/support/documentation/release/ to ensure that you are using the latest version of this document.

When you are ready to install Rational Rose, be sure to check the Web for the latest available downloads:

1. From http://www.rational.com, click Support.
2. Go to the Download Center and navigate to Rational Rose Upgrades and Patches.

Also remember to have the Rational Rose Installation Guide available to provide all the information you need to complete your installation.

Product Definition

Rational Rose helps customers design and develop software in an Internet-connected, global economy. As the Internet has grown to dominate both business and technology decisions, all organizations face a software development paradox. Traditionally, development organizations could choose between higher software quality or reduced time-to-market. In the new Internet economy, organizations have no choice: they must deliver higher quality software in less time. Rational Rose helps companies overcome the software paradox by unifying the communities that develop software with a common visual language that accelerates the creation of flexible applications with robust, resilient architectures.

Contents

What's New in This Release
Hardware/Software Information
Hardware Requirements
Software Requirements
General Install Information

• Pre-Installation Information
• Hardware / Software Patch Requirements
• Configuring Window Manager So Pop-Up Windows Will Remain On Top of their Parent Windows
• Running Multi-threaded GUI Applications on Multi-processor Solaris 2.6 Computers
• Displaying on Ultrabook, Using PGX Graphics Card
• Running Rose for UNIX/Linux on HP-UX 11.00 with HP-UX OS Patch PHSS_21493
  Installing and Utilizing Fonts Compatible on Both PC and UNIX/Linux Displays

Getting Started 
Core Rose and Rose Extensibility Interface
Rose C++ Add-In's and (ANSI C++, Rose C++)
Rose Ada Add-In
Rose Apex Add-In (Note:  Not Available on Linux)
Rose ClearCase  Add-In
Rose CORBA Add-In
Rose DDL Add-In
Rose Framework Add-In
Rose J Add-In
Rose Model Integrator Add-In
Rose Web Publisher Add-In
Rose XML DTD Add-In
Contacting Rational Technical Support

What's New in This Release

This release of Rational Rose includes these new features and enhancements:

• Rose 2003.06.00 creates models in a new petal version due to fixes / enhancements made to the CORBA Add-In (see "Updates to CORBA Actions" below)
• Enhanced Pattern Content, by adding patterns for:

• Gang of Four (GOF) - Analysis Mode

• Model Integrator Output File (Conflicts Logged)

• You may create a hardcopy of the conflicts reported by the Model Integrator

• JDK 1.4 Framework Included
• Updates to CORBA Actions

• CORBA Add-In actions include enhancements, involving attribute types, operation return types. operation parameter types, and operation exception types in Round Trip Engineering.

IMPORTANT:  Once the CORBA Model is converted by Rose 2003, it is no longer compatible with previous versions of Rose.  It is important, upon upgrading to Rose 2003, no users perform work on this model in a previous version of Rose as this can cause model corruption.

• Visual MainWin Control Panel now available - to configure application settings (i.e. Printer Settings)
• Integration Support for JBuilder 8.0 Added.
• Ability to Quickly and Easily Change the Default Language via Rose Main Window

Hardware/Software Information

System and Software Requirements

This section describes the system and software requirements for installing and running Rational Rose and its add-ins.

Hardware Requirements and Configurations

Table  1 contains the hardware requirements for installation and use of this product. Note that the recommended amount of memory is only the suggested minimum amount. Additional memory may improve performance. Your memory requirements will also be larger if you are constructing larger models.

Your hardware can be configured in various ways. For example:

• A powerful, stand-alone, desktop workstation
• Moderately powerful desktop workstations with a central file server
• Less powerful desktop workstations with a central file server
• X-terminals with a powerful central file and compute server

This chapter describes the requirements for a single-user desktop workstation that you will use either stand-alone or with a file server that provides no support other than file service. The desktop workstation will run all Rose processes.

The alternative is to run all Rose processes on a remote compute server, redirecting the display to your local workstation or X-terminal. If the compute server is shared by several Rose users, it will need to be more powerful than a desktop workstation that supports only one Rose user.

Software Requirements

Table  2 contains the software requirements for installation and use of this product. Note that this is also only a suggested amount of swap space. Your requirements may be larger if you expect to construct very large models. If all of your models are small, you may need less than the amount shown here.

General Install Information

As a precaution, always make back ups of any Rose model files that you will be accessing with this software.

Note: Rose 98i, 2000e, 2001,2001a, and 2002 for UNIX licenses are valid for this release. You will not need to utilize the startup licenses or obtain new permanent licenses if you are already utilizing Rose 98i, 2000e, 2001, or 2001a for UNIX licenses.

Pre-Installation Information

You may want to back up your Registry prior to running the installation program. Specifically, we recommend you make backups of the following files:

• You should always have a backup of all your model files. These can include files that end with .mdl,.cat,.ptl, .red, and .sub.
• Custom property files, which can include files that end with .pty and .prp

Note: There is no need to save .pty files that ship with Rose since these will be re-installed.

• Custom script files, which can include files that end with .ebs and .ebx

Note: There is no need to save .ebs or .ebx files that ship with Rose, since these will be re-installed.

• Path Maps (For Rose 98i, 2000e, 2001, 2001a, and 2002 path map variables are saved in the registry.)

Follow these steps to back up path maps:

1. Run regedit and navigate to HKEY_CURRENT_USER\Software\Rational Software\Rose\Virtual Path Map
2. Click Registry > Export Registry File...

Follow these steps to restore path maps:

1. Run regedit and navigate to HKEY_CURRENT_USER\Software\Rational Software\Rose\Virtual Path Map
2. Click Registry > Import Registry File... and import the file you exported

Hardware/Software Patch Requirements

Please see "Operating System Runtime and/or Patch Requirements" in the Installation Guide for system patch requirements.

When installing and running Rose for UNIX/Linux for the first time, you will be alerted if hardware or software patches are necessary.  If running on a Solaris or HP-UX server, Rose for UNIX/Linux will attempt to automatically determine if patches are necessary on your server and/or Solaris display, and will advise accordingly.

You may also run the following anytime to determine if your computer requires operating system patches to run Rose for UNIX/Linux.

• SUN Solaris Server (computer running Rose for UNIX/Linux)

cd rational_dir/releases/rose.I.J.K/bin

./check_rose_reqs sol2_server rose

• SUN Solaris Display (computer displaying Rose for UNIX/Linux)

Check that the DISPLAY environment variable is set to your display, and then:

cd rational_dir/releases/rose.I.J.K/bin

./check_rose_reqs sol2_client rose

• HP-UX Server

cd rational_dir/releases/rose.I.J.K/bin

./check_rose_reqs hp_runtime rose

Configuring Window Manager So Pop-Up Windows Will Remain On Top of their Parent Windows

Configure your Window Manager such that pop-up windows will remain on top of their parent windows, in compliance with the Windows API. Under X11, Window Managers may implement different strategies for maintaining the Z-order of pop-up windows.

In order to keep pop-ups on top, if possible:

• For MWM - Motif Window Manager

There is no specific configuration to keep pop-up (transient) windows on top. Pop-up windows are kept on top by default.

• For DTWM - Desk Top Window Manager (shipped with CDE)

Depending on your system's configuration, the default behavior of dtwm may not keep pop-up (transient) windows on top of their owner.

For example, it may be that the window stacking behavior for dialogs is specific, such as "Dtwm*secondariesOnTop = False". In such a case, here are some possible solutions for keeping the pop-ups on top:

a Change Dtwm*secondariesOnTop to True in the system-wide dtwm configuration file. On Solaris, the dtwm configuration file is located at /usr/dt/app-defaults/C/Dtwm. On platforms other than Solaris, the path to the dtwm configuration file may be different.

b Add

Dtwm*secondariesOnTop: True

to your .Xdefaults file.

c Be more specific with the program name, and add, for example:

Dtwm*ssexp*secondariesOnTop: True

to your .Xdefaults file.
Note: The .Xdefaults file needs to be reloaded with:
xrdb ~/.Xdefaults

• For OLWM -- Open Look Window Manager

Add the following line to your .Xdefaults file:

OpenWindows.KeepTransientsAbove: True

Running Multi-threaded GUI Applications on Multi-processor Solaris 2.6 Computers

If Rose for UNIX/Linux hangs when running on a multi-processor Solaris 2.6 computer, verify that the Solaris 2.6 server and display (if applicable) includes the Sun Solaris XSun Patch 105633-32 or higher. This patch includes a fix for Sun Defect 4233280, Sun SO#3918581 (multi-threaded applications crash/hang on 2.6 multiprocessor computers). To check for this patch, run

showrev -p | grep 105633

on both the server running Rose and the display (if display Solaris 2.6).

When installing or running the application for the first time, Rose will advise if this patch is installed or required.

Displaying on Ultrabook, Using PGX Graphics Card

A CDE crash may occur when displaying Rose for UNIX/Linux on a Ultrabook using a PGX Graphics Card, if SUN Solaris patch 105362-26 is installed.

If using a PGX Graphics Card, we recommend that SUN Solaris patch 105362-20 be installed as this is the latest version tested and determined to be compatible with this release.

If you encounter the CDE crash, uninstall patch 105362-26 and if possible install "105362-20". If SUN Solaris patch "105362-20" is not installed, the following may occur:

• GUI Hanging Issues
• Paint Problems (i.e. black/white regions may appear in menus, dialog boxes, toolbars, etc.)

If you uninstall patch 105362-26 and encounter any of the issues described above, contact Rational Technical Support if patch 105362-20 is not available.

Running Rose for UNIX/Linux on HP-UX 11.00 with HP-UX OS Patch PHSS_21493

Rose for UNIX/Linux requires HP-UX OS Patch PHSS_17327 (X/Motif 2.1 Dev Kit Mar99 Periodic Patch). This Patch requires PHSS_17326 (X/Motif2.1 Runtime Mar99 Periodic Patch). PHSS_17326 has been superseded by HP-UX OS Patch PHSS_23823.

It is important to use PHSS_23823 as Rose for UNIX/Linux will not start (display) if an earlier version of this patch is installed (i.e. PHSS_21493).

If it is necessary to have a Motif Xlib runtime patch prior to PHSS_23823 and you encounter this issue, refer to the following instructions to workaround this problem:

1. Make sure your Rose process is no longer running. (Use ps to determine if the process is running, and "kill -TERM [pid]" if it is necessary to kill the process.)
2. As the owner of these files,

cd rational_dir/releases/rose.I.J.K/install/patches/hppa_hpux/hp11

3. cp libX11.3 rational_dir/releases/rose.I.J.K/hppa_hpux/hp11/lib/.
4. chmod 555 rational_dir/releases/rose.I.J.K/hppa_hpux/hp11/lib/libX11.3
5. Run rose_cleanup.
6. Run rose.

MainWin Runtime Components

When Rose for UNIX/Linux runs for the first time, an $MWUSER_DIRECTORY directory is created which includes MainWin files and directories. Rose is created utilizing MainWin (developed by Mainsoft) and requires specific MainWin components to operate correctly. $MWUSER_DIRECTORY may be set to serve as the windows directory. For example, $MWUSER_DIRECTORY may be set to $HOME/.windows. If $MWUSER_DIRECTORY is not set, the default location will be $HOME/windows.

Within the $MWUSER_DIRECTORY directory, you will find the following type of files and directories:

• mwfc-* -Font caches, are created incrementally over the duration of the application process; activating when a user chooses a new font. The font cache is built each time Rose for UNIX/Linux is run on a new X server, or if the server's font path is changed. Each font cache file has a unique name:

mwfc-xxxx (where xxxx is dependent on the specific display used)

This file can be removed if it is suspected of interfering with font operations. If removed, it will be regenerated the next time Rose is invoked.

When Rose for UNIX/Linux is invoked by the user on the same X server, the application can quickly look up the font cache file and select the closest X font available.

• registry directory - This directory includes a binary "registry" file which is created the first time the user runs Rose for UNIX/Linux (for each version of the Operating System). For example, a "registry.5.6" registry is created for a user running the release on a SUN Solaris 2.6 computer. The registry stores Rose for UNIX/Linux configuration and initialization data.

The registry directory also includes rose_reg_check, an ascii file which includes the version of Rose for UNIX/Linux and it's associated add-ins. This file is created the first time a user runs Rose for UNIX/Linux.

A specific registry file may be utilized by setting the following environment variable:

setenv USE_MWREGISTRY /path/myregistry

• help - This directory includes files that get created and stored every time the user runs help and creates the help keyword database.
• win.ini file - This is a default configuration file. It includes such information as print device/port settings.

During a Rose session, Rose for UNIX/Linux *.ini files may also be created in the user's "windows" directory. These files include Add-In specific settings.

Rational Rose for UNIX/Linux includes "mw" directory

Rational uses MainWin (by Mainsoft) to rehost Rose for UNIX/Linux platforms. Specific MainWin runtime components are included in Rose. Below is a description of the type of MainWin files included in Rose for UNIX/Linux under the rational_dir/rel*/rose*/mw directory.

• afm directory - Includes support fonts.
• bin directory - Includes programs which perform such functions as determining hardware configuration, removing unreleased X resources, showing X resources, and converting old registries to new.
• bin-<os>_optimized directory - Includes binaries designed to register libraries and controls, provides registry browser and support, and type library browser, and font server.
• fonts directory - Includes release fonts and font files compatible on both PC and UNIX/Linux displays. See Installing and Utilizing Fonts Compatible on Both PC and UNIX/Linux Displays .
• fontserver.cfg file - Font configuration file used by font server.
•   helpfile directory - Includes help files provide by Mainsoft.
•   lib directory - Includes scripts to order library paths correctly, and to setup MainWin configuration.
• lib-<arch>_<os> directory - Includes an nls directory which holds *.nls (Nation Language Support) files that are used upon application startup. It also includes mwperl (an executable called upon by the MainWin scripts).
• lib-<os> directory - Includes files to manage the font cache, provide support for type library browser and registry browser.
• lib-<os>_optimized directory - Includes MainWin support libraries and resources.
• system directory - Includes default binary registry and system MainWin registry files.
• setmw* and setup* files - These files provide appropriate MainWin environment settings.
• win.ini is the default Windows configuration file (which gets copied in $MWUSER_DIRECTORY the first time Rose is run).

Installing and Utilizing Fonts Compatible on Both PC and UNIX/Linux Displays

Rose for UNIX/Linux now includes the following release fonts which are compatible and may be used on both the PC and UNIX/Linux displays:

• MS Sans Serif
• Arial
• Times New Roman
• Courier New
• Tahoma

As it now is possible to display these same fonts on UNIX/Linux and the PC - models, etc. created on the PC (using these fonts) should display easily and accurately in Rose for UNIX/Linux on PC and UNIX/Linux displays. Furthermore, utilization of these fonts will provide the following additional enhancements:

• Resolves defects when these PC fonts were not always available on UNIX/Linux displays. Previously, a model created on the PC would utilize an Arial font (not available on UNIX/Linux). Opening the same model on a UNIX/Linux display could produce unpredictable results when the font would map to "Application".
• Resolves defects when users were creating/sharing models to be displayed on PC and UNIX/Linux displays. Display difficulties could occur when models created or edited on PC display (i.e. using eXceed) were then opened on a UNIX/Linux display.

Font files (in *.bdf - binary distributable files), are now included in the rational_dir/releases/rose.I.J.K/mw/fonts directory of your release. This directory also includes the following fonts* files:

• fonts.dir - The X11 fonts dir file.
• fonts.mwd - MainWin fonts dir file. This file is accessed by this release and contains, for each font, the WIN32 metrics, the X11 fontname, a mask stating whether it is a "stock" font, and a "used on unix" flag.

A fontserver.cfg file is included in the rational_dir/releases/rose.I.J.K/mw directory. This file is used when starting the font server to provide the new fonts to the Rose application.

Making The Release Fonts Available on Your $DISPLAY

Prior to running Rose for UNIX/Linux for the first time, run rational_dir/releases/rose.I.J.K/bin/rose_cleanup. Upon starting Rose for UNIX/Linux, you will notice some new messages in relation to the availability of the new fonts. Rose will attempt to determine if the new fonts are available for your $DISPLAY, by running the new Rose for UNIX/Linux rose_fonts utility.

UNIX/Linux DISPLAY with visibility to Rose fonts

rose_fonts will make the fonts available to your DISPLAY by including the path to rational_dir/releases/rose.I.J.K/mw/fonts/ in your DISPLAY's font path.

DISPLAY other than UNIX/Linux (i.e. PC using eXceed) or UNIX/Linux DISPLAY without visibility to Rose fonts

In this case, fonts must be made available by using a font server and including the font server in the DISPLAY's font path.

rose_fonts will determine if a font server is providing access to the Rose fonts, as described below:

• Determines if a font server is already running (on the server used to run Rose). There may already be a font server running on the designated font server's port# 7100. On SUN systems 2.5.1 and above it is likely that a font server is already running and defined in the /etc/services file, as "xfs" or "fs". The existing font server's default fontserver.cfg file will not include a path to the Rose fonts (unless it has been configured to do so).
• If a font server is running, rose_fonts determines whether the existing font server is already providing access to the rose_fonts (i.e. it determines if the fontserver.cfg includes the path to the Rose fonts provided in the release).
• If a font server is not running, rose_fonts attempts to start a font server "xfs".
• If a font server is running and does provide access to the Rose fonts, rose_fonts adds the font server to the DISPLAY's font path.

If Necessary To Configure Existing Font Server

If a font server is running on the Rose server and it is not already providing access to the Rose fonts, contact your System Administrator to perform this setup or refer to the man pages for xfs(1). The following advises how to configure an existing font server on SUN Solaris.

Note: Configuring an existing font server to provide access to the Rose fonts may produce less than optimal font results, based on the font paths included in the fontserver.cfg's catalogue setting. This is due to a potential Rose 2000e for UNIX/Linux font mapping issue that is currently under investigation. If you elect to continue with the following instructions, and you encounter poor font results please notify Rational Technical Support and remove the Rose font support from your fontserver.cfg file.

If you elect not to add the Rose font support (as described next) or elect to remove the Rose font support from an existing font server Rose will continue to operate correctly, however the font enhancements listed in Installing and Utilizing Fonts Compatible on Both PC and UNIX/Linux Displays will not be available and you may encounter the following defects:

Defect 10386
Defect 10387

Adding Rose fonts to Existing Font Server on SUN Solaris

To add Rose font support to an existing font server on SUN (it may be necessary to su to root to perform these actions):

• Edit the default fontserver.cfg file "/usr/openwin/lib/X11/fontserver.cfg" to add the location of the Rose fonts in the "catalogue" path (being careful not to add or remove extra spaces).

A catalogue path may appear as:

/usr/openwin/lib/X11/fonts/F3bitmaps/,/usr/openwin/lib/X11/fonts/Type1/

Add the Rose font path, by prepending the path to the catalogue path.

For example:

rational_dir/releases/rose.I.J.K/mw/fonts/,/usr/openwin/lib/X11/fonts/F3bitmaps/,...

Do not include spaces. Each path is separated by a colon.

• Use ps to determine the process ID of the "fs" or "xfs" process, and then stop (kill) the "fs" or "xfs" process, if running.
• Set the DISPLAY font path to include the path to the existing font server by running:

xset +fp tcp/<fontserver>:7100

and then

xset fp rehash

• Determine if the Rose fonts are available and restart font server:

fslsfonts -server <fontserver>:7100 | grep -i mainwin

The font server must be the current host for it to restart the font server ("fs" or "xfs"). In many cases these x* utilities are located in /usr/openwin/bin.

Rose (upon starting) should indicate that the Rose fonts are now available.

Upon performing this setup, it will be important to update the fontserver.cfg file if Rose is uninstalled or moved to a different location (path changes).

Starting a Font Server

If a font server is not running (on the server running Rose), rose_fonts will start a font server if available on your system, if necessary. This is necessary if the DISPLAY is not a UNIX/Linux display, or if the display does not have direct visibility to the fonts provided in the Rose release.

X Font Commands Utilized by rose_fonts

The following commands are typically located in one of the following directories: /usr/openwin/bin, /usr/bin/X11, /usr/X11R6/bin, /usr/openwin/lib/X11, or /usr/openwin/include/X11.

To Start a Font Server

xfs -config rational_dir/releases/rose.I.J.K/mw/fontserver.cfg -port 7100

To Set the Font Path

xset +fp rational_dir/releases/rose.I.J.K/mw/fonts/ (direct path to fonts in release)

xset +fp tcp/$host:7100 (font server path)

To Determine if Rose Fonts Available

xlsfonts | grep -i mainwin

xlsfonts may hang if a font path includes a path to a font server which is not running. rose_fonts will not let xlsfonts run for longer than a specified period of time (typically 30 seconds), to safeguard against this event. If an xlsfonts hang occurs, rose_fonts will provide status with recommendations.

rose_fonts Overview

In summary, rose_fonts will provide the Rose fonts to your DISPLAY by either setting the font path to point to the fonts in the release (UNIX/Linux display with visibility to the fonts), or by setting the font path to a running font server if the font server is providing access to the Rose fonts. rose_fonts will use "xset" to set the font path, "xfs" to start a font server (if necessary) and "xlsfonts" to determine if the Rose fonts are available after the setup has been performed. If a font server is already running and does not already provide support for the Rose fonts, manual setup is necessary (i.e. see Adding Rose fonts to Existing Font Server on SUN Solaris ) to complete the Rose font setup. In this case, manual set up is required as it is often necessary to su to root to perform this action. rose_fonts will provide messages describing the current status each time Rose is started.

Contact Rational Technical Support if you should have any questions or encounter any difficulties accessing or utilizing the new Rose fonts.

If Rose Fonts Not Available

There may be occasions when the Rose fonts will not be available. rose_fonts will alert you if, when starting Rose, if the Rose fonts are not available. If this occurs, Rose will continue operate correctly, however the font enhancements listed in Installing and Utilizing Fonts Compatible on Both PC and UNIX/Linux Displays will not be available and you may encounter the following defects:

Defect 10386
Defect 10387

To Eliminate Output from "rose_fonts" When Running Rose

Each time that you start Rose, rose_fonts determines whether the Rose Fonts are available, attempting to make the fonts available when necessary. Each time Rose is started, rose_fonts displays messages advising current Rose Font status. In order to eliminate output from rose_fonts, set the following environment variable prior to running Rose.

setenv ROSE_NO_FONT_MSG 1

Setting this environment variable will allow rose_fonts to run, but will refrain from printing Rose Font status messages

Rose Documentation

The goal of all Rose technical documentation is to provide the most appropriate and usable product information possible so that our users can benefit fully from all of the features of Rose and its add-ins. To that end, Rose and its add-ins provide a complete, integrated online Help system, along with a set of supplemental printed manuals.

Rational Rose printed documentation has not been updated for this release. Please note that you can still order the previous version of printed documentation, most of which remains valid for this release. It is recommended that you are aware of any important changes to functionality or behavior.

Note   Printed documentation not provided with Beta Release.

Online and Printed Documentation

You may have noticed that the printed documentation set has changed recently. Several printed manuals have been eliminated because their content was exactly the same as that of the online Help. On the other hand, several newer books that provide important background or supplemental information are now available. In future releases, we hope to provide more of these value-added publications, while continuing to update our comprehensive online Help systems.

To print the complete online Help for Rose or any of its add-ins, you can easily do so from the Contents tab of the Help system:

1. On the Rose Help menu, click Contents and Index.
2. On the Contents tab, click the help book that contains the help you want to print.
   (For example, to choose the entire help for Rational Rose, click the Rational Rose help book; to choose the entire help for Rose J, click the book called Rose J .)
3. Click Print.

All of the Help topics contained in the selected book (including those that are contained in sub-books of the selected Help book) will print in the order in which they appear in the table of contents.

Of course, you can still print single topics whenever you need to do so.

In addition to the Release Notes, the following manuals constitute the printed documentation available for Rose and its add-ins:

• Installing Rose
• Using Rose
• Using the Rose Extensibility Interface
• Rose Guide to Team Development
• Using Rose Data Modeler
• Using Rose Ada for Forward and Reverse Engineering

These manuals are also available in Portable Document Format (PDF) on the documentation CD that comes with all editions of Rational Rose. You can also download the PDF files from the Rational Web site, http://www.rational.com .

Getting Started

Consider the following guidelines as you plan to install or remove this version of Rational Rose.

Rose Add-in Guidelines

Core Rose and Rose Extensibility Interface

Core Rose Features and Enhancements

This release of Rational Rose includes these new features and enhancements:

• Enhanced Pattern Content, by adding patterns for:
  • Gang of Four (GOF) - Analysis Mode
    
• Ability to perform application settings via a new Visual MainWin Control Panel

Enhanced Pattern Content 

Users will have the ability to utilize Rose J Gang Of Four (GOF) patterns, as before. In addition, users may now access pattern content for additional languages - as described below. The user may apply a pattern through the context menu of a class or interface element defined in the tree browser or in the class diagram.

• New GOF - Analysis Mode Patterns

These GOF patterns are applied the same way you currently apply the Rose J GOF patterns, i.e.:

• Verify the Tools > Options > Default Language is set correctly (i.e. Java or  Analysis). For this example, we will set language to Java.
• Add to your model - a testing package (ObserverApplied) and some testing elements (participants):

• Observer - interface
• Subject - abstract class
• ConcreteObserver1 - class
• ConcreteObserver2 - class
• ConcreteSubject - class
• Client -class

• Right click on the Observer interface and on the Context Menu select Java/J2EE > GOF Patterns > Observer :

The participant Observer will show that it is bound to an existing model element (asterisk missing on its line).

All the other participants will be bound by default with classes named by adding the starting class qualified name to the (indexed) participant name. The asterisk at the right end of the participant row shows visually that it is not bound to an existing element in the model. If applied with these default names, the application will add these new elements in the model.

• Bind participants with existing elements in the model

Select an existing element in the model for the remaining two SimpleParticipants (Subject and Client). If the type of the selected element does not match with the one declared in the XML file, the application will display a warning message.  You may select a new element with the right type or ignore the message. 

• Click OK and the Progress Monitor will advise when the pattern has been applied. You can inspect and forward engineer the updated model.  Source file shown below.

//Source file: C:\Test\ObserverApplied\ConcreteObserver1.java

package ObserverApplied;

public class ConcreteObserver1 implements Observer
{
private Subject subject;

/**
* @roseuid 3D7E719602A3
public ConcreteObserver1()
{

}

/**
* @roseuid 3D7E6FE90170
*/
public void update()
{
observerState = subject.getState();
}
}

Design Patterns Dialog Box Reference

The Design Patterns dialog box allows you to specify the participants for the selected design pattern. These are classes that will be added to your model, or classes that already exist in your model. The layout of the dialog box changes from design pattern to design pattern, displaying the participants of the selected design pattern only. The title of the dialog box matches the name of the design pattern you are applying.

Participants - The set of classes that make up this design pattern. Each class plays a role of a particular participant type. Each participant type labels a group of classes. Some groups contain only one class, others contain more. Initially, all groups contain names automatically generated by Rose. You can apply the design pattern using these names, and new classes with these names will be added to your model; or you can supply new ones. You can also substitute them with the names of classes that already exist in your model. If you do, Rose will not create new classes for you, but will use these classes instead.

Class Browser - Opens the Class Browser, from which you can select an existing class to use as a participant. This element appears when you double-click a participant class to edit its name. It is a gray button with three dots (an ellipsis).

Description - Displays design pattern information for the selected pattern. This includes an explanation of the kind of problem the design pattern solves, a brief overview of how it addresses the problem, descriptions of the participants that make up the design pattern, and a class diagram showing the pattern's structure.

Cancel - Discontinues the design pattern application process, and exits the Design Patterns dialog box.

The following elements appear in participant tables:

Add Participant Class - Adds a class to the selected participant table. It is a gray button with a small yellow starburst in the top left corner of a square.

Remove Participant Class - Removes the selected class from the participant table. It is a gray button with a red X.

Ability to Change Application Settings via new Visual MainWin Control Panel

Rose now includes a Control Panel, which will allow you to configure the following system settings:

• Display
• Internet Options
• Printers
• Regional Settings
• Date/Time

Changes to the Display and Internet Options applets are stored in the current user portion of the registry. Changes to the Printers and Regional Settings are stored in either the current user and machine settings portions of the registry, depending on the parameters affected. If you need more details about where exactly specific parameters are stored, contact Rational Technical Support. Changes to the Date/Time affect the host computer directly, and are not stored in the registry.

To Run the Visual MainWin Control Panel

1. cd rational_dir/releases/rose.I.J.K.bin
2. Run "mwcontrol"

Setting the application display

Use the Display applet to configure the display appearance of Rose. Note that it does not affect your Unix desktop.

When you make changes using the Display applet, the changes only affect Rose sessions that you open after you have saved the Display changes. Rose sessions that were running when you changed the Display must be restarted for your changes to take effect.

Setting Internet options

Use the Internet Options applet to set MSHTML properties in applications that use MSHTML.

When you make changes using the Internet Options applet, applications running on the same machine are affected as soon as you save the changes. Applications running on other machines must be restarted for the changes to take effect.

Setting up printers

The Printers applet allows you to map a print request to a proper print command on your Unix host.

The Printers applet includes a default generic postscript printer command mapping that meets most printing needs. If you need to add other printer command mappings, the applet includes an Add Printer wizard, as described below.

Changes that you make using the Printers applet affect your Rose session running on the same machine as soon as you save the changes.

To add a printer using the Add Printer wizard

1. Launch the Visual MainWin Control Panel:

• cd rational_dir/releases/rose.I.J.K/bin
• Run "mwcontrol"

2. Double-click Printers. The Printers applet opens.
3. Double-click Add New Printer in the Printers applet. The Add New Printer wizard starts.
4. Click Next.
5. Specify the Unix printer to which you want to print. A list of the printers defined on the Unix host appears at the bottom of the wizard. If the printer you want to add is in the list, select it. To add a printer that does not appear in the list, type the Unix name of the printer in the Unix printer text box.

Note:  The list of printers is extracted from the /etc/printcap file, which contains a list of all printers on the network to which your Unix host has access. The printcap file is used on all Unix platforms as the central location for specifying printers. It is configured and maintained by the system administrator.

6. Click Next.
7. The default print command for the selected printer appears in the Print command text box. Usually, the default command is the one you should use. You should not modify the command unless your system administrator instructs you to do so.
8. Click Next.
9. The Printer Name is used by the application when displaying available printers in the Print dialog. You may modify the default name if you wish.
10. Click Next.
11. Verify the information you specified in the Add Printer wizard is correct. If you are satisfied with the settings, click Finish. Otherwise, click Back to change the settings.  The printer you added now appears in the list of printers and will be available when printing from Rose (upon restarting Rose).

Setting date and time

You can use it to set your host computer's date and time, but you must have root privileges. If you have root privileges, changes that you make using the Date/Time applet take effect immediately on the host computer.

Ability to Easily Change Default Language

You may now change the default language, by right clicking on the bottom Rose window pane (which, currently displays the current default language).  A context menu will appear, with all language options.  Apply the new default language, by selecting one of the options presented in the context menu.

Core Rose and Extensibility Defects Fixed in This Release                         

• In order to most efficiently fix these Sequence Diagram issues, it was necessary to remove a fix for RBU 00072192 - FOCs problem in Sequence diagrams (adding messages may cause hierarchical issues). In addition, issues may still be encountered when moving an actor in a Sequence Diagram, by dragging it to various positions. In some cases, this will cause poor positioning of the existing messages.  These issues are being evaluated to be resolved a future release.  If you encounter these difficulties, contact Rational Technical Support.

Known Core Rose and Extensibility Defects

Rose C++ Add-In's

Rose ANSI C++ Add-In

Rose ANSI C++ Enhancements Added in This Release

There are no new features or enhancements in this release of Rose

Rose ANSI C++ provides:

• Design, modeling and visualization of all C++ constructs including classes, templates, namespaces, inheritance, and class members functions.
• Support for the C++ language, without being restricted to a single vendor's C++ compiler.
• Support for large frameworks.
• Automatic generation and reverse engineering of C++ source code.
• User-controlled code generation using patterns of default constructors, destructors and class members. One-step reverse engineering from Rose, without a separate import step.
• Style sheet mechanism to allow custom formatting of generated code.
• Simplified, yet complete round-trip engineering support, which synchronizes models and generated C++ code across multiple iterations. After assigning files or classes to a project, you can forward or reverse engineer the entire project using a single context menu command.
• Update-in-place mechanism to determine the differences between model and code, and make only those changes required to maintain consistency between the two.

Rose ANSI C++ Defects Fixed in This Release

**Documentation (comments) can be both generated and reverse engineered for all model elements.

Code Generation

Documentation is generated directly preceding the generated item and the items model Id. For example, the following code fragment shows generated documentation for two attributes within a class:

// The customer's date of birth.
//##ModelId=351ADC1EF002
CDate dob;
// The customer Id is used to record the
// unique Id given to each customer object
// in the system.
//##ModelId=351ADC1EF002
long custId;

The documentation text is converted into a comment block by generating single-line comments for each line of text. A space is automatically inserted between the single-line comment (//) and the start of the text. A line of documentation text may also begin explicitly with a comment delimiter, either a single-line (//) or multi-line (/*). The text is then generated as is in its entire form. This allows user-specific comments to be generated.

Reverse Engineering

Documentation can be reverse-engineered as well. Reverse engineering of documentation follows specific rules. From the code item's declaration, the code is traversed upward. A single optional blank line is allowed between the model Id comment tag and the end of the documentation comment block. If no model Id comment tag is found, a single optional blank line is allowed between the declaration and the end of the documentation comment block. The documentation comment block can use multiple single-line comments (//), multi-line (/*, */) comments, or a combination of both. However, only single-line comments (//) with a space will be converted to plain text. All other comments will appear as explicit comments in the documentation text. The comment block extends up until a blank line or another code declaration is reached.

Thus, to reverse engineer the documentation comment block, the code must be in the following format:

blank line or code
[ Comment Block
[ A single blank line ] ]
[ Model Id Tag ]
code declaration

The blank line will be preserved during synchronization; it can only be deleted in the source code.

Synchronization

The property CommentRules is used to control the synchronization of the UML documentation and the corresponding comment block in the source code. There are four choices available:

• Always Synchronize

This supports full synchronization of comments in the model and source code. This is the default.

• Code Generation Only

This setting will only generate comments into the source code, overwriting any comment section that differs with the documentation text.

• Reverse Engineering Only

This setting will only update the UML documentation for the associated entity, overwriting any text that differs from the comment.

• Never Synchronize

This setting is used to turn off synchronization completely. This ensures that no updates will be performed on either the documentation or source code.

The property CommentRules can be set in the Properties dialog box under the ANSI C++ tab. Choose either the "Module Specification" or Module Body" type.

The property may also be set in the ANSI C++ specification of a component. Select the style tab and choose the appropriate setting under "Comments" in the "Round-Trip Engineering Options".

Prior Convention

Prior versions of the Rose ANSI C++ addin used a different style for generating comments in the source code. For example, the following code fragment shows generated documentation for two attributes within a class showing the old style:

//##ModelId=351ADC1EF002
//##Documentation
//## The customer's date of birth.
CDate dob;

//##ModelId=351ADC1EF002
//##Documentation
//## The customer Id is used to record the
//## unique Id given to each customer object
//## in the system.
long custId;

This style will be preserved, although no longer generated, as long as no model changes to the documentation text are made (if code generation synchronization is active). It is still possible to directly make any changes to the source code, and these can be synchronized with the model. However, should a change be required, stemming from a change in the model, then the old-style comment block will be rewritten to the new-style, and the comment block will be moved ahead of the model Id.

Known Rose ANSI C++ Defects

Rose C++ Add-In

Rose C++ Features and Enhancements

• This addin is disabled by default. If the addin is needed, it can be enabled using the addin manager available from the Rose top level menu.

Rose C++ Defects Fixed in This Release

Known Rose C++ Defects in This Release

Rose Ada Add-In

The Rose Ada add-in allows you to produce Ada source code from the information contained in a Rose model.

The code generated for each selected model component is a function of that component's Specification and code generation properties, and the model's properties. These properties provide the language-specific information required to map your model to Ada code.

Rose Ada preserves user-supplied declarations and statements from one iteration to the next. You place such user-supplied code in protected code regions which are preserved whenever code is regenerated.

The Rose Ada code generator:

• Substantially reduces the elapsed time between design and execution
• Produces uniformly structured source code files, promoting consistent coding and commenting styles with minimal typing.
• ·Supports both Ada 83 and Ada 95.

New Rose Ada Features and Enhancements

• (Ada95 only) The Export Control field of a class now controls where the declaration is defined in the package spec/body.  The class property TypeVisibility now controls whether a public class is a private type.  The class visibility also restricts the visibility of static data members and the operations; they are reduced to the visibility of the class. NOTE: Check model, beforehand, for any classes with a visibility other than Public, and reset to Public, as needed.
• Subprogram generics and instantiations can be can now be declared within a package specification or body. The Export Control field controls the location where the generic subprogram or instantiation is declared. The stereotype of a parameterized class utility can now be set to "subprogram",  this now allows the component to be mapped to a package specification.
• (Ada95 only) The new attribute/has/role property AccessDiscriminantClassWide controls whether the type, of the access discriminant, is made class-wide, i.e. generated with Class.
• (Ada95 only) The new class property IncompleteType with the values (DoNotDeclare, NoDiscriminantPart, UnknownDiscriminantPart, KnownDiscriminantPart) can be used to declare an incomplete type declaration. The default value is DoNotDeclare.
• (Ada95 only) The new class property TypeControlVisibility specifies whether to make the controlled extension visible in the public part.  The default is Private.
• The class property Representation, where TypeImplementation is set to Task or Protected, can be used to place pragma or representation items within the specification, after the is and before any other declarations.
• The class property CodeName is now supported for subprogram instantiations, to support overloading, since classes must be uniquely named.
• Any attribute, has, or role, which is public, static, constant, and whose type is that of the class type, will be generated as a deferred constant.

Rose Ada Problems and Limitations

The following list describes the known problems and limitations for this release of Rose Ada:

• During installation of Apex NT, the Update Environment option must be set.

Rose Ada Defects Fixed in This Release

Apex Add-In (Not Available for Linux)

The Apex Add-In of Rose for UNIX/Linux provides direct access to the Compile and Control commands in Apex. It also works with language add-ins for Rose, including Rose C++, Ada 95, and Ada 83 Add-Ins, to create Apex subsystems and views during the code generation from the model to the source files of the specified language.

• It is required to run Rose inside an Apex shell window to use the Apex Add-Ins.
• If the Apex submenu is not in the Tools menu, select Add-Ins > Add-In Manager to make sure the Apex Add-In is activated.

The following information is also located in your Apex Add-In online documentation.

Apex Compile and Control Commands

The Compile and Control commands of Apex are directly accessible from Rose through the Tools > Apex menu. The Compile commands compile and link the source files, generated into Apex views via Apex Add-In, that correspond to the selected items in the diagram. The Control commands perform Apex source code control operations on the source files generated in the same way.

To use these commands, select Tools > Apex, and then select Compile or Control to get to the list of commands, respectively.

For the descriptions on these Apex commands, please consult the online help in the Apex windows.

Code Generation With Apex Add-In

In general, the code generation operation for a regular language Add-In is based on a directory structure where top-level packages, nested packages, and classes (or modules) are mapped, respectively, into directories, subdirectories, and source files in a hierarchical way. The operation can create such directories or subdirectories if they do not already exist, and then generate source files into these (sub)directories. This works with the regular source code control system and build management.

Apex has a different style of source code control and build management. An Apex project has a set of subsystems which contain the source files and subdirectories of source files for development. Each developer has his own views, one for each subsystem, which collectively reflect the source base the developer uses for the project. For this reason, Apex-style code generation is different from the regular style. From a Rose model, the top level packages will be mapped into subsystems and the associated views for the developers; the packages nested inside another package will be mapped into the subdirectories inside an Apex view, or a subdirectory already enclosed by a view; the classes (or modules) will be mapped into the source files inside the views or the subdirectories.

The Apex Add-In provides a mechanism for the user to select which of the two code generation styles to use. When the property CreateApexSubsystemAndView of the Apex tool set is set to "Yes", the code generation command for a language add-in will automatically create Apex subsystems and views for the top-level packages selected in the model, followed by the generation of subdirectories and source files into the views. If the property is not set to "Yes", the code generation command does the regular style of code generation.

The language add-ins that work with Apex Add-In include C++, Ada 95, and Ada 83.

Properties for Apex Add-In

Refer to the online documentation for a list of the properties used by the Apex Add-In for Apex-style code generation. Some are properties for the project, and the others for the subsystems in the model. The code generation command will use the combination of these properties when it needs to generate code into Apex subsystems and views.

All the properties except CreateApexSubsystemAndView will take effect only when the CreateApexSubsystemAndView property is set to "Yes" and when the selected item is a top-level package. When any of these properties are specified differently from their default value, the Directory property for the top-level package should remain as the default value.

Utilizing Apex Add-In on HP-UX

In order for Apex to generate subsystems correctly, it is necessary for "tmp-mnt" to be placed in the automount field of the Virtual Pathmap dialog box. The "/tmp-mnt" entry should be removed from the Virtual Pathmap dialog box when not using Apex.

Known Rose Apex Defects

Rose ClearCase Add-In

Rose ClearCase Features and Enhancements

Note: Prior to using the Rose for UNIX/Linux ClearCase Add-In, it is necessary to review and follow the steps outlined in the README file. Please see the rational_dir/releases/rose.I.J.K/addins/clearcase/README file.

The ClearCase Add-In provides a tight integration between Rational Rose and the Rational ClearCase version control system. This add-in is intended as a replacement for the ClearCase capabilities provided through the previous Rose/ClearCase integration. This has and will continue to allow Rational to provide more ClearCase specific customization to this add-in.

When performing ClearCase actions on a unit in a Rose model, the ClearCase Add-In will now perform CM status checking on all ClearCase elements within the model. This provides an opportunity to perform the same ClearCase action on any element which applies. When the ClearCase dialog is displayed, you will have an opportunity to perform the selected ClearCase action on any or all of the ClearCase elements presented in the dialog. The CM status checking which is performed to provide this new capability can at times seem lengthy if working with a large model. In this case, you may elect not to utilize this feature by placing the following in either your $USER.reg (applies to single user) or the rational_dir/releases/rose.I.J.K/registry/rose.reg file (applies to anyone using the release):

[HKEY_LOCAL_MACHINE\SOFTWARE\Rational 

   /Software\Rose\AddIns\ClearCase\Custom Settings]

"ShowAll"="No" 

Rose ClearCase Add-in Defects Fixed in this Release 

Known Rose ClearCase Add-in Defects

Rose CORBA Add-In

Rose CORBA Features and Enhancements

The Rational Rose CORBA add-in allows you to forward engineer Rose model elements into CORBA-compliant IDL code and reverse engineer CORBA IDL code into a Rose model.

In support of the CORBA 2.3 Specification, Rose CORBA implements the use of value types. Value types allow you to pass objects by value rather than by reference, which is particularly useful when an object's primary purpose is to encapsulate data, or when you want to explicitly make a copy of an object. Two CORBA stereotypes make use of this enhancement:

• CORBAValue
• CORBAFixed

This Release includes modifications to the CORBA Add-In actions involving attribute types, operation return types, operation parameter types, and operation exception types in Round Trip Engineering.

Existing CORBA Models will be converted (by this Release) to recognize and identify these changes, automatically during code generation when selected to be forward engineered and during reverse engineering.  There is now one more phase during code generation - the CORBA conversion process.  You may notice performance degradation when performing code generation on an existing CORBA model, the first time after installation of this Hot Fix, due to this additional conversion phase.

Note:   If the type cannot be resolved in the model (i.e. the type cannot be found in the model OR if more than one type class of the same name is found in the model), the type would not be set and warning will be logged.  The following would be the warning message format:

[Resolving corba type references:  Start ]

WARNING:  Class <fully qualified class name> - operation <operation name> - <item type> cannot be resolved - '<type string>' will be used.

WARNING:  Class <fully qualified class name> - attribute <attribute name> - type cannot be resolved - '<type string>' will be used.

[Resolving corba type references:  Finish ]

* <item type> could be "parameter type",  "return type",  "exception type".

If code generation is occurring on a read-only subunit OR read-only model, the conversion will NOT take place during code generation.  Hence, the type would not be set.  In this case you will need to make these units write-able for complete conversion.

IMPORTANT:  Once the CORBA Model is converted by Rose 2003 (as described above), it is no longer compatible with previous versions of Rose.  It is important, upon upgrading to Rose 2003, no users perform work on this model in a previous version of Rose as this can cause model corruption.

Rose CORBA Add-in Defects Fixed in this Release 

Known Rose CORBA Defects

The Rose CORBA online Help references the old Rose internal editor (R2Editor); however, Rose CORBA now uses the new internal Rose editor.

DDL Add-In

The Data Definition Language (DDL) Add-In release note contains known problems and limitations as well as fixed defects since the last release.

The gap between object technology and relational databases is closed by providing a mapping interface to relational databases through generation of persistent classes to Structured Query Language (SQL) and Data Definition Language (DDL). 

Framework Add-In

The Framework Add-In provides a library of frameworks that can be used as templates when creating new models. There are no new features or enhancements for this version of the Framework Add-In.

Rose J Add-In

Rose J and J2EE Defects Fixed in This Release

Known Rose J and J2EE Defects

Rose Model Integrator Add-In

Rose Model Integrator Features and Enhancements

The Rose Model Integrator Add-In lets you compare model elements from up to seven contributor files, discover their differences, and merge them into the base model.

Model Integrator – Ability to Log Conflicts to a File

Overview

The "Log Conflicts to file" feature enables the user of the Model Integrator to generate a hardcopy of the elements in conflict when comparing a number of up to 7 models.

How To Create "Conflict" Output File from Model Integrator

1. The user selects and loads contributors in the Model Integrator application.
2. The user selects "Compare".

The model shows up in the Model Integrator with the first node with conflict selected and the property values for all the contributors displayed in the right section of the screen.  To log the conflicted items (of the entire model) to a file, select File->Log conflicts.  Note that this option is enabled ONLY if the application is in Compare mode.

3. Once this option selected, you are prompted to enter the file name (in the Save As dialog box) where the items with conflicts (between contributors) should be logged, along with the values for each contributor.

Note:  The log file format may be text (*.log) or CSV (*.csv).  The CSV format enables you to open the file with Excel, which will provide a comprehensive layout.

Description of Model Integrator "Conflicts" Log File Output

The log file provides the user with the following information:

• Title:  "Rational Rose Model Integrator - Compare Models"
• Date and time information logged.
• File name (full path) for each contributor.
• List of items whose values differ between contributors, along with the following information:
• Difference Type – Reflects the difference symbol displayed in the "C" column of the Model Integrator (e.g. if the difference symbol is a "+"  the difference type in the log file would be "Item Added")
• Item Kind– The node type (e.g. operation, class, etc) followed by the indicator "Field" or "Property"
• Field Name– Full path from the node to the current field (or sub-field).  For example, if this is the location of the label for an InterObjView, the field name will display "label::location"
• Parent– The full path of the node the field belongs to.
• Contributor Values(one column for each contributor) – The value of the item (field or property) for the specified contributor.

Rose Model Integrator Defects Fixed in this Release

Rose Web Publisher Add-In

Rose Web Publisher Features and Enhancements

Rose Web Publisher allows you to publish Rational Rose models in HTML format. The Web Publisher Add-In exports your Rose model as HTML (including diagrams) so you can view them using a standard browser such as Netscape Communicator. The Web Publisher also produces meta tags for use by search engines.

There are no new features in this release of Rose Web Publisher.

Browser Data

In order for Netscape to find the correct Java jar files, you must have the browser on your PATH, or set the environment variable BROWSER_PATH to the absolute path of your browser.

The Web Publisher on UNIX supports only .jpg file format.

The Web Publisher has only been tested with Netscape versions 4.6 and 4.7*.

Rose Web Publisher Defects Fixed in This Release

Known Rose Web Publisher Defects

Rose XML DTD Add-In

Rose XML DTD Features and Enhancements

The Rational Rose XML DTD Add-In provides visualization, modeling, and code generation to create XML document type definitions (DTD) for use in your application. You can reverse engineer an existing XML DTD to visualize a DTD's structure using a Rose class diagram. After modeling an XML DTD, you can use the Syntax Checker to validate your XML DTD. From the valid XML DTD model, you can generate code to create a new XML DTD.

In addition to reverse engineering an existing XML DTD, you can model a DTD using Rose class stereotypes for XML elements, element attributes, entities, and notations. By modeling an XML DTD, you can visualize the structure of the document to see which element definitions to change or remove. You can also share your XML DTD model with members of your development team to verify that you have captured the XML document requirements.

An XML DTD syntax checker finds errors in the XML DTD model, allowing you to make corrections before the DTD is implemented. Use the Generate Code feature to produce an XML DTD that you can test or implement in your environment.

To support mapping XML to UML, Rational Rose extends UML with stereotypes for XML elements, element attribute lists, entities, and notations. Stereotypes also represent XML operator symbols, sequence lists, choice lists, and element and element attribute multiplicity.

• DTDElementANY cannot be nested. Use this DTDElement at the root level.

Contacting Rational Technical Support

If you have questions about installing, using, or maintaining this product, contact Rational Technical Support as follows:

When you contact Rational Technical Support, please be prepared to supply the following information:

• Your name, company name, telephone number, and e-mail address
• Your operating system, version number, and any service packs or patches you have applied
• Product name and release number
• Your case ID number (if you are following up on a previously reported problem)