breakpoints funktionieren auch bei step over und step out

src/animation/AlgorithmStage.java

@@ -20,6 +20,7 @@ public interface AlgorithmStage {
 	public static enum StageStatus
 	{
 		UNFINISHED,
+		BREAKPOINT,
 		FINISHED
 	}
 	

src/animation/PseudoCodeNode.java

@@ -54,7 +54,7 @@ public class PseudoCodeNode extends DefaultMutableTreeNode {
         return selected;
     }
     
-    public void setSelected( boolean selected )
+    public boolean setSelected( boolean selected )
     {
         if( selected && breakPoint )
             controller.setContinuous( false );
@@ -63,6 +63,7 @@ public class PseudoCodeNode extends DefaultMutableTreeNode {
         else
             tree.collapsePath( new TreePath( this.getPath() ) );
         this.selected = selected;
+        return !breakPoint || !selected;
     }
     
     public void setBreakPoint( boolean breakPoint )

src/bk/BKNodePlacement.java

@@ -5,7 +5,6 @@ import java.lang.reflect.InvocationTargetException;
 import javax.swing.JFrame;
 import javax.swing.JTree;
 
-import animation.AlgorithmStage;
 import animation.AnimatedAlgorithm;
 import animation.AnimationController;
 import animation.PseudoCodeNode;
@@ -93,7 +92,7 @@ public class BKNodePlacement extends AnimatedAlgorithm {
         {
             State oldState = state;
             StageStatus status = StageStatus.UNFINISHED;
-            while( state == oldState && status != StageStatus.FINISHED )
+            while( state == oldState && status == StageStatus.UNFINISHED )
                 status = forwardStep();
             return status;
         }
@@ -106,7 +105,7 @@ public class BKNodePlacement extends AnimatedAlgorithm {
         if( !inside )
         {
             StageStatus status = StageStatus.UNFINISHED;
-            while( status != StageStatus.FINISHED )
+            while( status == StageStatus.UNFINISHED )
                 status = forwardStep();
             return status;
         }
@@ -120,7 +119,7 @@ public class BKNodePlacement extends AnimatedAlgorithm {
         {
             State oldState = state;
             StageStatus status = StageStatus.UNFINISHED;
-            while( state == oldState && status != StageStatus.FINISHED )
+            while( state == oldState && status == StageStatus.UNFINISHED )
                 status = backwardStep();
             return status;
         }
@@ -133,7 +132,7 @@ public class BKNodePlacement extends AnimatedAlgorithm {
         if( !inside )
         {
             StageStatus status = StageStatus.UNFINISHED;
-            while( status != StageStatus.FINISHED )
+            while( status == StageStatus.UNFINISHED )
                 status = backwardStep();
             return status;
         }
@@ -143,73 +142,102 @@ public class BKNodePlacement extends AnimatedAlgorithm {
     
     private StageStatus forward( String fName )
     {
+        boolean breakpoint = false;
         try {
             switch( state )
             {
             case CONFLICTS:
-                conflictsNode.setSelected( true );
-                    if( (StageStatus)(ConflictDetection.class.getMethod( fName ).invoke( conftion ) ) == StageStatus.FINISHED )
+                breakpoint |= !conflictsNode.setSelected( true );
+                    switch( (StageStatus)(ConflictDetection.class.getMethod( fName ).invoke( conftion ) ) )
                     {
+                    case FINISHED:
                         inside = false;
                         conflictsNode.setSelected( false );
-                        layout1Node.setSelected( true );
+                        breakpoint |= !layout1Node.setSelected( true );
                         state = State.LAYOUT1;
-                    }
-                    else
+                        break;
+                    case BREAKPOINT:
+                        inside = true;
+                        return StageStatus.BREAKPOINT;
+                    case UNFINISHED:
                         inside = true;
+                    }
                 break;
             case LAYOUT1:
-                if( (StageStatus)(ExtremalLayoutCalc.class.getMethod( fName ).invoke( layouts[ 0 ] ) ) == StageStatus.FINISHED )
+                switch( (StageStatus)(ExtremalLayoutCalc.class.getMethod( fName ).invoke( layouts[ 0 ] ) ) )
                 {
+                case FINISHED:
                     inside = false;
                     layout1Node.setSelected( false );
-                    layout2Node.setSelected( true );
+                    breakpoint |= !layout2Node.setSelected( true );
                     state = State.LAYOUT2;
-                }
-                else
+                    break;
+                case BREAKPOINT:
+                    inside = true;
+                    return StageStatus.BREAKPOINT;
+                case UNFINISHED:
                     inside = true;
+                }
                 break;
             case LAYOUT2:
-                if( (StageStatus)(ExtremalLayoutCalc.class.getMethod( fName ).invoke( layouts[ 1 ] ) ) == StageStatus.FINISHED )
+                switch( (StageStatus)(ExtremalLayoutCalc.class.getMethod( fName ).invoke( layouts[ 1 ] ) ) )
                 {
+                case FINISHED:
                     inside = false;
                     layout2Node.setSelected( false );
-                    layout3Node.setSelected( true );
+                    breakpoint |= !layout3Node.setSelected( true );
                     state = State.LAYOUT3;
-                }
-                else
+                    break;
+                case BREAKPOINT:
                     inside = true;
+                    return StageStatus.BREAKPOINT;
+                case UNFINISHED:
+                    inside = true;
+                }
                 break;
             case LAYOUT3:
-                if( (StageStatus)(ExtremalLayoutCalc.class.getMethod( fName ).invoke( layouts[ 2 ] ) ) == StageStatus.FINISHED )
+                switch( (StageStatus)(ExtremalLayoutCalc.class.getMethod( fName ).invoke( layouts[ 2 ] ) ) )
                 {
+                case FINISHED:
                     inside = false;
                     layout3Node.setSelected( false );
-                    layout4Node.setSelected( true );
+                    breakpoint |= !layout4Node.setSelected( true );
                     state = State.LAYOUT4;
-                }
-                else
+                    break;
+                case BREAKPOINT:
+                    inside = true;
+                    return StageStatus.BREAKPOINT;
+                case UNFINISHED:
                     inside = true;
+                }
                 break;
             case LAYOUT4:
-                if( (StageStatus)(ExtremalLayoutCalc.class.getMethod( fName ).invoke( layouts[ 3 ] ) ) == StageStatus.FINISHED )
+                switch( (StageStatus)(ExtremalLayoutCalc.class.getMethod( fName ).invoke( layouts[ 3 ] ) ) )
                 {
+                case FINISHED:
                     inside = false;
                     layout4Node.setSelected( false );
-                    combineNode.setSelected( true );
+                    breakpoint |= !combineNode.setSelected( true );
                     state = State.COMBINE;
-                }
-                else
+                    break;
+                case BREAKPOINT:
+                    inside = true;
+                    return StageStatus.BREAKPOINT;
+                case UNFINISHED:
                     inside = true;
+                }
                 break;
             case COMBINE:
-                if( (StageStatus)(Combine.class.getMethod( fName ).invoke( combine ) ) == StageStatus.FINISHED )
+                switch( (StageStatus)(Combine.class.getMethod( fName ).invoke( combine ) ) )
                 {
+                case FINISHED:
                     inside = false;
                     return StageStatus.FINISHED;
-                }
-                else
+                case BREAKPOINT:
+                    return StageStatus.BREAKPOINT;
+                case UNFINISHED:
                     inside = true;
+                }
             }
         } catch (IllegalAccessException e) {
             e.printStackTrace();
@@ -222,75 +250,107 @@ public class BKNodePlacement extends AnimatedAlgorithm {
         } catch (SecurityException e) {
             e.printStackTrace();
         }
+        if( breakpoint )
+            return StageStatus.BREAKPOINT;
         return StageStatus.UNFINISHED;
     }
 
     private StageStatus backward( String fName ) {
+        boolean breakpoint = false;
         try {
             switch( state )
             {
             case CONFLICTS:
-                if( (StageStatus)(ConflictDetection.class.getMethod( fName ).invoke( conftion ) ) == StageStatus.FINISHED )
+                switch( (StageStatus)(ConflictDetection.class.getMethod( fName ).invoke( conftion ) ) )
                 {
+                case FINISHED:
                     inside = false;
                     return StageStatus.FINISHED;
-                }
-                else
+                case BREAKPOINT:
                     inside = true;
+                    return StageStatus.BREAKPOINT;
+                case UNFINISHED:
+                    inside = true;
+                }
             case LAYOUT1:
-                if( (StageStatus)(ExtremalLayoutCalc.class.getMethod( fName ).invoke( layouts[ 0 ] ) ) == StageStatus.FINISHED )
+                switch( (StageStatus)(ExtremalLayoutCalc.class.getMethod( fName ).invoke( layouts[ 0 ] ) ) )
                 {
+                case FINISHED:
                     inside = false;
                     layout1Node.setSelected( false );
-                    conflictsNode.setSelected( true );
+                    breakpoint |= !conflictsNode.setSelected( true );
                     state = State.CONFLICTS;
-                }
-                else
+                    break;
+                case BREAKPOINT:
                     inside = true;
+                    return StageStatus.BREAKPOINT;
+                case UNFINISHED:
+                    inside = true;
+                }
                 break;
             case LAYOUT2:
-                if( (StageStatus)(ExtremalLayoutCalc.class.getMethod( fName ).invoke( layouts[ 1 ] ) ) == AlgorithmStage.StageStatus.FINISHED )
+                switch( (StageStatus)(ExtremalLayoutCalc.class.getMethod( fName ).invoke( layouts[ 1 ] ) ) )
                 {
+                case FINISHED:
                     inside = false;
                     layout2Node.setSelected( false );
-                    layout1Node.setSelected( true );
+                    breakpoint |= !layout1Node.setSelected( true );
                     state = State.LAYOUT1;
-                }
-                else
+                    break;
+                case BREAKPOINT:
+                    inside = true;
+                    return StageStatus.BREAKPOINT;
+                case UNFINISHED:
                     inside = true;
+                }
                 break;
             case LAYOUT3:
-                if( (StageStatus)(ExtremalLayoutCalc.class.getMethod( fName ).invoke( layouts[ 2 ] ) ) == AlgorithmStage.StageStatus.FINISHED )
+                switch( (StageStatus)(ExtremalLayoutCalc.class.getMethod( fName ).invoke( layouts[ 2 ] ) ) )
                 {
+                case FINISHED:
                     inside = false;
                     layout3Node.setSelected( false );
-                    layout2Node.setSelected( true );
+                    breakpoint |= !layout2Node.setSelected( true );
                     state = State.LAYOUT2;
-                }
-                else
+                    break;
+                case BREAKPOINT:
                     inside = true;
+                    return StageStatus.BREAKPOINT;
+                case UNFINISHED:
+                    inside = true;
+                }
                 break;
             case LAYOUT4:
-                if( (StageStatus)(ExtremalLayoutCalc.class.getMethod( fName ).invoke( layouts[ 3 ] ) ) == AlgorithmStage.StageStatus.FINISHED )
+                switch( (StageStatus)(ExtremalLayoutCalc.class.getMethod( fName ).invoke( layouts[ 3 ] ) ) )
                 {
+                case FINISHED:
                     inside = false;
                     layout4Node.setSelected( false );
-                    layout3Node.setSelected( true );
+                    breakpoint |= !layout3Node.setSelected( true );
                     state = State.LAYOUT3;
-                }
-                else
+                    break;
+                case BREAKPOINT:
+                    inside = true;
+                    return StageStatus.BREAKPOINT;
+                case UNFINISHED:
                     inside = true;
+                }
                 break;
             case COMBINE:
-                if( (StageStatus)(Combine.class.getMethod( fName ).invoke( combine ) ) == AlgorithmStage.StageStatus.FINISHED )
+                switch( (StageStatus)(Combine.class.getMethod( fName ).invoke( combine ) ) )
                 {
+                case FINISHED:
                     inside = false;
                     combineNode.setSelected( false );
-                    layout4Node.setSelected( true );
+                    breakpoint |= !layout4Node.setSelected( true );
                     state = State.LAYOUT4;
-                }
-                else
+                    break;
+                case BREAKPOINT:
                     inside = true;
+                    return StageStatus.BREAKPOINT;
+                case UNFINISHED:
+                    inside = true;
+                }
                 break;
             }
         } catch (IllegalAccessException e) {
@@ -304,6 +364,8 @@ public class BKNodePlacement extends AnimatedAlgorithm {
         } catch (SecurityException e) {
             e.printStackTrace();
         }
+        if( breakpoint )
+            return StageStatus.BREAKPOINT;
         return StageStatus.UNFINISHED;
     }
     

src/bk/BlockCalc.java

@@ -97,8 +97,15 @@ public class BlockCalc implements AlgorithmStage {
 			    loopNode.add( extcalc.createPseudocodeTree( loopNode.getTree() ) );
 				subgraphAlgs.get( calcLayerIndex() ).set( calcNodeIndex( nodeIndex ), extcalc );
 			}
-			if( subgraphAlgs.get( calcLayerIndex() ).get( calcNodeIndex( nodeIndex ) ).forwardStep() == StageStatus.UNFINISHED )
+			switch( subgraphAlgs.get( calcLayerIndex() ).get( calcNodeIndex( nodeIndex ) ).forwardStep() )
+			{
+            case BREAKPOINT:
+                return StageStatus.BREAKPOINT;
+			case UNFINISHED:
 				return StageStatus.UNFINISHED;
+            default:
+                break;
+			}
 		}
 		ArrayList< LayeredGraphEdge > incommingEdges = null;
         if( layout == LayoutType.TOP_BOTTOM_LEFT || layout == LayoutType.TOP_BOTTOM_RIGHT )
@@ -174,7 +181,7 @@ public class BlockCalc implements AlgorithmStage {
 	
 	private StageStatus calcNextState()
 	{
-        loopNode.setSelected( true );
+        boolean breakpoint = !loopNode.setSelected( true );
 		if( layerIndex >= graph.getContainedLayers().size() - 1 )
 		{
 			if( nodeIndex >= graph.getContainedLayers().get( calcLayerIndex() ).size() -1 )
@@ -194,6 +201,8 @@ public class BlockCalc implements AlgorithmStage {
 			   this.r = oldR;
 			});
 		}
+		if( breakpoint )
+		    return StageStatus.BREAKPOINT;
 		return StageStatus.UNFINISHED;
 	}
 
@@ -225,7 +234,7 @@ public class BlockCalc implements AlgorithmStage {
 	
 	private StageStatus calcBeforeState()
 	{
-	    loopNode.setSelected( true );
+	    boolean breakpoint = !loopNode.setSelected( true );
 		if( layerIndex == 0 )
 		{
 			if( nodeIndex == 0 )
@@ -242,6 +251,8 @@ public class BlockCalc implements AlgorithmStage {
 	        backwards.remove( 0 );
 			nodeIndex = graph.getContainedLayers().get( calcLayerIndex() ).size() - 1;
 		}
+        if( breakpoint )
+            return StageStatus.BREAKPOINT;
 		return StageStatus.UNFINISHED;
 	}
 
@@ -261,7 +272,7 @@ public class BlockCalc implements AlgorithmStage {
     @Override
     public StageStatus forwardStepOut() {
         StageStatus status = StageStatus.UNFINISHED;
-        while( status != StageStatus.FINISHED )
+        while( status == StageStatus.UNFINISHED )
             status = forwardStep();
         return status;
     }
@@ -274,7 +285,7 @@ public class BlockCalc implements AlgorithmStage {
     @Override
     public StageStatus backwardStepOut() {
         StageStatus status = StageStatus.UNFINISHED;
-        while( status != StageStatus.FINISHED )
+        while( status == StageStatus.UNFINISHED )
             status = backwardStep();
         return status;
     }

src/bk/Combine.java

@@ -38,6 +38,7 @@ public class Combine implements AlgorithmStage {
     private PseudoCodeNode setNode;
     private PseudoCodeNode loopNode;
     private boolean inside;
+    private boolean breakPoint;
 	
 	public Combine( LayeredGraphNode graph )
 	{
@@ -53,7 +54,7 @@ public class Combine implements AlgorithmStage {
 		if( state == State.ALIGN )
 		{
 		    inside = false;
-		    alignNode.setSelected( true );
+		    breakPoint = !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 );
@@ -85,8 +86,8 @@ public class Combine implements AlgorithmStage {
 			//MainView.frame.setSize( MainView.frame.getWidth() - 1, MainView.frame.getHeight() );
 			actions.add( 0, () -> {
                 inside = false;
-	            setNode.setSelected( false );
-                alignNode.setSelected( true );
+                setNode.setSelected( false );
+                breakPoint = !alignNode.setSelected( true );
 				state = State.ALIGN;
 				graph.setColor( null, null );
 				//MainView.frame.setSize( MainView.frame.getWidth() + 1, MainView.frame.getHeight() );
@@ -94,11 +95,12 @@ public class Combine implements AlgorithmStage {
 			});
 			state = State.SET_COORDINATES;
             alignNode.setSelected( false );
-            setNode.setSelected( true );
-            loopNode.setSelected( true );
+            breakPoint |= !setNode.setSelected( true );
+            breakPoint |= !loopNode.setSelected( true );
 		}
 		else
 		{
+            breakPoint = !loopNode.setSelected( true );
 			if( vIndex >= graph.getContainedNodes().size() )
 			{
 	            inside = false; 
@@ -120,14 +122,16 @@ public class Combine implements AlgorithmStage {
 			current.setX( (positions.get( 1 ) + positions.get( 2 )) / 2, true, LayoutType.COMBINED );
 			actions.add( 0, () -> {
                 inside = true; 
-                setNode.setSelected( true );
-                loopNode.setSelected( true );
+                breakPoint = !setNode.setSelected( true );
+                breakPoint |= !loopNode.setSelected( true );
 				vIndex--;
 				current.setX( oldX, true, LayoutType.COMBINED );
 				current.setSelected( null );
 			});
 			vIndex++;
-		}		
+		}
+		if( breakPoint )
+		    return StageStatus.BREAKPOINT;
 		return StageStatus.UNFINISHED;
 	}
 	
@@ -150,6 +154,8 @@ public class Combine implements AlgorithmStage {
 		}
 		actions.get( 0 ).reverse();
 		actions.remove( 0 );
+        if( breakPoint )
+            return StageStatus.BREAKPOINT;
 		return StageStatus.UNFINISHED;
 	}
 
@@ -171,7 +177,7 @@ public class Combine implements AlgorithmStage {
         {
             State oldState = state;
             StageStatus stage = StageStatus.UNFINISHED;
-            while( state == oldState && stage != StageStatus.FINISHED )
+            while( state == oldState && stage == StageStatus.UNFINISHED )
                 stage = forwardStep();
             return stage;
         }
@@ -184,7 +190,7 @@ public class Combine implements AlgorithmStage {
         if( !inside )
         {
             StageStatus status = StageStatus.UNFINISHED;
-            while( status != StageStatus.FINISHED )
+            while( status == StageStatus.UNFINISHED )
                 status = forwardStep();
             return status;
         }
@@ -192,7 +198,7 @@ public class Combine implements AlgorithmStage {
         {
             State oldState = state;
             StageStatus stage = StageStatus.UNFINISHED;
-            while( state == oldState && stage != StageStatus.FINISHED )
+            while( state == oldState && stage == StageStatus.UNFINISHED )
                 stage = forwardStep();
             return stage;
         }
@@ -204,7 +210,7 @@ public class Combine implements AlgorithmStage {
         {
             State oldState = state;
             StageStatus stage = StageStatus.UNFINISHED;
-            while( state == oldState && stage != StageStatus.FINISHED )
+            while( state == oldState && stage == StageStatus.UNFINISHED )
                 stage = backwardStep();
             return stage;
         }
@@ -217,7 +223,7 @@ public class Combine implements AlgorithmStage {
         if( !inside )
         {
             StageStatus status = StageStatus.UNFINISHED;
-            while( status != StageStatus.FINISHED )
+            while( status == StageStatus.UNFINISHED )
                 status = backwardStep();
             return status;
         }
@@ -225,7 +231,7 @@ public class Combine implements AlgorithmStage {
         {
             State oldState = state;
             StageStatus stage = StageStatus.UNFINISHED;
-            while( state == oldState && stage != StageStatus.FINISHED )
+            while( state == oldState && stage == StageStatus.UNFINISHED )
                 stage = backwardStep();
             return stage;
         }

src/bk/Compaction.java

@@ -41,6 +41,7 @@ public class Compaction implements AlgorithmStage{
     private PseudoCodeNode placeLoopNode;
     private PseudoCodeNode applyNode;
     private PseudoCodeNode applyLoopNode;
+    private boolean breakPoint;
     private boolean inside;
 	
 	
@@ -86,8 +87,8 @@ public class Compaction implements AlgorithmStage{
 		if( state == CompactionState.PLACE_BLOCKS ) // blöcke platzieren
 		{
 		    inside = true;
-		    placeNode.setSelected( true );
-		    placeLoopNode.setSelected( true );
+		    breakPoint = !placeNode.setSelected( true );
+		    breakPoint |= !placeLoopNode.setSelected( true );
 			if( stack.size() == 0 ) // äußere schleife, placeblocks bisher nicht aufgerufen
 			{
 				ArrayList< LayeredGraphNode > nodes = graph.getContainedNodes();
@@ -110,16 +111,16 @@ public class Compaction implements AlgorithmStage{
 				    // wechsele in die phase des Blöckeshiftens
 		            placeNode.setSelected( false );
 		            placeLoopNode.setSelected( false );
-		            applyNode.setSelected( true );
-		            applyLoopNode.setSelected( true );
+		            breakPoint |= !applyNode.setSelected( true );
+		            breakPoint |= !applyLoopNode.setSelected( true );
 					state = CompactionState.APPLY_SHIFT;
 					inside = false;
 					vIndex = 0;
 					actions.add( 0, ()-> {
 	                    applyNode.setSelected( false );
 	                    applyLoopNode.setSelected( false );
-                        placeNode.setSelected( true );
-                        placeLoopNode.setSelected( true );
+	                    breakPoint = !placeNode.setSelected( true );
+	                    breakPoint |= !placeLoopNode.setSelected( true );
 						vIndex = oldVIndex;
 						inside = false;
 						state = CompactionState.PLACE_BLOCKS;
@@ -138,6 +139,8 @@ public class Compaction implements AlgorithmStage{
 					
 					// die "undo"-action
 					actions.add( 0, ()-> {
+                        breakPoint = !placeNode.setSelected( true );
+                        breakPoint |= !placeLoopNode.setSelected( true );
 					    inside = true;
 						stack.get( 0 ).v.setX( oldX, false, layout );
 						stack.get( 0 ).v.setSelected( layout );
@@ -173,6 +176,8 @@ public class Compaction implements AlgorithmStage{
 		                    
 		                    // die "undo"-action
 							actions.add( 0, ()-> {
+		                        breakPoint = !placeNode.setSelected( true );
+		                        breakPoint |= !placeLoopNode.setSelected( true );
 							    inside = true;
 								stack.get( 0 ).v.setX( oldX, false, layout );
 								stack.get( 0 ).v.setSelected( layout );
@@ -185,6 +190,8 @@ public class Compaction implements AlgorithmStage{
 						    // tue nix
 							sf.w.setSelected( layout );
 							actions.add( 0, ()-> {
+		                        breakPoint = !placeNode.setSelected( true );
+		                        breakPoint |= !placeLoopNode.setSelected( true );
                                 inside = true;
 								stack.get( 0 ).u = null;
 							});
@@ -200,6 +207,8 @@ public class Compaction implements AlgorithmStage{
                             System.out.println( "return place_block( " + sf.v + " )" );
 							stack.remove( 0 );
 							actions.add( 0, ()-> {
+		                        breakPoint = !placeNode.setSelected( true );
+		                        breakPoint |= !placeLoopNode.setSelected( true );
                                 inside = true;
 								stack.add( 0, sf );
 								sf.w = oldW;
@@ -209,6 +218,8 @@ public class Compaction implements AlgorithmStage{
 						else
 						{ //nur "undo aktion" hinzufügen
 							actions.add( 0, ()-> {
+		                        breakPoint = !placeNode.setSelected( true );
+		                        breakPoint |= !placeLoopNode.setSelected( true );
                                 inside = true;
 								sf.w = oldW;
 								sf.w.setSelected( layout );
@@ -255,6 +266,8 @@ public class Compaction implements AlgorithmStage{
 					    System.out.println( "return place_block( " + sf.v + " )" );
 						stack.remove( 0 );
 						actions.add( 0, ()-> {
+	                        breakPoint = !placeNode.setSelected( true );
+	                        breakPoint |= !placeLoopNode.setSelected( true );
                             inside = true;
 							stack.add( 0, sf );
 							stack.get( 0 ).v.setSink(  oldSink, layout );
@@ -268,6 +281,8 @@ public class Compaction implements AlgorithmStage{
 					else
 					{ //nur "undo aktion" hinzufügen
 						actions.add( 0, ()-> {
+	                        breakPoint = !placeNode.setSelected( true );
+	                        breakPoint |= !placeLoopNode.setSelected( true );
                             inside = true;
 							stack.get( 0 ).v.setSink(  oldSink, layout );
 							sinkOfU.setShift( oldShift, layout );
@@ -283,6 +298,8 @@ public class Compaction implements AlgorithmStage{
 		else if( state == CompactionState.APPLY_SHIFT )// "Compute absolute coordinates"
 		{
             inside = true;
+            breakPoint = !applyNode.setSelected( true );
+            breakPoint |= !applyLoopNode.setSelected( true );
 		    if( vIndex >= graph.getContainedNodes().size() )
 		    {
                 inside = false;
@@ -300,8 +317,8 @@ public class Compaction implements AlgorithmStage{
 				v.setX( v.getX( layout ) + v.getSink( layout ).getShift( layout ), true, layout );
 			actions.add( 0, ()-> {
                 inside = true;
-                applyNode.setSelected( true );
-                applyLoopNode.setSelected( true );
+                breakPoint = !applyNode.setSelected( true );
+                breakPoint |= !applyLoopNode.setSelected( true );
 				v.setX( oldX, oldDef, layout );
 				v.setSelected( layout );
 				vIndex--;
@@ -316,6 +333,8 @@ public class Compaction implements AlgorithmStage{
 		}
 		if( actions.size() != acSize + 1 )
 			System.out.println( "ERROR" );
+		if( breakPoint )
+		    return StageStatus.BREAKPOINT;
 		return StageStatus.UNFINISHED;
 	}
 
@@ -330,6 +349,8 @@ public class Compaction implements AlgorithmStage{
 		}
 		actions.get( 0 ).reverse();
 		actions.remove( 0 );
+        if( breakPoint )
+            return StageStatus.BREAKPOINT;
 		return StageStatus.UNFINISHED;
 	}
 
@@ -353,7 +374,7 @@ public class Compaction implements AlgorithmStage{
         {
             CompactionState oldState = state;
             StageStatus stage = StageStatus.UNFINISHED;
-            while( state == oldState && stage != StageStatus.FINISHED )
+            while( state == oldState && stage == StageStatus.UNFINISHED )
                 stage = forwardStep();
             return stage;
         }
@@ -366,7 +387,7 @@ public class Compaction implements AlgorithmStage{
         if( !inside )
         {
             StageStatus status = StageStatus.UNFINISHED;
-            while( status != StageStatus.FINISHED )
+            while( status == StageStatus.UNFINISHED )
                 status = forwardStep();
             return status;
         }
@@ -374,7 +395,7 @@ public class Compaction implements AlgorithmStage{
         {
             CompactionState oldState = state;
             StageStatus stage = StageStatus.UNFINISHED;
-            while( state == oldState && stage != StageStatus.FINISHED )
+            while( state == oldState && stage == StageStatus.UNFINISHED )
                 stage = forwardStep();
             return stage;
         }
@@ -386,7 +407,7 @@ public class Compaction implements AlgorithmStage{
         {
             CompactionState oldState = state;
             StageStatus stage = StageStatus.UNFINISHED;
-            while( state == oldState && stage != StageStatus.FINISHED )
+            while( state == oldState && stage == StageStatus.UNFINISHED )
                 stage = backwardStep();
             return stage;
         }
@@ -399,7 +420,7 @@ public class Compaction implements AlgorithmStage{
         if( !inside )
         {
             StageStatus status = StageStatus.UNFINISHED;
-            while( status != StageStatus.FINISHED )
+            while( status == StageStatus.UNFINISHED )
                 status = backwardStep();
             return status;
         }
@@ -407,7 +428,7 @@ public class Compaction implements AlgorithmStage{
         {
             CompactionState oldState = state;
             StageStatus stage = StageStatus.UNFINISHED;
-            while( state == oldState && stage != StageStatus.FINISHED )
+            while( state == oldState && stage == StageStatus.UNFINISHED )
                 stage = backwardStep();
             return stage;
         }

src/bk/ConflictDetection.java

@@ -32,7 +32,7 @@ public class ConflictDetection implements AlgorithmStage {
     	int oldI = i;
     	int oldL1 = l1;
     	((PseudoCodeNode)markNode.getParent()).setSelected( true );
-    	markNode.setSelected( true );
+    	boolean breakPoint = !markNode.setSelected( true );
     	if( i + 1 >= graph.getContainedLayers().size() - 1 )
     	{
             ((PseudoCodeNode)markNode.getParent()).setSelected( false );
@@ -81,6 +81,8 @@ public class ConflictDetection implements AlgorithmStage {
             for( LayeredGraphEdge c : conflicts )
             	c.setConflicted( false, null );
     	});
+    	if( status != StageStatus.FINISHED && breakPoint )
+    	    return StageStatus.BREAKPOINT;
     	return status;
     }
     
@@ -106,7 +108,7 @@ public class ConflictDetection implements AlgorithmStage {
     @Override
     public StageStatus backwardStep() {
         ((PseudoCodeNode)markNode.getParent()).setSelected( true );
-        markNode.setSelected( true );
+        boolean breakPoint = !markNode.setSelected( true );
         if( actions.size() == 0 )
         {
             ((PseudoCodeNode)markNode.getParent()).setSelected( false );
@@ -115,6 +117,8 @@ public class ConflictDetection implements AlgorithmStage {
         }
         actions.get( 0 ).reverse();
         actions.remove( 0 );
+        if( breakPoint )
+            return StageStatus.BREAKPOINT;
         return StageStatus.UNFINISHED;
     }
 
@@ -136,7 +140,7 @@ public class ConflictDetection implements AlgorithmStage {
     @Override
     public StageStatus forwardStepOut() {
         StageStatus status = StageStatus.UNFINISHED;
-        while( status != StageStatus.FINISHED )
+        while( status == StageStatus.UNFINISHED )
             status = forwardStep();
         return status;
     }
@@ -149,7 +153,7 @@ public class ConflictDetection implements AlgorithmStage {
     @Override
     public StageStatus backwardStepOut() {
         StageStatus status = StageStatus.UNFINISHED;
-        while( status != StageStatus.FINISHED )
+        while( status == StageStatus.UNFINISHED )
             status = backwardStep();
         return status;
     }

src/bk/ExtremalLayoutCalc.java

@@ -131,31 +131,42 @@ public class ExtremalLayoutCalc implements AlgorithmStage {
     
     private StageStatus forward( String fName )
     {
+        boolean breakpoint = false;
         try {
             if( status == LayoutState.BLOCK_CALCULATION )
             {
-                bcNode.setSelected( true );
-                if( (StageStatus)(BlockCalc.class.getMethod( fName ).invoke( bc ) ) == StageStatus.FINISHED )
+                breakpoint |= !bcNode.setSelected( true );
+                switch( (StageStatus)(BlockCalc.class.getMethod( fName ).invoke( bc ) ) )
                 {
+                case FINISHED:
                     inside = false;
                     bcNode.setSelected( false );
                     cpNode.setSelected( true );
                     status = LayoutState.COMPACTION;
-                }
-                else
+                    break;
+                case BREAKPOINT:
+                    inside = true;
+                    return StageStatus.BREAKPOINT;
+                case UNFINISHED:
                     inside = true;
+                }
                 return StageStatus.UNFINISHED;
             }
             if( status == LayoutState.COMPACTION )
             {
-                if( (StageStatus)(Compaction.class.getMethod( fName ).invoke( cp ) ) == StageStatus.FINISHED )
+                breakpoint |= !cpNode.setSelected( true );
+                switch( (StageStatus)(Compaction.class.getMethod( fName ).invoke( cp ) ) )
                 {
+                case FINISHED:
                     inside = false;
                     cpNode.setSelected( false );
                     return StageStatus.FINISHED;
-                }
-                else
+                case BREAKPOINT:
+                    inside = true;
+                    return StageStatus.BREAKPOINT;
+                case UNFINISHED:
                     inside = true;
+                }
             }
         } catch (IllegalAccessException e) {
             e.printStackTrace();
@@ -168,35 +179,47 @@ public class ExtremalLayoutCalc implements AlgorithmStage {
         } catch (SecurityException e) {
             e.printStackTrace();
         }
+        if( breakpoint )
+            return StageStatus.BREAKPOINT;
         return StageStatus.UNFINISHED;
     }
     
     private StageStatus backward( String fName )
     {
+        boolean breakpoint = false;
         try {
             if( status == LayoutState.BLOCK_CALCULATION )
             {
-                bcNode.setSelected( true );
-                if( (StageStatus)(BlockCalc.class.getMethod( fName ).invoke( bc ) ) == StageStatus.FINISHED )
+                breakpoint |= !bcNode.setSelected( true );
+                switch( (StageStatus)(BlockCalc.class.getMethod( fName ).invoke( bc ) ) )
                 {
+                case FINISHED:
                     inside = false;
                     bcNode.setSelected( false );
                     return StageStatus.FINISHED;
-                }
-                else
+                case BREAKPOINT:
+                    inside = true;
+                    return StageStatus.BREAKPOINT;
+                case UNFINISHED:
                     inside = true;
+                }
             }
             if( status == LayoutState.COMPACTION )
             {
-                cpNode.setSelected( true );
-                if( (StageStatus)(Compaction.class.getMethod( fName ).invoke( cp ) ) == StageStatus.FINISHED )
+                breakpoint |= !cpNode.setSelected( true );
+                switch( (StageStatus)(Compaction.class.getMethod( fName ).invoke( cp ) ) )
                 {
+                case FINISHED:
                     inside = false;
                     cpNode.setSelected( false );
                     status = LayoutState.BLOCK_CALCULATION;
-                }
-                else
+                    break;
+                case BREAKPOINT:
+                    inside = true;
+                    return StageStatus.BREAKPOINT;
+                case UNFINISHED:
                     inside = true;
+                }
             }
         } catch (IllegalAccessException e) {
             e.printStackTrace();
@@ -209,6 +232,8 @@ public class ExtremalLayoutCalc implements AlgorithmStage {
         } catch (SecurityException e) {
             e.printStackTrace();
         }
+        if( breakpoint )
+            return StageStatus.BREAKPOINT;
         return StageStatus.UNFINISHED;
     }
 }