Erster Pseudocode

src/animation/AlgorithmStage.java

@@ -1,5 +1,7 @@
 package animation;
 
+import javax.swing.tree.DefaultMutableTreeNode;
+
 import bk.BlockCalc;
 
 /**
@@ -34,4 +36,6 @@ public interface AlgorithmStage {
      * For example if all steps are reverted, then {@code FINISHED} is returned.
      */
 	public StageStatus backwardStep();
+	
+    public PseudoCodeNode createPseudocodeTree();
 }

src/animation/AnimatedAlgorithm.java

@@ -1,5 +1,7 @@
 package animation;
 
+import javax.swing.tree.DefaultMutableTreeNode;
+
 import graph.LayeredGraphNode;
 
 public abstract class AnimatedAlgorithm extends Thread implements AlgorithmStage {
@@ -37,4 +39,6 @@ public abstract class AnimatedAlgorithm extends Thread implements AlgorithmStage
 			
 		}
 	}
+	
+    public abstract PseudoCodeNode createPseudocodeTree();
 }

src/animation/PseudoCodeNode.java

@@ -0,0 +1,36 @@
+package animation;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+import javax.swing.tree.TreePath;
+
+import view.MainView;
+
+public class PseudoCodeNode extends DefaultMutableTreeNode {
+
+    /**
+     * 
+     */
+    private static final long serialVersionUID = 1L;
+    
+    private boolean selected;
+    
+    public PseudoCodeNode( String description )
+    {
+        super( description );
+        selected = false;
+    }
+    
+    public boolean isSelected()
+    {
+        if( selected )
+            MainView.pseudoTree.expandPath( new TreePath( this.getPath() ) );
+        //else
+        //    MainView.pseudoTree.collapsePath( new TreePath( this.getPath() ) );
+        return selected;
+    }
+    
+    public void setSelected( boolean selected )
+    {
+        this.selected = selected;
+    }
+}

src/bk/BKNodePlacement.java

@@ -3,6 +3,7 @@ package bk;
 import animation.AlgorithmStage;
 import animation.AnimatedAlgorithm;
 import animation.AnimationController;
+import animation.PseudoCodeNode;
 import graph.LayeredGraphNode;
 
 /**
@@ -30,6 +31,12 @@ public class BKNodePlacement extends AnimatedAlgorithm {
 	private State state;
 	private ExtremalLayoutCalc layouts[];
 	private Combine combine;
+    private PseudoCodeNode conflictsNode; 
+    private PseudoCodeNode layout1Node;
+    private PseudoCodeNode layout2Node;
+    private PseudoCodeNode layout3Node;
+    private PseudoCodeNode layout4Node;
+    private PseudoCodeNode combineNode;
 	
 	public BKNodePlacement(AnimationController controller, LayeredGraphNode graph) {
 		super(controller, graph);
@@ -48,24 +55,45 @@ public class BKNodePlacement extends AnimatedAlgorithm {
 		switch( state )
 		{
 		case CONFLICTS:
+		    conflictsNode.setSelected( true );
 			if( conftion.forwardStep() == StageStatus.FINISHED )
+			{
+	            conflictsNode.setSelected( false );
+	            layout1Node.setSelected( true );
 				state = State.LAYOUT1;
+			}
 			break;
 		case LAYOUT1:
-			if( layouts[ 0 ].forwardStep() == AlgorithmStage.StageStatus.FINISHED )
+			if( layouts[ 0 ].forwardStep() == StageStatus.FINISHED )
+			{
+	            layout1Node.setSelected( false );
+	            layout2Node.setSelected( true );
 				state = State.LAYOUT2;
+			}
 			break;
 		case LAYOUT2:
-			if( layouts[ 1 ].forwardStep() == AlgorithmStage.StageStatus.FINISHED )
+			if( layouts[ 1 ].forwardStep() == StageStatus.FINISHED )
+			{
+	            layout2Node.setSelected( false );
+                layout3Node.setSelected( true );
 				state = State.LAYOUT3;
+			}
 			break;
 		case LAYOUT3:
-			if( layouts[ 2 ].forwardStep() == AlgorithmStage.StageStatus.FINISHED )
+			if( layouts[ 2 ].forwardStep() == StageStatus.FINISHED )
+			{
+                layout3Node.setSelected( false );
+                layout4Node.setSelected( true );
 				state = State.LAYOUT4;
+			}
 			break;
 		case LAYOUT4:
-			if( layouts[ 3 ].forwardStep() == AlgorithmStage.StageStatus.FINISHED )
+			if( layouts[ 3 ].forwardStep() == StageStatus.FINISHED )
+			{
+	            layout4Node.setSelected( false );
+                combineNode.setSelected( true );
 				state = State.COMBINE;
+			}
 			break;
 		case COMBINE:
 			return combine.forwardStep();
@@ -81,25 +109,63 @@ public class BKNodePlacement extends AnimatedAlgorithm {
 			return conftion.backwardStep();
 		case LAYOUT1:
 			if( layouts[ 0 ].backwardStep() == StageStatus.FINISHED )
+			{
+	            layout1Node.setSelected( false );
+	            conflictsNode.setSelected( true );
 				state = State.CONFLICTS;
+			}
 			break;
 		case LAYOUT2:
 			if( layouts[ 1 ].backwardStep() == AlgorithmStage.StageStatus.FINISHED )
+			{
+	            layout2Node.setSelected( false );
+	            layout1Node.setSelected( true );
 				state = State.LAYOUT1;
+			}
 			break;
 		case LAYOUT3:
 			if( layouts[ 2 ].backwardStep() == AlgorithmStage.StageStatus.FINISHED )
+			{
+	            layout3Node.setSelected( false );
+	            layout2Node.setSelected( true );
 				state = State.LAYOUT2;
+			}
 			break;
 		case LAYOUT4:
 			if( layouts[ 3 ].backwardStep() == AlgorithmStage.StageStatus.FINISHED )
+			{
+                layout4Node.setSelected( false );
+                layout3Node.setSelected( true );
 				state = State.LAYOUT3;
+			}
 			break;
 		case COMBINE:
 			if( combine.backwardStep() == AlgorithmStage.StageStatus.FINISHED )
+			{
+	            combineNode.setSelected( false );
+	            layout4Node.setSelected( true );
 				state = State.LAYOUT4;
+			}
 			break;
 		}
 		return StageStatus.UNFINISHED;
 	}
+	
+	public PseudoCodeNode createPseudocodeTree()
+	{
+	    PseudoCodeNode root = new PseudoCodeNode( "BK Node Placement Algorithm" );
+        conflictsNode = conftion.createPseudocodeTree();
+        layout1Node = layouts[ 0 ].createPseudocodeTree();
+        layout2Node = layouts[ 1 ].createPseudocodeTree();
+        layout3Node = layouts[ 2 ].createPseudocodeTree();
+        layout4Node = layouts[ 3 ].createPseudocodeTree();
+        combineNode = combine.createPseudocodeTree();
+        root.add( conflictsNode );
+        root.add( layout1Node );
+        root.add( layout2Node );
+        root.add( layout3Node );
+        root.add( layout4Node );
+        root.add( combineNode );
+        return root;
+	}
 }

src/bk/BlockCalc.java

@@ -6,6 +6,7 @@ import java.util.Collections;
 
 import animation.AlgorithmStage;
 import animation.BackwardAction;
+import animation.PseudoCodeNode;
 import bk.ExtremalLayoutCalc.LayoutType;
 import graph.LayeredGraphEdge;
 import graph.LayeredGraphNode;
@@ -228,4 +229,10 @@ public class BlockCalc implements AlgorithmStage {
 		}
 		return StageStatus.UNFINISHED;
 	}
+
+    @Override
+    public PseudoCodeNode createPseudocodeTree() {
+        PseudoCodeNode root = new PseudoCodeNode( "Berechne den Block Graph" );
+        return root;
+    }
 }

src/bk/Combine.java

@@ -6,6 +6,7 @@ import java.util.Collections;
 
 import animation.AlgorithmStage;
 import animation.BackwardAction;
+import animation.PseudoCodeNode;
 import bk.ExtremalLayoutCalc.LayoutType;
 import graph.LayeredGraphNode;
 import view.MainView;
@@ -125,4 +126,9 @@ public class Combine implements AlgorithmStage {
 		return StageStatus.UNFINISHED;
 	}
 
+    @Override
+    public PseudoCodeNode createPseudocodeTree() {
+        PseudoCodeNode root = new PseudoCodeNode( "Berechne das durchschnittliche Layout" );
+        return root;
+    }
 }

src/bk/Compaction.java

@@ -4,6 +4,7 @@ import java.util.ArrayList;
 
 import animation.AlgorithmStage;
 import animation.BackwardAction;
+import animation.PseudoCodeNode;
 import bk.ExtremalLayoutCalc.LayoutType;
 import graph.LayeredGraphNode;
 
@@ -283,4 +284,9 @@ public class Compaction implements AlgorithmStage{
 		return StageStatus.UNFINISHED;
 	}
 
+    @Override
+    public PseudoCodeNode createPseudocodeTree() {
+        PseudoCodeNode root = new PseudoCodeNode( "Plaziere die Knoten" );
+        return root;
+    }
 }

src/bk/ConflictDetection.java

@@ -4,6 +4,7 @@ import java.util.ArrayList;
 
 import animation.AlgorithmStage;
 import animation.BackwardAction;
+import animation.PseudoCodeNode;
 import graph.LayeredGraphEdge;
 import graph.LayeredGraphNode;
 
@@ -99,4 +100,10 @@ public class ConflictDetection implements AlgorithmStage {
         actions.remove( 0 );
         return StageStatus.UNFINISHED;
     }
+
+    @Override
+    public PseudoCodeNode createPseudocodeTree() {
+        PseudoCodeNode root = new PseudoCodeNode( "Markiere alle Konflikte mit inneren Kantensegmenten" );
+        return root;
+    }
 }

src/bk/ExtremalLayoutCalc.java

@@ -1,6 +1,7 @@
 package bk;
 
 import animation.AlgorithmStage;
+import animation.PseudoCodeNode;
 import graph.LayeredGraphNode;
 
 /**
@@ -24,9 +25,12 @@ public class ExtremalLayoutCalc implements AlgorithmStage {
 		COMPACTION
 	}
 	
+	private PseudoCodeNode pseudoCode;
 	private BlockCalc bc;
 	private Compaction cp;
 	private LayoutState status;
+	private PseudoCodeNode bcNode;
+	private PseudoCodeNode cpNode;
 	
 	
 	public ExtremalLayoutCalc( LayoutType typ, LayeredGraphNode graph )
@@ -40,27 +44,56 @@ public class ExtremalLayoutCalc implements AlgorithmStage {
 	public StageStatus forwardStep() {
 		if( status == LayoutState.BLOCK_CALCULATION )
 		{
+		    bcNode.setSelected( true );
 			if( bc.forwardStep() == StageStatus.FINISHED )
 			{
+	            bcNode.setSelected( false );
+	            cpNode.setSelected( true );
 				status = LayoutState.COMPACTION;
 			}
 			return StageStatus.UNFINISHED;
 		}
 		if( status == LayoutState.COMPACTION )
-			return cp.forwardStep();
+		{
+			if( cp.forwardStep() == StageStatus.FINISHED )
+			{
+			    cpNode.setSelected( false );
+			    return StageStatus.FINISHED;
+			}
+		}
 		return StageStatus.UNFINISHED;
 	}
 
 	@Override
 	public StageStatus backwardStep() {
 		if( status == LayoutState.BLOCK_CALCULATION )
-			return bc.backwardStep();
+		{
+            bcNode.setSelected( true );
+			if( bc.backwardStep() == StageStatus.FINISHED )
+			{
+	            bcNode.setSelected( false );
+                return StageStatus.FINISHED;
+			}
+		}
 		if( status == LayoutState.COMPACTION )
 		{
+            cpNode.setSelected( true );
 			if( cp.backwardStep() == StageStatus.FINISHED )
+			{
+	            cpNode.setSelected( false );
 				status = LayoutState.BLOCK_CALCULATION;
+			}
 		}
 		return StageStatus.UNFINISHED;
 	}
 
+    @Override
+    public PseudoCodeNode createPseudocodeTree() {
+        pseudoCode = new PseudoCodeNode( "Berechne extremes Layout" );
+        bcNode = bc.createPseudocodeTree();
+        cpNode = cp.createPseudocodeTree();
+        pseudoCode.add( bcNode );
+        pseudoCode.add( cpNode );
+        return pseudoCode;
+    }
 }

src/view/MainView.java

@@ -16,7 +16,10 @@ import javax.swing.JFrame;
 import javax.swing.JLabel;
 import javax.swing.JLayeredPane;
 import javax.swing.JPanel;
+import javax.swing.JScrollPane;
 import javax.swing.JTextField;
+import javax.swing.JTree;
+import javax.swing.tree.DefaultMutableTreeNode;
 
 import animation.Action;
 import animation.AnimationController;
@@ -53,6 +56,7 @@ public class MainView {
     private JButton generateRandom;
     private JLabel delayText;
     private JTextField delay;
+    public static JTree pseudoTree;
 	
 	private String strToLen( String s, int l )
 	{
@@ -98,6 +102,14 @@ public class MainView {
 	    
 		controller = new AnimationController();
 		controller.setTimeBetween( 50 );
+        BKNodePlacement algorithm = new BKNodePlacement( controller, graph );
+        pseudoTree = new JTree( algorithm.createPseudocodeTree() );
+        pseudoTree.setEnabled( false );
+        pseudoTree.setCellRenderer( new PseudoCodeRenderer() );
+        
+        JScrollPane treeView = new JScrollPane( pseudoTree );
+        treeView.setBounds( 10,  110,  380, 380 );
+        
 		frame = new JFrame(); // this may write to a static field because there should be only one instance of this class.
         frame.setSize( Math.min( (int)graph.getWidth( LayoutType.TOP_BOTTOM_LEFT ) * 2 + 200, 1700 ), Math.min( (int)graph.getHeight( LayoutType.TOP_BOTTOM_LEFT ) * 2 + 200, 900 ) );
 		frame.setLocation( 100, 100 );
@@ -207,6 +219,7 @@ public class MainView {
         menue.add( stepBackward );
         menue.add( delayText );
         menue.add( delay );
+        menue.add( treeView );
         //menue.add( stepBackwardInto );
         menue.add( stepBackwardOut );
         menue.add( runBackward );
@@ -218,6 +231,8 @@ public class MainView {
 		{  
 	        public void componentResized(ComponentEvent evt) {
 	    		pl.setSize( layne.getSize() );
+	    		menue.setSize( menue.getWidth(), layne.getHeight() );
+	    		treeView.setSize( treeView.getWidth(), layne.getHeight() - 120 );
 	    		if( graph.getColor( LayoutType.COMBINED ) == null )
 	    		{
 		    		grout.setHgap( 10 );
@@ -234,7 +249,7 @@ public class MainView {
 	    		frame.repaint();
 	        }
 		});
-		new BKNodePlacement( controller, graph ).start();
+        algorithm.start();
 	}
 	
 	private NodeView createNodeView( LayeredGraphNode gNode, LayoutType lt )

src/view/PseudoCodeRenderer.java

@@ -0,0 +1,45 @@
+package view;
+
+import java.awt.Color;
+import java.awt.Component;
+
+import javax.swing.JTree;
+import javax.swing.tree.DefaultTreeCellRenderer;
+
+import animation.PseudoCodeNode;
+
+public class PseudoCodeRenderer extends DefaultTreeCellRenderer {
+    
+    /**
+     * 
+     */
+    private static final long serialVersionUID = 1L;
+    
+    boolean specialColor = false;
+
+    @Override
+    public Color getBackgroundNonSelectionColor() {
+        if(specialColor) {
+            return Color.GREEN;
+        } else {
+            return null;
+        }
+    }
+
+
+    @Override
+    public Component getTreeCellRendererComponent(JTree tree, Object value, boolean arg2, boolean arg3, boolean arg4, int arg5, boolean arg6) {
+
+        Component c = super.getTreeCellRendererComponent(tree, value, arg2, arg3, arg4, arg5, arg6);
+        specialColor = false;
+        if( value instanceof PseudoCodeNode )
+        {
+            PseudoCodeNode node = (PseudoCodeNode) value;
+            if(node.isSelected()) {
+                specialColor = true;
+            }
+        }
+        return c;
+    }
+
+}