Generating Meta-Model-Based Freehand Editors

Most visual languages as of today (e.g., UML) are specified using a model in a meta-model-based approach. Editors for such languages have supported structured editing as the only editing mode so far. Free-hand editing that leaves the user more freedom during editing was not supported by any editor or editor framework since parsing has not yet been considered for meta-model-based specifications. This paper describes the diagram editor generator framework DiaMeta that makes use of meta-model-based language specifications and supports free-hand as well as structured editing. For analyzing freely drawn diagrams, DiaMeta parses a graph representation of the diagram by solving a constraint satisfaction problem

A Pattern-based Approach for Initial Diagram Layout

In a diagram editor, one can distinguish initial from incremental diagram layout. The former computes a diagram layout from scratch, whereas the latter adjusts an existing layout after diagram modifications.In previous work, we have proposed a pattern-based approach as a solution for incremental diagram layout in visual language editors. Each LP encapsulates certain layout behavior. A diagram's layout is then defined by simultaneously applying several LPs to the diagram. This solution has been designed for an interactive environment where the user may select and alter the layout behavior at runtime. This paper describes an extension of this approach that now supports initial diagram layout, too. While the old version only enabled freehand editing, the extended version now supports diagram import and structured editing as well

Pattern-Based Layout Specifications for Visual Language Editors

When creating an editor for a visual language, a challenging task is the layout specification. Many visual languages, e.g., Ecore diagrams or Petri nets, show similar layout characteristics, and hence reuse of layout behavior should be enabled. For that purpose, we introduce the concept of layout patterns, which encapsulates certain layout behavior. With the approach, it is possible to combine different layout algorithms, e.g., standard graph drawing algorithms and constraint-based algorithms. In addition, rule-based layout algorithms may be used that are specifically tailored to the interactive nature of visual language editors

Ludo: A Case Study for Graph Transformation Tools

In this paper we describe the Ludo case, one of the case studies of the AGTIVE 2007 Tool Contest (see [22]). After summarising the case description, we give an overview of the submitted solutions. In particular, we propose a number of dimensions along which choices had to be made when solving the case, essentially setting up a solution space; we then plot the spectrum of solutions actually encountered into this solution space. In addition, there is a brief description of the special features of each of the submissions, to do justice to those aspects that are not distinguished in the general solution space

Specifying and Generating Editing Environments for Interactive Animated Visual Models

The behavior of a dynamic system is most easily understood if it is illustrated by a visual model that is animated over time. Graphs are a widely accepted approach for representing such dynamic models in an abstract way. System behavior and, therefore, model behavior corresponds to modifications of its representing graph over time. Graph transformations are an obvious choice for specifying these graph modifications and, hence, model behavior. Existing approaches use a graph to represent the static state of a model whereas modifications of this graph are described by graph transformations that happen instantaneously, but whose durations are stretched over time in order to allow for smooth animations. However, long-running and simultaneous animations of different parts of a model as well as interactions during animations are difficult to specify and realize that way. This paper describes a different approach. A graph does not necessarily represent the static aspect of a model, but rather represents the currently changing model. Graph transformations, when triggered at specific points of time, modify such graphs and thus start, change, or stop animations. Several concurrent animations may simultaneously take place in a model. Graph transformations can easily describe interactions within the model or between user and model, too. This approach has been integrated into the DiaMeta framework that now allows for specifying and generating editing environments for interactive animated visual models. The approach is demonstrated using the game Avalanche where many parallel and interacting movements take place

A Pattern-Based Layout Algorithm for Diagram Editors

The diagram editor generator framework DIAMETA utilizes meta-model-based language specifications and supports free-hand as well as structured editing. We presented a generic layout algorithm that meets the demands of this kind of editors. The algorithm combines two concepts, constraint satisfaction and attribute evaluation, to a powerful methodology for specifying the layout for a particular visual language. As the layout specification for this algorithm is rather complex, we encapsulated basic functionality into reusable patterns. This paper describes this pattern concept of the generic layout algorithm, and shows how they simplify the layout specification of a specific language

Combination of Different Layout Approaches

In an interactive environment such as a visual language editor, it is not sufficient to apply the same layout algorithm in every situation. Instead, the user often wants to select the layout behavior at runtime. With the approach presented, the user can control the layout behavior by choosing different layout patterns for different parts of a diagram, e.g., a graph drawing algorithm may be applied to some selected components while others are aligned vertically or horizontally. To enable the specification of layout behavior, we introduced the concept of layout patterns in previous work. Each layout pattern encapsulates certain layout behavior, and hence enables modularization and reuse. To specify user-controlled layout behavior, a flexible combination of arbitrary layout patterns needs to be enabled. Therefore, we introduce an approach that is capable of combining diverse layout approaches, such as standard graph drawing algorithms, constraint-based algorithms, or rule-based layout algorithms. More specifically, an algorithm is presented that automatically computes the complete layout in a straightforward way

Experimental Object-Oriented Modelling

This thesis examines object-oriented modelling in experimental system development. Object-oriented modelling aims at representing concepts and phenomena of a problem domain in terms of classes and objects. Experimental system development seeks active experimentation in a system development project through, e.g., technical prototyping and active user involvement. We introduce and examine "experimental object-oriented modelling" as the intersection of these practices

Reusing Semantics in Visual Editors: A Case for Reference Attribute Grammars

The semantic formalism reference attribute grammars (RAGs) allows graphs to be superimposed on abstract syntax trees. This paper investigates how RAGs can be used to model visual languages, with a case study of a control language that also has a textual syntax. The language contains blocks on which a total execution order is defined based on connections and layout information. One strength of RAGs is reusability, and we demonstrate this by reusing the definition of the execution order in the visual editor to provide semantic feedback to the user