DirectedGraph.java

/*******************************************************************************
 * Copyright (c) 2003, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.draw2d.graph;

import org.eclipse.draw2d.PositionConstants;
import org.eclipse.draw2d.geometry.Dimension;
import org.eclipse.draw2d.geometry.Insets;

/**
 * A graph consisting of nodes and directed edges.  A DirectedGraph serves as the input to
 * a graph layout algorithm.  The algorithm will place the graph's nodes and edges
 * according to certain goals, such as short, non-crossing edges, and readability.
 * 
 * @author hudsonr
 * @since 2.1.2
 */
public class DirectedGraph {

private int direction = PositionConstants.SOUTH;

/**
 * The default padding to be used for nodes which don't specify any padding.  Padding is
 * the amount of empty space to be left around a node.  The default value is undefined.
 */
private Insets defaultPadding = new Insets(16);

/**
 * All of the edges in the graph.
 */
public EdgeList edges = new EdgeList();

/**
 * All of the nodes in the graph.
 */
public NodeList nodes = new NodeList();

/**
 * For internal use only. The list of rows which makeup the final graph layout.
 * @deprecated
 */
public RankList ranks = new RankList();

Node forestRoot;
Insets margin = new Insets();
int[] rankLocations;
int[][] cellLocations;
int tensorStrength;
int tensorSize;
Dimension size = new Dimension();

/**
 * Returns the default padding for nodes.
 * @return the default padding
 * @since 3.2
 */
public Insets getDefaultPadding() {
	return defaultPadding;
}

/**
 * Returns the direction in which the graph will be layed out.
 * @return the layout direction
 * @since 3.2
 */
public int getDirection() {
	return direction;
}

/**
 * Sets the outer margin for the entire graph. The margin is the space in which nodes
 * should not be placed.
 * @return the graph's margin
 * @since 3.2
 */
public Insets getMargin() {
	return margin;
}

/**
 * Returns the effective padding for the given node.  If the node has a specified padding,
 * it will be used, otherwise, the graph's defaultPadding is returned.  The
 * returned value must not be modified.
 * @param node the node
 * @return the effective padding for that node
 */
public Insets getPadding(Node node) {
	Insets pad = node.getPadding();
	if (pad == null)
		return defaultPadding;
	return pad;
}

int[] getCellLocations(int rank) {
	return cellLocations[rank];
}

int[] getRankLocations() {
	return rankLocations;
}
//
//public Cell getCell(Point pt) {
//	int rank = 0;
//	while (rank < rankLocations.length - 1 && rankLocations[rank] < pt.y)
//		rank++;
//	int cells[] = cellLocations[rank];
//	int cell = 0;
//	while (cell < cells.length - 1 && cells[cell] < pt.x)
//		cell++;
//	return new Cell(rank, cell, ranks.getRank(rank).getNode(index));
//}

public Node getNode(int rank, int index) {
	if (ranks.size() <= rank)
		return null;
	Rank r = ranks.getRank(rank);
	if (r.size() <= index)
		return null;
	return r.getNode(index);
}

/**
 * Removes the given edge from the graph.
 * @param edge the edge to be removed
 */
public void removeEdge(Edge edge) {
	edges.remove(edge);
	edge.source.outgoing.remove(edge);
	edge.target.incoming.remove(edge);
	if (edge.vNodes != null)
		for (int j = 0; j < edge.vNodes.size(); j++)
			removeNode(edge.vNodes.getNode(j));
}

/**
 * Removes the given node from the graph. Does not remove the node's edges.
 * @param node the node to remove
 */
public void removeNode(Node node) {
	nodes.remove(node);
	if (ranks != null)
		ranks.getRank(node.rank).remove(node);
}

/**
 * Sets the default padding for all nodes in the graph.  Padding is the empty space left
 * around the <em>outside</em> of each node.  The default padding is used for all nodes
 * which do not specify a specific amount of padding (i.e., their padding is
 * <code>null</code>).
 * @param insets the padding
 */
public void setDefaultPadding(Insets insets) {
	defaultPadding = insets;
}

/**
 * Sets the layout direction for the graph. Edges will be layed out in the specified
 * direction (unless the graph contains cycles). Supported values are:
 * <UL>
 * <LI>{@link org.eclipse.draw2d.PositionConstants#EAST}
 * <LI>{@link org.eclipse.draw2d.PositionConstants#SOUTH}
 * </UL>
 * <P>The default direction is south.
 * @param direction the layout direction
 * @since 3.2
 */
public void setDirection(int direction) {
	this.direction = direction;
}

//public void setGraphTensor(int length, int strength) {
//	tensorStrength = strength;
//	tensorSize = length;
//}

/**
 * Sets the graphs margin.
 * @param insets the graph's margin
 * @since 3.2
 */
public void setMargin(Insets insets) {
	this.margin = insets;
}

public Dimension getLayoutSize() {
	return size;
}

}