Merge remote-tracking branch 'origin/master'

src/bk/BlockCalc.java

@@ -24,10 +24,12 @@ public class BlockCalc implements AlgorithmStage {
 	private int nodeIndex;
 	private int r;
 	private LayeredGraphNode graph;
+	private ArrayList< ArrayList< PseudoCodeNode > > subgraphNodes;
 	private ArrayList< ArrayList< ExtremalLayoutCalc > > subgraphAlgs;
 	private ArrayList< BackwardAction > backwards; // TODO: evtl richtigen "Stack" benutzen
 	private LayoutType layout;
 	private PseudoCodeNode loopNode;
+	private boolean inside;
 	int step;
 	
 	public BlockCalc( LayeredGraphNode graph, LayoutType layout )
@@ -38,14 +40,21 @@ public class BlockCalc implements AlgorithmStage {
 		layerIndex = 0;
 		nodeIndex = 0;
 		r = 0;
+		subgraphNodes = new ArrayList<>();
 		subgraphAlgs = new ArrayList<>();
 		for( ArrayList<LayeredGraphNode> l : graph.getContainedLayers() )
 		{
+			ArrayList< PseudoCodeNode > nodes = new ArrayList<>();
 			ArrayList< ExtremalLayoutCalc > algs = new ArrayList<>();
 			for( int i = 0; i < l.size(); i++ )
+			{
+				nodes.add( null );
 				algs.add( null );
+			}
 			subgraphAlgs.add( algs );
+			subgraphNodes.add( nodes );
 		}
+		inside = false;
 		backwards = new ArrayList<>();
 	}
 	
@@ -91,20 +100,22 @@ public class BlockCalc implements AlgorithmStage {
 		current.setSelected( layout );
 		if( current.getContainedNodes().size() > 0 )
 		{
-			if( subgraphAlgs.get( calcLayerIndex() ).get( calcNodeIndex( nodeIndex ) ) == null )
-			{
-			    ExtremalLayoutCalc extcalc = new ExtremalLayoutCalc( layout, current );
-			    loopNode.add( extcalc.createPseudocodeTree( loopNode.getTree() ) );
-				subgraphAlgs.get( calcLayerIndex() ).set( calcNodeIndex( nodeIndex ), extcalc );
-			}
+			inside = true;
+			boolean breakpoint = false;
+			if( !subgraphNodes.get( calcLayerIndex() ).get( calcNodeIndex( nodeIndex ) ).isSelected() )
+				breakpoint |= !subgraphNodes.get( calcLayerIndex() ).get( calcNodeIndex( nodeIndex ) ).setSelected( true );
 			switch( subgraphAlgs.get( calcLayerIndex() ).get( calcNodeIndex( nodeIndex ) ).forwardStep() )
 			{
             case BREAKPOINT:
                 return StageStatus.BREAKPOINT;
 			case UNFINISHED:
+				if( breakpoint )
+					return StageStatus.BREAKPOINT;
 				return StageStatus.UNFINISHED;
-            default:
-                break;
+			case FINISHED:
+				inside = false;
+				subgraphNodes.get( calcLayerIndex() ).get( calcNodeIndex( nodeIndex ) ).setSelected( false );
+				break;
 			}
 		}
 		ArrayList< LayeredGraphEdge > incommingEdges = null;
@@ -210,12 +221,24 @@ public class BlockCalc implements AlgorithmStage {
 	public StageStatus backwardStep() {
 		if( subgraphAlgs.get( calcLayerIndex() ).get( calcNodeIndex( nodeIndex ) ) != null )
 		{
-			if( subgraphAlgs.get( calcLayerIndex() ).get( calcNodeIndex( nodeIndex ) ).backwardStep() == StageStatus.UNFINISHED )
+			inside = true;
+			boolean breakpoint = false;
+			if( !subgraphNodes.get( calcLayerIndex() ).get( calcNodeIndex( nodeIndex ) ).isSelected() )
+				breakpoint |= !subgraphNodes.get( calcLayerIndex() ).get( calcNodeIndex( nodeIndex ) ).setSelected( true );
+			switch( subgraphAlgs.get( calcLayerIndex() ).get( calcNodeIndex( nodeIndex ) ).backwardStep() )
 			{
+			case BREAKPOINT:
+				return StageStatus.BREAKPOINT;
+			case UNFINISHED:
 				LayeredGraphNode current = graph.getContainedLayers().get( calcLayerIndex() ).get( nodeIndex );
 				current.setSelected( layout );
-				//current.update();
+				if( breakpoint )
+					return StageStatus.BREAKPOINT;
 				return StageStatus.UNFINISHED;
+			case FINISHED:
+				inside = false;
+				subgraphNodes.get( calcLayerIndex() ).get( calcNodeIndex( nodeIndex ) ).setSelected( false );
+				break;
 			}
 		}
 		StageStatus status = calcBeforeState();
@@ -260,33 +283,139 @@ public class BlockCalc implements AlgorithmStage {
     public PseudoCodeNode createPseudocodeTree( JTree tree ) {
         PseudoCodeNode root = new PseudoCodeNode( "Vertical alignment", tree );
         loopNode = new PseudoCodeNode( "Loop through all nodes...", tree );
+        do {
+    		LayeredGraphNode current = graph.getContainedLayers().get( calcLayerIndex() ).get( calcNodeIndex( nodeIndex ) );
+    		if( current.getContainedNodes().size() > 0 )
+    		{
+			    ExtremalLayoutCalc extcalc = new ExtremalLayoutCalc( layout, current );
+			    PseudoCodeNode subNode = extcalc.createPseudocodeTree( loopNode.getTree() );
+			    loopNode.add( subNode );
+				subgraphAlgs.get( calcLayerIndex() ).set( calcNodeIndex( nodeIndex ), extcalc );
+				subgraphNodes.get( calcLayerIndex() ).set( calcNodeIndex( nodeIndex ), subNode );
+        	}
+        } while( calcNextState() != StageStatus.FINISHED );
+		layerIndex = 0;
+		nodeIndex = 0;
+		backwards.clear();
         root.add( loopNode );
         return root;
     }
 
     @Override
     public StageStatus forwardStepOver() {
-        return forwardStep();
+    	if( !inside )
+    		return forwardStep();
+    	else
+    	{
+    		boolean breakpoint = false;
+			if( !subgraphNodes.get( calcLayerIndex() ).get( calcNodeIndex( nodeIndex ) ).isSelected() )
+				breakpoint |= !subgraphNodes.get( calcLayerIndex() ).get( calcNodeIndex( nodeIndex ) ).setSelected( true );
+			switch( subgraphAlgs.get( calcLayerIndex() ).get( calcNodeIndex( nodeIndex ) ).forwardStepOver() )
+			{
+            case BREAKPOINT:
+                return StageStatus.BREAKPOINT;
+			case UNFINISHED:
+				if( breakpoint )
+					return StageStatus.BREAKPOINT;
+				return StageStatus.UNFINISHED;
+			case FINISHED:
+				inside = false;
+				subgraphNodes.get( calcLayerIndex() ).get( calcNodeIndex( nodeIndex ) ).setSelected( false );
+				break;
+			}
+			return StageStatus.UNFINISHED;
+    	}
     }
 
     @Override
     public StageStatus forwardStepOut() {
-        StageStatus status = StageStatus.UNFINISHED;
-        while( status == StageStatus.UNFINISHED )
-            status = forwardStep();
-        return status;
+    	if( !inside )
+    	{
+	        StageStatus status = StageStatus.UNFINISHED;
+	        while( status == StageStatus.UNFINISHED )
+	            status = forwardStep();
+	        return status;
+    	}
+    	else
+    	{
+    		boolean breakpoint = false;
+			if( !subgraphNodes.get( calcLayerIndex() ).get( calcNodeIndex( nodeIndex ) ).isSelected() )
+				breakpoint |= !subgraphNodes.get( calcLayerIndex() ).get( calcNodeIndex( nodeIndex ) ).setSelected( true );
+			switch( subgraphAlgs.get( calcLayerIndex() ).get( calcNodeIndex( nodeIndex ) ).forwardStepOut() )
+			{
+            case BREAKPOINT:
+                return StageStatus.BREAKPOINT;
+			case UNFINISHED:
+				if( breakpoint )
+					return StageStatus.BREAKPOINT;
+				return StageStatus.UNFINISHED;
+			case FINISHED:
+				inside = false;
+				subgraphNodes.get( calcLayerIndex() ).get( calcNodeIndex( nodeIndex ) ).setSelected( false );
+				break;
+			}
+			return StageStatus.UNFINISHED;
+    	}
     }
 
     @Override
     public StageStatus backwardStepOver() {
-        return backwardStep();
+    	if( !inside )
+    		return backwardStep();
+    	else
+    	{
+    		boolean breakpoint = false;
+			if( !subgraphNodes.get( calcLayerIndex() ).get( calcNodeIndex( nodeIndex ) ).isSelected() )
+				breakpoint |= !subgraphNodes.get( calcLayerIndex() ).get( calcNodeIndex( nodeIndex ) ).setSelected( true );
+			switch( subgraphAlgs.get( calcLayerIndex() ).get( calcNodeIndex( nodeIndex ) ).backwardStepOver() )
+			{
+			case BREAKPOINT:
+				return StageStatus.BREAKPOINT;
+			case UNFINISHED:
+				LayeredGraphNode current = graph.getContainedLayers().get( calcLayerIndex() ).get( nodeIndex );
+				current.setSelected( layout );
+				if( breakpoint )
+					return StageStatus.BREAKPOINT;
+				return StageStatus.UNFINISHED;
+			case FINISHED:
+				inside = false;
+				subgraphNodes.get( calcLayerIndex() ).get( calcNodeIndex( nodeIndex ) ).setSelected( false );
+				break;
+			}
+			return StageStatus.UNFINISHED;
+    	}
     }
 
     @Override
     public StageStatus backwardStepOut() {
-        StageStatus status = StageStatus.UNFINISHED;
-        while( status == StageStatus.UNFINISHED )
-            status = backwardStep();
-        return status;
+    	if( !inside )
+    	{
+	        StageStatus status = StageStatus.UNFINISHED;
+	        while( status == StageStatus.UNFINISHED )
+	            status = backwardStep();
+	        return status;
+    	}
+    	else
+    	{
+    		boolean breakpoint = false;
+			if( !subgraphNodes.get( calcLayerIndex() ).get( calcNodeIndex( nodeIndex ) ).isSelected() )
+				breakpoint |= !subgraphNodes.get( calcLayerIndex() ).get( calcNodeIndex( nodeIndex ) ).setSelected( true );
+			switch( subgraphAlgs.get( calcLayerIndex() ).get( calcNodeIndex( nodeIndex ) ).backwardStepOut() )
+			{
+			case BREAKPOINT:
+				return StageStatus.BREAKPOINT;
+			case UNFINISHED:
+				LayeredGraphNode current = graph.getContainedLayers().get( calcLayerIndex() ).get( nodeIndex );
+				current.setSelected( layout );
+				if( breakpoint )
+					return StageStatus.BREAKPOINT;
+				return StageStatus.UNFINISHED;
+			case FINISHED:
+				inside = false;
+				subgraphNodes.get( calcLayerIndex() ).get( calcNodeIndex( nodeIndex ) ).setSelected( false );
+				break;
+			}
+			return StageStatus.UNFINISHED;
+    	}
     }
 }

src/graph/LayeredNode.java

@@ -3,8 +3,10 @@ package graph;
 import java.awt.Color;
 import java.util.ArrayList;
 
+import org.eclipse.elk.graph.ElkConnectableShape;
 import org.eclipse.elk.graph.ElkEdge;
 import org.eclipse.elk.graph.ElkNode;
+import org.eclipse.emf.common.util.EList;
 
 import bk.ExtremalLayoutCalc.LayoutType;
 
@@ -59,6 +61,31 @@ public class LayeredNode implements LayeredGraphNode {
     private ArrayList< LayeredGraphNode > nodes;
     private ArrayList< ArrayList< LayeredGraphNode > > layers;
     
+    /**
+     * Konvertiert einen Graph aus dem Elk format in einen Graph, der mehr Informationen enthält
+     * @param n Der Graph, welcher konvertiert werden soll
+     * @return Ein layered Graph, welcher im wesentlichen ein Wrapper für den ursprünglichen Graphen ist
+     */
+    public static LayeredGraphNode convertToLayeredGraph( ElkNode n )
+    {
+        LayeredNode ln = new LayeredNode( n, null );
+        for( ElkNode node : n.getChildren() )
+            ln.addNode( convertToLayeredGraph( node ) );
+        for( ElkEdge edge : n.getContainedEdges() )
+        {
+            ArrayList< LayeredGraphNode > sources = new ArrayList<>();
+            ArrayList< LayeredGraphNode > targets = new ArrayList<>();
+            EList<ElkConnectableShape> s = edge.getSources();
+            EList<ElkConnectableShape> t = edge.getTargets();
+            for( ElkConnectableShape shape : s )
+                sources.add( ln.findNodeFromOriginal( shape ) );
+            for( ElkConnectableShape shape : t )
+                targets.add( ln.findNodeFromOriginal( shape ) );
+            ln.createEdge( edge, sources, targets );
+        }
+        return ln;
+    }
+    
     public LayeredNode( ElkNode original, LayeredGraphNode parent )
     {
         this.original = original;

src/view/MainView.java

@@ -34,6 +34,8 @@ import javax.swing.filechooser.FileNameExtensionFilter;
 import javax.swing.tree.DefaultTreeModel;
 import javax.swing.tree.TreePath;
 
+import org.eclipse.elk.graph.ElkNode;
+
 import animation.Action;
 import animation.AnimationController;
 import animation.PseudoCodeNode;
@@ -42,6 +44,7 @@ import bk.ExtremalLayoutCalc.LayoutType;
 import graph.InitializeNodePositions;
 import graph.LayeredGraphEdge;
 import graph.LayeredGraphNode;
+import graph.LayeredNode;
 import graph.RandomGraphGenerator;
 import graph.io.Reader;
 import graph.io.Writer;
@@ -145,6 +148,11 @@ public class MainView {
         debugFrame.setSize( frame.getWidth(), frame.getHeight() );
 	    debugFrame.setVisible( true );
 	}
+
+	public MainView( ElkNode graph )
+	{
+		this( LayeredNode.convertToLayeredGraph( graph ) );
+	}
 	
 	/**
 	 * Initialize the window and its contents.
@@ -156,7 +164,7 @@ public class MainView {
 	    this.graph = graph;
         controller = new AnimationController();
         controller.setTimeBetween( 50 );
-        frame = new JFrame();
+        frame = new JFrame( "NodeShuffler" );
         frame.addWindowListener(new java.awt.event.WindowAdapter() {
             @Override
             public void windowClosing(java.awt.event.WindowEvent windowEvent) {