noch etwas mehr pseudocode

src/animation/PseudoCodeNode.java

@@ -22,15 +22,15 @@ public class PseudoCodeNode extends DefaultMutableTreeNode {
     
     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 )
     {
+        if( selected )
+            MainView.pseudoTree.expandPath( new TreePath( this.getPath() ) );
+        else
+            MainView.pseudoTree.collapsePath( new TreePath( this.getPath() ) );
         this.selected = selected;
     }
 }

src/bk/BlockCalc.java

@@ -25,6 +25,7 @@ public class BlockCalc implements AlgorithmStage {
 	private ArrayList< ArrayList< ExtremalLayoutCalc > > subgraphAlgs;
 	private ArrayList< BackwardAction > backwards; // TODO: evtl richtigen "Stack" benutzen
 	private LayoutType layout;
+	private PseudoCodeNode loopNode;
 	int step;
 	
 	public BlockCalc( LayeredGraphNode graph, LayoutType layout )
@@ -167,10 +168,14 @@ public class BlockCalc implements AlgorithmStage {
 	
 	private StageStatus calcNextState()
 	{
+        loopNode.setSelected( true );
 		if( layerIndex >= graph.getContainedLayers().size() - 1 )
 		{
 			if( nodeIndex >= graph.getContainedLayers().get( calcLayerIndex() ).size() -1 )
+			{
+                loopNode.setSelected( false );
 				return StageStatus.FINISHED;
+			}
 		}
 		nodeIndex++;
 		if( nodeIndex >= graph.getContainedLayers().get( calcLayerIndex() ).size() )
@@ -214,10 +219,14 @@ public class BlockCalc implements AlgorithmStage {
 	
 	private StageStatus calcBeforeState()
 	{
+	    loopNode.setSelected( true );
 		if( layerIndex == 0 )
 		{
 			if( nodeIndex == 0 )
+			{
+		        loopNode.setSelected( false );
 				return StageStatus.FINISHED;
+			}	
 		}
 		nodeIndex--;
 		if( nodeIndex < 0 )
@@ -233,6 +242,8 @@ public class BlockCalc implements AlgorithmStage {
     @Override
     public PseudoCodeNode createPseudocodeTree() {
         PseudoCodeNode root = new PseudoCodeNode( "Berechne den Block Graph" );
+        loopNode = new PseudoCodeNode( "Loop durch alle Knoten..." );
+        root.add( loopNode );
         return root;
     }
 }

src/bk/Combine.java

@@ -33,6 +33,9 @@ public class Combine implements AlgorithmStage {
 	private int tbrOffset;
 	private int vIndex;
 	private ArrayList< BackwardAction > actions;
+    private PseudoCodeNode alignNode;
+    private PseudoCodeNode setNode;
+    private PseudoCodeNode loopNode;
 	
 	public Combine( LayeredGraphNode graph )
 	{
@@ -46,6 +49,7 @@ public class Combine implements AlgorithmStage {
 	public StageStatus forwardStep() {
 		if( state == State.ALIGN )
 		{
+		    alignNode.setSelected( true );
 			int tblw = (int)graph.getWidth( LayoutType.TOP_BOTTOM_LEFT );
 			int tbrw = (int)graph.getWidth( LayoutType.TOP_BOTTOM_RIGHT );
 			int btlw = (int)graph.getWidth( LayoutType.BOTTOM_TOP_LEFT );
@@ -76,17 +80,26 @@ public class Combine implements AlgorithmStage {
 			MainView.frame.setSize( MainView.frame.getWidth() + 1, MainView.frame.getHeight() );
 			MainView.frame.setSize( MainView.frame.getWidth() - 1, MainView.frame.getHeight() );
 			actions.add( 0, () -> {
+	            setNode.setSelected( false );
+                alignNode.setSelected( true );
 				state = State.ALIGN;
 				graph.setColor( null, null );
 				MainView.frame.setSize( MainView.frame.getWidth() + 1, MainView.frame.getHeight() );
 				MainView.frame.setSize( MainView.frame.getWidth() - 1, MainView.frame.getHeight() );
 			});
 			state = State.SET_COORDINATES;
+            alignNode.setSelected( false );
+            setNode.setSelected( true );
+            loopNode.setSelected( true );
 		}
 		else
 		{
 			if( vIndex >= graph.getContainedNodes().size() )
+			{
+			    setNode.setSelected( false );
+			    loopNode.setSelected( false );
 				return StageStatus.FINISHED;
+			}
 			LayeredGraphNode current = graph.getContainedNodes().get( vIndex );
 			current.setSelected( null );
 			ArrayList< Integer > positions = new ArrayList<>();
@@ -98,6 +111,8 @@ public class Combine implements AlgorithmStage {
 			int oldX = (int)current.getX( LayoutType.COMBINED );
 			current.setX( (positions.get( 1 ) + positions.get( 2 )) / 2, true, LayoutType.COMBINED );
 			actions.add( 0, () -> {
+                setNode.setSelected( true );
+                loopNode.setSelected( true );
 				vIndex--;
 				current.setX( oldX, true, LayoutType.COMBINED );
 				current.setSelected( null );
@@ -129,6 +144,12 @@ public class Combine implements AlgorithmStage {
     @Override
     public PseudoCodeNode createPseudocodeTree() {
         PseudoCodeNode root = new PseudoCodeNode( "Berechne das durchschnittliche Layout" );
+        alignNode = new PseudoCodeNode( "Align Layouts" );
+        setNode = new PseudoCodeNode( "Setze Koordinaten auf Mittelwert" );
+        loopNode = new PseudoCodeNode( "Loop durch alle Knoten");
+        setNode.add( loopNode );
+        root.add( alignNode );
+        root.add( setNode );
         return root;
     }
 }

src/bk/Compaction.java

@@ -35,6 +35,11 @@ public class Compaction implements AlgorithmStage{
 	private ArrayList< StackFrame > stack; // TODO: evtl richtigen "Stack" benutzen
 	private ArrayList< BackwardAction > actions; // TODO: evtl richtigen "Stack" benutzen
 	private LayoutType layout;
+	private PseudoCodeNode placeNode;
+    private PseudoCodeNode placeLoopNode;
+    private PseudoCodeNode applyNode;
+    private PseudoCodeNode applyLoopNode;
+	
 	
 	public Compaction( LayeredGraphNode graph, LayoutType layout )
 	{
@@ -76,6 +81,8 @@ public class Compaction implements AlgorithmStage{
 		int acSize = actions.size();
 		if( state == CompactionState.PLACE_BLOCKS ) // blöcke platzieren
 		{
+		    placeNode.setSelected( true );
+		    placeLoopNode.setSelected( true );
 			if( stack.size() == 0 ) // äußere schleife, placeblocks bisher nicht aufgerufen
 			{
 				ArrayList< LayeredGraphNode > nodes = graph.getContainedNodes();
@@ -96,9 +103,17 @@ public class Compaction implements AlgorithmStage{
 				if( !found )
 				{
 				    // wechsele in die phase des Blöckeshiftens
+		            placeNode.setSelected( false );
+		            placeLoopNode.setSelected( false );
+		            applyNode.setSelected( true );
+		            applyLoopNode.setSelected( true );
 					state = CompactionState.APPLY_SHIFT;
 					vIndex = 0;
 					actions.add( 0, ()-> {
+	                    applyNode.setSelected( false );
+	                    applyLoopNode.setSelected( false );
+                        placeNode.setSelected( true );
+                        placeLoopNode.setSelected( true );
 						vIndex = oldVIndex;
 						state = CompactionState.PLACE_BLOCKS;
 					} );
@@ -262,13 +277,19 @@ public class Compaction implements AlgorithmStage{
 			if( v == v.getRoot( layout ) && v.getSink( layout ).getShift( layout ) < Double.POSITIVE_INFINITY )
 				v.setX( v.getX( layout ) + v.getSink( layout ).getShift( layout ), true, layout );
 			actions.add( 0, ()-> {
+                applyNode.setSelected( true );
+                applyLoopNode.setSelected( true );
 				v.setX( oldX, oldDef, layout );
 				v.setSelected( layout );
 				vIndex--;
 			} );
 			vIndex++;
 			if( vIndex >= graph.getContainedNodes().size() )
+			{
+                applyNode.setSelected( false );
+                applyLoopNode.setSelected( false );
 				return StageStatus.FINISHED;
+			}
 		}
 		if( actions.size() != acSize + 1 )
 			System.out.println( "ERROR" );
@@ -278,7 +299,11 @@ public class Compaction implements AlgorithmStage{
 	@Override
 	public StageStatus backwardStep() {
 		if( actions.size() == 0 )
+		{
+            placeNode.setSelected( false );
+            placeLoopNode.setSelected( false );
 			return StageStatus.FINISHED;
+		}
 		actions.get( 0 ).reverse();
 		actions.remove( 0 );
 		return StageStatus.UNFINISHED;
@@ -287,6 +312,14 @@ public class Compaction implements AlgorithmStage{
     @Override
     public PseudoCodeNode createPseudocodeTree() {
         PseudoCodeNode root = new PseudoCodeNode( "Plaziere die Knoten" );
+        placeNode = new PseudoCodeNode( "Berechne die Klasen und Plaziere sie" );
+        placeLoopNode = new PseudoCodeNode( "Loop durch alle Wurzelknoten..." );
+        placeNode.add( placeLoopNode );
+        applyNode = new PseudoCodeNode( "Shift anwenden" );
+        applyLoopNode = new PseudoCodeNode( "Loop durch alle Knoten..." );
+        applyNode.add( applyLoopNode );
+        root.add( placeNode );
+        root.add( applyNode );
         return root;
     }
 }

src/bk/ConflictDetection.java

@@ -15,6 +15,7 @@ public class ConflictDetection implements AlgorithmStage {
     
     private int i;
     private int l1;
+    private PseudoCodeNode markNode;
     
     ConflictDetection( LayeredGraphNode graph )
     {
@@ -28,8 +29,14 @@ public class ConflictDetection implements AlgorithmStage {
     public StageStatus forwardStep() {
     	int oldI = i;
     	int oldL1 = l1;
+    	((PseudoCodeNode)markNode.getParent()).setSelected( true );
+    	markNode.setSelected( true );
     	if( i + 1 >= graph.getContainedLayers().size() - 1 )
+    	{
+            ((PseudoCodeNode)markNode.getParent()).setSelected( false );
+            markNode.setSelected( false );
     		return StageStatus.FINISHED;
+    	}
     	LayeredGraphNode curr = graph.getContainedLayers().get( i + 1 ).get( l1 );
     	curr.setSelected( null );
     	ArrayList< LayeredGraphEdge > edges = curr.getIncomingEdges();
@@ -94,8 +101,14 @@ public class ConflictDetection implements AlgorithmStage {
 
     @Override
     public StageStatus backwardStep() {
+        ((PseudoCodeNode)markNode.getParent()).setSelected( true );
+        markNode.setSelected( true );
         if( actions.size() == 0 )
+        {
+            ((PseudoCodeNode)markNode.getParent()).setSelected( false );
+            markNode.setSelected( false );
         	return StageStatus.FINISHED;
+        }
         actions.get( 0 ).reverse();
         actions.remove( 0 );
         return StageStatus.UNFINISHED;
@@ -104,6 +117,10 @@ public class ConflictDetection implements AlgorithmStage {
     @Override
     public PseudoCodeNode createPseudocodeTree() {
         PseudoCodeNode root = new PseudoCodeNode( "Markiere alle Konflikte mit inneren Kantensegmenten" );
+        PseudoCodeNode loopNode = new PseudoCodeNode( "Loop durch alle Knoten" );
+        markNode = new PseudoCodeNode( "Wenn eine eingehende Kante aus einem Inneren segmen existiert, markiere alle anderen Kanten die diese Kreuzen als Conflicted" );
+        loopNode.add( markNode );
+        root.add( loopNode );
         return root;
     }
 }