de.uni_due.inf.ti.dragom.gui

Class AnnotatedTypeGraphVisualizer

java.lang.Object

de.uni_due.inf.ti.dragom.gui.AnnotatedTypeGraphVisualizer

public class AnnotatedTypeGraphVisualizer
extends java.lang.Object

Instances of this class convert Graph instances to VxGraph instances.

Author:

Dennis Nolte

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	AnnotatedTypeGraphVisualizer.AddMode Represents whether added objects are created, deleted or neither.
static class	AnnotatedTypeGraphVisualizer.GraphColor Specifies the color to be used for colored graphs.
static class	AnnotatedTypeGraphVisualizer.MorphismVisi Class used to return morphism visualizations.
static class	AnnotatedTypeGraphVisualizer.RuleVisi Class used to return morphism visualizations.
class	AnnotatedTypeGraphVisualizer.VisualSynchronizer GraphEditSynchronizer implementation which uses the style properties of this GraphVisualizer.

Field Summary

Fields

Modifier and Type	Field and Description
static java.lang.String	arityStyleName
static java.lang.String	connectionStyleName
static java.lang.String	createdArityStyleName
static java.lang.String	createdConnectionStyleName
static java.lang.String	createdEdgeStyleName
static java.lang.String	createdHyperedgeStyleName
static java.lang.String	createdLabelStyleName
static java.lang.String	createdNodeStyleName
static java.lang.String	deletedArityStyleName
static java.lang.String	deletedConnectionStyleName
static java.lang.String	deletedEdgeStyleName
static java.lang.String	deletedHyperedgeStyleName
static java.lang.String	deletedLabelStyleName
static java.lang.String	deletedNodeStyleName
static java.lang.String	edgeStyleName
static java.lang.String	grayNodeStyleName
static java.lang.String	hyperedgeStyleName
static java.lang.String	interfaceEdgeStyleName
static java.lang.String	interfaceNodeStyleName
static java.lang.String	labelStyleName
static java.lang.String	morphismEdgeStyleName
static java.lang.String	morphismStyleName
static java.lang.String	nodeStyleName
static java.lang.String	rightEdgeStyleName
static java.lang.String	rightNodeStyleName
static java.lang.String	stateStyleName
static java.lang.String	transitionStyleName

Constructor Summary

Constructors

Constructor and Description
AnnotatedTypeGraphVisualizer() Creates a new GraphVisualizer instance.

Method Summary

Modifier and Type	Method and Description
void	addDefaultStyles(de.uni_due.inf.ti.visigraph.StyleMap styleMap) Adds default styles to the style names of this GraphVisualizer.
java.awt.geom.Rectangle2D	getBounds() Returns the bounds of the generated graphs.
java.awt.geom.Rectangle2D	getBounds(java.awt.geom.Rectangle2D result) Returns the bounds of the generated graphs.
AnnotatedTypeGraphVisualizer.VisualSynchronizer	getSynchronizer() Returns a GraphEditSynchronizer for Graph instances which uses the style properties of this visualizer.
boolean	hasEdgeLabels() Determines whether graph visualizations have edge labels.
boolean	hasEdgesMultiplicityStyle() Returns whether this GraphVisualizer will always display multiplicities on edges.
boolean	hasHyperStyle() Returns whether this GraphVisualizer will always generate hypergraph representations.
boolean	hasNodeLabels() Determines whether graph visualizations have node labels.
boolean	hasNodeMultiplicityStyle() Returns whether this GraphVisualizer will always display multiplicities on nodes instead of id's.
void	setBounds(double x, double y, double width, double height) Sets the bounds of the generated graphs.
void	setBounds(java.awt.geom.Rectangle2D rect) Sets the bounds of the generated graphs to a rectangle.
void	setEdgeLabels(boolean edgeLabels) Sets whether graph visualizations have edge labels.
void	setHyperStyle(boolean h) Sets whether this GraphVisualizer will always generated hypergraph representations.
void	setMultiplicityStyle(boolean m) Sets whether this GraphVisualizer will always display multiplicities.
void	setNodeIDs(boolean nodeIDs) Sets whether graph visualizations have node IDs.
void	setNodeLabels(boolean nodeLabels) Sets whether graph visualizations have node labels.
de.uni_due.inf.ti.visigraph.VxGraph	visualizeColoredGraph(AnnotatedTypeGraph graph, java.util.Set<de.uni_due.inf.ti.graph.Node> coloredNodes, java.util.Set<de.uni_due.inf.ti.graph.Edge> coloredEdges, AnnotatedTypeGraphVisualizer.GraphColor style, boolean simplified) Creates a VxGraph which visualizes a graph.
AnnotatedTypeGraphVisualizer.RuleVisi	visualizeDPO(de.uni_due.inf.ti.graph.Morphism leftMorph, de.uni_due.inf.ti.graph.Morphism rightMorph) Creates a VxGraph which visualizes a morphism.
de.uni_due.inf.ti.visigraph.VxGraph	visualizeFlatMorphism(de.uni_due.inf.ti.graph.Morphism morph) Creates a VxGraph which visualizes a rule, where the rule is displayed as a single graph with different style for deleted and created parts.
de.uni_due.inf.ti.visigraph.VxGraph	visualizeGraph(AnnotatedTypeGraph graph) Creates a VxGraph which visualizes a graph.
AnnotatedTypeGraphVisualizer.MorphismVisi	visualizeMorphism(de.uni_due.inf.ti.graph.Morphism morph, boolean leftMulti, boolean rightMulti) Creates a VxGraph which visualizes a morphism.
AnnotatedTypeGraphVisualizer.MorphismVisi	visualizePostconditionMatch(de.uni_due.inf.ti.graph.Morphism morph, java.util.Set<de.uni_due.inf.ti.graph.Node> coloredNodes, java.util.Set<de.uni_due.inf.ti.graph.Edge> coloredEdges, AnnotatedTypeGraphVisualizer.GraphColor color, boolean simplified)
de.uni_due.inf.ti.visigraph.VxGraph	visualizeSystem(de.uni_due.inf.ti.graph.ExplicitTransitionSystem system) Visualizes a transition system.

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

nodeStyleName

public static java.lang.String nodeStyleName

grayNodeStyleName

public static java.lang.String grayNodeStyleName

createdNodeStyleName

public static java.lang.String createdNodeStyleName

rightNodeStyleName

public static java.lang.String rightNodeStyleName

deletedNodeStyleName

public static java.lang.String deletedNodeStyleName

interfaceNodeStyleName

public static java.lang.String interfaceNodeStyleName

hyperedgeStyleName

public static java.lang.String hyperedgeStyleName

createdHyperedgeStyleName

public static java.lang.String createdHyperedgeStyleName

deletedHyperedgeStyleName

public static java.lang.String deletedHyperedgeStyleName

edgeStyleName

public static java.lang.String edgeStyleName

createdEdgeStyleName

public static java.lang.String createdEdgeStyleName

rightEdgeStyleName

public static java.lang.String rightEdgeStyleName

deletedEdgeStyleName

public static java.lang.String deletedEdgeStyleName

interfaceEdgeStyleName

public static java.lang.String interfaceEdgeStyleName

morphismEdgeStyleName

public static java.lang.String morphismEdgeStyleName

labelStyleName

public static java.lang.String labelStyleName

createdLabelStyleName

public static java.lang.String createdLabelStyleName

deletedLabelStyleName

public static java.lang.String deletedLabelStyleName

connectionStyleName

public static java.lang.String connectionStyleName

createdConnectionStyleName

public static java.lang.String createdConnectionStyleName

deletedConnectionStyleName

public static java.lang.String deletedConnectionStyleName

arityStyleName

public static java.lang.String arityStyleName

createdArityStyleName

public static java.lang.String createdArityStyleName

deletedArityStyleName

public static java.lang.String deletedArityStyleName

morphismStyleName

public static java.lang.String morphismStyleName

stateStyleName

public static java.lang.String stateStyleName

transitionStyleName

public static java.lang.String transitionStyleName

Constructor Detail

AnnotatedTypeGraphVisualizer

public AnnotatedTypeGraphVisualizer()

Creates a new GraphVisualizer instance.

Method Detail

addDefaultStyles

public void addDefaultStyles(de.uni_due.inf.ti.visigraph.StyleMap styleMap)

Adds default styles to the style names of this GraphVisualizer. For each style name, this method determines if a style is already set in the style map; if not, a suitable default is added to the style map.

Parameters:

styleMap - style map to add default style to

setBounds

public void setBounds(double x,
                      double y,
                      double width,
                      double height)

Sets the bounds of the generated graphs. The generated graphs will have random positions within these bounds.

Parameters:

x - x-coordinate of the top-left corner of the bounding rectangle

y - y-coordinate of the top-left corner of the bounding rectangle

width - width of the bounding rectangle

height - height of the bounding rectangle

setBounds

public void setBounds(java.awt.geom.Rectangle2D rect)

Sets the bounds of the generated graphs to a rectangle. The generated graphs will have random positions within these bounds.

Parameters:

rect - the new bounding rectangle

getBounds

public java.awt.geom.Rectangle2D getBounds(java.awt.geom.Rectangle2D result)

Returns the bounds of the generated graphs. If the second parameter is non-null, it is modified to hold the bounds and returned. If it is null, a new Rectangle2D object holding the bounds is created and returned.

Parameters:

result - buffer to hold the return value

Returns:

rectangle in which new elements are created by this GraphVisualizer

getBounds

public java.awt.geom.Rectangle2D getBounds()

Returns the bounds of the generated graphs.

Returns:

rectangle in which new elements are created by this GraphVisualizer

setHyperStyle

public void setHyperStyle(boolean h)

Sets whether this GraphVisualizer will always generated hypergraph representations. If true, the GraphVisualizer will generate hypergraph representations of graphs which contain only binary edges.

Parameters:

h - whether this GraphVisualizer will always generate hypergraph representations

hasHyperStyle

public boolean hasHyperStyle()

Returns whether this GraphVisualizer will always generate hypergraph representations.

Returns:

Boolean if hyper style is used

See Also:

setHyperStyle(boolean)

setMultiplicityStyle

public void setMultiplicityStyle(boolean m)

Sets whether this GraphVisualizer will always display multiplicities. If true, the GraphVisualizer will generate graphs which contain multiplicities on nodes and edges.

Parameters:

m - whether this GraphVisualizer will always display multiplicities

hasNodeMultiplicityStyle

public boolean hasNodeMultiplicityStyle()

Returns whether this GraphVisualizer will always display multiplicities on nodes instead of id's.

Returns:

Boolean if multiplicity style is used

See Also:

setMultiplicityStyle(boolean)

hasEdgesMultiplicityStyle

public boolean hasEdgesMultiplicityStyle()

Returns whether this GraphVisualizer will always display multiplicities on edges.

Returns:

Boolean if edge multiplicity style is used

See Also:

setMultiplicityStyle(boolean)

setNodeLabels

public void setNodeLabels(boolean nodeLabels)

Sets whether graph visualizations have node labels. If set to true, graph visualizations created afterwards will have the nodes' id numbers or multiplicities as labels.

The default value is true.

Parameters:

nodeLabels - whether or not nodes will have their id numbers as labels

See Also:

hasNodeLabels()

hasNodeLabels

public boolean hasNodeLabels()

Determines whether graph visualizations have node labels.

Returns:

whether graph visualizations created by this GraphVisualizer have node labels

See Also:

setNodeLabels(boolean)

setEdgeLabels

public void setEdgeLabels(boolean edgeLabels)

Sets whether graph visualizations have edge labels. If set to true, edges in graph visualization created with this GraphVisualizer afterwards will have labels. Since edge labels are semantically significant in the graphs modelled by Graph objects, setting this property to false is mainly useful if it is known that only one label can occur in a graph.

The default value of this property is true.

Parameters:

edgeLabels - whether or not edges will have labels

See Also:

hasEdgeLabels()

hasEdgeLabels

public boolean hasEdgeLabels()

Determines whether graph visualizations have edge labels.

Returns:

whether graph visualizations created by this GraphVisualizer have edge labels

See Also:

setEdgeLabels(boolean)

setNodeIDs

public void setNodeIDs(boolean nodeIDs)

Sets whether graph visualizations have node IDs. If set to true, graph visualizations created afterwards will have the nodes' id numbers as labels.

The default value is true.

Parameters:

nodeIDs - whether or not nodes will have their id numbers as labels

See Also:

hasNodeLabels()

visualizeGraph

public de.uni_due.inf.ti.visigraph.VxGraph visualizeGraph(AnnotatedTypeGraph graph)

Creates a VxGraph which visualizes a graph.

If either getHyperStyle() == true, or this graph contains non-binary edges, the graph is visualized using a hypergraph representation; otherwise an ordinary graph representation is used.

The nodes and hyperedges of the graphical representation are put on arbitrary positions, whereas all edges will be straight lines from the source to the target node. In most cases, it will be necessary to layout the resulting graphical representation, either manually or with one of the graph layout algorithm provided with the VisiGraph library.

The result visualization uses the following style names:

• nodeStyleName: the style for the nodes of the graph
• edgeStyleName: the style for the edges in the graph (only in ordinary graph representations)
• hyperedgeStyleName: the style for hyperedges in the graph (only in hypergraph representations)
• connectionStyleName: the style for connections between hyperedges and nodes (only in hypergraph representations)
• labelStyleName: the style of labels of edges and connections

Parameters:

graph - the graph of which a visualization is generated

Returns:

new VxGraph instance which visualizes the graph

Throws:

java.lang.NullPointerException - if graph is null

visualizeColoredGraph

public de.uni_due.inf.ti.visigraph.VxGraph visualizeColoredGraph(AnnotatedTypeGraph graph,
                                                                 java.util.Set<de.uni_due.inf.ti.graph.Node> coloredNodes,
                                                                 java.util.Set<de.uni_due.inf.ti.graph.Edge> coloredEdges,
                                                                 AnnotatedTypeGraphVisualizer.GraphColor style,
                                                                 boolean simplified)

Creates a VxGraph which visualizes a graph.

If either getHyperStyle() == true, or this graph contains non-binary edges, the graph is visualized using a hypergraph representation; otherwise an ordinary graph representation is used.

The nodes and hyperedges of the graphical representation are put on arbitrary positions, whereas all edges will be straight lines from the source to the target node. In most cases, it will be necessary to layout the resulting graphical representation, either manually or with one of the graph layout algorithm provided with the VisiGraph library.

The result visualization uses the following style names:

• nodeStyleName: the style for the nodes of the graph
• edgeStyleName: the style for the edges in the graph (only in ordinary graph representations)
• hyperedgeStyleName: the style for hyperedges in the graph (only in hypergraph representations)
• connectionStyleName: the style for connections between hyperedges and nodes (only in hypergraph representations)
• labelStyleName: the style of labels of edges and connections

Parameters:

graph - the graph of which a visualization is generated

coloredNodes - the nodes to be colored

coloredEdges - the edges to be colored

style - the graph color to be used

simplified - boolean if the graph should be simplified

Returns:

new VxGraph instance which visualizes the graph

Throws:

java.lang.NullPointerException - if graph is null

visualizeMorphism

public AnnotatedTypeGraphVisualizer.MorphismVisi visualizeMorphism(de.uni_due.inf.ti.graph.Morphism morph,
                                                                   boolean leftMulti,
                                                                   boolean rightMulti)

Creates a VxGraph which visualizes a morphism. The visual representation will consist of the left-hand side and the right-hand side with explicit morphism arrows between nodes which are mapped to one another by the correspondence morphism. The parts of the representation belonging to the left-hand side and right-hand side are added to the leftGroup and rightGroup groups, respectively.

If either getHyperStyle() == true, this rule contains non-binary edges, or the correspondence morphism maps at least one edge of the left-hand side to one edge in the right-hand side, the graph is visualized using a hypergraph representation; otherwise an ordinary graph representation is used.

The nodes and hyperedges of the graphical representation are put on random positions, whereas all edges will be straight lines from the source to the target node. In most cases, it will be necessary to layout the resulting graphical representation, either manually or with one of the graph layout algorithm provided with the VisiGraph library.

The resulting visualization uses the following style names:

• nodeStyleName: the style for the nodes of the graph
• edgeStyleName: the style for the edges in the graph (only in ordinary graph representations)
• hyperedgeStyleName: the style for hyperedges in the graph (only in hypergraph representations)
• connectionStyleName: the style for connections between hyperedges and nodes (only in hypergraph representations)
• labelStyleName: the style of labels of edges and connections
• morphismStyleName (edge style): the style for the morphism arrows

Parameters:

morph - the morphism of which a visualization is generated

leftMulti - boolean if the domain graph has multiplicities

rightMulti - boolean if the codomain graph has multiplicities

Returns:

RuleVisi which contains a new VxGraph instance visualizing the morphism, and the groups which contain the nodes and edges of the domain and codomain respectively

Throws:

java.lang.NullPointerException - if morph is null

visualizePostconditionMatch

public AnnotatedTypeGraphVisualizer.MorphismVisi visualizePostconditionMatch(de.uni_due.inf.ti.graph.Morphism morph,
                                                                             java.util.Set<de.uni_due.inf.ti.graph.Node> coloredNodes,
                                                                             java.util.Set<de.uni_due.inf.ti.graph.Edge> coloredEdges,
                                                                             AnnotatedTypeGraphVisualizer.GraphColor color,
                                                                             boolean simplified)

visualizeDPO

public AnnotatedTypeGraphVisualizer.RuleVisi visualizeDPO(de.uni_due.inf.ti.graph.Morphism leftMorph,
                                                          de.uni_due.inf.ti.graph.Morphism rightMorph)

Creates a VxGraph which visualizes a morphism. The visual representation will consist of the left-hand side and the right-hand side with explicit morphism arrows between nodes which are mapped to one another by the correspondence morphism. The parts of the representation belonging to the left-hand side and right-hand side are added to the leftGroup and rightGroup groups, respectively.

If either getHyperStyle() == true, this rule contains non-binary edges, or the correspondence morphism maps at least one edge of the left-hand side to one edge in the right-hand side, the graph is visualized using a hypergraph representation; otherwise an ordinary graph representation is used.

The nodes and hyperedges of the graphical representation are put on random positions, whereas all edges will be straight lines from the source to the target node. In most cases, it will be necessary to layout the resulting graphical representation, either manually or with one of the graph layout algorithm provided with the VisiGraph library.

The resulting visualization uses the following style names:

• nodeStyleName: the style for the nodes of the graph
• edgeStyleName: the style for the edges in the graph (only in ordinary graph representations)
• hyperedgeStyleName: the style for hyperedges in the graph (only in hypergraph representations)
• connectionStyleName: the style for connections between hyperedges and nodes (only in hypergraph representations)
• labelStyleName: the style of labels of edges and connections
• morphismStyleName (edge style): the style for the morphism arrows

Parameters:

leftMorph - the left-hand morphism of which a visualization is generated

rightMorph - the right-hand morphism of which a visualization is generated

Returns:

RuleVisi which contains a new VxGraph instance visualizing the morphism, and the groups which contain the nodes and edges of the domain and codomain respectively

Throws:

java.lang.NullPointerException - if morph is null

visualizeFlatMorphism

public de.uni_due.inf.ti.visigraph.VxGraph visualizeFlatMorphism(de.uni_due.inf.ti.graph.Morphism morph)

Creates a VxGraph which visualizes a rule, where the rule is displayed as a single graph with different style for deleted and created parts. For this visualization to work, the rule must have an injective correspondence morphism.

If either getHyperStyle() == true, or this rule contains non-binary edges, the rule is visualized using a hypergraph representation; otherwise an ordinary graph representation is used.

The nodes and hyperedges of the graphical representation are put on random positions, whereas all edges will be straight lines from the source to the target node. In most cases, it will be necessary to layout the resulting graphical representation, either manually or with one of the graph layout algorithms provided with the VisiGraph library.

The result visualization uses the styles associated with the following style identifiers:

• createNodeStyleName: for nodes which are in the right-hand side of the rule, but have no corresponding node in the left-hand side, that is, nodes created by this rule
• deletedNodeStyleName: for nodes which are in the left-hand side of the rule, but have no corresponding node in the right-hand side, that is, nodes deleted by this rule
• nodeStyleName: for nodes which are neither created nor deleted by the rule
• createdEdgeStyleName: for edges which are created by this rule (only in ordinary graph representation)
• deletedEdgeStyleName: for edge which are deleted by this rule (only in ordinary graph representation)
• edgeStyleName: for edges which are neither deleted nor created by this rule
• createdHyperedgeStyleName: for hyperedges which are created by this rule (only in hypergraph representation)
• deletedHyperedgeStyleName: for hyperedges which are deleted by this rule (only in hypergraph representation)
• hyperedgeStyle: for hyperedges which are neither created nor deleted by this rule (only in hypergraph representation)
• createdConnectionStyleName: for connections between hyperedge and node, for hyperedges which are created by the rule (only in hypergraph representation)
• deletedConnectionStyleName (edge style): for connections between hyperedge and node, for hyperedges which are deleted by the rule (only in hypergraph representation)
• connectionStyleName (edge style): for connections between hyperedge and node, for hyperedges which are neither deleted nor created by this rule (only in hypergraph representation)
• createdLabelStyleName: for labels of edges and connections which are created by the rule
• deletedLabelStyleName: for labels of edges and connections which are deleted by the rule
• labelStyleName: for labels of edges and connections which are neither created nor deleted by the rule

Parameters:

morph - the morphism to be visualized

Returns:

a visual representation of the morphism

Throws:

java.lang.NullPointerException - if rule is null

java.lang.IllegalArgumentException - if rule does not have an injective correspondence morphism

visualizeSystem

public de.uni_due.inf.ti.visigraph.VxGraph visualizeSystem(de.uni_due.inf.ti.graph.ExplicitTransitionSystem system)

Visualizes a transition system. This method generates a VxGraph representing the labeled transition system of the given system. It does not visualize the objects of the transition system.

This method ignores the property set by setHyperStyle(boolean) and will always produce binary, directed graphs.

The result visualization uses the styles associated with the following style identifiers:

• stateStyleName (node style): The style used for the objects in the transition system.
• transitionStyleName (edge style): The style used for the transitions in the transition system.

Parameters:

system - system for which a visual representation is to be generated

Returns:

VxGraph which represents the given transition system

getSynchronizer

public AnnotatedTypeGraphVisualizer.VisualSynchronizer getSynchronizer()

Returns a GraphEditSynchronizer for Graph instances which uses the style properties of this visualizer.

Returns:

The visual synchronizer