NodeShuffler/src/Model/LayeredEdge.java

package Model;

import java.awt.Point;
import java.util.ArrayList;

import org.eclipse.elk.graph.ElkEdge;

/**
 * Die Implementation einer Kante aus einem Layered Graphen
 * 
 * @author kolja
 *
 */
public class LayeredEdge implements LayeredGraphEdge {

    ElkEdge original;
    ArrayList< LayeredGraphNode > sources;
    ArrayList< LayeredGraphNode > targets;
    LayeredGraphNode graph;
    boolean reversed;
    boolean dummy;
    ArrayList< Point > bindPoints;
    
    public LayeredEdge( ElkEdge original, ArrayList< LayeredGraphNode > sources, ArrayList< LayeredGraphNode > targets, LayeredGraphNode graph )
    {
        this.original = original;
        this.sources = sources;
        this.targets = targets;
        this.graph = graph;
        reversed = false;
        dummy = false;
        bindPoints = new ArrayList<>();
        bindPoints.add( null );
        bindPoints.add( null );
    }

    @Override
    public void setStartPoint( int x, int y )
    {
        bindPoints.set( 0, new Point( x, y ) );
    }
    
    @Override
    public void addBindPoint( int x, int y )
    {
        bindPoints.add( bindPoints.size() - 1, new Point( x, y ) );
    }
    
    @Override
    public void setEndPoint( int x, int y )
    {
        bindPoints.set( bindPoints.size() - 1, new Point( x, y ) );
    }

    @Override
    public ArrayList<Point> getLinePoints()
    {
        //if( bindPoints.get( 0 ) == null && sources.size() > 0 )
        //{
            setStartPoint( (int)sources.get( 0 ).getX() + (int)sources.get( 0 ).getWidth() / 2, (int)sources.get( 0 ).getY() + (int)sources.get( 0 ).getHeight() );
        //}
        //if( bindPoints.get( bindPoints.size() - 1 ) == null && targets.size() > 0 )
        //{
            setEndPoint( (int)targets.get( 0 ).getX() + (int)targets.get( 0 ).getWidth() / 2, (int)targets.get( 0 ).getY() );
        //}
        return bindPoints;
    }
    
    @Override
    public ElkEdge getOriginalEdge() {
        return original;
    }

    @Override
    public void remove() {
        graph.removeEdge( this );
    }

    @Override
    public ArrayList<LayeredGraphNode> getSources() {
        return sources;
    }

    @Override
    public ArrayList<LayeredGraphNode> getTargets() {
        return targets;
    }

    @Override
    public boolean isCrossLayerEdge() {
        int sl = sources.get( 0 ).getLayer();
        for( LayeredGraphNode s : sources )
        {
            if( sl != s.getLayer() )
                return true;
        }
        int tl = targets.get( 0 ).getLayer();
        if( Math.abs( tl - sl ) != 1 )
            return true;
        for( LayeredGraphNode t : targets )
        {
            if( tl != t.getLayer() )
                return true;
        }
        return false;
    }

    @Override
    public void replaceByDummyNodes() {
        if( isCrossLayerEdge() )
        {
            remove();
            if( sources.size() == 1 && targets.size() == 1 )
            {
                LayeredGraphNode last = sources.get( 0 );
                int sl = last.getLayer();
                int tl = targets.get( 0 ).getLayer();
                for( int i = sl + 1; i < tl; i++ )
                {
                    LayeredGraphNode n = graph.createNode( null );
                    n.setLayer( i );
                    LayeredGraphEdge e = graph.createSimpleEdge( original, last, n );
                    e.setDummyEdge();
                    if( reversed )
                        e.setReversedEdge();
                    last = n;
                }
                LayeredGraphEdge e = graph.createSimpleEdge( original, last, targets.get( 0 ) );
                e.setDummyEdge();
                if( reversed )
                    e.setReversedEdge();
            }
        }
    }

    @Override
    public void reverse() {
        reversed = !reversed;
        ArrayList< LayeredGraphNode > tmp = sources;
        sources = targets;
        targets = tmp;
    }

    @Override
    public boolean isDummyEdge() {
        return dummy;
    }

    @Override
    public void removeDummyNodes() {
        if( isDummyEdge() )
        {
            remove();
            ArrayList< LayeredGraphNode > sours = sources;
            for( int i = 0; i < sours.size(); i++ )
            {
                LayeredGraphNode n = sours.get( i );
                if( n.getOriginalNode() == null )
                {
                    sours.remove( n );
                    for( LayeredGraphEdge e : n.getIncomingEdges() )
                    {
                        if( e.isDummyEdge() && e.getOriginalEdge() == original )
                            sours.addAll( e.getSources() );
                    }
                }
            }
            ArrayList< LayeredGraphNode > targs = targets;
            for( int i = 0; i < targs.size(); i++ )
            {
                LayeredGraphNode n = targs.get( i );
                if( n.getOriginalNode() == null )
                {
                    targs.remove( n );
                    for( LayeredGraphEdge e : n.getOutgoingEdges() )
                    {
                        if( e.isDummyEdge() && e.getOriginalEdge() == original )
                            targs.addAll( e.getTargets() );
                    }
                }
                    
            }
            LayeredGraphEdge e = graph.createEdge( original, sours, targs );
            if( reversed )
                e.setReversedEdge();
        }
    }

    @Override
    public void setDummyEdge() {
        dummy = true;
    }

    @Override
    public void setReversedEdge() {
        reversed = true;
    }

    @Override
    public void setGraph(LayeredGraphNode graph) {
        this.graph = graph;
    }

    @Override
    public boolean isReversedEdge() {
        return reversed;
    }
}