View Javadoc
   package com.bonevich.erj.diagram;
   
   import com.bonevich.erj.model.*;
   
   import org.tigris.gef.graph.*;
   
   import java.util.*;
   
   /*** This class defines a bridge between the Relational meta-model
   *  representation of the database design and the GraphModel interface 
   *  used by GEF.
   */
  public class ERDiagramGraphModel 
  	extends MutableGraphSupport
  	implements MutableGraphModel 
  {
  	////////////////////////////////////////////////////////////////
  	// instance variables
  	private Schema _schema;
  
  	////////////////////////////////////////////////////////////////
  	// constructors
  	public ERDiagramGraphModel()
  	{
  		this(new Schema());
  		_schema.setName(Schema.NEW_SCHEMA_STR);
  		_schema.setIdentifier(Schema.NEW_SCHEMA_STR);
  	}
  
  	public ERDiagramGraphModel(Schema schema)
  	{
  		_schema = schema;
  	}
  
  	public Schema getSchema() { return _schema; }
  
  	////////////////////////////////////////////////////////////////
  	// GraphModel implementation
  
  	/*** Return all nodes in the graph */
  	public Vector getNodes()
  	{
  		Vector v = new Vector();
  		Iterator relations = _schema.getRelationIterator();
  		while (relations.hasNext())
  		{
  			v.addElement(relations.next());
  		}
  		return v;
  	}
  
  	/*** Return all edges in the graph */
  	public Vector getEdges()
  	{
  		Vector v = new Vector();
  		Iterator keys = _schema.getKeyIterator();
  		while (keys.hasNext())
  		{
  			v.addElement(keys.next());
  		}
  		return v;
  	}
  
  	/*** Return all ports on node or edge */
  	public Vector getPorts(Object nodeOrEdge)
  	{
  		Vector v = new Vector();  //wasteful!
  		if (nodeOrEdge instanceof Relation) 
  		{
  			v.addElement(nodeOrEdge);
  		}
  		if (nodeOrEdge instanceof ForeignKey) 
  		{
  			ForeignKey key = (ForeignKey)nodeOrEdge;
  			v.addElement(key.getRelation());
  			v.addElement(key.getReferentRelation());
  		}
  		return v;
  	}
  
  	/*** Return the node or edge that owns the given port */
  	public Object getOwner(Object port)
  	{
  		return port;
  	}
  
  	/*** Return all edges going to given port */
  	public Vector getInEdges(Object port)
  	{
  		Vector v = new Vector(); //wasteful!
  		if (port instanceof Relation)
  		{
  			Relation rel = (Relation) port;
  			Iterator keys = rel.getKeyIterator();
  			while (keys.hasNext())
  			{
  				KeyConstraint c = (KeyConstraint)keys.next();
  				if (c instanceof ForeignKey)
  				{
 					v.addElement(c);
 				}
 			}
 		}
 		return v;
 	}
 
 	/*** Return all edges going from given port */
 	public Vector getOutEdges(Object port)
 	{
 		//FIXME: we can do this, cannot we?
 		return new Vector();
 	}
 
 	/*** Return one end of an edge */
 	public Object getSourcePort(Object edge)
 	{
 		if (edge instanceof ForeignKey)
 		{
 			ForeignKey fk = (ForeignKey) edge;
 			return fk.getRelation();
 		}
 		return null;
 	}
 
 	/*** Return  the other end of an edge */
 	public Object getDestPort(Object edge)
 	{
 		if (edge instanceof ForeignKey)
 		{
 			ForeignKey fk = (ForeignKey) edge;
 			return fk.getReferentRelation();
 		}
 		return null;
 	}
 
 
 	////////////////////////////////////////////////////////////////
 	// MutableGraphModel implementation
 
 	/*** Return true if the given object is a valid node in this graph */
 	public boolean canAddNode(Object node)
 	{
 		if (node instanceof Relation)
 		{
 			return _schema.containsRelation( (Relation)node );
 		}
 		return false;
 	}
 
 	/*** Return true if the given object is a valid edge in this graph */
 	public boolean canAddEdge(Object edge)
 	{
 		if (edge instanceof ForeignKey)
 		{
 			ForeignKey fk = (ForeignKey) edge;
 			if (!_schema.containsKey(fk))
 			{
 				Relation referrer  = fk.getRelation();
 				Relation referent = fk.getReferentRelation();
 				if (referrer == null || referent == null) return false;
 				if (!_schema.containsRelation(referrer)) return false;
 				if (!_schema.containsRelation(referent)) return false;
 			}
 		}
 		return false;
 	}
 
 	/*** Add the given node to the graph, if valid. */
 	public void addNode(Object node)
 	{
 		// node has already been added to schema
 		fireNodeAdded(node);
 	}
 
 	/*** Remove the given node from the graph. */
 	public void removeNode(Object node)
 	{
 		if (!_schema.containsRelation( (Relation)node )) return;
 		_schema.deleteRelation( (Relation)node );
 		fireNodeRemoved(node);
 	}
 
 	/*** Add the given edge to the graph, if valid. */
 	public void addEdge(Object edge)
 	{
 		// edge has already been added to relation and schema
 		fireEdgeAdded(edge);
 	}
 
 	/*** Remove the given edge from the graph. */
 	public void removeEdge(Object edge)
 	{
 		if (!_schema.containsKey( (ForeignKey)edge )) return;
 		Relation r = ((ForeignKey)edge).getRelation();
 		r.deleteKey((ForeignKey)edge);
 		fireEdgeRemoved(edge);
 	}
 
 	/*** Add existing edges that are related to the node. */
 	public void addNodeRelatedEdges(Object node)
 	{
 		if (node instanceof Relation)
 		{
 			Iterator keys = ((Relation)node).getKeyIterator();
 			while (keys.hasNext())
 			{
 				KeyConstraint c = (KeyConstraint) keys.next();
 				if(canAddEdge(c))
 				{
 					addEdge(c);
 				}
 			}
 		}
 	}
 
 	/*** Return true if the two given ports can be connected by a 
 	 * kind of edge to be determined by the ports. */
 	public boolean canConnect(Object fromP, Object toP)
 	{
 		return (fromP instanceof Relation && toP instanceof Relation);
 	}
 
 	/*** Contruct and add a new edge of a kind determined by the ports */
 	public Object connect(Object fromPort, Object toPort)
 	{
 		return connect(fromPort, toPort, ForeignKey.class);
 	}
 
 	/*** Contruct and add a new edge of the given kind */
 	public Object connect(Object fromPort, Object toPort, Class edgeClass)
 	{
 		if (fromPort instanceof Relation && 
 		    toPort instanceof Relation &&
 		    edgeClass == ForeignKey.class)
 		{
 			Relation fromRelation = (Relation) fromPort;
 			Relation toRelation = (Relation) toPort;
 			ForeignKey key = fromRelation.createForeignKey(toRelation);
 			addEdge(key);
 			return key;
 		}
 		System.out.println("connect: Cannot make a "+ edgeClass.getName() +
 		                   " between a " + fromPort.getClass().getName() +
 		                   " and a " + toPort.getClass().getName());
 		return null;
 	}
 
 	//////////////////////////////////////////////////////////
 	// Event notification
 	/***
 	 * This method provides a signature taking a node or edge as an argument
 	 * (unlike the method in MutableGraphSupport, which takes no arguments).
 	 */
 	public void fireGraphChanged(Object nodeOrEdge)
 	{
 		//System.err.println("(graphmodel) fireGraphChanged called!");
 		if (_graphListeners == null) return;
 		GraphEvent ge = new GraphEvent(this, nodeOrEdge);
 		Iterator listeners = _graphListeners.iterator();
 		while (listeners.hasNext())
 		{
 			GraphListener listener = (GraphListener) listeners.next();
 			listener.graphChanged(ge);
 		}
 	}
 	
 } /* end class ERDiagramGraphModel */