klappt irgendwie noch nicht ganz

.classpath

@@ -2,5 +2,25 @@
 <classpath>
 	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
 	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="lib" path="C:/Users/kolja/graphdrawing-master/NodePlacementAnimation/lib/guava-18.0-sources.jar"/>
+	<classpathentry kind="lib" path="C:/Users/kolja/graphdrawing-master/NodePlacementAnimation/lib/org.eclipse.elk.alg.common.compaction-0.3.0.jar"/>
+	<classpathentry kind="lib" path="C:/Users/kolja/graphdrawing-master/NodePlacementAnimation/lib/org.eclipse.elk.alg.common.compaction-0.3.0-sources.jar"/>
+	<classpathentry kind="lib" path="C:/Users/kolja/graphdrawing-master/NodePlacementAnimation/lib/org.eclipse.elk.alg.force-0.3.0.jar"/>
+	<classpathentry kind="lib" path="C:/Users/kolja/graphdrawing-master/NodePlacementAnimation/lib/org.eclipse.elk.alg.force-0.3.0-sources.jar"/>
+	<classpathentry kind="lib" path="C:/Users/kolja/graphdrawing-master/NodePlacementAnimation/lib/org.eclipse.elk.alg.layered-0.3.0.jar"/>
+	<classpathentry kind="lib" path="C:/Users/kolja/graphdrawing-master/NodePlacementAnimation/lib/org.eclipse.elk.alg.layered-0.3.0-sources.jar"/>
+	<classpathentry kind="lib" path="C:/Users/kolja/graphdrawing-master/NodePlacementAnimation/lib/org.eclipse.elk.alg.mrtree-0.3.0.jar"/>
+	<classpathentry kind="lib" path="C:/Users/kolja/graphdrawing-master/NodePlacementAnimation/lib/org.eclipse.elk.alg.mrtree-0.3.0-sources.jar"/>
+	<classpathentry kind="lib" path="C:/Users/kolja/graphdrawing-master/NodePlacementAnimation/lib/org.eclipse.elk.core-0.3.0.jar"/>
+	<classpathentry kind="lib" path="C:/Users/kolja/graphdrawing-master/NodePlacementAnimation/lib/org.eclipse.elk.core-0.3.0-sources.jar"/>
+	<classpathentry kind="lib" path="C:/Users/kolja/graphdrawing-master/NodePlacementAnimation/lib/org.eclipse.elk.graph-0.3.0.jar"/>
+	<classpathentry kind="lib" path="C:/Users/kolja/graphdrawing-master/NodePlacementAnimation/lib/org.eclipse.elk.graph-0.3.0-sources.jar"/>
+	<classpathentry kind="lib" path="C:/Users/kolja/graphdrawing-master/NodePlacementAnimation/lib/org.eclipse.emf.common-2.12.0.jar"/>
+	<classpathentry kind="lib" path="C:/Users/kolja/graphdrawing-master/NodePlacementAnimation/lib/org.eclipse.emf.common-2.12.0-sources.jar"/>
+	<classpathentry kind="lib" path="C:/Users/kolja/graphdrawing-master/NodePlacementAnimation/lib/org.eclipse.emf.ecore.xmi-2.12.0.jar"/>
+	<classpathentry kind="lib" path="C:/Users/kolja/graphdrawing-master/NodePlacementAnimation/lib/org.eclipse.emf.ecore.xmi-2.12.0-sources.jar"/>
+	<classpathentry kind="lib" path="C:/Users/kolja/graphdrawing-master/NodePlacementAnimation/lib/org.eclipse.emf.ecore-2.12.0.jar"/>
+	<classpathentry kind="lib" path="C:/Users/kolja/graphdrawing-master/NodePlacementAnimation/lib/org.eclipse.emf.ecore-2.12.0-sources.jar"/>
+	<classpathentry kind="lib" path="C:/Users/kolja/graphdrawing-master/NodePlacementAnimation/lib/java-json.jar"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>

src/Main.java

@@ -0,0 +1,14 @@
+import Model.LayeredGraphNode;
+import View.MainView;
+import inputReader.Reader;
+
+public class Main {
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+		Reader r = new Reader( "test.graph" );
+		LayeredGraphNode graph = r.readInputGraph();
+		new MainView( graph );
+	}
+
+}

src/Model/LayeredEdge.java

@@ -0,0 +1,171 @@
+package Model;
+
+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;
+    
+    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;
+    }
+    
+    @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;
+    }
+}

src/Model/LayeredGraphEdge.java

@@ -0,0 +1,76 @@
+ package Model;
+
+import java.util.ArrayList;
+
+import org.eclipse.elk.graph.ElkEdge;
+
+/**
+ * Ein Interface, welches die Methoden einer Kante aus einem gelayerten Graphen beschreibt
+ * @author kolja
+ *
+ */
+public interface LayeredGraphEdge {
+
+    /**
+     * @return Gibt die originale Kante des Elk Graphen zurück
+     */
+    ElkEdge getOriginalEdge();
+    
+    /**
+     * Entfernt diese Kante vom Graphen
+     */
+    void remove();
+    /**
+     * Gibt eine Liste mit Knoten zurück, von welchen die Kante beginnt
+     * @return Liste mit Startknoten
+     */
+    ArrayList< LayeredGraphNode > getSources();
+    /**
+     * Gibt eine Liste mit Knoten zurück, bei welchen die Kante endet
+     * @return Liste mit Endknoten
+     */
+    ArrayList< LayeredGraphNode > getTargets();
+    /**
+     * Prüft, ob die Kante über mehrere Layer hinweg geht
+     * @return true, falls die Kante über mehrere Layer hinweg geht
+     */
+    boolean isCrossLayerEdge();
+    /**
+     * Für jeden Layer über den die Kante geht wird ein Dummy Node erzeugt.
+     * Diese werden durch Dummy Kanten verbunden, welche diese Kante ersetzen.
+     * Die Kante wird automatisch aus dem Graphen entfernt
+     */
+    void replaceByDummyNodes();
+    /**
+     * Dreht die Kante um, indem die Startknoten mit den Endknoten getauscht werden
+     */
+    void reverse();
+    /**
+     * Prüft, ob die Kante umgedreht wurde
+     * @return true, falls die Kante umgedreht wurde
+     */
+    boolean isReversedEdge();
+    /**
+     * Prüft, ob die Kante eine Dummy Kante ist (also ob sie von einem Dummy Knoten startet oder zu einem DummyKnoten hinführt)
+     * @return true, falls die Kante eine Dummy Kante ist
+     */
+    boolean isDummyEdge();
+    /**
+     * Ermittelt, welche für welche originale Kante diese Kante als Dummykante eingesetzt wurd
+     * und entfernt all die Dummynodes und Dummykanten wieder. Anschließend wird die alte Kante wieder zum Graphen hinzugefügt
+     */
+    void removeDummyNodes();
+    /**
+     * Legt fest, dass es sich bei dieser Kante um eine Dummykante handelt
+     */
+    void setDummyEdge();
+    /**
+     * Legt fest, dass es sich bei dieser Kante um eine umgedrehte Kante handelt
+     */
+    void setReversedEdge();
+    /**
+     * Legt den Graphen fest, zu dem diese Kante gehört
+     * @param graph Der Graph, zu dem die Kante gehört
+     */
+    void setGraph( LayeredGraphNode graph );
+}

src/Model/LayeredGraphNode.java

@@ -0,0 +1,192 @@
+package Model;
+
+import java.util.ArrayList;
+
+import org.eclipse.elk.graph.ElkEdge;
+import org.eclipse.elk.graph.ElkNode;
+
+/**
+ * Ein Interface, welches die Methoden eines Knotens aus einem gelayerten Graphen beschreibt (Ein Knoten kann dabei auch einen weiteren Graphen beinhalten)
+ * @author kolja
+ *
+ */
+public interface LayeredGraphNode {
+    
+    // for this node
+    
+    /**
+     * Gibt den originalen Elk Knoten zurück
+     * @return
+     */
+    ElkNode getOriginalNode();
+    
+    public void setName( String n );
+    public String getName();
+    /**
+     * Setzt den Index des Layers, zu dem der Knoten gehören soll
+     * @param index Der Index mit 0 beginnend
+     */
+    void setLayer( int index );
+    /**
+     * Gibt den Index des Layers zurück, dem dieser Knoten angehört
+     * @return Der Index des Layers mit 0 beginnend
+     */
+    int getLayer();
+    /**
+     * Entfernt den Knoten aus dem Graphen
+     */
+    void remove();
+    /**
+     * Ermittelt eine Liste von Kanten, die an diesem Knoten beginnen
+     * @return Liste mit Kanten
+     */
+    ArrayList< LayeredGraphEdge > getOutgoingEdges();
+    /**
+     * Ermittelt eine Liste von Kanten, die an diesem Knoten enden
+     * @return Liste mit Kanten
+     */
+    ArrayList< LayeredGraphEdge > getIncomingEdges();
+    /**
+     * Gibt den Knoten zurück, zu dessen Subgraph dieser Knoten gehört
+     * @return Der Elternknoten
+     */
+    LayeredGraphNode parent();
+    /**
+     * Legt den Knoten fest, zu dessen Subgraph dieser Knoten gehört
+     * @param parent Der Elternknoten
+     */
+    void setParent( LayeredGraphNode parent );
+    /**
+     * Legt die X Koordinate des Knotens fest
+     * @param x die X Koordinate in Pixeln
+     */
+    void setX( double x );
+    /**
+     * Legt die Y Koordinate des Knotens Fest
+     * @param y die Y Koordinate in Pixeln
+     */
+    void setY( double y );
+    /**
+     * Gibt die X Koordinate zurück
+     * @return die X Koordinate in Pixeln zurück
+     */
+    double getX();
+    /**
+     * Gibt die Y Koordinate zurück
+     * @return die Y Koordinate in Pixeln zurück
+     */
+    double getY();
+    /**
+     * Gibt die Breite des Knotens zurück
+     * @return die Breite in Pixeln
+     */
+    double getWidth();
+    /**
+     * Gibt die Höhe des Knotens zurück
+     * @return die Höhe in Pixeln
+     */
+    double getHeight();
+    
+    // for subgraph
+    
+    /**
+     * Ermittelt den Index des Layers, dem ein Knoten angehört
+     * @param n der Knoten, zu dem der Layerindex gesucht wird
+     * @return der Index des Layers mit 0 beginnend
+     */
+    int getNodeLayer( LayeredGraphNode n );
+    /**
+     * Sortiert einen Layer nach bestimmten Gewichten
+     * Die Knoten mit dem geringsten Gewicht kommen vor den Knoten mit größerem Gewicht
+     * @param indizes Eine Liste mit einem Gewicht für jeden Knoten
+     * @param layerIndex Der Index des Layers, der sortiert werden soll
+     */
+    void setOrderedLayer( ArrayList< Double > indizes, int layerIndex );
+    /**
+     * Legt fest zu welchem Layer ein bestimmter Knoten gehört
+     * @param n Der Knoten
+     * @param index Der Index des Layers
+     */
+    void setNodeLayer( LayeredGraphNode n, int index );
+    /**
+     * @return Eine Liste mit allen Kanten des Subgraphen
+     */
+    ArrayList< LayeredGraphEdge > getContainedEdges();
+    /**
+     * @return Eine Liste mit allen Knoten des Subgraphen
+     */
+    ArrayList< LayeredGraphNode > getContainedNodes();
+    /**
+     * @return Eine Liste mit allen Layern des Subgraphen
+     */
+    ArrayList< ArrayList< LayeredGraphNode > > getContainedLayers();
+    /**
+     * Entfernt eine Kante aus dem Subgraph
+     * @param e die Kante, die entfernt werden soll
+     */
+    void removeEdge( LayeredGraphEdge e );
+    /**
+     * Entfernt einen Knoten aus dem Subgraph
+     * @param n der Knoten, die entfernt werden soll
+     */
+    void removeNode( LayeredGraphNode n );
+    /**
+     * Ermittelt eine Liste von ausgehenden Kanten eines Knotens
+     * @param n Der Knoten
+     * @return Die Liste mit Kanten
+     */
+    ArrayList< LayeredGraphEdge > getOutgoingEdges( LayeredGraphNode n );
+    /**
+     * Ermittelt eine Liste von eingehenden Kanten eines Knotens
+     * @param n Der Knoten
+     * @return Die Liste mit Kanten
+     */
+    ArrayList< LayeredGraphEdge > getIncomingEdges( LayeredGraphNode n );
+    
+    /**
+     * Fügt einen neuen Knoten zum Subgraph hinzu
+     * @param original Der originale Elk Knoten
+     * @return Der neu erzeugte Knoten
+     */
+    LayeredGraphNode createNode( ElkNode original );
+    /**
+     * Fügt eine neue Kante zum Subgraph hinzu
+     * @param original Die Originale Elk Kante
+     * @param sources Eine Liste mit Startknoten
+     * @param targets Eine Liste mit Endknoten
+     * @return Die neue Kante
+     */
+    LayeredGraphEdge createEdge( ElkEdge original, ArrayList< LayeredGraphNode > sources, ArrayList< LayeredGraphNode > targets );
+    /**
+     * Fügt eine neue Kante zum Subgraph hinzu
+     * @param original Die Originale Elk Kante
+     * @param sources Der Startknoten
+     * @param targets Der Endknoten
+     * @return Die neue Kante
+     */
+    LayeredGraphEdge createSimpleEdge( ElkEdge original, LayeredGraphNode source, LayeredGraphNode target );
+    /**
+     * Findet zu einer Originalen Kante eine Layered Kante
+     * @param original die originale Kante
+     * @return die layered Kante
+     */
+    LayeredGraphEdge findEdgeFromOriginal( Object original );
+    /**
+     * Findet zu einem Originalen Knoten einen Layered Knoten
+     * @param original der originale Knoten
+     * @return der layered Knoten
+     */
+    LayeredGraphNode findNodeFromOriginal( Object original );
+    
+    LayeredGraphNode findNodeByName( String name );
+    /**
+     * Fügt einen Knoten zum Subgraphen hinzu
+     * @param n Der neue Knoten
+     */
+    void addNode( LayeredGraphNode n );
+    /**
+     * Fügt eine Kante zum Subgraphen hinzu
+     * @param e Die neue Kante
+     */
+    void addEdge( LayeredGraphEdge e );
+}

src/Model/LayeredNode.java

@@ -0,0 +1,318 @@
+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;
+    }
+}

src/View/MainView.java

@@ -0,0 +1,36 @@
+package View;
+
+import javax.swing.JFrame;
+
+import Model.LayeredGraphNode;
+
+public class MainView {
+
+	JFrame frame;
+	
+	public MainView( LayeredGraphNode graph )
+	{
+		frame = new JFrame();
+		frame.setSize( (int)graph.getWidth() + 100, (int)graph.getHeight() + 100 );
+		frame.setLocation( 100, 100 );
+		frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
+		frame.setVisible( true );
+		frame.getContentPane().setLayout( null );
+		
+		frame.getContentPane().add( createNodeView( graph ) );
+		
+		frame.repaint();
+	}
+	
+	private NodeView createNodeView( LayeredGraphNode gNode )
+	{
+		NodeView graphView = new NodeView( gNode );
+		int x = 0;
+		for( LayeredGraphNode n : gNode.getContainedNodes() )
+		{
+			n.setX( x += 20 );
+			graphView.add( createNodeView( n ) );
+		}
+		return graphView;
+	}
+}

src/View/NodeView.java

@@ -0,0 +1,31 @@
+package View;
+
+import java.awt.Color;
+import java.awt.Graphics;
+
+import javax.swing.*;
+
+import Model.LayeredGraphNode;
+
+public class NodeView extends JPanel {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 1L;
+	private LayeredGraphNode model;
+	
+	public NodeView( LayeredGraphNode model ) {
+		this.model = model;
+		setLocation( (int)model.getX(), (int)model.getY() );
+		setSize( (int)model.getWidth(), (int)model.getHeight() );
+	}
+	
+	@Override
+	public void paintComponent( Graphics g )
+	{
+		System.out.print( "Drawing: Node " + model.getName() + " Position (" + model.getX() + "," + model.getY() + ") Size (" + model.getWidth() + "," + model.getHeight() + ")\n" );
+		g.setColor( Color.RED );
+		g.drawRect( (int)model.getX(), (int)model.getY(), (int)model.getWidth(), (int)model.getHeight() );
+	}
+}

src/inputReader/Reader.java

@@ -0,0 +1,89 @@
+package inputReader;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import Model.LayeredGraphEdge;
+import Model.LayeredGraphNode;
+import Model.LayeredNode;
+
+public class Reader {
+
+	private String fileName;
+	
+	public Reader( String inputFileName )
+	{
+		fileName = inputFileName;
+	}
+	
+	public LayeredGraphNode readInputGraph()
+	{
+		String file = "";
+		try {
+			BufferedReader r = new BufferedReader( new FileReader( fileName ) );
+			file += r.readLine();
+			r.close();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		try {
+			JSONObject json = new JSONObject( file );
+			return parseNode( json, null );
+		} catch (JSONException e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+	
+	private LayeredGraphNode parseNode( JSONObject node, LayeredGraphNode parent ) throws JSONException
+	{
+		LayeredGraphNode newNode = new LayeredNode( null, null );
+		if( parent != null )
+			newNode = parent.createNode( null );
+		if( node.has( "layers" ) )
+		{
+			JSONArray layers = node.getJSONArray( "layers" );
+			for( int i = 0; i < layers.length(); i++ )
+			{
+				for( LayeredGraphNode n : parseLayer( layers.getJSONArray( i ), newNode ) )
+					n.setLayer( i );
+			}
+		}
+		if( node.has( "edges" ) )
+		{
+			JSONArray edges = node.getJSONArray( "edges" );
+			for( int i = 0; i < edges.length(); i++ )
+			{
+				JSONObject edge = edges.getJSONObject( i );
+				newNode.addEdge( parseEdge( edge, newNode ) );
+			}
+		}
+		if( node.has( "name" ) )
+			newNode.setName( node.getString( "name" ) );
+		return newNode;
+	}
+	
+	private LayeredGraphEdge parseEdge( JSONObject edge, LayeredGraphNode parent ) throws JSONException
+	{
+		if( !edge.has( "source" ) || !edge.has( "target" ) )
+			throw new JSONException( edge + " is no valid Layered Graph Edge." );
+		return parent.createSimpleEdge( null, parent.findNodeByName( edge.getString( "source" ) ), parent.findNodeByName( edge.getString( "target" ) ) );
+	}
+	
+	private ArrayList<LayeredGraphNode> parseLayer( JSONArray layer, LayeredGraphNode parent ) throws JSONException
+	{
+		ArrayList<LayeredGraphNode> nodes = new ArrayList<>();
+		for( int i = 0; i < layer.length(); i++ )
+		{
+			JSONObject node = layer.getJSONObject( i );
+			nodes.add( parseNode( node, parent ) );
+		}
+		return nodes;
+	}
+}

test.graph

@@ -0,0 +1 @@
+{"layers": [[{"name": "n1"},{"name":"n2"}],[{"name":"n3"}]],"edges":[{"source":"n1","target":"n3"},{"source":"n2","target":"n3"}],"name":"n0"}