org.eclipse.draw2d.graph.Node Maven / Gradle / Ivy
/*******************************************************************************
* Copyright (c) 2003, 2010, 2012 IBM Corporation, Gerhardt Informatics Kft. 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
* Gerhardt Informatics Kft. - GEFGWT port
*******************************************************************************/
package org.eclipse.draw2d.graph;
import java.util.Iterator;
import org.eclipse.draw2d.geometry.Dimension;
import org.eclipse.draw2d.geometry.Insets;
/**
* A node in a DirectedGraph. A node has 0 or more incoming and outgoing
* {@link Edge}s. A node is given a width and height by the client. When a
* layout places the node in the graph, it will determine the node's x and y
* location. It may also modify the node's height.
*
* A node represents both the input and the output for a
* layout algorithm. The following fields are used as input to a graph layout:
*
* - {@link #width} - the node's width.
*
- {@link #height} - the node's height.
*
- {@link #outgoing} - the node's outgoing edges.
*
- {@link #incoming} - the node's incoming edges.
*
- padding - the amount of space to be left around the outside of the node.
*
- {@link #incomingOffset} - the default attachment point for incoming
* edges.
*
- {@link #outgoingOffset} - the default attachment point for outgoing
* edges.
*
- parent - the parent subgraph containing this node.
*
*
* The following fields are calculated by a graph layout and comprise the
* output:
*
* - {@link #x} - the node's x location
*
- {@link #y} - the node's y location
*
- {@link #height} - the node's height may be stretched to match the height
* of other nodes
*
*
* @author Randy Hudson
* @since 2.1.2
*/
public class Node {
Node left, right;
Object workingData[] = new Object[3];
int workingInts[] = new int[4];
/**
* Clients may use this field to mark the Node with an arbitrary data
* object.
*/
public Object data;
// used by various graph visitors
boolean flag;
/**
* The height of this node. This value should be set prior to laying out the
* directed graph. Depending on the layout rules, a node's height may be
* expanded to match the height of other nodes around it.
*/
public int height = 40;
/**
* @deprecated use {@link #setRowConstraint(int)} and
* {@link #getRowConstraint()}
*/
public int rowOrder = -1;
/**
* The edges for which this node is the target.
*/
public EdgeList incoming = new EdgeList();
/**
* The default attachment point for incoming edges. -1
* indicates that the node's horizontal center should be used.
*/
public int incomingOffset = -1;
// A non-decreasing number given to consecutive nodes in a Rank.
int index;
// Used in Compound graphs to quickly determine whether a node is inside a
// subgraph.
int nestingIndex = -1;
/**
* The edges for which this node is the source.
*/
public EdgeList outgoing = new EdgeList();
Insets padding;
private Subgraph parent;
int rank;
/**
* @deprecated for internal use only
*/
public double sortValue;
/**
* The node's outgoing offset attachment point.
*/
public int outgoingOffset = -1;
/**
* The node's width. The default value is 50.
*/
public int width = 50;
/**
* The node's x coordinate.
*/
public int x;
/**
* The node's y coordinate.
*/
public int y;
/**
* Constructs a new node.
*/
public Node() {
}
/**
* Constructs a node with the given data object
*
* @param data
* an arbitrary data object
*/
public Node(Object data) {
this(data, null);
}
/**
* Constructs a node inside the given subgraph.
*
* @param parent
* the parent subgraph
*/
public Node(Subgraph parent) {
this(null, parent);
}
/**
* Constructs a node with the given data object and parent subgraph. This
* node is added to the set of members for the parent subgraph
*
* @param data
* an arbitrary data object
* @param parent
* the parent subgraph or null
*/
public Node(Object data, Subgraph parent) {
this.data = data;
this.parent = parent;
if (parent != null)
parent.addMember(this);
}
/**
* Returns the incoming attachment point. This is the distance from the left
* edge to the default incoming attachment point for edges. Each incoming
* edge may have it's own attachment setting which takes priority over this
* default one.
*
* @return the incoming offset
*/
public int getOffsetIncoming() {
if (incomingOffset == -1)
return width / 2;
return incomingOffset;
}
/**
* Returns the outgoing attachment point. This is the distance from the left
* edge to the default outgoing attachment point for edges. Each outgoing
* edge may have it's own attachment setting which takes priority over this
* default one.
*
* @return the outgoing offset
*/
public int getOffsetOutgoing() {
if (outgoingOffset == -1)
return width / 2;
return outgoingOffset;
}
/**
* Returns the padding for this node or null if the default
* padding for the graph should be used.
*
* @return the padding or null
*/
public Insets getPadding() {
return padding;
}
/**
* Returns the parent Subgraph or null if there is no parent.
* Subgraphs are only for use in {@link CompoundDirectedGraphLayout}.
*
* @return the parent or null
*/
public Subgraph getParent() {
return parent;
}
/**
* For internal use only. Returns true if the given node is
* equal to this node. This method is implemented for consitency with
* Subgraph.
*
* @param node
* the node in question
* @return true if nested
*/
boolean isNested(Node node) {
return node == this;
}
/**
* Sets the padding. null indicates that the default padding
* should be used.
*
* @param padding
* an insets or null
*/
public void setPadding(Insets padding) {
this.padding = padding;
}
/**
* Sets the parent subgraph. This method should not be called directly. The
* constructor will set the parent accordingly.
*
* @param parent
* the parent
*/
public void setParent(Subgraph parent) {
this.parent = parent;
}
/**
* Sets the row sorting constraint for this node. By default, a node's
* constraint is -1. If two nodes have different values both >=
* 0, the node with the smaller constraint will be placed to the left of the
* other node. In all other cases no relative placement is guaranteed.
*
* @param value
* the row constraint
* @since 3.2
*/
public void setRowConstraint(int value) {
this.rowOrder = value;
}
/**
* Returns the row constraint for this node.
*
* @return the row constraint
* @since 3.2
*/
public int getRowConstraint() {
return rowOrder;
}
/**
* Sets the size of this node to the given dimension.
*
* @param size
* the new size
* @since 3.2
*/
public void setSize(Dimension size) {
width = size.width;
height = size.height;
}
/**
* @see Object#toString()
*/
public String toString() {
return "N(" + data + ")"; //$NON-NLS-1$ //$NON-NLS-2$
}
Iterator iteratorNeighbors() {
return new Iterator() {
int offset;
EdgeList list = outgoing;
public Object next() {
Edge edge = list.getEdge(offset++);
if (offset < list.size())
return edge.opposite(Node.this);
if (list == outgoing) {
list = incoming;
offset = 0;
} else
list = null;
return edge.opposite(Node.this);
}
public boolean hasNext() {
if (list == null)
return false;
if (offset < list.size())
return true;
if (list == outgoing) {
list = incoming;
offset = 0;
}
return offset < list.size();
}
public void remove() {
throw new RuntimeException("Remove not supported"); //$NON-NLS-1$
}
};
}
/**
* Returns a reference to a node located left from this one
*
* @return Node on the left from this one
* @since 3.4
*/
public Node getLeft() {
return left;
}
/**
* Returns a reference to a node located right from this one
*
* @return Node on the right from this one
* @since 3.4
*/
public Node getRight() {
return right;
}
}