/**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.oodt.cas.workflow.gui.perspective.view.impl;
//JDK imports
import java.awt.Color;
import java.awt.Font;
import java.awt.geom.Rectangle2D;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.BorderFactory;
//OODT imports
import org.apache.oodt.cas.workflow.gui.model.ModelNode;
//JGraph imports
import org.jgraph.event.GraphModelEvent;
import org.jgraph.event.GraphModelListener;
import org.jgraph.graph.AttributeMap;
import org.jgraph.graph.ConnectionSet;
import org.jgraph.graph.DefaultEdge;
import org.jgraph.graph.DefaultGraphCell;
import org.jgraph.graph.DefaultGraphModel;
import org.jgraph.graph.DefaultPort;
import org.jgraph.graph.GraphConstants;
//Jung imports
import edu.uci.ics.jung.graph.ObservableGraph;
import edu.uci.ics.jung.graph.event.GraphEvent;
import edu.uci.ics.jung.graph.event.GraphEventListener;
/**
*
* This class integrates OODT, Jung and JGraph.
*
* Not necessarily in that order. It acts as a facade, wrapping a Jung graph
* (and its modifications) and then using that to update the current state of
* the associated JGraph model.
*
* @author mattmann
*
*/
public class JungJGraphModelAdapter extends DefaultGraphModel {
private static final long serialVersionUID = 205647349848965651L;
private ObservableGraph<ModelNode, IdentifiableEdge> jungGraph;
private Map<String, DefaultGraphCell> cellMap;
private static final Logger LOG = Logger
.getLogger(JungJGraphModelAdapter.class.getName());
public JungJGraphModelAdapter(
final ObservableGraph<ModelNode, IdentifiableEdge> jungGraph) {
this.jungGraph = jungGraph;
this.jungGraph.addGraphEventListener(new WorkflowChangeListener(this));
this.cellMap = new HashMap<String, DefaultGraphCell>();
this.addGraphModelListener(new GraphModelListener() {
@Override
public void graphChanged(GraphModelEvent e) {
Object[] added = e.getChange().getInserted();
Object[] removed = e.getChange().getRemoved();
Object[] changed = e.getChange().getChanged();
if (added != null && added.length > 0) {
for (Object a : added) {
LOG.log(Level.FINE, "Jgraph notification of object added: ["
+ a.getClass().getName() + "]");
if (a instanceof org.jgraph.graph.DefaultEdge) {
LOG.log(Level.FINE, "Edge added to jgraph");
org.jgraph.graph.DefaultEdge edge = (org.jgraph.graph.DefaultEdge) a;
if (!jungGraph.getEdges().contains(edge.getUserObject())) {
jungGraph.addEdge(
new IdentifiableEdge((ModelNode) edge.getSource(),
(ModelNode) edge.getTarget()), (ModelNode) edge
.getSource(), (ModelNode) edge.getTarget());
}
} else if (a instanceof org.jgraph.graph.DefaultGraphCell) {
LOG.log(Level.FINE, "Vertex added to jgraph");
org.jgraph.graph.DefaultGraphCell cell = (org.jgraph.graph.DefaultGraphCell) a;
if (!jungGraph.getVertices().contains(cell.getUserObject())) {
jungGraph.addVertex((ModelNode) cell.getUserObject());
}
}
}
}
if (removed != null && removed.length > 0) {
for (Object r : removed) {
LOG.log(Level.FINE, "Jgraph notification of object removed: ["
+ r.getClass().getName() + "]");
if (r instanceof org.jgraph.graph.DefaultEdge) {
LOG.log(Level.FINE, "Edge removed from jgraph");
org.jgraph.graph.DefaultEdge edge = (org.jgraph.graph.DefaultEdge) r;
if (jungGraph.getEdges().contains(edge.getUserObject())) {
jungGraph.removeEdge((IdentifiableEdge) edge.getUserObject());
}
} else if (r instanceof org.jgraph.graph.DefaultGraphCell) {
LOG.log(Level.FINE, "Vertex removed from jgraph");
org.jgraph.graph.DefaultGraphCell cell = (org.jgraph.graph.DefaultGraphCell) r;
if (jungGraph.getVertices().contains(cell.getUserObject())) {
jungGraph.removeVertex((ModelNode) cell.getUserObject());
}
}
}
}
}
});
}
public DefaultGraphCell getVertexCell(ModelNode node) {
if (cellMap.get(node.getId()) != null) {
return cellMap.get(node.getId());
}
DefaultGraphCell cell = new DefaultGraphCell(node);
cell.add(new DefaultPort());
return cell;
}
private AttributeMap getEdgeAttributes(DefaultEdge edge) {
AttributeMap eMap = new AttributeMap();
GraphConstants.setLineEnd(eMap, GraphConstants.ARROW_TECHNICAL);
GraphConstants.setEndFill(eMap, true);
GraphConstants.setEndSize(eMap, 10);
GraphConstants.setForeground(eMap, Color.decode("#25507C"));
GraphConstants.setFont(eMap,
GraphConstants.DEFAULTFONT.deriveFont(Font.BOLD, 12));
GraphConstants.setLineColor(eMap, Color.decode("#7AA1E6"));
AttributeMap map = new AttributeMap();
map.put(edge, eMap);
return map;
}
private AttributeMap getVertexAttributes(DefaultGraphCell cell) {
AttributeMap vMap = new AttributeMap();
Color c = Color.decode("#FF9900");
GraphConstants.setBounds(vMap, new Rectangle2D.Double(50, 50, 90, 30));
GraphConstants.setBorder(vMap, BorderFactory.createRaisedBevelBorder());
GraphConstants.setBackground(vMap, c);
GraphConstants.setForeground(vMap, Color.white);
GraphConstants.setFont(vMap,
GraphConstants.DEFAULTFONT.deriveFont(Font.BOLD, 12));
GraphConstants.setOpaque(vMap, true);
AttributeMap map = new AttributeMap();
map.put(cell, vMap);
return map;
}
private class WorkflowChangeListener implements
GraphEventListener<ModelNode, IdentifiableEdge> {
private JungJGraphModelAdapter adapter;
public WorkflowChangeListener(JungJGraphModelAdapter adapter) {
this.adapter = adapter;
}
/*
* (non-Javadoc)
*
* @see
* edu.uci.ics.jung.graph.event.GraphEventListener#handleGraphEvent(edu.
* uci.ics.jung.graph.event.GraphEvent)
*/
@Override
public void handleGraphEvent(GraphEvent<ModelNode, IdentifiableEdge> e) {
if (e.getType().equals(GraphEvent.Type.EDGE_ADDED)) {
LOG.log(Level.FINE, "EDGE ADDED!");
GraphEvent.Edge<ModelNode, IdentifiableEdge> event = (GraphEvent.Edge<ModelNode, IdentifiableEdge>) e;
addJGraphEdge(event.getEdge());
} else if (e.getType().equals(GraphEvent.Type.EDGE_REMOVED)) {
LOG.log(Level.FINE, "EDGE REMOVED!");
} else if (e.getType().equals(GraphEvent.Type.VERTEX_ADDED)) {
LOG.log(Level.FINE, "VERTEX ADDED!");
GraphEvent.Vertex<ModelNode, IdentifiableEdge> event = (GraphEvent.Vertex<ModelNode, IdentifiableEdge>) e;
addJGraphVertex(event.getVertex());
} else if (e.getType().equals(GraphEvent.Type.VERTEX_REMOVED)) {
LOG.log(Level.FINE, "VERTEX REMOVED!");
}
}
}
private void addJGraphVertex(ModelNode node) {
DefaultGraphCell cell = new DefaultGraphCell(node);
cell.add(new DefaultPort());
insert(new Object[] { cell }, getVertexAttributes(cell), null, null, null);
cellMap.put(node.getId(), cell);
}
private void addJGraphEdge(IdentifiableEdge e) {
ConnectionSet set = new ConnectionSet();
DefaultEdge theEdge = new DefaultEdge(e);
DefaultGraphCell from = null;
DefaultGraphCell to = null;
String fromVertexId = e.getFrom().getId();
String toVertexId = e.getTo().getId();
if (!cellMap.containsKey(fromVertexId)) {
addJGraphVertex(e.getFrom());
}
from = cellMap.get(fromVertexId);
if (!cellMap.containsKey(toVertexId)) {
addJGraphVertex(e.getTo());
}
to = cellMap.get(toVertexId);
set.connect(theEdge, (DefaultPort) from.getChildAt(0),
(DefaultPort) to.getChildAt(0));
insert(new Object[] { theEdge }, getEdgeAttributes(theEdge), set, null,
null);
}
}