Windows
Version 2003.06.13
Release Date: September 2004
Last Updated: 08/24/2004
Material ID/Part Number: GI11-5903-03
© Copyright IBM Corporation. 1992, 2004. All Rights Reserved.
Any reproduction or distribution of this work is expressly prohibited without the prior written consent of IBM Corporation.
These Release Notes are accurate at the time this product was prepared for release.
The most recent version of this file is available in the IBM Publications at
www.ibm.com/shop/publications/order.
Search for GI11-5903-03
to find the latest version of these Release Notes in the IBM Publications Center.
(To search for the IBM Publications Center, go to www.ibm.com and enter
"IBM Publications Center" in the Search field.)
These IBM Rational Rose release notes provide:
Go to Rational Rose Service Release Notes if you are upgrading for Service Release note information.
When you are ready to install IBM Rational Rose, be sure to check the Web for the latest available downloads:
1. Go to http://www.ibm.com/software/rational/support/.
2. Then, go to the Download Center and navigate to Rational patches and service releases.
Also remember to have the Installing Rose and Administering Licenses manuals available to provide all the information you need to complete your installation.
IBM 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. IBM 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.
Important
Notice !!
(Read before Installing)
Microsoft .NET v.1.1 or higher Required to Install Rose Data Modeler and Rose Web Modeler
What's New in This Release
Product Documentation
Hardware/Software Information
Server Requirements
Client Requirements
Getting Started
Core Rose and Rose Extensibility Interface
Rose C++ Add-In’s (ANSI
C++, Rose C++, and Rose Visual C++ )
Rose Ada Add-In
Rose ClearCase Add-In
Rose CORBA Add-In
Rose Data Modeler Add-In
Rose Framework Wizard
Rose J Add-In
Rose Oracle8 Add-In
Rose Model Integrator Add-In
Rose Quality Architect
Rose Webgain TOPLink Wizard
Rose Type Library Importer Add-In
Rose Version Control Add-In
Rose Visual Basic Add-In
Rose WebModeler Add-In
Rose Web Publisher Add-In
Rose XML DTD Add-In
Contacting IBM Rational Customer Support
This release of IBM Rational Rose includes these new features and enhancements:
Core Rose Enhancements
· Analysis Mode, Rose VC++ & Rose ANSI C++
· Ability to create a dockable window in Rose that can host an ActiveX control.
Rose ANSI C++ Enhancement
· Provides CM integration for source code generation and reverse engineering.
The new Rose J CMR functionality includes the following capabilities:
1. Ability to add a CMR relation between Container Managed beans using the Rose Association Tool*. Validation is performed on the association and if the CMR is validated a CMR stereotype is added and the association configuration completes. Upon changing any CMR relationship, CMR validation will occur. If the CMR becomes invalid a warning will be issued.
2. Rose J generates the XML code for the CMR relationship into the bean XML file.
3. Rose J will reverse engineer any CMR relationship(s) from the bean XML file and configure the relationship(s) in Rose..
4. Check and Repair functionality available for CMR relationships. Use Rose to attempt to Repair a CMR association.
5. Rose will continue to support loading of prior models which may contain invalid CMR's, without performing any change on the model. Rose will report any invalid CMR's.
*To Draw Association on Diagram
a. Select the Main Class Diagram.
b. Select Java as the Default Language from the Tools->Options->Notation menus.
c. Create an EJB by selecting Tools->Java/J2EE->New EJB.
· Select EJB-Type as Entity.
· Select Persistence type as Container Managed.
· Ensure Local Name checkbox is checked.
· Type a name into the Bean name.
d. Repeat step "c" for a second bean, using a different name.
e. From the class diagram click in the toolbar (Uni-Directional Association or Association), select one Enterprise Container Managed JavaBean(CM EJB) and drag to the next CM EJB. Optionally you may also do this action from Tools->Create->Uni-directional association or Association.
The resultant association that is drawn has a CMR stereotype. The roles are also named, and the multiplicity is set to 1 by default. You may observe the difference by drawing an association between 2 regular classes.
· J2EE Deploy Add-In added, allowing deployment to WebLogic, Web Sphere, Sun Reference implementation, and to Borland Enterprise 4.5 and 5.1 servers.
· Rose can now detect if supported Java IDE’s are installed on your machine, after Rose is installed.
· JBuilder 8, 9 and JBuilderX (10) IDE Link Support now available!
Rose Model Integrator
Add-In Enhancements
· You may create a hardcopy of the conflicts reported by the Model Integrator
Rose CORBA Add-In Enhancements
· 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.
Rose VC++ Add-In Enhancements
Modifications to "Include" statements in the
Component Specification > External Map tab are now reflected in code, after
code generation.
.NET Managed Extensions for C++ Support in Rose VC Add-In
Rose VC++
Rose Data Modeler Enhancements
Rose Version Control Add-In Enhancement
Documentation for IBM Rational is available on-line at http://www.ibm.com/software/rational/support/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.
IBM 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.
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 IBM Rational Rose, click the Rational
Rose help book; to choose the entire help for Rose J, click the book called
Rose J .)
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:
This section describes the system and software requirements for installing and running IBM Rational Rose and its add-ins.
To plan your IBM Rational Rose environment, you will need to determine which systems, if any, will be server machines. Server systems need to be highly available, and may need extra memory and disk space. The following table describes the types of servers you may need.
Servers Used with IBM Rational Rose |
|
If you use floating licenses, you need to set up a server to administer the licenses. For more information, see Administering Licenses for Rational Software . |
|
|
Under certain circumstances, file system corruption can result from installing Rational Version 2003 products on Windows 2000 to an NTFS partition that has enabled the Windows "Change Journal" (log). This corruption is caused by a defect in Windows 2000. Before you install any Rational Version 2003 product on Computer that is running Windows 2000:
The Microsoft .NET Framework (v.1.1 or higher) is required to install the Rose Data Modeler and Rose Web Modeler Add-Ins. If you do not have the required .NET Framework version installed and choose to continue the installation, these Add-ins will not be installed and previously installed versions of these add-ins will be disabled. You can install these Add-ins at any time after you install the .NET Framework by using the Change option of your Rose installation in the Add/Remove Programs in the Control Panel.
For additional information in relation to installing Microsoft .NET Framework, please refer to:
http://msdn.microsoft.com/netframework/technologyinfo/howtoget/default.aspx.
The following describes Rose Enterprise Installation behavior in relation to the Rose Data Modeler and Rose Web Modeler Add-In's.
Microsoft .NET Framework Availability | Installation Results | User Action Required |
New Installation |
||
.NET Framework version 1.1 or higher is installed on the same machine on which installing Rose v2003.06.13. | Rose Data Modeler & Rose Web Modeler install correctly. | None |
.NET Framework version 1.1 or higher is not installed on the same machine on which installing Rose v2003.06.13. | General Install continues, however, the Rose Data Modeler & Rose Web Modeler Add-In's will not be installed. | These Add-Ins may be installed at any time after you install the .NET Framework by accessing them from the Control Panel > Add or Remove Programs > Change button. (Also see RATLC 247844, below) |
Upgrade Current Installation |
||
.NET Framework version 1.1 or higher is installed on the same machine on which installing Rose v2003.06.13. | New v2003.06.13 Rose Data Modeler & Rose Web Modeler Add-In's install correctly and the previous versions of these Add-In's will no longer be available. | None |
.NET Framework version 1.1 or higher is not installed on the same machine on which installing Rose v2003.06.13. | New v2003.06.13 Rose Data Modeler & Rose Web Modeler Add-In's do not get installed. Previous version of these Add-In's are also deactivated. | These Add-Ins may be installed at any time after you install the .NET Framework by accessing them from the Control Panel > Add or Remove Programs > Change button. (Also, see RATLC 247844, below) |
RATLC00247844: Installing Rational Suite Enterprise on machine which does not have .NET Framework version 1.1 or higher installed, warns that the Rose Data Modeler and Rose Web Modeler Add-In's will not be installed although the installation incorrectly attempts to proceed with installing these Add-In's. These Add-In's will be listed in the Add-In Manager, however, you will be unable to active them. These Add-In's should be re-installed (as described above in "User Action Required") after installing .NET Framework 1.1 or higher.
The following describes Rose Data Modeler Installation behavior in relation to the Rose Data Modeler and Rose Web Modeler Add-In's.
Microsoft .NET Framework Availability | Installation Results | User Action Required |
New Installation |
||
.NET Framework version 1.1 or higher is installed on the same machine on which installing Rose v2003.06.13. | Rose Data Modeler & Rose Web Modeler install correctly. | None |
.NET Framework version 1.1 or higher is not installed on the same machine on which installing Rose v2003.06.13. | Product Installation exits with error. | Rose Data Modeler Edition v2003.06.13 may be installed at any time, after installing Microsoft .NET Framework version 1.1 or higher. |
Upgrade Installation |
||
.NET Framework version 1.1 or higher is installed on the same machine on which installing Rose v2003.06.13. | New v2003.06.13 Rose Data Modeler version is installed correctly and the previous version will no longer be available. | None |
.NET Framework version 1.1 or higher is not installed on the same machine on which installing Rose v2003.06.13. | Product installation exits with error. | Rose Data Modeler Edition v2003.06.13 may be installed at any time, after installing Microsoft .NET Framework version 1.1 or higher. |
The following table describes the additional system and software requirements for IBM Rational Rose and its add-ins.
IBM Rational Rose Requirements |
|
Note Windows XP Home Edition is not supported in this release. |
|
Rose add-ins that use a Web browser (for example, Web Publisher) support most common browsers. Note: Because some IBM Rational products (including some Rose Add-In's) may require certain Microsoft Internet Explorer components, if the IBM Rational Setup program does not detect Internet Explorer 5.5 SP1 or SP2, or 6.0 SP1 on your system, you will be warned during the installation process - however, as this is only a warning, you may proceed with the remainder of the installation. Rose is tested with one of the recommended versions of Internet Explorer installed. Attempting to install and run Rose without Internet Explorer installed, may cause unpredictable results. You, however, are not required to use Internet Explorer as your browser. |
|
Rose J supports the following Java IDEs. Use the JDK appropriate for your IDE.
If the link for IBM VisualAge for Java 3.5.3 and/or IBM VisualAge for Java 4.0 does not get installed correctly, click on the Detect IDE button in the Code Generation tab of the Java Project Spec in Rose. |
|
If you use Sybase SQL Anywhere software, make sure that your database server meets the following minimum hardware and software requirements: |
|
Microsoft .NET Framework |
Version 1.1 or Higher Required for the Rose Data Modeler and Rose Web Modeler
Add-In's. This may be obtained from: http://msdn.microsoft.com/netframework/technologyinfo/howtoget/default.aspx |
|
|
Rose RQA Add-In
|
The Rose RQA Add-In requires the "File and
Printer Sharing for Microsoft Networks" service be available for use by
the LAN Local Area Connection. The Rose RQA Add-In is part of the Typical
Installation. Installing the Rose RQA Add-In without this service
will result in the following errors:
"Error 1920. Service NuTCRACKERService (NuTCRACKERService) failed to start. Verify that you have sufficient priviliges to start system services" and / or "Could not start the NuTCRACKERService service on Local Computer. Error 1075: The dependency service does not exist or has been marked for deletion." To verify the service is available, select: Start -> Settings -> Network and Dial-up Connections -> Local Area Connection (Properties) and verify "File and Printer Sharing for Microsoft Networks" is listed and checked in the "Components checked are used by this connection:" listbox. If it is not listed, select Install -> Service -> Add... -> File and Printer Sharing for Microsoft Networks -> OK. |
SVGA-compatible display (256 or more colors recommended) with resolution of at least 1024 X 768 pixels |
|
Installation of IBM Rational Rose on dual-boot systems is not supported |
|
The following files from LEAD Technologies, Inc., are included in this release:
Consider the following guidelines as you plan to install or remove this version of IBM Rational Rose.
Note You cannot run two different versions of Rose on the same machine.
· Member of the local administrator's group
· Domain administrator who is a member of the local administrator's group
Note If you are required to reboot after installation, you must log on using the same administrator ID as the one you used to start the installation.
The IBM Rational Software Setup program installs some shared components, which are potentially available to other applications on your system. Setup installs the U.S. English version of these files. It does not overwrite newer file versions.
If the Setup program needs to update shared components, it displays a list of the shared components that require updates. The files listed must be installed on your system before the installation can proceed.
In general, we recommend that you allow the installation procedure to install shared files for you. In the following circumstances, you may want to install the files yourself:
The Replace files with newer versions in English check box is selected when you have installed earlier versions of shared files that are localized to a non-U.S. English language. If you clear this check box, you can save and print the list of files that need to be updated. You will need to update the files yourself.
You should back up your registry and system directories prior to running the IBM Rational Software Setup program. In addition, make system backups of any machines on which you plan to install Rose. Specifically, we recommend you make backups of the following files:
Rose path map variables are saved in the registry.
1. Run regedit and navigate to HKEY_CURRENT_USER\Software\Rational Software\Rose\Virtual Path Map .
2. On the Registry menu, click Export Registry File....
To restore path map variables:
1. Run regedit and navigate to HKEY_CURRENT_USER\Software\Rational Software\Rose\Virtual Path Map .
2. On the Registry menu, click Import Registry File...and import the file you exported.
If you have older IBM Rational products installed on your system, you must ensure that all IBM Rational products on that system are upgraded to the same version. Because IBM Rational tools share files and components, a new installation can cause the older IBM Rational products to stop working. You will see no visual clue that the older products may be compromised.
This release of IBM Rational Rose includes these new features and enhancements:
· Ability to create a dockable (or floating) window in Rose that can host an ActiveX control.
When enhancements are included in a new petal file format for Rose, it is necessary to re-save previously created Rose models in the new Rose format. Previously, this could only be done through a registry setting named, "Force Save". A new option is now available in the Tools > Options > General Tab in order eliminate the need to modify the registry. To use this new option:
Rose 2003.06.12 includes significant enhancements to Sequence Diagrams, as described below
You now have the ability to create Transitions and Object Flows to read-only Activities or States. This enhancement allows you to share Activity States even though they reside in read-only controlled units. Browser representation is now available for Transition and Object Flows.
A new "Relationship" folder is now available under a State Machine that holds the Transition and Object Flow items.
Transition is
represented with an icon whereas Object Flow is represented
with an icon
in the browser. It is now possible to rename and
delete transition and object flow items from the Relationship folder.
Once these actions are performed, the view on the Activity diagrams will be
updated accordingly. It is also possible to relocate the transition and
object flow items from one State Machine to another without affecting the
corresponding view drawn in the Activity diagrams.
Illustration of Transition representation in Browser:
Illustration of Object Flow representation in Browser:
State Transitions and Object Flows may also be created through REI or Rose Script, as before. The results will now be represented in both the diagram view and in the Relationships folder in the browser.
Double-clicking on the State Transitions and Object Flows in the browser will open the Specification dialog which is the same dialog available in previous Rose releases and may be used in the same manner as before, i.e.:
· State Transition Specification dialog also accessible by double-clicking on a Transition from the State Specification > Transitions tab.
· Object Flow Specification dialog also accessible by double-clicking on an Object Flow from the Object Specification > Outgoing Object Flows tab or Incoming Object Flow tab.
Right-clicking on the State Transitions and Object Flows in the browser will present the following context menu options (options are synonymous with the Association browser item):
· Open Specification
· Delete (All corresponding transition or object flow views in write-able Activity diagrams in the model will be deleted, and those views in read-only Activity diagrams in the model will be marked as unresolved.)
· Rename (Behavior synonymous to browser behavior of Associations)
Additional Available Browser Actions:
· Dragging and dropping Transitions or Object Flows (if the transitions or object flows are in writeable units) from one State Machine to another State Machine is supported. This will not affect the Activity diagrams that contain transition or object flow views, respectively.
· If Transitions or Object Flows are in read-only units (packages) it is not possible drag and drop these transitions or object flows (similar to the behavior for Associations).
· Dragging and dropping a Transition or Object Flow to an Activity diagram is supported.
Note:
· Transitions and Object Flows are now saved in the appropriate StateMachine in which the client of the State Transition or Object Flow resides.
· Unloading controlled units that contain Transitions or Object Flows in the browser Relationship folder will cause the transition or object flow views in the diagram to show as unresolved. Reloading the controlled units that contain Transitions or Object Flows will show these views are again resolved.
· Unloading a unit which contains an Activity and Object Flow will still allow the ability to edit the Object Flow in the browser. The change to the Object Flow will be available when reloading the unit.
Users will have the ability to utilize Rose J 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.
These patterns (based on "Design Patterns: Elements of Reusable Object-Oriented Software") are applied the same way you currently apply the Rose J patterns, i.e.:
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.
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 (except, in the case of an Analysis model) 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();
}
}
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.
Rose may now be used as a container for all loaded ActiveX controls.
For example: HKEY_CURRENT_USER\Software\Rational Software\Rose\ActiveX
E.g.: To use the Microsoft Excel Spreadsheet (with ProgramID = "OWC.Spreadsheet.9" ) you should have the following key:
Upon restarting Rose you may now load any ActiveX control, which appears in the View menu option. Each ActiveX control (which, has been registered as described in "How To Perform the Rose / ActiveX Registry Configuration (Example: Microsoft Office Spreadsheet 9.0)" will list it's own menu option, directly under the Editor menu option.
Whenever an ActiveX control is created and loaded, it appears in the menu and the associated menu item is checked.
· Drag the ActiveX control window by clicking on the caption.
· Resize the ActiveX control window by clicking on a border.
· Switch between docked and floating window state by double-clicking on the caption or dragging the ActiveX control, until achieving the shape you desire.
The size and position of the ActiveX window are saved into the registry when closing the Rose application.
Once the ActiveX control is loaded in Rose, it continues to be loaded until explicitly closing it.
The ActiveX controls project was added to the Rose workspace. It is based on a SECMultiDocTemplate which creates a document and a view at runtime. You can use Rose to load your COM object only if it is an ActiveX control.
A COM object is an ActiveX control if it exposes the following interfaces:
For each selected ActiveX, Rose creates the following:
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.
When starting Rose, sometimes the introductory splash screen takes over the entire screen and you cannot do anything else until Rose is loaded. Use the - noSplashScreen command line switch to control display of the splash screen. Use one of the following methods to set this switch: 1. In Windows, click Start > Run. |
|
Problems with McAfee Virus Scan software When some software is installed or launched, some virus scanners check each file, including .dll and .ini files, being read and loaded, as part of their normal process. However, this functionality can significantly increase the amount of time it takes for some software to load. This is a result of the interaction between the loading software's dynamic extensibility functionality and the virus checking mechanism used by the anti-virus software. This functionality of certain anti-virus software could affect the performance of IBM Rational Rose and of the IBM Rational Installer. Rose stores a significant amount of information in the default stereotype.ini file, as well as ini files used by different Rose Add-ins. Rose accesses keys in these ini files using the standard windows calls, which unfortunately open, search, and close the ini file every time we query for a key from a file. This means that McAfee scans the complete ini file every time we attempt to read a key, literally 100s of times for some of the files. This, in addition to the dll scanning that is exacerbated by the fact that Rose' is comprised of many components, is the cause of the slowdown in Rose startup. The best solution at this time is to disable scanning of ini files in McAfee. To do this follow these steps: 1. Go to the system tray and double-click the Vshield icon. 2. In the System Scan dialog box, click Properties . 3. In the Properties dialog box, make sure that the Virus scanner is scanning for program files only. 5. In the Program File Extensions dialog box, find the .ini extension and click Delete . 6. Click Ok to close the Program File Extensions dialog box. 7. In the Properties dialog box, click Apply to save the changes. |
|
rose00011800 |
You may encounter an unresolved model warning if there is a view of an item on a diagram, but the underlying item is not loaded or could not be found in the current model. Items and relations are correctly displayed and reported by the Check Model command as unresolved references when the view to the item is in a diagram that is in the current model but the item resides in an unloaded package (controlled unit). The reference becomes resolved and the unresolved indicator is removed when the unit containing the item is loaded. The unresolved model warning occurs occasionally during model loading if the model was created using a previous version of Rose and that version of Rose allowed an invalid model to be created. Some known cases are: Circular Generalize/Realize Relationship Combinations (allowable in Rose2000e but no longer valid ). Note that if you attempt to create a circular generalize/realize relationship combination, you will get an error and the relationship will not be created. Circular generalize/realize relationship combinations that exist in models files created with earlier versions of Rose are detected upon model load and one of the relationships involved in the circularity is left unresolved. You may delete the unresolved view and then add new ones as appropriate. Running Tools > Check Model will provide in a list of unresolved views in the Rose Log. If the relationship has no view on a diagram in the model, then an Unresolved Relation warning is placed in the RoseLog. The warning is also generated by Tools -> Check Model . To correct the unresolved relations: 2. Check the Log file for Unresolved Relation warnings. 3. Open the Class Specification for the client class and click the Relations tab. 4. Note that the unresolved relation (generalize or realize) is the one with the class name in brackets in the name column. 5. Determine which classes are involved in the circularity. 6. Delete the undesired relationship using the Class Specifications Relations tab. Shared Objects - Shared activity diagram objects (allowed in Rose2000e, but no longer valid in this release). A shared object is an object that belongs to one state machine and has a view on an activity diagram belonging to another state machine. The drag and drop of the object is now disabled if the object does not belong to the same state machine as the diagram. In general, the unresolved object can be deleted from the diagram and a new object can be created on that diagram. The model does not lose integrity or validity because of this since an object is not actually a model element -- it does not define anything, and is only an instance of a class used for visualizing state or behavior. |
rose00014249 |
A new Creates a Form class diagram toolbar is available, but you must manually add it to the toolbar. |
rose00016544 |
Module 6 of the tutorial asks you to register some DLLs. These are the DLLs that are shipped with the tutorial. Doing this on Windows 2000 may fail, causing an error when attempting to drag the DLLs to the regsvr32.exe. You may need to give yourself administrative rights to your machine in order to complete this step in the tutorial. |
RATLC00028780 |
Rose IDE Link mechanism does not correctly link to (or, integrate with) VAJ 3.5.3. If encountering this problem, contact IBM Rational Technical Support and ask for Technical Note# 16907. |
Korean character input; slow display for question marks. If a class name contains a question mark (?), Rose takes longer than expected to display the class name. Turning autosize off will help alleviate the delay. |
|
Print Preview does not work consistently for all diagram types. |
|
The Activity icon does not display the history graphical depiction on it. It is also not possible to drag the "History" icon from the browser to the diagram. |
|
Text within the brackets on messages is lost on all sequence diagrams when user clicks Apply after changing the Message Signature option. |
|
Some custom stereotype icons added to previous versions of IBM Rational Rose do not display correctly. Workaround: Open the icon file (.wmf) in a graphics application that supports .wmf files. Set the color palette to Transparency . |
|
To change the ROSE_CPP path map variable, you must first manually remove its entry from the registry. In the Windows Registry, this pathmap variable is located at two different locations: |
|
RATLC0040998 | Errors may occur upon selecting Tools > Options > XML tab and right-clicking on item and selecting Help. |
If a state or activity diagram contains a view of an element from another state or activity diagram/model, the Query > Expand command will not work for that element. |
|
Deleting a package with a class attached to a read-only object in an activity diagram will cause Rose to crash |
|
It is not possible to delete an unloaded controlled unit from a model. To delete a unit from a model, first load that unit and then delete it. |
|
RATLC00212699 |
Rose crash may occur on VC++ update code (only when model opened by double-clicking). Workaround: Start Rose once and close it. You may now double-click on the model and it will load and may be utilized, correctly. |
RATLC00213677 |
Printed diagrams can differ from what is displayed on the user's screen. For example, some longer operations do not print completely. |
RATLC00237076 |
Extended Help cannot be opened if RUP is not installed. This is correct behavior, however, this menu option should be grayed out in this circumstance. |
RATLC00238101 |
Rose may consume a significant amount of CPU (i.e. 99%), if a Merant PVCS version prior to 7.5.00 is installed. Work-around: Disable the Version Control Add-In, or do not install the Version Control Add-In when installing Rose. |
RATLC00238431, 371412 |
Rose appends Virtual Path Map variable after drive letter if there are two equal folders on two drives |
RATLC00238854 |
Help About - Characters may not display properly in Contact Information window on Korean Windows. The paragraph should read: Before contacting IBM Rational Software, please visit www.ibm.com/software/rational/support for detailed product and contact information. |
RATLC00239236 |
Cursor does not position correctly in the editor on DBC characters. |
RATLC00239886 |
Repair Installer functionality may not completely repair Rose installed files. If you continue to encounter a problem, after running ‘Repair’, contact Technical Support. |
RATLC00443765 |
Generated DDL script does not escape DBCS 1. Create Japanese table/col/view names. Workaround: You must turn on "Quoted Identifier" option when using non-ASCII characters for object names. |
RATLC00444954 |
A generalization and association may overlap each other, in diagram |
RATLC00445804 |
Print Preview does not clearly represent activity diagram |
RATLC00449778 / IC39598 |
Loading a large Model
containing many controlled units when the Version Control Add-In is checked,
causes all Add-Ins to become un-checked in the Add-In Manager. Workaround: Write-enable the model properties and reload the Model. All Add-Ins should then stay checked. |
The Help topic Visual Studio RTE Extensibility Drag-Drop Add-In Sample , section How to Run the Sample requires the following update: |
This involves Rose models that use version control with ClearCase and integrated use cases with RequisitePro. If you have unsaved changes within a controlled package and attempt to check in that package, ClearCase prompts you to save your changes. In this case, RequisitePro does not recognize the save operation. When you subsequently close the Rose model, RequisitePro removes all changes since your last recognized save operation. Therefore, use case information in Rose and RequisitePro may not be synchronized. To avoid this, be sure to save the controlled package in Rose before checking it in to ClearCase.
The following new features are included in this Release:
**Documentation (comments) can be both generated and reverse engineered for all model elements.
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.
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.
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:
This supports full synchronization of comments in the model and source code. This is the default.
This setting will only generate comments into the source code, overwriting any comment section that differs with the documentation text.
This setting will only update the UML documentation for the associated entity, overwriting any text that differs from the comment.
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 versions of the Rose ANSI C++ add-in 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.
Defect |
Description |
RATLC00042669 |
Setting “Forward Reference Only” on Parameterized class may cause Rose to crash. |
RATLC00053166 |
Qualified name not used for nested C++ classes. |
RATLC00054248 |
Forward engineering of a specific construct may cause the following Rose crash: SYSTEM ERROR: line xx, pc ..: Cannot find property “GenerateInclude” in property set “default_Role”. |
RATLC00236173 |
Header file is not included in the body file when the package body and package spec components are not in the same package. |
RATLC00240069 |
Generating code on
nested classes may cause the following error: |
RATLC00442224 |
Constraint ordered does not work correctly in Japanese version of Rose. |
Defect |
Description |
RATLC00039470 | Unable to suppress the generation of an operation in a class. |
RATLC00238885 |
Rose Analyzer may write associated files to the Rose Release Area location, while in use. |
The Rational Rose Visual C++ Add-In provides the interface between the IBM Rational Rose modeling environment and Microsoft Visual C++. The main features of IBM Rational Rose Visual C++ include:
· Code generation (Code Update Tool)
· Reverse engineering (Model Update Tool)
This release of the Rose Visual C++ Add-In is backward compatible with previous versions of the add-in.
The support for MIDL in this version of Rose is deeper than in previous versions of Rose. When you use the Code Update Tool or Model Update Tool on a model created by Rose 2000, this version of Rose will automatically add new components stereotyped as <<MIDL>> for existing components that represent MIDL projects. Model classes that are stereotyped <<coclass>> or <<interface>> will automatically be assigned to the <<MIDL>> components.
It is recommended that you use the Model UpdateTool on any Rose 2000 models before attempting to generate code using this version of Rose.
The model formats used by the Visual C++ and Classic C++ Add-Ins are not interchangeable. If you want to use the Rose Visual C++ on models created for use with Rose Classic C++, you must convert the models using the Model Converter.
To do this, on the Tools menu, click Visual C++ > Model Converter.
In earlier versions of Rose VC++, round-trip engineering would write directly to the file system to update code files. If those files were open in the IDE at the time, you would see a dialog box indicating "This file has been modified outside of the source editor. Do you want to reload it?", asking you if you would like to reload the file into the IDE.
In Rose 2003.06.10, if this feature is enabled (see below) files that are already open in the IDE will be modified directly in the IDE, thus avoiding the reload dialogs.
In the case of ClearCase managed files, there was also a problem in the interaction between the Visual C++ IDE and the ClearCase files that reside in the ClearCase link directories. Visual C++ never receives file change notification events from link directories. In this case you would not see the message, indicating the file would need to be reloaded.
In Rose 2003.06.10, if this feature is enabled (see below) the files open in the IDE will automatically be updated during round-trip engineering.
To Enable Rose VC++ Automatic Source File Updates in the IDE: Set the following registry key to "1".
To disable this feature, set the registry key to "0". By default, the value is "0".
HKEY_LOCAL_MACHINE\SOFTWARE\Rational Software\Rose\Addins\VC++\Custom Settings\Language Properties\ReloadFilesInIDE
The Rose Visual C++ Add-In may now access projects loaded in the Microsoft Visual Studio .NET IDE.
Note Rose Visual C++ Add-In does not support the .NET “managed C++” code extensions to the C++ language, at this time. In addition, the Rose VC++ Add-In will not recognize the new “#” directives, added in .NET 7.0.
How To Access .NET 7.0 Projects in Rose
The “Recent” and “Running” tabs will show VC++ .NET projects, as well as VC 6.0 projects.
Ability to Update Code with
"Include" changes after Making Changes to List of Includes in
External Map tab
Any modification in the list of
includes, specified in the Include File / Filename list (in the External Map
tab of the Component Specification), will be reflected in the code after the
next code generation. In previous Rose releases, the list of includes
specified in the External Map Tab was only generated one time and any
modifications to the list were not reflected (updated) in the code.
This enhancement allows the user to modify any includes and after the next code generation the mapping classes-modified includes will be reflected in the code.
To access External Map tab (in the Component Specification dialog):
Select VC++ Component in browser Component View
Right Click and Select Properties
The External Map tab maps classes realized by this component to the include statements required to reference these classes by classes realized in other components.
If the External Map tab for a sample Component "SupplierComp" includes the following generated code:
#include "stdafx.h"
#include "WrongHeader.h"
#include "Client.h"
and a change is made to the Include file name (from "WrongHeader.h" to "RightHeader.h") in the External Map tab of the "SupplierComp" component.
Generated code will now include:
#include "stdafx.h"
#include "RightHeader.h"
#include "Client.h"
Note : After every modification of the include list (in the External Map tab) the user is notified by a warning message to regenerate the code. The "Include" modifications will be effective (in the code) only after the next code generation.
Upon selecting "Yes", code will be generated and the "Include" changes will be realized in the newly generated code.
Selecting "No" (i.e. delaying the code generation), at the next attempt to generate code, the user will be notified by a final warning message to generate code for the components affected by the changes in the External Map otherwise changes will not be reflected in the code.
.NET Managed
Extensions for C++ Support in Rose VC++ Add-In
The Rose VC++ .NET support has been enhanced to include Managed Extensions
for C++ Support for the Rose VC++ Add-In for
Reverse Engineering purposes. The following new keywords have been added
to the Managed Extensions in the Grammar file for Rose VC++. When
necessary, they are interpreted and reflected in the Model in order to be
properly reverse engineered.
Keyword | Description |
__abstract | Declares a class that cannot be instantiated directly. |
__box | Creates a copy of a __value class on the common language runtime heap. |
__delegate | Declares a reference to a unique method (a function pointer) of a managed class. |
__event | Declares an event method of a managed class. |
__finally | Declares a finally block associated with a try block. |
__gc | Declares a gc type. |
__identifier | Enables the use of a C++ keyword as an identifier. |
__interface | Declares an interface. |
__nogc | Declares a native C++ class that is not garbage-collected. |
__pin | Prevents an object or embedded object of a managed class from being moved by the common language runtime during garbage collection. |
__property | Declares a property member for a managed class. |
public, protected and private | Determines the accessibility of specified types and methods outside of an assembly. |
__sealed | Prevents a __gc class from being a base class, or a method from being overridden by one in a derived class. |
__try_cast | Performs the specified cast or throws an exception if the cast fails. |
__typeof | Returns the System::Type of a given type. |
__value | Declares a value type. |
Defect |
Description |
RATLC00041560 |
VC++ role type and relationship not consistently linked together. |
RATLC00053232 |
VC++ Add-In may not generate code or reverse engineer after upgrading from Rose 2000e. |
RATLC00055339 |
Comments on inline operations added twice to VC++ header file |
RATLC00212957 |
Rose V++ unassigns interface from component in the model when including midl code. |
RATLC00213032 |
Unable to work on a project when files have been moved from their original location. |
RATLC00213384 |
VC++ Add-In appears to ignore namespaces when reverse engineering. |
RATLC00214070 |
Operation comments added by the VC++ add-in in the cpp file are not deleted when operation is deleted from Model. |
RATLC00227834 |
#include not generated if the classes the dependency relates to are generated before the dependence was added. |
RATLC00227928 |
Updated VC++ documentation in Online Help. |
RATLC00231778 |
Updating the External Map does not affect the re-generation of the #includes in client classes. |
RATLC00232264 |
Static Initializer declared in nested class lacks outer class scope in definition |
RATLC00232265 |
Static Initializer in source is not recognized by the parser and is not updated |
RATLC00235393 |
Rose incorrectly deletes implementation code for abstract destructors. |
RATLC00238846 |
Entire "Options" groupbox should be enabled or disabled upon "Generate Documentation" check box change |
RATLC00241604 |
Error occurs when opening Model Assistant on typedefs that are stored in read-only *.cat file. After error occurs, user must kill and restart Rose. |
RATLC00438375 |
"int* const" gets changed to "int" when reverse engineering using VC++. |
RATLC00439082 |
#include for aggregation and dependency ignores HeaderFileName property (was RBU21771). |
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 following list describes the known problems and limitations for this release of Rose Ada:
rose00014965 |
Rose/Apex needlessly reports circularities among nested packages. |
rose00016142 |
Private only visibility for cg of operations. |
rose00029061 |
Rose/Ada does not support RUP component view mapping. The following settings are now supported for the Apex properties ApexSubsystem and ApexView: ApexSubsystem: [/]{directory/}subsystem ApexView: {directory/}view |
rose00031390 |
Parameter mode field using Rose/Ada A new parameter property Mode, is used to specify the parameter mode. It is no longer necessary to specify the mode in the type field. |
rose00069859 |
Ability to specify a text file in the Copyright notice property. A new property Declare, with the values (Before, After), can now be used to specify where the static declaration should be declared, either before or after the class type. |
rose00073946 |
Suppress the generation of access procedures to public task entries of private task types (or any task type, for that matter). |
rose00074511 |
Wrong signature generated in the Generic Subprogram Body. |
rose00075639 |
Rose Ada: System Error: line 10811, pc 27607 Null Handle in request for property "inherits". |
RATLC00039909 |
Context menu for a package should have "Browse" as an option. |
RATLC00040027 |
Browse on a package does nothing if Apex Add-In is disabled. |
RATLC00040199 |
CG property required to specify controlled type visibility. A new class property TypeControlVisibility, specifies whether to make the controlled extension visible in the public part. The default is Private. |
RATLC00040756 |
Unable to code generate Ada83 / Ada95 from a read only model. |
RATLC00040821 |
Allow completely private types. |
RATLC00040865 |
Ada95 creates new file even when selecting no. |
RATLC00041000 |
Error when trying to browse spec/body. |
RATLC00041082 |
Browses to wrong spec after class is assigned to a component. |
RATLC00041232 |
Unable to select multiple components for code generation in browser. |
RATLC00041586 |
Type definition in package body. |
RATLC00041617 |
Request for Representation property for association roles. |
RATLC00042019 |
Apex and Rose/Ada: problems with code regeneration and checked in units. |
RATLC00042861 |
Unable to change browse information in read only *.cat file after code generation. |
RATLC00043143 |
Cannot browse body from component view - package body. |
RATLC00047509 |
Update to Add-In Manager, to include Rose Ada Add-In minor version update number. |
RATLC00047852 |
Add capability to generate Class wide Access Discriminants. The new attribute/has/role property AccessDiscriminantClassWide controls whether type is generate as ‘Class. |
RATLC00049240 |
Errors on code generation of overloaded operators (Unix only). |
RATLC00053250 |
Rose Ada generates 'with' in the Package Spec when it could be in the Body. |
RATLC00054636 |
Generation of generics in a package. Supports subprogram generics only. The stereotype of an instantiated class utility must be set to subprogram. The class must also be assigned to a package spec component. The Export Control field controls the location where the generic subprogram is declared. |
RATLC00055342 |
Ada95 code generation of nested classes (level 3) raises a System Error. |
RATLC00211903 |
Private constant not generated correctly. |
RATLC00212355 |
Ada 95 Browse Spec bring up the same code as Browse Body on Parameterized classes. |
RATLC00212510 |
Subtype to be generated in private part. |
RATLC00212616 |
Need Rose/Ada to maintain implementation declarations in body. Export control or "class visibility" controls where the declaration is defined in the package spec/body. TypeVisibility controls whether a public class is a private type. A new class property IncompleteType (DoNotDeclare, NoDiscriminantPart, UnknownDiscriminantPart, KnownDiscriminantPart) is used to declare an incomplete type declaration. The default is DoNotDeclare. |
RATLC00212637 |
Unable to model a task that is completely private. |
RATLC00212696 |
Generic subprogram instantiation for a class method. Using the Export Control field on the instantiated class now controls the location where the instantiation is generated. The property CodeName is now supported. |
RATLC00212878 |
Browse Body from a Class assigned to a "main Program" component does not work. |
RATLC00214057 |
Ada can't generate missing directory during code gen. |
RATLC00234488 |
The following error message could occur, upon generation Ada95 code (which, includes many operations): Error: Internal Error: The error type is unknown, an old type error id is used. |
RATLC0041393 |
Rose / Ada generates not Set / Get for tasks. |
The ClearCase add-in provides a tight integration between Rational Rose and the IBM Rational ClearCase version control system. This add-in is intended to replace the ClearCase capabilities provided through the generic Version Control Add-In. Unlike the Version Control Add-In, the ClearCase Add-In does not use the Microsoft SCC API to communicate with ClearCase. This allows for more ClearCase-specific customization.
If you are already familiar with the Version Control Add-In, you will find the transition to the ClearCase add-in simple because many of the dialogs and menu items are identical.
The IBM 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:
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 it can cause model corruption.
The Rose CORBA Add-In has been enhanced to allow repeated forward and reverse engineering of CORBA IDL's. It is important, however, that IDL files be reverse engineered in the decreasing order of dependency, for example the most dependent file should be reverse engineered first an the least dependent file should be reverse engineered last.
Defect |
Description |
RATLC00054223 |
CORBA Add-In does not recognize “#undef”. |
RATLC00212301 |
CORBA Add-In does not use Logical View structure for storing type references. |
RATLC00212792 |
Modifiers are placed inside parameter type definition – no unique ID saved. |
RATLC00368093 |
Order of operations/types not correct in resulting CORBA/IDL generated code. |
The Rose CORBA online Help references the old Rose internal editor (R2Editor); however, Rose CORBA now uses the new internal Rose editor.
Defect |
Description |
RATLC00039757 |
Comments placed on the same line as a definition may cause CORBA reverse engineering to fail. |
RATLC00041558 |
Unable to suppress full PATH in #include in CORBA-code. |
IBM Rational Rose Data Modeler is a database modeling and design tool that uses UML (Unified Modeling Language) notation. It allows you to work with UML object models as logical models and data models as physical models, and helps you maintain synchronization between the data model and the database.
The Rose Data Modeler Add-In now supports Name Shortening in order to adhere to specific database requirements. The following specification pages have been enhanced to allow user to specify a SQL Name for DDL generation. The Name Shortening logic will be applied to this field. The "Compare and Sync…" feature also compares the SQL name (if not blank) with the data-modeling element name in the selected database/DDL script.
The Name Shortening mechanism applies to the SQL Name if it is not blank, or to the actual name of the data-modeling element if SQL Name is blank. The new name shortening mechanism utilizes an algorithm to strip out vowels and to ensure uniqueness. Name shortening is accomplished via Registry settings (prior to starting Rose). The following registry entries are set up automatically (using the default values for each supported database, as shown below) by the installer. To change these Registry settings
1. "Adaptive Server" with value 128
2. "ANSI" with value 128
3. "DB2" with value 128
4. "Oracle" with value 30
5. "SQL Server" with value 128
Any names generated in the DDL that are longer than 128 characters (based, on the above settings) will be automatically shortened during the Forward Engineering process. This feature, therefore ensures that all names generated in the DDL are valid in the database context of these strings.
Warnings you may encounter in Rose log if one or more of the following conditions exist:
1.
Name
shortening applies and the SQL name is blank.
NOTE: When the SQL name user
input is correct, data modeler accepts it and you will not be notified when
name shortening is applied.
2. SQL name conflict occurs.
Note: In any cases where name shortening is applied to the name/SQL name of the data-modeling element, the SQL name field in the model will not be updated in the model.
Rose Data Modeler now supports comparison between the Data Model and its Transformed Object Model. The following differences between the object model and transformed data model will be displayed in the comparison report:
1. Foreign Key changes in data model. [i.e. the parent / child of an transformed identifying / non-identifying relationship has been changed.]
2. Primary Key changes in Data Model [i.e. The addition / deletion of Primary Key Column(s)]
3. Objects that have been deleted from object model but still exist in data model.
4. Attributes in object model which are not in data model.
5. Attribute data type changes in object model which are not in the corresponding column data type in data model.
The Data Model-Object Model Comparison Wizard allows you to save the differences (report) to a text file for future reference.
To Utilize the Data Model-Object Model Comparison Wizard
1. Right-click on the schema
2. Select Data Modeler->Compare to Object Model
3. Follow the online instructions to compare the selected data model with the transformed object model.
Note: A valid comparison can only be performed only if the Data Model has a Transformed Object Model.
Rose Data Modeler now supports synchronization between Data Model and Object Model during Transformation. Any extra elements will be deleted if the "Delete Extra Element In Destination" option is selected during transformation. The "Delete Extra Element In Destination" option is provided in both "Transform Data Model to Object Model" specification and the "Transform Object Model to Data Model" specification.
Rose Data Modeler now generates DDL commands organized by table instead of by command types. Description below lists original (previous) order and new enhanced DDL Elements Generation Order.
Original Generation Order
Drop statements
Create Database statements
Create Tablespace statements
Create Distinct Type statements
Create Table
Indexes
Alter Table add Foreign Key
Create View
Create Stored Procedure
Create Trigger
Comment
Enhanced DDL Elements Generation Order
- Create Aux Table if Aux Table / Create Table …Like … if it's a Like table
- Alter Table add column (For Like Table, if column definitions are present)
- Indexes for the Table
- Alter Table add Constraints (For Like Table, if PK constraint or Unique constraints are present)
Rose Data Modeler now supports DDL Round-Trip Engineering for Database Type IBM DB2 OS390 version 7 on the following DDL statements:
1. CREATE DATABASE statement (newly added)
2. CREATE AUXILIARY TABLE statement (newly added)
3. User-defined column data type definition in ALTER TABLE ADD <column definition> statement.
4. ROWID data type
5. The following keywords in CREATE TABLE statement:
a. AUDIT
b. DATA CAPTURE
c. CCSID
d. WITH DEFAULT
e. DEFAULT
f. GENERATED ALWAYS
g. GENERATED BY DEFAULT
h. As-identity clause
i. LIKE <table name>
I. Only <table name> is supported
II. Column definition for LIKE table is generated as ALTER TABLE ADD <column definition> statement instead of being generated together with the CREATE TABLE statement.
6. The following keywords in CREATE INDEX statement:
a. BUFFERPOOL
b. PIECESIZE
c. CLOSE
d. COPY
e. Using-block
f. Free-block
g. Gbpcache-block
h. CLUSTER PART partition information
i. ASC
j. DESC
7. The following keywords/constructs in CREATE TABLESPACE statement:
a. LOB
b. DSSIZE
c. SEGSIZE
d. BUFFERPOOL
e. LOCKSIZE
f. LOCKMAX
g. CLOSE
h. COMPRESS
i. CCSID
j. LOCKPART
k. MAXROWS
l. NUMPARTS
m. MEMBER CLUSTER
n. Using-block
o. Free-block
p. Gbpcache-block
q. Trackmod-block
r. PART Partition information
Unique constraints and Primary Key constraint are now generated as ALTER TABLE statements immediately after the CREATE INDEX statement rather than being generated together with CREATE TABLE statement. The ALTER TABLE statement construct will appear as:
ALTER TABLE <table name> ADD <constraint definition>
Constraint name generation is supported if v7 is selected in the DDL Forward Engineering wizard.
Data Modeler now supports Microsoft SQL Server 2000, including the following SQL Server 2000 features:
Data Modeler allows you to create, edit, delete, and use Specifications for the following new elements:
Data Modeler now supports data storage modeling for DB2, Oracle, and SQL Server. You can:
You can also assign tables to a tablespace using the enhanced Table Specification.
Data Modeler now supports modeling views in a data model. You can:
Defect |
Description |
||||||||||||||||||||||
rose00054342 |
VAJ 3.2 is no longer supported |
||||||||||||||||||||||
rose00056595 |
In VisualAge persistence for a Container Managed EJB is recognized as Bean Managed. |
||||||||||||||||||||||
RATLC00237106 |
If the owner of tables in SQL 2000 is not dbo, the primary / foreign keys are not reverse engineered into Rose. |
||||||||||||||||||||||
RATLC00246184 | Rose may hang when attempting to delete a relationship after reverse engineering database from SQL Server 2000. | ||||||||||||||||||||||
RATLC00248119 |
Browse
button missing in the Forward Engineering wizard on Windows NT Simplified
Chinese. Workaround: Enter the absolute PATH. |
||||||||||||||||||||||
RATLC00248121 RATLC00248122 | Text may appear to be mingled and fields may overlap in the Forward Engineering dialog boxes and Forward Engineering Wizard on Windows NT Simplified Chinese. | ||||||||||||||||||||||
RATLC00367758 |
Correct
Oracle Object to Data Model Data Type Mapping should read as follows:
|
||||||||||||||||||||||
RATLC00373262 |
Change and Apply may cause incorrect SQL format. |
||||||||||||||||||||||
RATLC00373752 | Attempting to Reverse Engineer from Oracle (8 and/or 9) database, only one index per table is created in the model although the database includes multiple indexes assigned to each table. | ||||||||||||||||||||||
RATLC00444561 |
Changing the parent constraint causes a new column to be generated. |
||||||||||||||||||||||
RATLC00447653 |
Parser errors when reverse engineering DB2 7.x DDL script (unsupported keywords). |
The Framework Add-In provides a library of frameworks that can be used as templates when creating new models. The Framework Add-In also provides a wizard that helps you add additional frameworks.
Defect |
Description |
RATLC00053045 |
Framework does not correctly launch, after upgrading Rose. |
The Rose J add-in supports true round-trip engineering and provides support for large frameworks. This release of the Rose J add-in provides the following new capabilities:
· J2EE Deploy Add-In added, allowing deployment to Web Logic, Web Sphere, Sun Reference implementation, and to Borland Enterprise 4.5 and 5.1 servers..
· Provides CM integration for source code generation and reverse engineering.
· Rose J may be used to automatically detect the existence of supported Java IDE’s, after Rose is installed.
Previously, when attempting to perform code generation or reverse engineering while any controlled unit was unloaded, a dialog would be displayed, informing you that some units are unloaded and incorrect code might be generated. In Rose 2003.06.00 and earlier, it was not easily possible to determine which units required loading, in order to successfully perform code generation or reverse engineering
The Rose J Model Closure Autoload Feature automatically helps you determine the correct model closure necessary for successful forward and reverse engineering. Utilizing this feature, Rose will ensure the necessary units are loaded.
The following describes the steps necessary to utilize Rose J Model Closure Autoload.
I. To Enable Model for Model Closure Autoload Feature
a. How to Enable the Autoloading feature in a Newly Created Rose 2003.06.12 Model
Enable the “Maintain Model for Autoloading” flag in the model, as described below.
1. Load model file in Rose 2003.06.12.
2. Right-click on the Model Item in the browser. (The root of the browser tree).
3. Select Open Specification
4. Select "Maintain Model for Autoloading" on the General Tab.
5. Save the Model.
The model is now enabled for Model Closure Autoloading.
b. How to Enable Autoloading in a Rose model created prior to Rose 2003.06.12
Enable the “Maintain Model for Autoloading” flag in the model and force-save the model.
1. Set the registry key \HKCU\Software\Rational Software\rose\Rose\ForceSave to "Yes"
2. Open the entire model and all subunits in Rose 2003.06.12.
3. Select Maintain Model for Autoloading as described in “How to Utilize the Autoloading feature in Newly Created Rose 2003.06.12 Model”.
4. Save the model. It will ask to save all subunits. Click "Yes" to save them all.
5. The registry key value is reset. If you need to force-save another model, repeat Steps 1-4.
II. Utilizing Model Closure Autoload Feature
i. Auto Load this time only
ii. Auto Load always
iii. Continue with no Auto Load
Prior to this release, the Enterprise JavaBean Wizard for Rose J did not allow a developer to define an EJB that offers both local and remote interfaces. According to the EJB 2.0 specification, it is possible to provide both a remote client view and a local client view for an enterprise bean. This enhancement will allow you to create a dual role EJB that offers both local and remote client views.
Following new functionalities are included:
1. Create an EJB with both Local and Remote Client View A dual role EJB can be created by checking the checkboxes Component Name (for remote interface) and Local Name (for local interface) from the J2EE – EJB Specification page.
2. Remove a Client View from a Dual Role EJB You may open the J2EE – EJB Specification page of a dual role EJB. If you uncheck the checkbox of Component Name or Local Name, the corresponding client view will be removed.
3. Add EJB methods to a Dual Role EJB New context menu items are added to the EJB class. Remote/Local EJB methods can be added to the Bean class and exported to its remote and local interfaces. A new operation stereotype, EJBRemoteLocalMethod, is created. When an EJB business method is exported to both Local and Remote interfaces, its stereotype is set to EJBRemoteLocalMethod.
4. Remove an EJB methods from a Dual Role EJB An EJB method can be deleted from the Rose browser or class diagram. The corresponding EJB methods of the deleted method will also be removed from the EJB.
5. Forward Engineering and Reverse Engineering a Dual Role EJB You may generate java source files and deployment descriptors of a dual role EJB. You may also update Rose model from java source files and deployment descriptor of a dual role EJB.
You are now allowed to set EJB Query and EJB Abstract Schema Name(s) from Rose In previous versions of Rose, when forward engineering an EJB, you had to update the EJB Query or EJB Abstract Schema Name manually in an EJB Deployment Descriptor file. When reverse engineering an EJB Deployment Descriptor file, the information of EJB Query or EJB Abstract Schema Name could not be set into the Rose Model.
1. You may input/update EJB Query for EJB Find or Select method from EJB Query tab in Method Specification page.
2. After you reverse engineer an EJB Deployment Descriptor file, the EJB Query of a Find or Select method will be set into the Rose Model. You will be able to read/update the EJB Query from Method Specification page.
3. You may forward engineer an EJB and find out that EJB Query of a Find or Select method is written into the EJB Deployment Descriptor.
4. You may input/update an EJB Abstract Schema Name from J2EE--EJB Specification page.
5. After you reverse engineer the EJB Deployment Descriptor file, the EJB Abstract Schema Name is set into the Rose Model. You will be able to read/update it from J2EE—EJB Specification page.
6. An EJB Abstract Schema Name will be written into Deployment Descriptor when you forward engineer an EJB.
Rose
J / JBuilder 9 and JBuilderX (10) Integration Supported
The Rose J / JBuilder 9 and JBuilderX integration includes the same type of integration support which currently exists for JBuilder 8 and before. Rose is able to detect, during runtime, covered versions of JBuilder installed on your machine. Now, Rose also recognizes JBuilder9 and JBuilder 10 (as a supported versions of JBuilder in relation to the Rose J / JBuilder integration). Once a covered version of JBuilder is detected, the integration between Rose J and JBuilder is enabled. To detect JBuilder releases installed:
· Open Rose J Project Specification dialog
· Select “Code Generation” tab
· Select “Detect IDEs”
You have been able to manage fundamental types with the Rose J Project Specification dialog by adding and removing types displayed on the Fundamental Types tab. To add a type, you would click on the new entry button and add an entry in java fully qualified name format.. To remove a type, you would select the type from the list and click the delete button. The resulting list of fundamental types would be stored in the registry of the your local machine. Some of the major limitations of this current Rose J Fundamental Type Support, include:
1. Fundamental types were not shareable across teams or organization, i.e. there was no way to standardize/unify them.
2. The user interface for adding and removing fundamental types could be enhanced.
In order to resolve the limitations listed above, the following enhancements have been added to improve Rose J Fundamental Type Support:
To Add / Remove a Fundamental Type
1. Click on the target class either in the class diagram or in the browser
2. Select the Java/J2EE->Fundamental type toggle.
To View Fundamental Type List
1. Select the target class either in the class diagram or in the browser
2. Select Java/J2EE->View fundamental type.
The Deployment Add-In which already provided J2EE deployment capability to deploy J2EE modules into application servers such as BEA WebLogic 5.1, BEA WebLogic 6.0, and IBM WebSphere 3.5 has been extended to provide EJB deployment for:
If you are building J2EE applications in Rose, now you can select the Deployment Add-In to deploy EJBs from Rose into the appropriate EJB container for Borland Application Server 4.5 or Borland Enterprise Server 5.1. A deployable JAR file is generated, which will allow you to deploy the JAR file into a particular partition of server.
The additional deployments to the Borland Application Server 4.5 and Borland Enterprise Server 5.1, are utilized in the same manner as the previous deployment options. The following describes these basic steps.
Steps Required Prior to Deploying Java Models
1. Target Server (i.e. Borland Application Server 4.5 or Borland Enterprise Server 5.1) must be installed.
2. Enable the Deployment Add-In from the Add-In Manager.
3. Compile the Java files in Rose.
4. Verify the compiled Java class directory matches the logical package structure for the Java classes in Rose.
· J2EE deployment descriptors are generated
· Server specific deployment descriptors are generated
Editor for the XML deployment descriptors displays (if, selected)
· EJB's, Java classes, and deployment descriptor are archived in a JAR file
· EJB compiler will be invoked to produce a deployable JAR
You may now place Rose J source code, XML files, EJB-JAR and WAR files into a Source Control System via the Rose J / CM Integration. You may also start the Source Control System Explorer from the Rose J Add-In.
Note: The Rose J / CM Integration only supports those Source Code Control Providers which support standard SCC API's.
HKEY_LOCAL_MACHINE\SOFTWARE\SourceCodeControlProvider\ProviderRegKey
This key would be set to the value of one of the providers listed in the
HKEY_LOCAL_MACHINE\SOFTWARE\SourceCodeControlProvider\ProviderRegKey\InstalledSCCProviders
Setting (usually ClearCase or Microsoft Visual SourceSafe), according to the SCC provider to be used.
To select a location where the generated code files will be stored, click on the Select Source Root Path for Source Control button. Select the root path from class path for the source code. You may also edit class path from this dialog box via the Edit Class Path button. The root path is saved as a rose java property with Rose Model. The root path can be a virtual path, defined by Virtual Path Map from Rose.
If using ClearCase, the Root Path must be in a VOB
The following describes a basic use case scenario of the Rose J / SCC Integration when using ClearCase.
Verify the ProviderRegKey registry setting is appropriately set for ClearCase as the SCC provider. If necessary to change the registry setting, restart Rose.
From the ClearCase Explorer, verify you have a VOB available where you wish to put the Rose J files under source control. Set the Source Root Path for Source Control to a directory in your VOB (see instructions in "Rose J / CM Integration Setup" within the Project Specification settings).
· A Message Box will appear indicating the status of Code Generation.
· The following type of information will also appear in the Rose Log Window:
13:58:02| Component C:\Documents\joan\temp\joanac_view\JoanaVOB\myDemo\PkA\JavaA.java - Starting code generation
13:58:06| Add file C:\Documents\joan\temp\joanac_view\JoanaVOB\myDemo\PkA\JavaA.java to SCC successfully.
To verify that a new directory has been created and placed under source code control correctly under the selected project root path, for the package PkA and the *.java file (JavaA.java) - start the ClearCase Explorer, by selecting Tools > Java/J2EE > Use Source Code Control Explorer .
You may do the following in Rose and note the required CM actions are correctly implemented in ClearCase:
Right Click on the JavaA class in the diagram or in the browser and you will see the following context menu options, under the Java/J2EEselection:
Once Rose is installed, you may use the Rose J Add-In to detect the existence of supported Java IDE’s installed on your machine.
Select the “Detect IDE button” (located in the J2EE / Java Project Specification on the Code Generation tab). Once this is selected, the Rose J Add-In will automatically detect and allow you to integrate with supported versions of the following IDE’s:
Rose J will automatically detect all available / supported Java IDE’s. You will have the opportunity to integrate with multiple IDE’s, using this new Rose J feature.
Rational Rose Oracle8 allows you to create object models from Oracle8 relational schemas and extend them to exploit Oracle8's object capabilities.
IBM Rational Rose Oracle8 visualizes existing relational databases and facilitates the discovery and composition of existing business objects. This allows you to preserve your investment in existing relational databases while taking advantage of all the benefits that object modeling and development bring to desktop and server applications.
Defect |
Description |
RATLC00434774 |
Updated Rose Online Help, regarding Foreign Key Wizard. |
Rose Oracle8 add-in supports only Oracle 8.0.5 or higher using Windows 98. |
Selecting Rose Model Integrator Options > NewFiltering... presents a new Model Integrator Filter Settings dialog. This dialog allows you to "Ignore All" of the GUI filter groups (including, properties) listed below, or you may select each GUI filter group individually (that you wish to ignore in the Model Integrator comparison or merge):
By checking any of the filter groups (listed above) or "Ignore All", the Model Integrator will suppress all the differences associated with the selected filter groups among two or more contributors. For example, checking the "Colors" filter group will ignore the differences in the color related properties while performing a compare and/or merge.
Selecting (checking) Ignore All disables the individual selection of the filter groups as Ignore All will suppress the differences for all of the filter groups listed.
The Locations and Dimension filter groups allows you to enter the filter value in their respective edit box (positioned to the right of the "Locations" and "Dimension" filter check-boxes, respectively. If the value entered (in pixels) for the two contributors is less than or equal to the property value then that property will not be shown with a difference or a conflict. The other properties, "Fonts", "Colors" and "Visibility" do not have associated filter values.
Selecting the Filter options and selecting OK will save the filter settings for future sessions.
After loading two or more contributors in the Rose Model Integrator and subsequently changing the filter settings a message box indicating "You must reload contributors for this change to take effect" will be displayed. In this case it will be necessary to open the Add contributor dialog again and click on Merge or Compare buttons depending on the operation being performed. This message will not appear if the filter options are selected before adding any contributors.
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.
Rose Data Modeler persists constraints or index key column(s) as a Data Modeler specific property named "KeyList" in the model (.mdl) file. It is a comma-delimited list of Unique ID's. This has presented problems in Rose Model Integrator (MI) upon merging data models. The problem would surface when the user tries to generate the DDL for the data model. A Missing Primary Key from table warning was encountered although primary key is shown in the model. In some cases users would experience other problems, such as the table specification could not be opened. The merged data model was corrupt and could no longer to be used for further data modeling development.
An enhancement has been which allows you to effectively utilize the Rose Model Integrator on a Rose Data Model. You are able to use the Rose Model Integrator on the Rose Data Model as before, but the following enhancements will be available:
A
dialog box will
appear to
indicate one of the contributing models was saved in a previous version of Rose
and there may be errors with the resultant model.
Element
Description
theDependency as
DependencyRelationreturns the dependency relation being added to the operation.
theOperation as Operation
Operation to which the dependency is being added
theSupplierName as String
Name of the supplier of the dependency
theSupplierType as Attribute
the supplier attribute of the dependency
DeleteDependency
Description · This function deletes a dependency relation from an operation.
Syntax · IsDeleted = theOperation.DeleteDependency ( theDependency )
Element
Description
IsDeleted as boolean
Returns a value of True when the class dependency is deleted
theDependency as DependencyRelation
the dependency relation being deleted.
theOperation as Operation
Operation from which the dependency is being deleted
- GetDependencies
Description · This function retrieves the collection of dependency relationships from an operation.
Element
Description
theDependencies as
DependencyRelationCollectionreturns a collection of dependency relation belonging to the operation.
theOperation as Operation
Operation from which the dependency relations are being retrieved.
3. Petal changes to support the changes mentioned in 1) and 2) above
The following is added to be part of the operation object structure. The supplier of this dependency relation is an attribute object reference.
(object
Operation " PK_T_01"
quid "3EEFA8A10270"
visible_modules (list dependency_list (object Dependency_Relationship
attributes (list Attribute_Set (object Attribute
tool
"Data Modeler"
name "Order"
value
"1"))
quid "3EEFB4850245"
stereotype "PK"
supplier
"LogicalView::Schemas::S_0::Table1::COL_0"
quidu "3EEFB4800180")
stereotype "PK"
concurrency "Sequential"
opExportControl "Public" uid 0)
The Rose Model Integrator may not be able to validate correct merges if a model element is referenced by another model element. This may occur when you are manually correcting merge conflicts without consideration of the Rose Model Integrator automatic-merged dependencies. The Rose Model Integrator will display these issues as merge errors, preventing you from saving the merged model. In this case, you must manually resolve these selecting both the sides of the dependency.
A common situation where this limitation is encountered is when the node referenced by the supplier attribute from Dependency Relationship object (the column to which the constraint applies) is removed, but the Dependency Relationship object (the constraint) is removed. In this case, there are two choices: you must either resolve the supplier to a contributor that does not remove it or resolve the constraint to a contributor which removes the constraint.
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.
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.
The log file provides the user with the following information:
RATLC00213591 |
Merging *.cat files, using a base contributor may cause the Rose Model Integrator to crash with an access violation. |
RATLC00228098 |
Relationships can be lost during merge activity. |
RATLC00230575, 00234656, 367566 |
Merging models with Rose Model Integrator can cause classes to appear more than once in the diagram. |
RATLC00367538 |
Merging may cause duplication classes. |
Defect |
Description |
RATLC00239863 |
Rose Model Integrator may produce duplicated messages and objects. |
IBM Rational QualityArchitect is a powerful collection of integrated tools for testing middleware components built with technologies such as Enterprise JavaBeans and COM.
QualityArchitect, in conjunction with IBM Rational Rose, generates test scripts for components and interactions in your Rose model. Once generated, the test scripts can be edited and run right from your development environment or from IBM Rational TestManager.
With QualityArchitect, you can:
IBM Rational QualityArchitect has its own release note. For more information on this product, select the Quality Architect readme file, which is accessible from the Start > Programs menu.
The Rose Webgain TOPLink Wizard assists you in the final step of data modeling---data access. This wizard helps you create detailed data access mapping of your tables to your Java classes, for a persistent runtime environment, through integration into Webgain's TOPLink product.
The Rose Type Library Importer Add-In allows you to import a type library of a COM component into the model by dragging the COM component from Windows Explorer and dropping it into IBM Rational Rose.
You can control several aspects of how type libraries are imported into the model. For example, you can control:
The Version Control Add-In, formerly known as the Source Code Control Add-In, provides integration between IBM Rational Rose and any SCC-compliant version control system. It makes the most frequently used version control commands accessible directly from the Tools menu and from shortcut menus in Rose.
The specific Visual SourceSafe (VSS) integration available in Rose 98i was incorporated into the Version Control Add-In in the Rose 2000 release. This Add-In now handles a super set of the VSS specific features. To upgrade a model that has been put under version control through the VSS Add-In, use the following steps:
1. Make sure that the model is not open in IBM Rational Rose.
2. In Microsoft Visual SourceSafe, check out all the controlled units that belong to the model.
Note This cannot be done through the Version Control add-in because the add-in does not know the model is under version control.
3. In IBM Rational Rose, open the model.
4. For each set of units that are located in the same SourceSafe project:
a. Click Tools > Version Control > Add to Version Control .
c. Click Browse and search for the project that corresponds to the working folder where the unit files are located.
d. Clear the Keep Checked Out checkbox, if you want to check in the units again.
Because the model is already under version control, the Version Control Add-In only updates the controlled units with additional version control information. From now on you can use the Version Control commands to check out and check in the units.
The "Get Latest" option of the Rose Version Control Add-In will now allow you the ability to access all subunits of a loaded unit, even if the subunit (files) resides on another user's machine as described below.
Upon selecting the Version Control Get Latest option, the following dialog will include a list of all (loaded and unloaded) controlled units. (Previously, only loaded controlled units would be listed.)
The following new options are available in this dialog:
*Note: The Prompt Individually check box is visible only if the "Apply Recursively" check box is checked.
After selecting the appropriate check-boxes and selecting "Get" for the highlighted file:
Files will be accessed according to the “Apply Recursively” selection:
If the "Apply Recursively" checkbox is checked, all subunits of the file selected will be accessed recursively. If there are subunits that are not under source control, you will be notified via a message box:
If the "Prompt Individually" checkbox is checked, you will be prompted via a message box for every subunit accessed via the "Get Latest" command. In this case, you may decide whether the action should be performed individually for each file.
Upon selection the Cancel button, the "Get Latest" action will terminate immediately.
Upon completion of the "Get Latest" command, all subunits accessed recursively will now also be included on your machine and will be loaded based on your selection to "Load Unloaded Units". Refer to the chart below for each "Get Latest" option and corresponding result.
“Get Latest” Dialog Options |
|
||
Load Unloaded Units |
Apply Recursively |
Prompt Individually |
|
|
|
|
Get Latest will be performed ONLY for the file you select. Only those loaded units that have been refreshed will be reloaded. |
X |
|
|
Get Latest will be performed ONLY for the files you select. ALL units for the refreshed files will be loaded. |
|
X |
|
Get Latest will be performed for the files you select and their subunits, recursively. Only the loaded units which have been refreshed will be reloaded. |
X |
X |
|
Get Latest will be performed for the files you select and their subunits, recursively. ALL units for the refreshed files will be loaded. |
|
X |
X |
Get Latest will be performed for the files you select and their subunits, recursively. For every subunit, before Get Latest is performed, you will be prompted to decide whether or not the action should be performed. Only the loaded units, that have been refreshed, will be reloaded. |
X |
X |
X |
Get Latest will be performed for the files you select and their subunits, recursively. For every subunit, before Get Latest is performed, you will be prompted to decide whether or not the action should be performed. ALL units for the refreshed files will be loaded. |
Defect |
Description |
RATLC00213515 |
Rose may allow you to add subpackages to version control, even if they are read-only. |
Defect |
Description |
RATLC00238101 |
Rose may consume a significant amount of CPU (i.e. 99%), if a Merant PVCS version prior to 7.5.00 is installed. Work-around: Disable the Version Control Add-In, or do not install the Version Control Add-In when installing Rose. |
RATLC00371809 |
When a file is attached to a package, Version Control operations (i.e. Check-in, Check-out, etc.) may cease to work. |
The Rose Visual Basic Add-In enables Rose to model, generate, and reverse engineer code for applications written in Microsoft Visual Basic. The Rose Visual Basic language support tools in Rose are tightly integrated with the Microsoft Visual Basic environment, allowing you to seamlessly progress through the round-trip engineering process.
The Rose Visual Basic Add-In tools are:
Rose Visual Basic includes a WinDNA code template enhancement. The fetch methods provided by the ADB.Fetcher code template for Visual Basic classes can connect to a database using either stored procedures or SQL statements.
Note There is online Help for WinDNA code templates, but it is not completely integrated with the rest of the Rose online Help. For information on where to find the WinDNAHelp, search for WinDNA Code Templates in the Rose online Help index.
There are no new features in this release of Rose Visual Basic.
The IBM Rational Rose Web Modeler provides visualization, modeling, and tools for developing Web applications.
To visualize and model N-tier web applications, Rose Web Modeler assigns a set of stereotypes and tagged values to your Web artifacts. Unified Modeling Language (UML) extensibility features allow you to model the artifacts required to build a Web application. Stereotypes and tagged values represent an extension of UML.
We recommend setting the default notation to Web Modeler before attempting to model Web applications. This allows all directed modeling options to be present on the context menus. To set the default notation:
2. On the Notation tab, set Default Language to Web Modeler .
Defect |
Description |
RATLC00211306 |
Use Case Specification doesn't open if default language is set to Web Modeler. |
Rose Web Publisher allows you to publish IBM 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 Microsoft Internet Explorer or 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.
RATLC00212189 |
Documentation for Objects in Activity Diagram are not Web Published. |
RATLC00213284 / |
Error occurs when Web Publishing a model which includes many sub-packages. |
RATLC00213691 |
Documentation field loses white space when Web Published. |
The IBM 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, IBM 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.
The IBM software support Internet site provides you with self-help resources and electronic problem submission. The IBM Software Support homepage can be found at http://www.ibm.com/software/support.
Voice Support is available to all current contract holders via a telephone number in your country (where available). For specific country phone numbers, please refer to the IBM Software Support Handbook, Appendix B: Contact Information, found at http://www.ibm.com/software/support.