The transformation driven architecture (TDA) is a system building (in particular, tool building) approach that is based on model transformations, interface metamodels with corresponding engines, and event/command mechanism. This paper describes a metamodel and the corresponding engine for graph diagram presentations within TDA. The facilities of the metamodel and the engine include static diagram presentations, as well as graph diagram animations.
Developing a presentation engine and the corresponding metamodel may be a non-trivial job. But once implemented, the corresponding engine can be reused in several tools built upon the TDA.
In this paper a metamodel for graph diagram presentations within
TDA and the corresponding engine for drawing/editing graph
diagrams is presented. The metamodel along with the engine is a
development over previous authors’ work [
The Head Engine is a special engine, whose role is to provide services for transformations as well as for presentation engines. For instance, when in some presentation engine a user event (such as a mouse click) occurs, the Head Engine may be asked to call the corresponding transformation for handling this event. Also, a transformation may give commands to presentation engines. Thus, the Core Metamodel contains classes Event and Command, and the Head Engine is used as an event/command manager. The TDA has its own framework that comes with the built-in Head Engine (serving the Core Metamodel) and some predefined pluggable engines (the Graph Diagram Engine is one of them). Other presentation engines may also be written and plugged-in, when needed. The TDA framework is common to all the tools built upon the TDA. The framework is brought to life by means of transformations. One can choose between writing different transformations for different tools and writing one configurable transformation covering several tools. 3. GRAPH DIAGRAM METAMODEL AND GRAPH DIAGRAM ENGINE The visual elements of the presentation (see Fig. 2) correspond to the classes GraphDiagram, Box, Line, and Port along with Compartment corresponding to text fields that may be placed inside boxes or attached to lines and ports. Instances of the classes just mentioned will be diagrams and graphical elements created by the user. Every element, compartment and graph diagram has its style (see the ElementStyle class with its subclasses as well as classes CompartmentStyle and GraphDiagramStyle) being a composition of various style attributes. For example, the element style attributes supported by the graph diagram engine include line color, background color, shape, line width, attached pictures, etc. The compartment style attributes include such items as alignment, adornment, visibility, text font, etc.
Every GraphDiagram has its Palette consisting of PaletteElements, each of them being a line, a box or a port. Toolbars* consisting of ToolbarItems* can also be associated with the GraphDiagram. Additional MenuItems* could also be associated with the graph diagram. When the graph diagram is being activated, the corresponding toolbars and menu items are made visible. The currently active diagram is pointed to by the ActiveDiagramPointer singleton instance. The elements currently selected are linked to a CollectionOfActiveElements.
The metamodel allows the user to specify also a PopUpMenu* consisting of PopUpMenuItems*. Such a menu is usually activated when the user clicks the right mouse button.
The Graph Diagram Metamodel defines engine-specific events and commands that are subclasses of Event* and Command*. Every event and every command during tool runtime is placed within the context defined by the metamodel. For example, the NewBoxEvent is attached to the PaletteBox with which it is being created, and the Box in which it is being put (see associations from class NewBoxEvent).
The singleton class GraphDiagramEngine contains attributes that correspond to engine’s events. In the beginning a transformation can assign values for these attributes, each value representing the name of the transformation that has to be called when the particular event occurs.
The graph diagram engine is responsible for visualizing instances
of the Graph Diagram Metamodel. The engine is developed on the
basis of graphical engines for GRADE tools family [
In Fig. 3 we extend the metamodel of Fig. 2 by classes for describing graph diagram animations. The animation of graph diagrams is based on the notion of token that is associated with some element (box or line) in a graph diagram. Tokens do not imply any semantics, they are used only for managing the animation process. The semantics is up to transformations. A token is started by StartTokenCmd that specifies also its duration (how long the token “lives”). There are also commands for starting, stopping, pausing and resuming a token in the diagram, as well as pausing, resuming and stopping all tokens in the diagram. The “end of life” of a token is observed by the presentation engine — at that time it creates a corresponding EndTokenEvent. There can be several tokens living concurrently in the diagram.
An explicit token is able to simulate the activity of the associated element for the given duration. The visual effect of the simulation is determined by TokenStyle instance associated with the token. If an ElementStyle instance is associated with the token style, then the animation consists of just changing the element style for the token’s lifetime. Other options of animation consist of moving a bullet of certain size or some image along the line in the diagram, or animating a box by a line flowing over it in certain direction, with or without leaving the trailing part in the specified color. In the case of AUTOMATIC direction, the actual line flowing direction is determined by the presentation engine on the basis of the placement of the actual outgoing line from the box. A hidden token doesn’t animate any element, but just “lives” for the
0..1 previous
0..1 next
<<singleton>>
GraphDiagramEngine onOpenDiagramEvent: String onCloseDiagramEvent: String onOKStyleDialogEvent onLeftClickEvent: String onRightClickEvent: String onDoubleClickEvent: String onNewLineEvent: String onNewBoxEvent: String onNewPortEvent: String onChangeContainerEvent: String onMoveLineStartPointEvent: String onMoveLineEndPointEvent: String onKeyDownEvent: String
keyName: String
1
{ordered} * parent {ordered} *
name: String isVisible: Boolean isEnabled: Boolean onPopUpMenuItemSelectEvent: String 1
{ordered} * parent MenuItem name: String isVisible: Boolean
onMenuItemSelectEvent: String *
*
name: String * {ordered} 1
name: String picture: String isVisible: Boolean * isEnabled: Boolean {ordered} onToolbarItemSelectEvent: String
1
isVisible: String 1 1
1
name: String layoutMode: TLayoutMode layoutAlgorithm: TLayoutAlgorithm backgroundColor: TColor
{ordered}
* name: String picture: String
<<singleton>>
CollectionOfActiveElements 0..1 1 1 1 1 1 1 1 * *
Element * localStyle: String location: String hint: String * * 1 * * * * 0..1 0..1 0..1 start end
start end target target 1 1 1 1 {ordered} *
value: String
CompartmentStyle name: String 0..1 isVisible: Boolean alignment: TTexAlignment adjustment: TCompartmentAdjustment picture: TPictureRef picturePosition: TPicturePosition adornment: TAdornmentCode textFont: TFont
<<enumeration>>
specified amount of time. Hidden tokens can be useful, e.g., for accounting the global animation time, or for creating certain breakpoints during the animation when the control is transferred to transformations for some semantic actions.
The implementation of animation facilities in our graph diagram
engine is currently under development.
5. CONCLUSIONS
The Graph Diagram Engine has been successfully implemented in
recent version of transformation-based tool building platform
GrTP [