You might have read before about Griffon's JUNG plugin and wondered "how can I visualize an arbitrary object graph with it?", if so then the following steps should give you a few hints.

Let's start by fleshing out the domain. I realize that at the time of writing this post Griffon does not support domain classes like Grails does (i.e, with GORM & scaffolding enabled), however you can create them in the same fashion, that is, place your domain classes under griffon-app/domain and have them participate on your app. With that in mind let's create a few domain classes related to the book publishing business, mainly a Publisher, a Book and an Author classes, like this:
// griffon-app/domain/Publisher.groovy class Publisher { String name List books = [] String toString() { name } } // griffon-app/domain/Book.groovy class Book { String title List authors = [] String toString() { title } } // griffon-app/domain/Author.groovy class Author { String name String toString() { name } }If you're familiar with ObjectGraphBuilder you know you can populate an object graph with ease, as long as the domain classes follow the JavaBeans conventions. Luckily for us that is the case. Building a graph is as easy as executing the following code:
def ogb = new ObjectGraphBuilder() ogb.publisher(name: "Manning") { book(title: "Groovy in Action") { author(name: "Dierk König") author(name: "Guillaume Laforge") author(name: "Paul King") author(name: "Andy Glover") author(name: "Jon Skeet") } book(title: "Grails in Action") { author(name: "Glen Smith") author(name: "Peter Ledbrook") } book(title: "Griffon in Action") { author(name: "Andres Almiray") author(name: "Danno Ferrin") author(name: "Geertjan Wielenga") } }Nothing fancy, just what you would expect from a Groovy builder, isn't it? by the way I'm using the current list of Groovy related books published by Manning as an example. Alright, now comes the "tricky" part: transforming an object graph into something capable of being visualized with JUNG. I'm glad to say this task is also a simple one. We can instruct ObjectGraphBuilder to populate a JUNG Graph at the same time it builds the domain graph, after all ObjectGraphBuilder is quite extensible. There are two things to be done in order to achieve this goal:

1. set the root node.
2. append child nodes to their corresponding parents.

The following Griffon model shows how these two tasks can be done:
import edu.uci.ics.jung.graph.Graph import edu.uci.ics.jung.graph.DelegateTree class BooksModel { Graph publishers = new DelegateTree() BooksModel() { def ogb = new ObjectGraphBuilder() def childPropertySetter = ogb.childPropertySetter ogb.childPropertySetter = { parent, child, parentName, childName -> childPropertySetter.setChild(parent, child, parentName, childName) publishers.addChild("'${parent}' - '${child}'", parent, child) // TASK 2 } ogb.publisher(name: "Manning") { publishers.addVertex(current) // TASK 1 book(title: "Groovy in Action") { author(name: "Dierk König") author(name: "Guillaume Laforge") author(name: "Paul King") author(name: "Andy Glover") author(name: "Jon Skeet") } book(title: "Grails in Action") { author(name: "Glen Smith") author(name: "Peter Ledbrook") } book(title: "Griffon in Action") { author(name: "Andres Almiray") author(name: "Danno Ferrin") author(name: "Geertjan Wielenga") } } } }Task 1 is completed by calling addVertex on the publishers Graph using a special variable available to all FactoryBuilderSupport based builders: current. This variable points to the node that is currently being built, in our case, the publisher node. Task 2 is completed by changing the strategy used by the builder to set the parent/child relationships within nodes. Notice that it still calls the old behavior by keeping a reference to the previous strategy, then calls a Graph method on publishers that registers the child with its parent. Now both the object graph and the Graph are in sync. The following code shows how the publishers Graph can be visualized with minimal effort:
import edu.uci.ics.jung.visualization.renderers.Renderer import edu.uci.ics.jung.visualization.decorators.ToStringLabeller application(title: 'Groovy Books', pack:true, locationByPlatform:true, iconImage: imageIcon('/griffon-icon-48x48.png').image, iconImages: [imageIcon('/griffon-icon-48x48.png').image, imageIcon('/griffon-icon-32x32.png').image, imageIcon('/griffon-icon-16x16.png').image]) { visualizationViewer(model.publishers, id: "gview", preferredSize: [550,550], vertexLabelTransformer: new ToStringLabeller()) { radialTreeLayout() defaultModalGraphMouse() } gview.renderer.vertexLabelRenderer.position = Renderer.VertexLabel.Position.CNTR }Running the application should result in a screen similar to the following snapshot


Time to get fancier with the visualizations. JUNG allows you to tweak almost every aspect of a visualization, we will concentrate on shapes and colors for now. It can be argued that visualization metadata belongs or not to domain classes. For example we could add shape and color properties to our domain classes, but perhaps those properties do not make any sense should our domain classes be persisted. In the end is your call how you want to add such metadata. In this howto I'll simply wrap each domain instance with a map, have the metadata (or spillover properties) be added to the map and the corresponding bean properties to each bean. In order to do that we must tweak two other OGB strategies, as shown next on the app's model:
import java.awt.Color import edu.uci.ics.jung.graph.Graph import edu.uci.ics.jung.graph.DelegateTree class BooksModel { Graph publishers = new DelegateTree() BooksModel() { def ogb = new ObjectGraphBuilder() def newInstanceResolver = ogb.newInstanceResolver ogb.newInstanceResolver = { klass, attributes -> [bean: newInstanceResolver.newInstance(klass, attributes)] } ogb.addAttributeDelegate({ builder, node, attributes -> attributes.each { k, v -> try { node.bean[(k)] = v } catch(MissingPropertyException mpe) { node[(k)] = v } } attributes.clear() }) def childPropertySetter = ogb.childPropertySetter ogb.childPropertySetter = { parent, child, parentName, childName -> childPropertySetter.setChild(parent.bean, child, parentName, childName) publishers.addChild("'${parent}' - '${child}'", parent, child) } ogb.publisher(name: "Manning", color: Color.GREEN) { publishers.addVertex(current) book(title: "Groovy in Action", color: Color.CYAN) { author(name: "Dierk König") author(name: "Guillaume Laforge") author(name: "Paul King") author(name: "Andy Glover") author(name: "Jon Skeet") } book(title: "Grails in Action", color: Color.RED) { author(name: "Glen Smith") author(name: "Peter Ledbrook") } book(title: "Griffon in Action", color: Color.BLUE) { author(name: "Andres Almiray") author(name: "Danno Ferrin") author(name: "Geertjan Wielenga") } } } }The two strategies are

• newInstanceResolver - takes care of instantiating a node. This is the perfect time to wrap the bean with a map.
• attributeDelegate - this strategy takes care of setting properties on a node. By testing for MissingPropertyException we know the property may or may not be supported by the bean. If it is not supported we assume it is a metadata property and add it directly to the enclosing map.

Lastly we need to update the childPropertySetter strategy as the beans are now being wrapped. Now that the model has the desired metadata it is time to update the visualization code with a set of transformers. Given that the beans are now wrapped the ToStringLabeller will yield weird results, we need to provide a new value for vertexLabelTransformer. Two new transformers will be added:

• vertexShapeTransformer - takes care of setting up the shape to be used for each node.
• vertexFillPaintTransformer - takes care of setting up the color to be used as the fill for each node.

We will rely on jSilhouette's Star shape and a helper BasicVertexShapeTransfomer provided by the JUNG plugin. At this point only Books will have a custom shape (the Groovy star ) while the other domain classes will use a circle.
import edu.uci.ics.jung.visualization.renderers.Renderer import org.apache.commons.collections15.Transformer import org.apache.commons.collections15.functors.ConstantTransformer import java.awt.Color import java.awt.Shape import java.awt.geom.Ellipse2D import org.kordamp.jsilhouette.geom.Star import griffon.jung.visualization.decorators.BasicVertexShapeTransformer vertexLabeler = { v -> v.bean.toString() } as Transformer vertexPainter = { v -> v.color ?: Color.WHITE } as Transformer shaper = { Map shapes, v -> shapes[(v.bean.class.name)] ?: new Ellipse2D.Double(0, 0, 1d, 1d) } bean(id: "star", new Star(), or: 40f, ir: 20f, count: 5i) bean(new BasicVertexShapeTransformer(shaper.curry([(Book.name): star])), id: "vertexShaper", sizeTransformer: new ConstantTransformer(40i)) application(title: 'Groovy Books', pack:true, locationByPlatform:true, iconImage: imageIcon('/griffon-icon-48x48.png').image, iconImages: [imageIcon('/griffon-icon-48x48.png').image, imageIcon('/griffon-icon-32x32.png').image, imageIcon('/griffon-icon-16x16.png').image]) { visualizationViewer(model.publishers, id: "gview", preferredSize: [550,550], vertexShapeTransformer: vertexShaper, vertexFillPaintTransformer: vertexPainter, vertexLabelTransformer: vertexLabeler) { radialTreeLayout() defaultModalGraphMouse() } gview.renderer.vertexLabelRenderer.position = Renderer.VertexLabel.Position.CNTR }Reviewing each transformer yields:

• vertexLabeler - queries the node's bean. v is of type Map.
• vertexPainter - queries v's color property, uses a default color (WHITE) if no property is defined. The elvis operator becomes quite handy here.
• shaper - another elvis enabled transformer, this one checks for the existence of a shape related to a class name.
• vertexShaper - relies on the previous transformer to determine which shape will be used by each node. Notice that only books define a specific shape.

This is all that there is to it. Running the application should result in a similar screenshot like the following one


There you have it, a simple yet effective way to build and visualize an object graph with ObjectGraphBuilder and Griffon/JUNG.

Keep on Groovying!