• The installer program is robust with Eclipse installations that have configuration issues

UML4AS version 1.0.0 (2011-12-16)

• Minor bug fixes

UML4AS version 1.0.0 Release Candidate 1 (2011-12-06)

Diagram Features

• Improved ergonomics:
  
  • create a new element (e.g. class) or a new line (e.g. dependency) by dragging (no need to use the toolbar)
  • add a new element on diagram using content assist
  • + the combination of the above, in one operation as well (e.g. drag to create a generalization towards a type searched with the content assist)
  Layout fine-tuning:
  • z-order management of the elements (send to back/bring to front commands)
  • align elements
  • distribute elements
  • resize elements
  • basic auto layout algorithm
• Customizable diagram grid
• Diagram print
• Diagram export (as image, as pdf)
• Each diagram has a default package for new element creation
• Improved style editor
• Styles customization: create quick styles
• Fixed DND problems on Mac and Windows (using native code)

General Features

• Simplified install, upgrade and uninstall using an installer application
• Improved Model Source Navigation (using shortcuts)
• Predefined Flex libraries (e.g. Flex 3.5, Flex 4.1, Flex 4.5)
• Easy diagram creation from selected tree elements
• Generate getter and setter methods
• Add overridden methods
• New Flower Models Navigator that displays all models in the workspace (not just the opened ones)

UML4AS version 1.0.0.M2 update 2 (2011-01-12)

Solved Bugs

• #2488-FI: ASFunctions/Properties with identical name, but one with static modifier not supported
• #2709-FI: Error while parsing array initializers
• #3472-FI: Cannot drag and drop class from model tree onto diagram on Mac
• and others

UML4AS version 1.0.0.M2 update 1 (2010-12-28)

Solved Bugs

• #3460-FI: M2 install problem in FB4 stand alone (Cannot satisfy dependency ...)
• "Go to Source" not working for MXML classes

UML4AS version 1.0.0.M2 (2010-12-23)

Starting with this version, the installation of UML4AS is done using the site update mechanism. Please follow the install/uninstall instructions, because any older version needs to be uninstalled manually.

General Features

• Navigation within model: model relations can be navigated (either from the "Relations" section of the model tree, or using the "Model Relations" or "Containing Diagrams" context menu. Diagrams containing an element are displayed as well under the "Relations" section of the model tree.
• Model/source navigation: via the "Go to Source File"/"Go to Model" context menu entries
• Automatic synchronization can be enabled/disabled per model file (right click on the Eclipse project/Properties). A new option exists (Auto Open) which automatically opens selected model file(s) when Eclipse starts
• Improved, non-intrusive error handling and reporting
• Lock Sync disables element validation & file parsing (before elements were only ignored during synchronization)

Diagram Features

• Simplified new element creation: draw a rectangle on the diagram (it is green if nothing is selected) and select element type
• Auto enter in edit mode, after creating new elements. When adding an element from the model tree, or a compartment element on the diagram (annotation, attribute, operation), CTRL + ENTER finishes editing and adds a new similar element
• Pan behavior: hold shift and drag to scroll the diagram according to mouse movements
• Selection tool setting: select elements by fully or partially surrounding them with the selection rectangle
• Visual styles: almost all Flex CSS styles can be modified for visual elements, in order to customize their appearance on the diagram. A style inheritance mechanism is in place.
• Style for showing package name on diagram for classes/interfaces
• Style for hiding method parameters
• All tree context menu actions are shown within the diagram's context menu
• Enable/disable diagram translation effects, hover effects

Solved Bugs

Over 60 bugs were fixed (among them #2948-FI: Flex socket communication error, #3061-FI: Don't throw error on "include" and "script source"). Thanks a lot for your feedback on the forum, via the error reporting or direct.

Known Issues

Cf. 1.0.0.M1.

UML4AS version 1.0.0.M1 (2010-08-13)

Please follow the install/uninstall instructions and make sure that you uninstall any older UML4AS version. For the next version we are planning a simplified install procedure.

Features / Solved Bugs

• Experimental Use Case, Activity and Sequence diagrams
• Bug fixes
  • #2723-FI: Mac freezes after dragging elements from navigator over a diagram; the drag & drop mechanism for Mac was redesigned, as the previous implementation was quite buggy; now a native piece of code is used for proper DND handling
  • #2640-FI: Error if using Web Project (from WTP)
  • Added some shortcuts for Mac: CMD + A (Select all in a diagram), CMD + Mouse Wheel (zoom in a diagram), CMD + Enter (submits modifications for the Documentation view)
  • #2361-FI: Refresh problems for Flower Models Navigator; sometimes create actions were disappearing from the context menu
  • Known issue #1 from the previous release; now multiple Eclipse instances can run, with UML4AS enabled
  • Compatibility with FDT 4 and Eclipse 3.6
  • + other bugs, from the error reports and/or discovered internally

Known Issues

NOTE: On some systems we noticed the following behavior: diagrams don't open and an error message appears: Java/Flex socket communication error. If this happens, please use the patch provided here: http://www.uml4as.com/forum/index.php?topic=69.msg311#msg311.

1. Drag & drop from the tree to the diagram, in Windows: sometimes it doesn't work. Temporary work-around: drag the selection to the diagram, standing still (i.e. don't move the mouse): release mouse button, click again; the element is dropped.
2. Models Navigator View: it doesn't properly refresh when the model tree changes; we recommend not to use it yet, until this issue is solved.
3. On some Mac installations, a Flash error message box could appear from the Model Properties View.
   Java/Flex socket communication error
   [SecurityErrorEvent type="securityError" bubbles=false cancelable=false eventPhase=2 text="Error #2048: Security sandbox violation: ..../AppPropertiesEditorRelease.swf cannot load data from 127.0.0.1:18002."]
   If this happens, the view needs to be closed + opened again. Please report this issue if it appears, ideally with a reproduction scenario.
4. On some Mac installations, the Flash edit boxes don't respond to Enter or CTRL+Enter (editing classes, attributes, operations, notes). In this case, after having finished editing, click with the mouse somewhere on the diagram, outside the edit box. The problem doesn't seem to appear on FDT 4.
5. (KI #2 from the previous version) Drag and drop within the model tree: some invalid operations are permitted (e.g. move a class within another class, etc). Please be cautions when doing dnd within the model tree.

UML4AS version 1.0.0.M0 (2010-06-11)

Please follow the install/uninstall instructions and make sure that you uninstall any older UML4AS version.

Features / Solved Bugs

• Copy/Cut and Paste (for model tree and diagrams)
• Mac support
• Improved AS3 compliance
• Flower Modeling perspective
• Parse error fail safe (synchronization continues even if there are files with parse errors)
• Bug fixes
  
  • #2486-FI: Conditional Compilation Support
  • #2580-FI: Support for for flex4/generic arrays
  • #2496-FI: ActionScriptParser fails for methods outside classes
  • #2539-FI: Validation error for Flex 4/"library://ns.adobe.com/flex/mx"
  • #2540-FI: Parsing fails when including class names inside bodie.
  • #2541-FI: Documentation synchronization does not support special characters
  • #2542-FI: Parsing problem: Unexpected token DOT at line 1.
  • #2543-FI: Resource changed notification received before detection of metamodels
  • #2549-FI: Static initializer blocks
  • #2560-FI: Unexpected token STAR_ASSIGN (parameter or variable declaration)
    #2603-FI: Sel tool doesn't select all items if zoom level is smaller than 100%
  • + other bugs, discovered internally

Known Issues

1. UML4AS doesn't work correctly if more than 1 eclipse instance exists. On Windows there is a work-around: Windows/Preferences/Flower Modeling Platform/"Use JavaScript bridge for ..." -> enabled on the 2nd eclipse instance.
2. Drag and drop within the model tree: some invalid operations are permitted (e.g. move a class within another class, etc). Please be cautions when doing dnd within the model tree.

Eclipse Versions

{jumi [pn.inc]} is a product based on the Eclipse Platform. In order to use it, you should have an already existing installation of an Eclipse (or Eclipse based) IDE. If you don't, please download one from the Eclipse download section (http://www.eclipse.org/downloads/; Eclipse IDE for Java EE Developers is recommended).

The Eclipse version of your IDE should be at least 3.3. We have tested {jumi [pn.inc]} on the following configurations:

• Eclipse 3.3 + Flex Builder 3 Plug-in
• Eclipse 3.5 + Flex Builder 3 Plug-in
• FDT 3.5 (Eclipse 3.5 based)
• Flash Builder 4 Standalone (Eclipse 3.5 based)
• Flash Builder 4.5
• Eclipse 3.6, 3.7

Operating Systems

Windows family and Mac OS operating systems are supported. Linux OS is not supported.

UML4AS v1.0.0 beta and above

Use the easy-to-use install wizard. You can install the software directly over an existing {jumi [pn.inc]} installation (including M2, M1, etc.).

UML4AS v1.0.0.M2 and v1.0.0.M3

If you upgrade from {jumi [pn.inc]} version 1.0.0.M1 or below, please uninstall the application using the "old" procedure. The installation is done using the local Eclipse update site mechanism.

• download the latest version of {jumi [pn.inc]} and save it locally on you disk
• for Eclipse version >= 3.4, go to Help/Install New Software.../Add/Archive... and select the file you have downloaded; then select Uncategorized/Flower Modeling Platform - UML4AS
• for Eclipse version 3.3, go to Help/Softare Updates/Find and Install.../Search for new features to install/New Archived Site and select the file you have downloaded; then select Uncategorized/Flower Modeling Platform - UML4AS

UML4AS v1.0.0.M1 and below

Install

For the moment {jumi [pn.inc]} needs to be installed manually. We are investigating a better approach (either update site based or installer based). Please follow the following steps:

• download the latest version of {jumi [pn.inc]} and unzip it somewhere on your disk, in a temporary folder (e.g. d:/temp/uml4as); you will see 2 directories: features, plugins
• go to your existing Eclipse (or Eclipse based product, e.g. d:/java/eclipse); among others, you will see as well the following 2 directories: features, plugins
• uninstall {jumi [pn.inc]} if another version already exists (please see below)
• copy all the contents you unzipped, into the Eclipse directory (e.g. d:/temp/uml4as to d:/java/eclipse)
• start Eclipse; you should see an "About UML4AS" entry in the Help menu; that means the product has been successfully installed

Possible problems: if you don't see the "About UML4AS" menu entry, try the following:

• stop Eclipse
• delete all files and folders starting with "com.crispico.flower.mp*" form the /features and /plugins folders
  open a command prompt (e.g. Start Menu, Run, cmd)
  go to the Eclipse folder (e.g. d:, cd d:/java/eclipse)
  start Eclipse with the -clean argument (e.g. eclipse -clean; if eclipse.exe doesn't exist, there should be another executable, e.g. FlexBuilder.exe)
• repeat the installation procedure; when starting eclipse, use the -clean command line option again
• if the problem still persists, please use our forum to get in contact with us

Uninstall

To uninstall {jumi [pn.inc]} from your Eclipse installation, delete all files and folders starting with "com.crispico.flower.mp*" form the /features and /plugins folders (from your Eclipse installation directory, e.g. d:/java/eclipse).

UML4AS + Java

The extended version of {jumi [pn.inc]} that has support for the Java programming language has similar requirements and install instructions with the following notes:

• the Eclipse host installation needs to contain the JDT plugins (i.e. support for Java development) . You can use an Eclipse downloaded from here: http://www.eclipse.org/downloads/. Regarding commercial Flash IDEs:
  • FDT already has the JDT plugins
  • Flash Builder stand alone doesn't include the plugins. You could use a plain Eclipse installation and install the Flash Builder plugin instead

Before installing UML4AS + Java, please uninstall any existing version of UML4AS.

Creating a New UML4AS Model File

For this tutorial, please create (or open an existing) ActionScript/Flex project. For example, MyFirstUML4ASProject that already has a source directory (src) and a MXML file (MyFirstUML4ASProject.mxml).

Create a new folder (right click on the project, New/Folder) and name it model. Create a new model file inside:

• right click on the model folder, New/Other/Flower Modeling Platform/UML4AS File;
• first step of the wizard: select the file name (i.e. model);
• 2nd step: select an already existent directory that holds AS source files. E.g. select src from the current project. You can select directories from other projects as well, and you can also add them after the file is created (by right clicking on the Root entry of your file, Create ActionScript Element/SrcDirPackage).

   

  

Project Explorer, Automatic Synchronization

The contents of an UML4AS model file can be viewed in the Project Explorer view. If this view is not already available on your system, enable it from Window/Show View/Other/General/Project Explorer. Once enabled, drag it over the existing Navigator view.

The Project Explorer view displays the content of the workspace just like the Navigator view. However please notice that  the model.uml4as file has a + sign next to it in the Project Explorer view (that was not in the Navigator). Clicking on it, opens the file and displays its contents. But before doing that, adjust some global settings (from Window/Preferences/Flower Modeling Platform):

• Enable automatic synchronization -> true. With this setting on, the model/code synchronization is performed automatically when a resource is saved in the workspace (source file and/or model file); otherwise it should be invoked manually, by right clicking on the SrcDir and selecting Synchronize.
• Flat package presentation -> true. With this setting on, the packages will be shown in a flat way (like in java) rather than a tree style presentation. (Note: as of UML4AS 1.0.0.M0, this setting is by default true).

When you open the model file, the synchronization is performed and you can see the model contents:

The root entry contains the following elements:

• The src SrcDir (or longer, Source Directory Package). This is a special package that maps to a source directory on the file system. The path is relative to the current project. You can have several SrcDirs in a model file, and they can belong to other projects in the workspace as well (e.g. ../otherProject/src).
• ActionScriptUnknownTypes is another special package. {jumi [pn.inc]} puts here any type references that it finds during synchronization but cannot be resolved to a known implementation (e.g. primitive types, classes from the Flex framework or from swc libraries).

Adding and Modifying Source Files

Add some source files in the project. For example:

• com.uml4as.example.MyInterface with some methods
• com.uml4as.example.MyClass with some attributes and methods

Please notice that when adding elements (packages, files) or saving files, the model structure is updated (because you turned on the automatic synchronization).

Working with Diagrams

The model can be modified in two ways: from the model tree (by right clicking) or from diagrams. Of course, the main idea behind {jumi [pn.inc]} is to use diagrams. Right click on the Root package, Create Element/Package. Right click on it/Rename (or press F2) to change the name (e.g. Diagams). Right click on it, Create Diagram/Class Diagram. Double click and it opens.

Select some classes/interfaces from the model tree and drag them on the diagram (e.g. MyClass, MyInterface, MyFirstUML4ASProject).

Now you can play with the diagram. For example,

• add a Realization between MyClass and MyInterface (using the Interface Realization tool from the toolbar),
• add an Unidirectional Association between MyFirstUML4ASProject MXML class and MyClass class
• hide uninteresting labels from the association (use CTRL + click for multiple selection)
• rename the association attribute (by selecting + click or pressing F2) from attribute1 to myClass

ActionScript and Analysis Elements, SrcDirs

There are 2 types of model elements:

• analysis elements (e.g. packages, classes, operations, etc.). They cannot be synchronized with code; they are generic elements, meant to be used while doing a high level analysis of the system, when discussing general principles, etc. They can be created from the "Create Element" context menu, or from the diagram
• language specific elements (in our case, ActionScript). They can be created from the tree (using the "Create ActionScript Element" context menu) or from the diagram as well. These elements map to ActionScript constructs.
  • they have a slightly different icon with an "A" letter in the upper/right corner of the element icon,
  • they can be synchronized with the code IF they are contained in a SrcDir (directly or indirectly). In this case they have synchronization markers (upper left corner of the element icon),
  • if they are not contained in a SrcDir, they cannot be synchronized. Synchronizable AS Elements shouldn't be mixed with non-synchronizable ones

Adding New Types on the Diagram

There are 2 ways of doing this. The first one is by adding the element from the model tree and dragging it on the diagram. For example, add a MyClass1 class (by right clicking on the com.uml4as.example ActionScript package) and drag it on the diagram.

The other way of achieving this is to create the class from the diagram and move it (in the model tree) inside an ActionScript package. For example create the MyClass2 on the diagram. You will notice that it has been created in the same package as the diagram. As you want it to be synchronized with the code, you need to move it inside an ActionScript package, e.g. com.uml4as.example.

Save the model file and observe the changes on the file system.

Model Properties View, Documentation View

The Model Properties view displays available properties for the selected model element (in diagram or model tree). To enable this view, go to Window/Show View/Flower Modeling Platform/Model Properties.

The Documentation view displays the documentation for the selected model element. To enable it, go to Window/Show View/Flower Modeling Platform/Documentation.

As of UML4AS 1.0.0.M0, the Flower Modeling Perspective already contains the above views.

Next Steps

This tutorial has shown some basic usage principles. The next article in this Alpha documentation series will explain some other features more in detail.

Meanwhile please explore the {jumi [pn.inc]} product. If you find problems or if you would like a particular feature or if you just want to talk about it, we would be glad to discuss on the forum.

Thank you for reading and using {jumi [pn.inc]}.

UML Compliance, Analysis Elements, ActionScript Elements

{jumi [pn.inc]} is a graphical modeling tool that’s focused on code synchronization. The modeling language of {jumi [pn.inc]} is based on UML (Unified Modeling Language), with 2 particularities:

• It supports a subset of the full UML specification, more precisely diagrams and elements that are directly related to code,
• It extends existing UML elements that are rather generic, by adding programming language specific elements. This way they are less generic and closer to the programming language.

There are 2 types of elements (by elements we understand packages, classes, interfaces, attributes, operations, etc.):

• Analysis Elements. They are generic and cannot be synchronized with code. They are useful for high level design, discussions, expressing ideas, etc.;

• ActionScript specific elements. They support AS specific constructs (i.e. annotations, constants, override flag, etc.).

ActionScript elements have a slightly different icons and an "A" letter in the upper right corner. ActionScript elements can be synchronized with code. For this, they need to be placed (directly or indirectly) inside a SrcDir. In this case they receive additional graphical elements: the synchronization markers in the upper left corner of the element icon.

Code Synchronization and CodeSync Technology

ActionScript model and code synchronization is THE feature of {jumi [pn.inc]}. To achieve this, a technology that’s called CodeSync is used. Compared to traditional tools, the CodeSync technology has a new and innovative way of working. It’s "more" focused on code, more flexible and friendlier to the developer.

The synchronization can work in 2 ways:

• Automatically. It is fired when elements from the workspace are saved (i.e. source code files or model files);
• Manually. The user invokes the synchronization manually using the context menu action available on the SrcDir.

The “Enable automatic synchronization” option from the “Flower Modeling Platform” preferences page controls this behavior.

SrcDirs

The CodeSync story begins with a SrcDir. The SrcDir (or longer, Source Directory Package) is a special package that maps to a source directory on the file system. Everything that’s contained within a SrcDir has a one to one mapping with what’s on the file system. An ActionScript SrcDir can contain only ActionScript elements (analysis elements are not welcome here).

On the other hand, an ActionScript element can be contained or not (directly or not) in a SrcDir. If it is the case, then it is synchronized with the code (it is called a synchronizable element). If not, it’s ignored during code synchronization.

A model file can have several SrcDirs, from the same or other projects from the Eclipse workspace.

Synchronization Markers

All ActionScript elements from (and including) a SrcDir (i.e. synchronizable elements) have graphical synchronization markers, in the upper left corner of the element icons, with the following meaning:

• Green () - the element & its children are in sync with the code,
• Red () - the element is not in sync with the code; it has modifications that are not yet written,
• Yellow () - the element is in sync, but one of its children is not, or it is marked deleted,
• Marked Deleted () - the element is marked deleted; synchronizable elements cannot be directly deleted. They are marked for deletion and they are deleted when synchronizing (or not, because a delete can cause a conflict as well),
• Conflict () - during the last synchronization, overlapping changes were detected; the user needs to decide what to do in this case,
• Conflicts on children () - the element has one/several children with conflicts.

CodeSync Differences

The CodeSync Differences view is available from the tree context menu ("CodeSync Differences" entry), for each synchronizable element. It displays (for itself and its children) the state on the model, the state on the file system and the changes that were made.

Using this view, changes made on the model can be reverted. This view is used as well when conflicts are detected. The user can keep the changes from the model, the changes from the code or a mix between them.

Advanced Features

Timestamps and Version Management Systems

The CodeSync engine processes files only if their timestamp has been modified since the last synchronization (or if there are changes on the model side). It adopts this strategy in order to optimize the synchronization speed. In the manual synchronization mode, a full synchronization (with disregard of timestamps) can be done by selecting "Synchronize Full (Ignore Time Stamps)" (on a SrcDir, although it is used rarely or never). The CodeSync Log view (see below) displays the action taken by the CodeSync engine for each file.

When working in teams and using version management systems, the same file has different timestamps for different users, even if the contents are the same. However the model file memorizes the timestamps only for the last user who modified the model. This means that the above mechanism doesn't work well (meaning there is no speed gain every time).

There is a solution for this setup. Version management systems often have a setting to enforce the same timestamp for every working copy of the same repository. This setting should be enabled. For example on Subversion this setting is called "use-commit-times". It should be enabled for every user (e.g. on Windows, the file c:\Documents and Settings\User\Application Data\Subversion\config should contain use-commit-times = yes).

UID Annotations and Refactor Support

Synchronizable model elements (e.g. a class Customer) can be referenced:

• by other synchronizable elements (e.g. an attribute customer of type Customer),
• by elements that are non synchonizable (i.e. don't have an equivalent on the file system; e.g. some relations: associations, dependencies or graphical elements diagrams and their contents: documentation notes, etc.)

The second type of references (from non-synchronizable elements) are delicate some times. During most of the code synchronization operations, everything works fine.
However, if a refactor is done on the file system (rename or move for classes, attributes, etc), these references are lost (i.e. diagram data, documentation notes, associations, etc.).
Why is that? Because the CodeSync engine interprets the refactor operation as a delete + add, instead of a rename or move operation.

The solution for this problem is the use of Unique IDs (UIDs) attached to the model elements' documentation (e.g. @flowerModelElementId _t9B7oGUQEd-1u9VEndCgSA). They appear only for elements that are referenced by non-synchronizable items (they don't appear on all the elements to reduce unnecessary UID pollution of the source files).

For example, if the class Customer is on the Main diagram, and it is renamed to ImportantCustomer and moved to another package:

• without UID annotations, the diagram information is lost; the Main diagram won't contain the renamed class
• with UID annotation, the diagram Main will show the newly renamed and moved class, ImportantCustomer

This setting can be modified for each SrcDir (from the context menu entry, "Use UID Annotations"). When this setting is toggled (enabled/disabled), the elements from the SrcDir that are referenced by non-synchronizable items are updated (i.e. their documentation is updated: a "@flowerModelElementId" is added/removed).

Lock Synchronization (i.e. Ignore Elements)

It can be useful sometimes to temporarily ignore some elements during synchronization.

For example, we are working on the model side at the BasicCustomer class. We need to suspend the current work for something more urgent. In this case we don't want to synchronize our draft modifications, as they are not finished, but we would like to continue to use the tool normally for the rest of the model.

In this case we "lock" the BasicCustomer class.

• a red lock appears in the bottom right corner of the element icon, meaning that the element is locked;
• all of its children have a blue lock; that means that a parent (direct on indirect) is locked;
• all of its "parents" (direct or indirect) have a yellow lock; that means that on of their children (direct or indirect) is locked.

This feature is useful as well when working in teams. It can be enabled or disabled from the context menu, for synchronizable elements. It is recommended to lock only "higher" level elements: SrcDirs, packages or types (classes/interfaces).

CodeSync Log

{jumi [pn.inc]} keeps a detailed log of each synchronization operation. Using the CodeSync Log view (available in the tree’s context menu, for each element contained in a SrcDir, under "CodeSync Log" entry) you can view the log entries or erase them. The log should be erased from time to time to avoid having big model files.

Opening and Closing a Model File. Flower Modeling Perspective

A model file can be opened by clicking on the "+" next to it, in the Project Explorer view. Double clicking on the model file works as well. After opening, the user is invited to switch to the "Flower Modeling" perspective.

The "Flower Modeling" perspective is available in the perspectives menu as well (Window/Open Perspective). Hint: you can switch perspectives easily (e.g. "Flower Modeling" <-> Development) using shortcuts (e.g. CTRL + F8 by default in Windows).

A model file can be closed by right clicking on it and selecting "Close File" from the context menu. It is closed as well when the current project is closed.

For example closing a file can be useful when there are too many open files and we need more memory. If undesired behaviors appear (especially for alpha versions), closing/reopening the file often gives results.

Selection Tool

The selection tool (from the diagram's toolbar) is the tool that is enabled by default.

Besides mouse selection, key selection is possible as well:

• CTRL + click - toggles the selected state of an element,
• SHIFT + click - makes the selected element "main" selected element (i.e. black anchors); useful for some commands where the "main" selected element is important,
• CTRL + A - selects everything on the diagram.

Link Selection between Tree and Diagram

The selection between the model tree and opened diagrams can be linked together using the "Link with Editor" button from the Project Explorer view.

With this option turned on, when selecting an element in the model tree, it is selected as well in the diagram (if a diagram containing it is opened). And vice versa, when selecting an element on the diagram, it is selected as well in the model tree.

Zooming

There are 3 ways to control the zoom on a diagram:

• using CTRL + mouse scroll wheel,
• using the Zoom combo box in the toolbar,
• using the Zoom tool and selecting a rectangular area on the screen.

Elements

To create a class, interface or note, a tool from the toolbar needs to be used. Annotations, Attributes, Operations can be added using the buttons from classes/interfaces, or from the diagram context menu.

<

Please note that new types (classes or interfaces) are created in the diagram's package. In order to make it synchronizable it needs to be moved inside a SrcDir.

Relations

Creating and Moving

To create a relation or a note connector, a tool from the toolbar needs to be selected + a drag and drop (from the source element to the destination element). To move an end of an already existing connection, one of its end anchors need to be dragged and dropped on a new target.

When an association end is moved, its corresponding attribute is moved as well.

Bend Points

Bend points can be added on an existent connection by starting dragging from the connection. They can be moved by dragging their anchors and can be removed by in-lining the 2 segments linked to the bend point.

Labels

Some connections can have labels (e.g. associations, dependencies). They can be edited using the in-place editor (see below), removed ("Hide Label" from the label's context menu) or shown ("Show ..." from the connection's context menu). Label visibility can be controlled using styles as well (see below).

Displaying Existing Relations and Related Elements

If an element has relations but they are not displayed on the diagram, the following context menu commands are useful:

• "Display Missing Relations" - displays all the relations for which the opposite end (i.e. the related element) already exists on the diagram,
• "Add Related Elements and Display Relations" - adds related elements on the diagram if they don't already exist (i.e. opposite ends of the relations) and then displays the relations; this command includes the previous one.

In-place Editor and Content Assist

Many elements can be edited directly on the diagram by either clicking to select and clicking again for edit, or by pressing F2. To accept the modifications hit ENTER, CTRL + ENTER or click on the diagram (outside the edit box). To cancel the changes hit ESC.

When editing attributes (or association ends) or operations, a content assist is available that proposes existent types from the model. The content assist is opened automatically after typing ":" or when pressing CTRL + SPACE.

The in-place editor syntax is the following

• for attributes: [visibility] attributeName [: fully.qualified.name.attributeType][=defaultValue]; e.g. -attribute2 : com.uml4as.example.MyClass
• for operations: [visibility] operationName ({parameterName_i [: fully.qualified.name.parameterType_i] [= parameterDefaultValue_i]}) [: operationReturnValue] with i >= 0; e.g. ~myMethod1(param : int) : String or -get value() : String
• for annotations, several forms are supported:
  • annotationName; e.g. Annotation,
  • annotationName(value); e.g. Annotation(value),
  • annotationName({key_i = value_i}) with i >= 1; e.g. Annotation(p1 = value1, p2 = value2).

[] means it could be missing. {} means it can be repeated several times, separating with a comma ",".

visibility can be:

• - private
• # protected
• + public
• ~ package

Type search strategy:

• if the type name is fully qualified (e.g. com.uml4as.example.MyClass): the type is searched for in the specified package (e.g. com.uml4as.example); if found, it is used; otherwise a new class is created (e.g. named MyClass);
• if the type name is not fully qualified (e.g. MyClass),
  • if editing in the diagram (e.g.  Diagrams/MyDiagram): the default package (the root package from the compiler's point of view) is searched for the type; if found, it is used; otherwise, the diagram's package is searched for that type; if found it is used; otherwise a new class is created there (e.g. Diagrams/MyClass);
  • if editing in the tree (e.g. editing an attribute for com.uml4as.example.MyOtherClass): the default package is searched for the type; if found, it is used; otherwise, the current element's package is searched for that type; if found it is used; otherwise a new class is created there (e.g. com.uml4as.example.MyClass).

Associations

Creating Associations from Attributes

An attribute can have an association attached to it, in which case there is a small arrow icon in the bottom right corner of the element icon. To create an association from an existing attribute (that has no association), the "Create Association from Attribute" context menu command needs to be used.

An uni-directional association will be created between the current class (having the current attribute as end, e.g. customer) and the attribute type as other end (non-navigable). If the other end exists on the diagram, a graphical connector is added on the diagram as well; otherwise "Add Related Elements and Display Relations" needs to be used, to put it on the diagram.

Splitting and Combining Associations

A bi-directional association can be split into 2 uni-directional associations and vice versa, 2 uni-directional associations (that are compatible, i.e. link the same 2 types) can be combined into 1 uni-directional association. "Split into Uni-Directional Associations" and "Combine into a Bi-Directional Association" context menu commands are used for this.

Example: Creating an One to Many Association after Importing Code

When code is first synchronized for an existing project (i.e. imported), it might me useful to create some associations for some existing constructs. For example we have in class Customer an attribute orders:ArrayCollection and in class Order an attribute customer:Customer. We want to create a one to many bi-directional association between these 2 classes.

Step 1: create 2 uni-directional associations. We select the 2 attributes (orders and customer) and click on "Create Association from Attribute". This creates an association between Order and Customer and another one between Customer and ArrayCollection. The first one is already displayed on the diagram. We need to select "Add Related Elements and Display Relations" for class Customer to have the second association on the diagram.

Step 2: combine associations. We move the target of Customer/ArrayCollection association from ArrayCollection to Order. We have now 2 opposite uni-directional associations that can be combined using "Combine into a Bi-Directional Association".

Step 3: adjust multiplicities. Using the Model Properties view to adjust the Lower/Upper Multiplicity: 0..* for orders and 0..1 for customer.

Notes and Documentation

There are 2 types of notes:

• stand alone; they can be linked to 0, 1 or more elements with note connectors

• linked to documentation; in this case the note needs to be linked to only one element that allows documentation. When the note changes, the documentation is updated and vice versa (i.e. documentation changed -> note updated). To activate this behavior, there is a context menu entry "Retrieve documentation".

Notes that are linked with documentation have an icon in the upper left corner. They can be unlinked by deleting the note connector. Every note (linked or not) can be edited directly from the diagram or using the documentation view.

Compartments

Showing and Hiding

Analysis elements (classes, interfaces) have 2 compartments: attributes, operations. For ActionScript elements:

• classes have 3 compartments: annotations, attributes, operations
• interfaces have only 2: annotations and operations

Compartments can be hidden by using the "-" button from the element's compartment, or from the context menu. They can be shown using the context menu.

Compartment visibility can be controlled as well using styles (please see below).

Filtering

Compartment contents can be filtered (using the "Filter Compartment Elements" context menu entry).

There are 2 filtering strategies:

• Hide only selected elements (new elements are shown by default) - for this strategy the hidden elements are specified explicitly and newly added ones will be visible. E.g. if a new attribute appears after synchronization, it will be displayed.
• Show only selected elements (new elements are hidden by default) - for this strategy the shown elements are specified explicitly and newly added ones will be hidden. E.g. if a new attribute appears after synchronization, it won't be displayed.
  This behavior is useful sometimes, when we want emphasize only some elements (that participate to a feature of the app) and we don't want the diagram to be polluted in the future with new elements that may appear and are not related to the feature.

Compartment filtering can be controlled using styles as well; please see below. The "inherited" option relates to styles as well.

Styles

Documentation for the styling mechanism will be soon provided.

We don't want to hide errors and/or provide superficial corrections (e.g. unnecessary !null checks everywhere, etc.). This can lead to unwanted application states and behaviors that can be annoying, hard to reproduce, etc.

It's better to see errors than to swallow them and have obscure bugs & behaviors.

That's why you are seeing error dialogs from time to time. We recommend enabling error reports sending. You can always see what data is sent, you are not bothered while you work and you help a lot the user community.