rename stuff and set visibility

src/bk/BlockCalc.java

@@ -136,14 +136,14 @@ public class BlockCalc implements AlgorithmStage {
 		boolean backwardsAdded = false;
 		for( int m : ms )
 		{
-		    if( current.getAlignedTo( layout ) == current )
+		    if( current.getAlign( layout ) == current )
 		    {
                 LayeredGraphNode u = null;
                 if( layout == LayoutType.TOP_BOTTOM_LEFT || layout == LayoutType.TOP_BOTTOM_RIGHT )
                     u = incommingEdges.get( m - 1 ).getSources().get( 0 );
                 if( layout == LayoutType.BOTTOM_TOP_LEFT || layout == LayoutType.BOTTOM_TOP_RIGHT )
                     u = incommingEdges.get( m - 1 ).getTargets().get( 0 );
-                ArrayList<LayeredGraphEdge> conflicts = incommingEdges.get( m - 1 ).calcConflictedEdges();
+                ArrayList<LayeredGraphEdge> conflicts = incommingEdges.get( m - 1 ).calcEdgeCrossings();
                 
 		        if( !incommingEdges.get( m - 1 ).isConflicted( layout ) && r < calcBeforeLayerNodeIndex( graph.getContainedLayers().get( calcBeforeLayerIndex() ).indexOf( u ) ) + 1 )
 		        {
@@ -154,15 +154,15 @@ public class BlockCalc implements AlgorithmStage {
 		        		oldConflicts.add( e.isConflicted( layout ) );
 		        		e.setConflicted( true, layout );
 		        	}
-		            LayeredGraphNode oldAlignU = u.getAlignedTo( layout );
+		            LayeredGraphNode oldAlignU = u.getAlign( layout );
 		            Color oldColorCurrent = current.getColor( layout );
 		            LayeredGraphNode oldRootCurrent = current.getRoot( layout );
-		            LayeredGraphNode oldAlignCurrent = current.getAlignedTo( layout );
+		            LayeredGraphNode oldAlignCurrent = current.getAlign( layout );
 		            int oldR = r;
-		            u.setAlignTo( current, layout );
+		            u.setAlign( current, layout );
 		            current.setColor( u.getRoot( layout ).getColor( layout ), layout );
 		            current.setRoot( u.getRoot( layout ), layout );
-		            current.setAlignTo( current.getRoot( layout ), layout );
+		            current.setAlign( current.getRoot( layout ), layout );
 		            r = calcBeforeLayerNodeIndex( graph.getContainedLayers().get( calcBeforeLayerIndex() ).indexOf( u ) ) + 1;
 		            int oldStep = step++;
 		            final LayeredGraphNode uf = u;
@@ -170,10 +170,10 @@ public class BlockCalc implements AlgorithmStage {
 		                System.out.println( "Stepping Backwards... (Step " + oldStep + ")" );
 			        	for( int i = 0; i < conflicts.size(); i++ )
 			        		conflicts.get( i ).setConflicted( oldConflicts.get( i ), layout );
-			        	uf.setAlignTo( oldAlignU, layout );
+			        	uf.setAlign( oldAlignU, layout );
 		                current.setColor( oldColorCurrent, layout );
 		                current.setRoot( oldRootCurrent, layout );
-		                current.setAlignTo( oldAlignCurrent, layout );
+		                current.setAlign( oldAlignCurrent, layout );
 		                r = oldR;
 		            });
 		            backwardsAdded = true;

src/bk/Compaction.java

@@ -211,7 +211,7 @@ public class Compaction implements AlgorithmStage{
 					else 
 					{ // w = align[w]
 						LayeredGraphNode oldW = sf.w;
-						sf.w = sf.w.getAlignedTo( layout );
+						sf.w = sf.w.getAlign( layout );
 						sf.w.setSelected( layout );
 						if( sf.w == sf.v ) // schleifenabbruchbedingung
 						{ //abbrechen, placeblock beendet
@@ -273,7 +273,7 @@ public class Compaction implements AlgorithmStage{
 					LayeredGraphNode oldW = sf.w;
                     LayeredGraphNode oldU = sf.u;
                     
-					sf.w = sf.w.getAlignedTo( layout ); // w = align[w]
+					sf.w = sf.w.getAlign( layout ); // w = align[w]
 					sf.u = null; // u wird nächsten schleifendurchlauf neu gesetzt
 					
 					if( sf.w == sf.v ) // schleifenabbruchbedingung

src/bk/ConflictDetection.java

@@ -58,7 +58,7 @@ public class ConflictDetection implements AlgorithmStage {
     		{
     			if( e.isDummyEdge() )
     			{
-    				ArrayList< LayeredGraphEdge > conf = e.calcConflictedEdges();
+    				ArrayList< LayeredGraphEdge > conf = e.calcEdgeCrossings();
     				for( LayeredGraphEdge ce : conf )
     				{
     					if( !ce.isDummyEdge() )

src/graph/LayeredEdge.java

@@ -16,14 +16,14 @@ import bk.ExtremalLayoutCalc.LayoutType;
  */
 public class LayeredEdge implements LayeredGraphEdge {
 
-    ElkEdge original;
-    ArrayList< LayeredGraphNode > sources;
-    ArrayList< LayeredGraphNode > targets;
-    LayeredGraphNode graph;
-    boolean reversed;
-    boolean dummy;
-    ArrayList< Point >[] bindPoints;
-    boolean[] conflicted;
+    private ElkEdge original;
+    private ArrayList< LayeredGraphNode > sources;
+    private ArrayList< LayeredGraphNode > targets;
+    private LayeredGraphNode graph;
+    private boolean reversed;
+    private boolean dummy;
+    private ArrayList< Point >[] bindPoints;
+    private boolean[] conflicted;
     
     @SuppressWarnings("unchecked")
     public LayeredEdge( ElkEdge original, ArrayList< LayeredGraphNode > sources, ArrayList< LayeredGraphNode > targets, LayeredGraphNode graph )
@@ -62,7 +62,7 @@ public class LayeredEdge implements LayeredGraphEdge {
     }
     
     @Override
-    public ArrayList<LayeredGraphEdge> calcConflictedEdges()
+    public ArrayList<LayeredGraphEdge> calcEdgeCrossings()
     {
     	ArrayList<LayeredGraphEdge> list = new ArrayList<>();
     	ArrayList<LayeredGraphNode> l = graph.getContainedLayers().get( sources.get( 0 ).getLayer() );

src/graph/LayeredGraphEdge.java

@@ -17,72 +17,109 @@ public interface LayeredGraphEdge {
     /**
      * @return Gibt die originale Kante des Elk Graphen zur�ck
      */
-    ElkEdge getOriginalEdge();
-    
+    public ElkEdge getOriginalEdge();
     
+    /**
+     * Checks whether the edge has been marked as conflicted in the given layout.
+     * @param layout the layout to check
+     * @return whether the edge has been marked as conflicted in the given layout
+     */
     public boolean isConflicted( LayoutType layout );
-    public ArrayList<LayeredGraphEdge> calcConflictedEdges();
+    
+    /**
+     * Computes a list of edges that cross this edge.
+     * @return the list.
+     */
+    public ArrayList<LayeredGraphEdge> calcEdgeCrossings();
+    
+    /**
+     * Mark this edge as conflicted in the given layout.
+     * @param conflicted Whether to mark the edge as conflicted or to remove this mark.
+     * @param layout the layout
+     */
     public void setConflicted( boolean conflicted, LayoutType layout );
     /**
      * Entfernt diese Kante vom Graphen
      */
-    void remove();
+    public void remove();
     /**
      * Gibt eine Liste mit Knoten zur�ck, von welchen die Kante beginnt
      * @return Liste mit Startknoten
      */
-    ArrayList< LayeredGraphNode > getSources();
+    public ArrayList< LayeredGraphNode > getSources();
     /**
      * Gibt eine Liste mit Knoten zur�ck, bei welchen die Kante endet
      * @return Liste mit Endknoten
      */
-    ArrayList< LayeredGraphNode > getTargets();
+    public 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();
+    public 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();
+    public void replaceByDummyNodes();
     /**
      * Dreht die Kante um, indem die Startknoten mit den Endknoten getauscht werden
      */
-    void reverse();
-    
-    void setStartPoint( int x, int y, LayoutType layout );
-    void setEndPoint( int x, int y, LayoutType layout );
-    void addBindPoint( int x, int y, LayoutType layout );
-    ArrayList<Point> getLinePoints( LayoutType layout );
+    public void reverse();
+    /**
+     * Set the starting point of this edge in the given layout.
+     * @param x the x coordinate of the starting point
+     * @param y the y coordinate of the starting point
+     * @param layout the layout
+     */
+    public void setStartPoint( int x, int y, LayoutType layout );
+    /**
+     * Set the ending point of this edge in the given layout.
+     * @param x the x coordinate of the ending point
+     * @param y the y coordinate of the ending point
+     * @param layout the layout
+     */
+    public void setEndPoint( int x, int y, LayoutType layout );
+    /**
+     * Adds a bend point for this edge in the given layout.
+     * @param x the x coordinate of the bend point
+     * @param y the y coordinate of the bend point
+     * @param layout the layout
+     */
+    public void addBindPoint( int x, int y, LayoutType layout );
+    /**
+     * Get the list of bend points of this edge in the given layout.
+     * @param layout the layout
+     * @return the list
+     */
+    public ArrayList<Point> getLinePoints( LayoutType layout );
     /**
      * Pr�ft, ob die Kante umgedreht wurde
      * @return true, falls die Kante umgedreht wurde
      */
-    boolean isReversedEdge();
+    public 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();
+    public 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();
+    public void removeDummyNodes();
     /**
      * Legt fest, dass es sich bei dieser Kante um eine Dummykante handelt
      */
-    void setDummyEdge();
+    public void setDummyEdge();
     /**
      * Legt fest, dass es sich bei dieser Kante um eine umgedrehte Kante handelt
      */
-    void setReversedEdge();
+    public 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 );
+    public void setGraph( LayeredGraphNode graph );
 }

src/graph/LayeredGraphNode.java

@@ -9,233 +9,435 @@ import org.eclipse.elk.graph.ElkNode;
 import bk.ExtremalLayoutCalc.LayoutType;
 
 /**
- * Ein Interface, welches die Methoden eines Knotens aus einem gelayerten Graphen beschreibt (Ein Knoten kann dabei auch einen weiteren Graphen beinhalten)
+ * 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 setShift( double shift, LayoutType layout );
-    public double getShift( LayoutType layout );
-    public void setSink( LayeredGraphNode sink, LayoutType layout );
-    public LayeredGraphNode getSink( LayoutType layoutType);
-    public boolean isXUndefined( LayoutType layout );
-    public void setAlignTo( LayeredGraphNode align, LayoutType layout );
-    public LayeredGraphNode getAlignedTo( LayoutType layout );
-    public void setRoot( LayeredGraphNode root, LayoutType layout );
-    public LayeredGraphNode getRoot( LayoutType layout );
-    public void setName( String n );
-    public String getName();
-    public void setColor( Color c, LayoutType layout );
-    public Color getColor( LayoutType layout );
-    public void setSelected( LayoutType layoutType );
-    public boolean isSelected( LayoutType layout );
-    public void setDummyNode( boolean dummy );
-    public boolean isDummyNode();
-    public void unselectGraph();
-    
-    /**
-     * 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();
-    /**
-     * Ermittelt eine Liste von Kanten, die an diesem Knoten beginnen
-     * @return Liste mit Kanten sortiert nach den positionen der Endknoten in ihrem layer
-     */
-    ArrayList< LayeredGraphEdge > getSortedOutgoingEdges();
-    /**
-     * Ermittelt eine Liste von Kanten, die an diesem Knoten enden
-     * @return Liste mit Kanten sortiert nach den positionen der Startknoten in ihrem layer
-     */
-    ArrayList< LayeredGraphEdge > getSortedIncomingEdges();
-    /**
-     * 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, boolean def, LayoutType layout );
-    /**
-     * Legt die Y Koordinate des Knotens Fest
-     * @param y die Y Koordinate in Pixeln
-     */
-    void setY( double y, LayoutType layout );
-    /**
-     * Gibt die X Koordinate zur�ck
-     * @return die X Koordinate in Pixeln zur�ck
-     */
-    double getX( LayoutType layout );
-    /**
-     * Gibt die Y Koordinate zur�ck
-     * @return die Y Koordinate in Pixeln zur�ck
-     */
-    double getY( LayoutType layout );
-    /**
-     * Gibt die Breite des Knotens zur�ck
-     * @return die Breite in Pixeln
-     */
-    double getWidth( LayoutType layout );
-    /**
-     * Gibt die H�he des Knotens zur�ck
-     * @return die H�he in Pixeln
-     */
-    double getHeight( LayoutType layout );
-    
-    void setWidth( double w, LayoutType layout );
-    void setHeight( double h, LayoutType layout );
-    
-    // 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 Knoten des Subgraphen sortiert nach Layern und Positionen
-     */
-    ArrayList< LayeredGraphNode > getSortedContainedNodes();
-    /**
-     * @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 ausgehenden Kanten eines Knotens
-     * @param n Der Knoten
-     * @return Die Liste mit Kanten sortiert nach den positionen der Endknoten in ihren Layern
-     */
-    ArrayList< LayeredGraphEdge > getSortedOutgoingEdges( LayeredGraphNode n );
-    /**
-     * Ermittelt eine Liste von eingehenden Kanten eines Knotens
-     * @param n Der Knoten
-     * @return Die Liste mit Kanten
-     */
-    ArrayList< LayeredGraphEdge > getIncomingEdges( LayeredGraphNode n );
-    /**
-     * Ermittelt eine Liste von eingehenden Kanten eines Knotens
-     * @param n Der Knoten
-     * @return Die Liste mit Kanten sortiert nach den positionen der Startknoten in ihren Layern
-     */
-    ArrayList< LayeredGraphEdge > getSortedIncomingEdges( 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 source Der Startknoten
-     * @param target 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 );
+  /**
+   * Gibt den originalen Elk Knoten zur�ck
+   * 
+   * @return
+   */
+  public ElkNode getOriginalNode();
+
+  /**
+   * set the shift of this node in the given layout to the given value
+   * 
+   * @param shift
+   *          the value to set to
+   * @param layout
+   *          the layout
+   */
+  public void setShift(double shift, LayoutType layout);
+
+  /**
+   * get the shift of this node in the given layout
+   * 
+   * @param layout
+   *          the layout
+   * @return the shift
+   */
+  public double getShift(LayoutType layout);
+
+  /**
+   * set the sink of this node in the given layout
+   * 
+   * @param sink
+   *          the sink
+   * @param layout
+   *          the layout
+   */
+  public void setSink(LayeredGraphNode sink, LayoutType layout);
+
+  /**
+   * get the sink of this node in the given layout
+   * 
+   * @param layout
+   *          the layout
+   * @return the sink
+   */
+  public LayeredGraphNode getSink(LayoutType layout);
+
+  /**
+   * checks if the x coordinate of the node is defined
+   * 
+   * @param layout
+   *          the layout
+   * @return true iff the x coordinate is undefined
+   */
+  public boolean isXUndefined(LayoutType layout);
+
+  /**
+   * sets the align-attribute (the next node in the block) in the given layout
+   * 
+   * @param align
+   *          the next node in the block
+   * @param layout
+   *          the layout
+   */
+  public void setAlign(LayeredGraphNode align, LayoutType layout);
+
+  /**
+   * get the next node in the block of this node (in the given layout)
+   * 
+   * @param layout
+   *          the layout
+   * @return the next node
+   */
+  public LayeredGraphNode getAlign(LayoutType layout);
+
+  /**
+   * sets the root node of this node in the given layout which identifies the
+   * block that it belongs to
+   * 
+   * @param root
+   *          the new root node
+   * @param layout
+   *          the layout
+   */
+  public void setRoot(LayeredGraphNode root, LayoutType layout);
+
+  /**
+   * get the root node of this node in the given layout which identifies the
+   * block that it belongs to
+   * 
+   * @param layout
+   *          the layout
+   * @return the root node
+   */
+  public LayeredGraphNode getRoot(LayoutType layout);
+
+  /**
+   * set the name of this node
+   * 
+   * @param name
+   *          the name
+   */
+  public void setName(String name);
+
+  /**
+   * get the name of this node
+   * 
+   * @return the name
+   */
+  public String getName();
+
+  /**
+   * set the display color of this node in the given layout
+   * 
+   * @param c
+   *          the color
+   * @param layout
+   *          the layout
+   */
+  public void setColor(Color c, LayoutType layout);
+
+  public Color getColor(LayoutType layout);
+
+  public void setSelected(LayoutType layoutType);
+
+  public boolean isSelected(LayoutType layout);
+
+  public void setDummyNode(boolean dummy);
+
+  public boolean isDummyNode();
+
+  public void unselectGraph();
+
+  /**
+   * Setzt den Index des Layers, zu dem der Knoten geh�ren soll
+   * 
+   * @param index
+   *          Der Index mit 0 beginnend
+   */
+  public void setLayer(int index);
+
+  /**
+   * Gibt den Index des Layers zur�ck, dem dieser Knoten angeh�rt
+   * 
+   * @return Der Index des Layers mit 0 beginnend
+   */
+  public int getLayer();
+
+  /**
+   * Entfernt den Knoten aus dem Graphen
+   */
+  public void remove();
+
+  /**
+   * Ermittelt eine Liste von Kanten, die an diesem Knoten beginnen
+   * 
+   * @return Liste mit Kanten
+   */
+  public ArrayList<LayeredGraphEdge> getOutgoingEdges();
+
+  /**
+   * Ermittelt eine Liste von Kanten, die an diesem Knoten enden
+   * 
+   * @return Liste mit Kanten
+   */
+  public ArrayList<LayeredGraphEdge> getIncomingEdges();
+
+  /**
+   * Ermittelt eine Liste von Kanten, die an diesem Knoten beginnen
+   * 
+   * @return Liste mit Kanten sortiert nach den positionen der Endknoten in
+   *         ihrem layer
+   */
+  public ArrayList<LayeredGraphEdge> getSortedOutgoingEdges();
+
+  /**
+   * Ermittelt eine Liste von Kanten, die an diesem Knoten enden
+   * 
+   * @return Liste mit Kanten sortiert nach den positionen der Startknoten in
+   *         ihrem layer
+   */
+  public ArrayList<LayeredGraphEdge> getSortedIncomingEdges();
+
+  /**
+   * Gibt den Knoten zur�ck, zu dessen Subgraph dieser Knoten geh�rt
+   * 
+   * @return Der Elternknoten
+   */
+  public LayeredGraphNode parent();
+
+  /**
+   * Legt den Knoten fest, zu dessen Subgraph dieser Knoten geh�rt
+   * 
+   * @param parent
+   *          Der Elternknoten
+   */
+  public void setParent(LayeredGraphNode parent);
+
+  /**
+   * Legt die X Koordinate des Knotens fest
+   * 
+   * @param x
+   *          die X Koordinate in Pixeln
+   */
+  public void setX(double x, boolean def, LayoutType layout);
+
+  /**
+   * Legt die Y Koordinate des Knotens Fest
+   * 
+   * @param y
+   *          die Y Koordinate in Pixeln
+   */
+  public void setY(double y, LayoutType layout);
+
+  /**
+   * Gibt die X Koordinate zur�ck
+   * 
+   * @return die X Koordinate in Pixeln zur�ck
+   */
+  public double getX(LayoutType layout);
+
+  /**
+   * Gibt die Y Koordinate zur�ck
+   * 
+   * @return die Y Koordinate in Pixeln zur�ck
+   */
+  public double getY(LayoutType layout);
+
+  /**
+   * Gibt die Breite des Knotens zur�ck
+   * 
+   * @return die Breite in Pixeln
+   */
+  public double getWidth(LayoutType layout);
+
+  /**
+   * Gibt die H�he des Knotens zur�ck
+   * 
+   * @return die H�he in Pixeln
+   */
+  public double getHeight(LayoutType layout);
+
+  public void setWidth(double w, LayoutType layout);
+
+  public void setHeight(double h, LayoutType layout);
+
+  // 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
+   */
+  public 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
+   */
+  public 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
+   */
+  public void setNodeLayer(LayeredGraphNode n, int index);
+
+  /**
+   * @return Eine Liste mit allen Kanten des Subgraphen
+   */
+  public ArrayList<LayeredGraphEdge> getContainedEdges();
+
+  /**
+   * @return Eine Liste mit allen Knoten des Subgraphen
+   */
+  public ArrayList<LayeredGraphNode> getContainedNodes();
+
+  /**
+   * @return Eine Liste mit allen Knoten des Subgraphen sortiert nach Layern und
+   *         Positionen
+   */
+  public ArrayList<LayeredGraphNode> getSortedContainedNodes();
+
+  /**
+   * @return Eine Liste mit allen Layern des Subgraphen
+   */
+  public ArrayList<ArrayList<LayeredGraphNode>> getContainedLayers();
+
+  /**
+   * Entfernt eine Kante aus dem Subgraph
+   * 
+   * @param e
+   *          die Kante, die entfernt werden soll
+   */
+  public void removeEdge(LayeredGraphEdge e);
+
+  /**
+   * Entfernt einen Knoten aus dem Subgraph
+   * 
+   * @param n
+   *          der Knoten, die entfernt werden soll
+   */
+  public void removeNode(LayeredGraphNode n);
+
+  /**
+   * Ermittelt eine Liste von ausgehenden Kanten eines Knotens
+   * 
+   * @param n
+   *          Der Knoten
+   * @return Die Liste mit Kanten
+   */
+  public ArrayList<LayeredGraphEdge> getOutgoingEdges(LayeredGraphNode n);
+
+  /**
+   * Ermittelt eine Liste von ausgehenden Kanten eines Knotens
+   * 
+   * @param n
+   *          Der Knoten
+   * @return Die Liste mit Kanten sortiert nach den positionen der Endknoten in
+   *         ihren Layern
+   */
+  public ArrayList<LayeredGraphEdge> getSortedOutgoingEdges(LayeredGraphNode n);
+
+  /**
+   * Ermittelt eine Liste von eingehenden Kanten eines Knotens
+   * 
+   * @param n
+   *          Der Knoten
+   * @return Die Liste mit Kanten
+   */
+  public ArrayList<LayeredGraphEdge> getIncomingEdges(LayeredGraphNode n);
+
+  /**
+   * Ermittelt eine Liste von eingehenden Kanten eines Knotens
+   * 
+   * @param n
+   *          Der Knoten
+   * @return Die Liste mit Kanten sortiert nach den positionen der Startknoten
+   *         in ihren Layern
+   */
+  public ArrayList<LayeredGraphEdge> getSortedIncomingEdges(LayeredGraphNode n);
+
+  /**
+   * F�gt einen neuen Knoten zum Subgraph hinzu
+   * 
+   * @param original
+   *          Der originale Elk Knoten
+   * @return Der neu erzeugte Knoten
+   */
+  public 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
+   */
+  public 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 source
+   *          Der Startknoten
+   * @param target
+   *          Der Endknoten
+   * @return Die neue Kante
+   */
+  public 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
+   */
+  public LayeredGraphEdge findEdgeFromOriginal(Object original);
+
+  /**
+   * Findet zu einem Originalen Knoten einen Layered Knoten
+   * 
+   * @param original
+   *          der originale Knoten
+   * @return der layered Knoten
+   */
+  public LayeredGraphNode findNodeFromOriginal(Object original);
+
+  public LayeredGraphNode findNodeByName(String name);
+
+  /**
+   * F�gt einen Knoten zum Subgraphen hinzu
+   * 
+   * @param n
+   *          Der neue Knoten
+   */
+  public void addNode(LayeredGraphNode n);
+
+  /**
+   * F�gt eine Kante zum Subgraphen hinzu
+   * 
+   * @param e
+   *          Die neue Kante
+   */
+  public void addEdge(LayeredGraphEdge e);
 }

src/graph/LayeredNode.java

@@ -18,8 +18,6 @@ import bk.ExtremalLayoutCalc.LayoutType;
  *
  */
 public class LayeredNode implements LayeredGraphNode {
-
-    // for this node
     private ElkNode original;
     private LayeredGraphNode parent;
     private boolean dummy;
@@ -52,9 +50,9 @@ public class LayeredNode implements LayeredGraphNode {
         public boolean selected;
     }
     
-    LayoutInfo[] layouts;
-    CombinedLayoutInfo combined;
-    String name;
+    private LayoutInfo[] layouts;
+    private CombinedLayoutInfo combined;
+    private String name;
     
     // for subgraph in this node
     private ArrayList< LayeredGraphEdge > edges;
@@ -220,7 +218,7 @@ public class LayeredNode implements LayeredGraphNode {
     }
 
     @Override
-    public void setAlignTo( LayeredGraphNode align, LayoutType layout )
+    public void setAlign( LayeredGraphNode align, LayoutType layout )
     {
         if( layout == null )
         {
@@ -240,7 +238,7 @@ public class LayeredNode implements LayeredGraphNode {
     }
 
     @Override
-    public LayeredGraphNode getAlignedTo( LayoutType layout )
+    public LayeredGraphNode getAlign( LayoutType layout )
     {
         if( layout == LayoutType.TOP_BOTTOM_LEFT )
             return this.layouts[ 0 ].align;

src/view/MainView.java

@@ -107,28 +107,28 @@ public class MainView {
                     "|" + strToLen( n.getShift( LayoutType.TOP_BOTTOM_LEFT ) + "", 7 ) + 
                     "|" + strToLen( n.getSink( LayoutType.TOP_BOTTOM_LEFT ).getName(), 6 ) + 
                     "|" + strToLen( n.getRoot( LayoutType.TOP_BOTTOM_LEFT ).getName(), 6 ) + 
-                    "|" + strToLen( n.getAlignedTo( LayoutType.TOP_BOTTOM_LEFT ).getName(), 7 ) + 
+                    "|" + strToLen( n.getAlign( LayoutType.TOP_BOTTOM_LEFT ).getName(), 7 ) + 
                     "|" + strToLen( n.getX( LayoutType.TOP_BOTTOM_LEFT ) + "", 5 ) + 
                     "|" + strToLen( !n.isXUndefined( LayoutType.TOP_BOTTOM_LEFT ) + "", 8 ) + "| " +
                     "|" + strToLen( n.getName(), 6 ) + 
                     "|" + strToLen( n.getShift( LayoutType.TOP_BOTTOM_RIGHT ) + "", 7 ) + 
                     "|" + strToLen( n.getSink( LayoutType.TOP_BOTTOM_RIGHT ).getName(), 6 ) + 
                     "|" + strToLen( n.getRoot( LayoutType.TOP_BOTTOM_RIGHT ).getName(), 6 ) + 
-                    "|" + strToLen( n.getAlignedTo( LayoutType.TOP_BOTTOM_RIGHT ).getName(), 7 ) + 
+                    "|" + strToLen( n.getAlign( LayoutType.TOP_BOTTOM_RIGHT ).getName(), 7 ) + 
                     "|" + strToLen( n.getX( LayoutType.TOP_BOTTOM_RIGHT ) + "", 5 ) + 
                     "|" + strToLen( !n.isXUndefined( LayoutType.TOP_BOTTOM_RIGHT ) + "", 8 ) + "| " +
                     "|" + strToLen( n.getName(), 6 ) + 
                     "|" + strToLen( n.getShift( LayoutType.BOTTOM_TOP_LEFT ) + "", 7 ) + 
                     "|" + strToLen( n.getSink( LayoutType.BOTTOM_TOP_LEFT ).getName(), 6 ) + 
                     "|" + strToLen( n.getRoot( LayoutType.BOTTOM_TOP_LEFT ).getName(), 6 ) + 
-                    "|" + strToLen( n.getAlignedTo( LayoutType.BOTTOM_TOP_LEFT ).getName(), 7 ) + 
+                    "|" + strToLen( n.getAlign( LayoutType.BOTTOM_TOP_LEFT ).getName(), 7 ) + 
                     "|" + strToLen( n.getX( LayoutType.BOTTOM_TOP_LEFT ) + "", 5 ) + 
                     "|" + strToLen( !n.isXUndefined( LayoutType.BOTTOM_TOP_LEFT ) + "", 8 ) + "| " +
                     "|" + strToLen( n.getName(), 6 ) + 
                     "|" + strToLen( n.getShift( LayoutType.BOTTOM_TOP_RIGHT ) + "", 7 ) + 
                     "|" + strToLen( n.getSink( LayoutType.BOTTOM_TOP_RIGHT ).getName(), 6 ) + 
                     "|" + strToLen( n.getRoot( LayoutType.BOTTOM_TOP_RIGHT ).getName(), 6 ) + 
-                    "|" + strToLen( n.getAlignedTo( LayoutType.BOTTOM_TOP_RIGHT ).getName(), 7 ) + 
+                    "|" + strToLen( n.getAlign( LayoutType.BOTTOM_TOP_RIGHT ).getName(), 7 ) + 
                     "|" + strToLen( n.getX( LayoutType.BOTTOM_TOP_RIGHT ) + "", 5 ) + 
                     "|" + strToLen( !n.isXUndefined( LayoutType.BOTTOM_TOP_RIGHT ) + "", 8 ) + "|\n";
         }

src/view/NiceButton.java

@@ -13,14 +13,18 @@ import java.awt.image.RGBImageFilter;
 import javax.swing.ImageIcon;
 import javax.swing.JButton;
 
+/**
+ * A {@link NiceButton} is a {@link JButton} that has an image on it.
+ * @author kolja
+ *
+ */
 public class NiceButton extends JButton implements MouseListener {
+    private static final long serialVersionUID = 1L;
 
     /**
-     * 
+     * creates a {@link NiceButton}
+     * @param name the name of the image file, e.g. name="test" would correspond to "../img/test.png"
      */
-    private static final long serialVersionUID = 1L;
-
-    
     public NiceButton( String name )
     {
         super( NiceButton.class.getResource( "../img/" + name + ".png" ) != null ? makeColorTransparent( new ImageIcon( NiceButton.class.getResource( "../img/" + name + ".png" ) ).getImage().getScaledInstance( 40, 40, Image.SCALE_AREA_AVERAGING ), Color.WHITE, 0 ) : new ImageIcon() );

src/view/PseudoCodeRenderer.java

@@ -12,14 +12,17 @@ import javax.swing.tree.TreeNode;
 
 import animation.PseudoCodeNode;
 
+/**
+ * A tree-like display of pseudocode.
+ * Extends {@link DefaultTreeCellRenderer}
+ * @author kolja
+ *
+ */
 public class PseudoCodeRenderer extends DefaultTreeCellRenderer {
-    
-    /**
-     * 
-     */
+
     private static final long serialVersionUID = 1L;
     
-    boolean specialColor = false;
+    private boolean specialColor = false;
 
     @Override
     public Color getBackgroundNonSelectionColor() {

src/view/RenderHelper.java

@@ -12,7 +12,7 @@ import java.awt.geom.AffineTransform;
  */
 public class RenderHelper {
     /**
-     * creates an arrow shape to draw it, for example as an edge.
+     * creates an arrow shape to draw it, for example as part of an edge.
      * @param fromPt the starting point of the arrow
      * @param toPt the destination point of the arrow
      * @return the shape