NodeShuffler/src/Model/LayeredNode.java

package Model;

import java.util.ArrayList;

import org.eclipse.elk.graph.ElkEdge;
import org.eclipse.elk.graph.ElkNode;

/**
 * Die Implementation eines Knotens in einem Layered Graph
 * 
 * @author kolja
 *
 */
public class LayeredNode implements LayeredGraphNode {

    // for this node
    private ElkNode original;
    private LayeredGraphNode parent;
    
    double x;
    double y;
    double w;
    double h;
    
    String name;
    
    // for subgraph in this node
    private ArrayList< LayeredGraphEdge > edges;
    private ArrayList< LayeredGraphNode > nodes;
    private ArrayList< ArrayList< LayeredGraphNode > > layers;
    
    public LayeredNode( ElkNode original, LayeredGraphNode parent )
    {
        this.original = original;
        this.parent = parent;
        
        edges = new ArrayList<>();
        nodes = new ArrayList<>();
        layers = new ArrayList<>();
        w = 10;
        h = 10;
    }
    
    @Override
    public void setName( String n ) {
    	name = n;
    }
    
    @Override
    public String getName()
    {
    	return name;
    }
    
    @Override
    public ElkNode getOriginalNode() {
        return original;
    }

    @Override
    public void remove() {
        parent.removeNode( this );
    }

    @Override
    public LayeredGraphNode parent() {
        return parent;
    }

    @Override
    public void setLayer(int index) {
        parent.setNodeLayer( this, index );
    }

    @Override
    public int getLayer() {
        return parent.getNodeLayer( this );
    }

    @Override
    public void setX(double x) {
        if( original != null )
            original.setX( x );
        this.x = x;
    }

    @Override
    public void setY(double y) {
        if( original != null )
            original.setY( y );
        this.y = y;
    }

    @Override
    public double getX() {
        return x;
    }

    @Override
    public double getY() {
        return y;
    }

    @Override
    public double getWidth() {
        if( original != null )
            return original.getWidth();
        if( nodes.size() > 0 )
        {
        	double max = 0;
        	for( LayeredGraphNode n : nodes )
        	{
        		if( max < n.getX() + n.getWidth() )
        			max = n.getX() + n.getWidth();
        	}
        	return Math.max( max, w );
        }
        return w;
    }

    @Override
    public double getHeight() {
        if( original != null )
            return original.getHeight();
        if( nodes.size() > 0 )
        {
        	double max = 0;
        	for( LayeredGraphNode n : nodes )
        	{
        		if( max < n.getY() + n.getHeight() )
        			max = n.getY() + n.getHeight();
        	}
        	return Math.max( max, h );
        }
        return h;
    }

    @Override
    public void removeEdge(LayeredGraphEdge e) {
        edges.remove( e );
    }

    @Override
    public void removeNode(LayeredGraphNode n) {
        for( LayeredGraphEdge e : n.getIncomingEdges() )
            e.remove();
        for( LayeredGraphEdge e : n.getOutgoingEdges() )
            e.remove();
        nodes.remove( n );
        for( ArrayList<LayeredGraphNode> l : layers )
        {
            l.remove( n );
        }
    }

    @Override
    public void setNodeLayer(LayeredGraphNode n, int index) {
        while( index >= layers.size() )
            layers.add( new ArrayList<>() );
        int old = n.getLayer();
        if( old >= 0 )
            layers.get( old ).remove( n );
        layers.get( index ).add( n );
    }

    @Override
    public void setOrderedLayer(ArrayList<Double> indizes, int layerIndex) {
        ArrayList<LayeredGraphNode> l2 = layers.get( layerIndex );
        ArrayList<LayeredGraphNode> result = new ArrayList<LayeredGraphNode>();
        while( indizes.size() > 0 )
        {
            int mIndex = 0;
            double min = indizes.get( 0 );
            for( int i = 1; i < indizes.size(); i++ )
            {
                if( min > indizes.get( i ) )
                {
                    mIndex = i;
                    min = indizes.get( i );
                }
            }
            result.add( l2.get( mIndex ) );
            l2.remove( mIndex );
            indizes.remove( mIndex );
        }
        layers.set( layerIndex, result );
    }
    
    @Override
    public ArrayList<LayeredGraphEdge> getOutgoingEdges() {
        return parent.getOutgoingEdges( this );
    }

    @Override
    public ArrayList<LayeredGraphEdge> getIncomingEdges() {
        return parent.getIncomingEdges( this );
    }

    @Override
    public ArrayList<LayeredGraphEdge> getContainedEdges() {
        return edges;
    }

    @Override
    public ArrayList<LayeredGraphNode> getContainedNodes() {
        return nodes;
    }

    @Override
    public ArrayList<ArrayList<LayeredGraphNode>> getContainedLayers() {
        return layers;
    }

    @Override
    public int getNodeLayer(LayeredGraphNode n) {
        for( int i = 0; i < layers.size(); i++ )
        {
            if( layers.get( i ).contains( n ) )
                return i;
        }
        return -1;
    }

    @Override
    public ArrayList<LayeredGraphEdge> getOutgoingEdges(LayeredGraphNode n) {
        ArrayList<LayeredGraphEdge> result = new ArrayList<>();
        for( LayeredGraphEdge e : edges )
        {
            if( e.getSources().contains( n ) )
                result.add( e );
        }
        return result;
    }

    @Override
    public ArrayList<LayeredGraphEdge> getIncomingEdges(LayeredGraphNode n) {
        ArrayList<LayeredGraphEdge> result = new ArrayList<>();
        for( LayeredGraphEdge e : edges )
        {
            if( e.getTargets().contains( n ) )
                result.add( e );
        }
        return result;
    }

    @Override
    public LayeredGraphNode createNode(ElkNode original) {
        LayeredGraphNode n = new LayeredNode( original, this );
        nodes.add( n );
        return n;
    }

    @Override
    public LayeredGraphEdge createEdge(ElkEdge original, ArrayList<LayeredGraphNode> sources, ArrayList<LayeredGraphNode> targets) {
        LayeredGraphEdge e = new LayeredEdge( original, sources, targets, this );
        edges.add( e );
        return e;
    }

    @Override
    public LayeredGraphEdge createSimpleEdge(ElkEdge original, LayeredGraphNode source, LayeredGraphNode target) {
        ArrayList<LayeredGraphNode> sources = new ArrayList<>();
        ArrayList<LayeredGraphNode> targets = new ArrayList<>();
        sources.add( source );
        targets.add( target );
        LayeredGraphEdge e = new LayeredEdge( original, sources, targets, this );
        edges.add( e );
        return e;
    }
    
    @Override
    public LayeredGraphEdge findEdgeFromOriginal(Object original) {
        for( LayeredGraphEdge e : edges )
        {
            if( e.getOriginalEdge() == original )
                return e;
        }
        return null;
    }

    @Override
    public LayeredGraphNode findNodeFromOriginal(Object original) {
        for( LayeredGraphNode n : nodes )
        {
            if( n.getOriginalNode() == original )
                return n;
        }
        return null;
    }
    
    @Override
    public LayeredGraphNode findNodeByName( String name )
    {
    	for( LayeredGraphNode n : nodes )
        {
            if( n.getName() == name )
                return n;
        }
        return null;	
    }

    @Override
    public void addNode(LayeredGraphNode n) {
        nodes.add( n );
        n.setParent( this );
    }

    @Override
    public void addEdge(LayeredGraphEdge e) {
        edges.add( e );
        e.setGraph( this );
    }

    @Override
    public void setParent(LayeredGraphNode parent) {
        this.parent = parent;
    }
}