Abstract In this paper, we present ParVis, an interactive visual system for the animated visualization of logged parser trace executions. The system allows a parser implementer to create a visualizer for generated parsers by simply defining a JavaScript module that maps each logged parser instruction into a set of events driving the visual system interface. The result is a set of interacting graphical/text windows that allows users to explore logged parser executions and helps them to have a complete understanding of how the parser behaves during its execution on a given input. We used our system to visualize the behavior of textual as well as visual parsers and describe here two of these uses. Moreover, in order to validate the efficacy of our system, we ran a user experiment where students analyzed a CUP-generated parser both with ParVis, instantiated to LALR parsers, and the standard CUP debug facilities. The results show that students can indeed analyze parser behavior and find mistakes in parser specifications more easily and quickly using ParVis. In particular, in some parser design tasks, using ParVis participants achieved a higher success rate of 50% in 42% less time with respect to the baseline system.

In this paper, we present ParVis, an interactive visual system for the animated visualization of logged parser trace executions. The system allows a parser implementer to create a visualizer for generated parsers by simply defining a JavaScript module that maps each logged parser instruction into a set of events driving the visual system interface. The result is a set of interacting graphical/text windows that allows users to explore logged parser executions and helps them to have a complete understanding of how the parser behaves during its execution on a given input.

Generalized parsers for visual languages result to be more complex than the corresponding text parsers: their applications to ambiguous inputs with visual tokens scattered and/or connected on a 2d or 3d space are very difficult to trace without the support of proper visualization tools. In this work, we give a brief description of generalized parsers for visual structures and illustrate a tool for the visualization of its execution. To do this, we provide examples based on a Visual Generalized LR (VGLR) parser applied to flowcharts.

Nowadays, touch-input devices are widely available. The use of such touch input devices, e.g., large wall-mounted touchscreens in (team) meeting rooms appear appropiate and desirable. Thus, team meetings can change from one-man-presentation-shows towards collaborative and interactive developing of plans and processes via designing and creating its corresponding diagrams. In this paper, we present an approach for interacting with diagrams using uni-stroke touch gestures. We focus on large wall-mounted touchscreens and present an editor design for such environments. In order to validate the usability of our approach we report on the results of a user study with a diagram editor for Business Process Modeling Networks.

In software development processes, diagram editors play an important role. For instance, editors for creating UML diagrams are often used in early stages of software development. Three input methodologies can be distinguished: traditional mode-based editors, sketching editors, and gesture-based editors. Most of today's diagram editors are mode-based and use the mouse as an input device. (Multi-)touch inputs have not been integrated very well, yet, although a variety of touch input devices, such as (multi-)touch monitors and tablet computers, are quite common today. In this paper, we present an integration of an off-the-shelf unistroke recognizer into an existing diagram editor framework. This allows to reduce the number of different interaction modes in diagram editors as users perform editing tasks, such as creating, modifying, and deleting, by unistroke gestures. In order to examine the effect on the usability of such editors, we conducted a pilot study using a Statechart editor and present some preliminary findings here.

In software development processes, diagram editors play an important role. For instance, editors for creating UML diagrams are often used in early stages of software development. Three input methodologies can be distinguished: traditional mode-based editing, sketch-based editing, and gesture-based editing. Most of today's diagram editors are mode-based and use the mouse as an input device. (Multi-)touch inputs have not been integrated very well, although a variety of touch input devices, such as (multi-)touch monitors and tablet computers, are quite common today. In this paper, we provide some insights into the integration of an off-the-shelf unistroke gesture recognizer into an existing diagram editor framework, and give some details about three example diagram editors that incorporate a new interaction mode, the so-called gesture mode.

In this paper, we present methods and techniques to record, process, and visualize diagram changes. These methods help us understand diagram changes, and are the basis for more enhanced functionality, such as a more powerful undo functionality, or merging of different versions of a diagram. Our approach is based on the idea to record all diagram changes, including changes of the diagram layout. One of the main challenges is to provide a concise and comprehensible visualization of these changes. In order to produce such a visualization, the recordings need to be processed, comprising filtering and aggregation of changes. Our model-based approach is generic and makes use of the abstract and the concrete syntax (meaning and representation) of the specific diagram language.

We present an approach to the processing of hand-drawn diagrams. Hand drawing is inherently imprecise; we rely on syntactical and semantical analysis to resolve the inevitable ambiguities arising from this impreciseness. Based on the specification of a diagram language (containing aspects like concrete and abstract syntax, grammar rules for a parser, and attributes for semantics), editors supporting free hand drawing are generated. Since the generation process relies on the specifications only, our approach is fully generic. In this paper the overall architecture and concepts of our approach are explained and discussed. The user-drawn strokes (forming the diagram) are transformed into a number of independent models. The drawn components are recognized in these models, directed by the specification. Then the set of all components is analyzed to find the interpretation that best fits the whole diagram. We build upon DiaGen, a generic diagram editor generator enabling syntax and semantic analysis for diagrams, and extend it to support hand drawing. Case studies (done with a fully working implementation in Java) confirm the strength and applicability of our approach.

Graphs are known to be well-suited as an intermediate data structure in diagram editors. The syntax of a particular visual language can be defined by means of a graph grammar. In recent work we have proposed approaches to graph completion: given a possibly ldquoincompleterdquo graph, this graph is modified in such a way that the resulting graph is a member of the grammarpsilas language. In this paper we describe how graph completion can be used to realize diagram completion, an important requirement for the realization of content assist in diagram editors. With our approach, the advantages of free-hand and structured editing can be effectively combined: drawing of diagrams with maximal freedom and powerful guidance whenever needed.

Visual language syntax can be specified by grammars or meta-models. Grammars are more complicated to build than meta-models, but allow for parsing of visual sentences which is necessary for building free-hand editors. Parsing has not yet been considered for meta-model-based specifications. Such visual editors support only structured editing so far. This paper shows that the syntax analysis problem ("parsing") for meta-model-based language specifications can be transformed into a constraint satisfaction problem and solved that way. This approach, therefore, allows for easy free-hand editing and, at the same time, easy meta-model-based language specifications.