node marked in block calc

src/animation/PseudoCodeProcessor.java

@@ -75,7 +75,7 @@ public class PseudoCodeProcessor {
                     mem.undeclare( "_returnTo" + programPointer.getId(), MemoryType.LOCAL );
                 });
             }
-            if( programPointer.children() == null )
+            if( programPointer.getChildCount() == 0 )
                 throw new IllegalStateException( "A Codeline without sublines tryd to make a STEP_INTO." );
             else
                 return selectNextNode( (PseudoCodeNode)programPointer.getFirstChild(), programPointer );

src/bk/BKNodePlacement.java

@@ -17,6 +17,7 @@ import codelines.FunctionCall;
 import codelines.FunctionDefinition;
 import codelines.Kommentar;
 import codelines.SetVariable;
+import graph.LayeredGraphEdge;
 import graph.LayeredGraphNode;
 import lib.TextLayoutHelper;
 
@@ -83,6 +84,7 @@ public class BKNodePlacement extends AnimatedAlgorithm {
         root.setSelected( true );
     	
         PseudoCodeNode conflictDetectionFunction = new ConflictDetection( this ).createPseudocodeTree( tree );
+        @SuppressWarnings("serial")
         PseudoCodeNode calcLayout = new PseudoCodeNode( TextLayoutHelper.setupPseudoCode( "function calcLayout( layout, graph )", vars ), tree, new FunctionDefinition( vars ) );
         PseudoCodeNode combine = new Combine().createPseudocodeTree( tree );
         root.add( mainFunction );
@@ -118,7 +120,7 @@ public class BKNodePlacement extends AnimatedAlgorithm {
         mainFunction.add( new PseudoCodeNode( TextLayoutHelper.setupPseudoCode( "call combine( graph )", vars ), tree, new FunctionCall( combine, new String[]{ "graph" } ) ) );
         root.add( new PseudoCodeNode( TextLayoutHelper.setupPseudoCodeStage( "-- Markiert alle Typ 1 konflikte im Graphen --" ), tree, new Kommentar() ) );
         root.add( conflictDetectionFunction );
-        PseudoCodeNode blockCalc = new BlockCalc().createPseudocodeTree( tree );
+        PseudoCodeNode blockCalc = new BlockCalc( this ).createPseudocodeTree( tree );
         PseudoCodeNode horizontalCompaction = new Compaction().createPseudocodeTree( tree );
         calcLayout.add( new PseudoCodeNode( TextLayoutHelper.setupPseudoCode( "call calculateBlockGraph( layout, graph )", vars ), tree, new FunctionCall( blockCalc, vars ) ) );
         calcLayout.add( new PseudoCodeNode( TextLayoutHelper.setupPseudoCode( "call horizontalCompaction( layout, graph )", vars ), tree, new FunctionCall( horizontalCompaction, vars ) ) );

src/bk/BlockCalc.java

@@ -12,6 +12,7 @@ import animation.Memory;
 import animation.PseudoCodeNode;
 import animation.Memory.MemoryType;
 import animation.Memory.ReadOnlyMemory;
+import bk.BKNodePlacement.State;
 import codelines.AbstractForLoop;
 import codelines.DeclareVariable;
 import codelines.ForEachLoop;
@@ -29,10 +30,71 @@ import lib.TextLayoutHelper;
  */
 public class BlockCalc implements AlgorithmStage {
 
+    BKNodePlacement alg;
+    
+    public BlockCalc( BKNodePlacement a )
+    {
+        alg = a;
+    }
+    
     @Override
     public PseudoCodeNode createPseudocodeTree( JTree tree ) {
         String[] vars = { "graph", "L", "r", "neighbors", "layout", "m", "i", "k", "mids" };
-        PseudoCodeNode root = new PseudoCodeNode( TextLayoutHelper.setupPseudoCode( "function calculateBlockGraph( layout, graph )", vars ), tree, new FunctionDefinition( new String[]{ "layout", "graph" } ) );
+        @SuppressWarnings("serial")
+        PseudoCodeNode root = new PseudoCodeNode( TextLayoutHelper.setupPseudoCode( "function calculateBlockGraph( layout, graph )", vars ), tree, new FunctionDefinition( new String[]{ "layout", "graph" } ) ) {
+            @Override
+            public String getDebugOutput( Memory m )
+            {
+                switch( m.<String>read( "layout", MemoryType.LOCAL ) )
+                {
+                case "DOWN_RIGHT":
+                    alg.setAlgorithmState( State.LAYOUT1 );
+                    break;
+                case "DOWN_LEFT":
+                    alg.setAlgorithmState( State.LAYOUT2 );
+                    break;
+                case "UP_RIGHT":
+                    alg.setAlgorithmState( State.LAYOUT3 );
+                    break;
+                case "UP_LEFT":
+                    alg.setAlgorithmState( State.LAYOUT4 );
+                    break;
+                }
+                if( m.isSomewhereDefined( "i", MemoryType.LOCAL ) && m.isSomewhereDefined( "k", MemoryType.LOCAL ) )
+                    m.<LayeredGraphNode>read( "graph", MemoryType.LOCAL).getContainedLayers().get(m.read( "i", MemoryType.LOCAL )).get(m.<Integer>read( "k", MemoryType.LOCAL ) ).setSelected( LayoutType.fromString( m.read( "layout", MemoryType.LOCAL ) ) );
+                String info = "| i  | l  | l1 | k0 | k1 |  v  |  n  |\n";
+                info +=       "|----|----|----|----|----|-----|-----|\n";
+                String i = "null";
+                String l = "null";
+                String l1 = "null";
+                String k0 = "null";
+                String k1 = "null";
+                String v = "null";
+                String n = "null";
+                if( m.isSomewhereDefined( "i", MemoryType.LOCAL ) )
+                    i = "" + m.<Integer>read( "i", MemoryType.LOCAL );
+                if( m.isSomewhereDefined( "l", MemoryType.LOCAL ) )
+                    l = "" + m.<Integer>read( "l", MemoryType.LOCAL );
+                if( m.isSomewhereDefined( "l1", MemoryType.LOCAL ) )
+                    l1 = "" + m.<Integer>read( "l1", MemoryType.LOCAL );
+                if( m.isSomewhereDefined( "k0", MemoryType.LOCAL ) )
+                    k0 = "" + m.<Integer>read( "k0", MemoryType.LOCAL );
+                if( m.isSomewhereDefined( "k1", MemoryType.LOCAL ) )
+                    k1 = "" + m.<Integer>read( "k1", MemoryType.LOCAL );
+                if( m.isSomewhereDefined( "v", MemoryType.LOCAL ) && m.<LayeredGraphEdge>read( "v", MemoryType.LOCAL ).getSources().get( 0 ).getName() != null )
+                    v = "" + m.<LayeredGraphEdge>read( "v", MemoryType.LOCAL ).getSources().get( 0 ).getName();
+                if( m.isSomewhereDefined( "n", MemoryType.LOCAL ) && m.<LayeredGraphNode>read( "n", MemoryType.LOCAL ).getName() != null )
+                    n = "" + m.<LayeredGraphNode>read( "n", MemoryType.LOCAL ).getName();
+                info += "|" + TextLayoutHelper.strToLen( i, 4 ) + 
+                        "|" + TextLayoutHelper.strToLen( l, 4 ) + 
+                        "|" + TextLayoutHelper.strToLen( l1, 4 ) + 
+                        "|" + TextLayoutHelper.strToLen( k0, 4 ) + 
+                        "|" + TextLayoutHelper.strToLen( k1, 4 ) + 
+                        "|" + TextLayoutHelper.strToLen( v, 5 ) + 
+                        "|" + TextLayoutHelper.strToLen( n, 5 ) + "|\n";
+                return info;
+            }
+        };
         root.add( new PseudoCodeNode(TextLayoutHelper.setupPseudoCode( "L = graph.getContainedLayers();", vars), tree, new DeclareVariable<ArrayList<ArrayList<LayeredGraphNode>>>( "L" ) {
             @Override
             protected ArrayList<ArrayList<LayeredGraphNode>> value(ReadOnlyMemory m) {