random graph generieren ist jetzt simple implementiert möglich

src/animation/PseudoCodeNode.java

@@ -27,10 +27,13 @@ public class PseudoCodeNode extends DefaultMutableTreeNode {
     
     public void setSelected( boolean selected )
     {
-        if( selected )
-            MainView.pseudoTree.expandPath( new TreePath( this.getPath() ) );
-        else
-            MainView.pseudoTree.collapsePath( new TreePath( this.getPath() ) );
+        if( MainView.pseudoTree != null )
+        {
+            if( selected )
+                MainView.pseudoTree.expandPath( new TreePath( this.getPath() ) );
+            else
+                MainView.pseudoTree.collapsePath( new TreePath( this.getPath() ) );
+        }
         this.selected = selected;
     }
 }

src/bk/BKNodePlacement.java

@@ -70,6 +70,7 @@ public class BKNodePlacement extends AnimatedAlgorithm {
 	public PseudoCodeNode createPseudocodeTree()
 	{
 	    PseudoCodeNode root = new PseudoCodeNode( "BK Node Placement Algorithm" );
+	    root.setSelected( true );
         conflictsNode = conftion.createPseudocodeTree();
         layout1Node = layouts[ 0 ].createPseudocodeTree();
         layout2Node = layouts[ 1 ].createPseudocodeTree();

src/graph/RandomGraphGenerator.java

@@ -67,6 +67,8 @@ public class RandomGraphGenerator {
                         }
                     }
                     n.setName( "" + (index+1) );
+                    n.setWidth( 40, null );
+                    n.setHeight( 40, null );
                     index++;
                 }
             }

src/view/MainView.java

@@ -4,15 +4,20 @@ import java.awt.BorderLayout;
 import java.awt.Color;
 import java.awt.Dimension;
 import java.awt.Font;
+import java.awt.GridBagConstraints;
+import java.awt.GridBagLayout;
 import java.awt.GridLayout;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import java.awt.event.ComponentAdapter;
 import java.awt.event.ComponentEvent;
+import java.awt.event.FocusEvent;
+import java.awt.event.FocusListener;
 import java.awt.event.KeyEvent;
 import java.awt.event.KeyListener;
 
 import javax.swing.JButton;
+import javax.swing.JDialog;
 import javax.swing.JFrame;
 import javax.swing.JLabel;
 import javax.swing.JLayeredPane;
@@ -21,7 +26,6 @@ import javax.swing.JScrollPane;
 import javax.swing.JTextArea;
 import javax.swing.JTextField;
 import javax.swing.JTree;
-import javax.swing.UIManager;
 import javax.swing.event.DocumentEvent;
 import javax.swing.event.DocumentListener;
 
@@ -29,9 +33,12 @@ import animation.Action;
 import animation.AnimationController;
 import bk.BKNodePlacement;
 import bk.ExtremalLayoutCalc.LayoutType;
+import graph.InitializeNodePositions;
 import graph.LayeredGraphEdge;
 import graph.LayeredGraphNode;
+import graph.RandomGraphGenerator;
 import graph.io.Writer;
+import lib.SweepCrossingMinimizer;
 
 /**
  * The main window of the application.
@@ -57,7 +64,7 @@ public class MainView {
     private JButton runBackward;
     private JButton pause;
     private JButton debug;
-    private JButton generateRandom;
+    private JButton randomGraph;
     private JLabel delayText;
     private JTextField delay;
     public static JTree pseudoTree;
@@ -249,15 +256,295 @@ public class MainView {
             }
             
         });
-        generateRandom = new NiceButton( "generateRandom" );
-        generateRandom.setLocation( 350, 60 );
-        generateRandom.addActionListener( new ActionListener() {
+        randomGraph = new NiceButton( "randomGraph" );
+        randomGraph.setLocation( 350, 60 );
+        randomGraph.addActionListener( new ActionListener() {
 
             @Override
             public void actionPerformed(ActionEvent e) {
-                
+                JDialog diag = new JDialog( frame, "Zufälligen Graph gennerieren" );
+                diag.setLayout( new GridBagLayout() );
+                GridBagConstraints c = new GridBagConstraints();
+                c.gridx = 0;
+                c.gridy = 0;
+                diag.add( new JLabel( "P(Subgraph exists)="), c );
+                c = new GridBagConstraints();
+                c.gridx = 1;
+                c.gridy = 0;
+                JTextField pSubgraph = new JTextField( "0.1" );
+                pSubgraph.setPreferredSize( new Dimension( 100, 20 ) );
+                pSubgraph.addFocusListener( new FocusListener() {
+                    @Override
+                    public void focusGained(FocusEvent e) {
+                        pSubgraph.setBackground( Color.WHITE );
+                    }
+
+                    @Override
+                    public void focusLost(FocusEvent e) {
+                        try {
+                            double d = Double.parseDouble( pSubgraph.getText() );
+                            if( d > 1 || d < 0 )
+                                pSubgraph.setBackground( Color.RED );
+                        } catch( Exception e1 )
+                        {
+                            pSubgraph.setBackground( Color.RED );
+                        }
+                    }
+                });
+                diag.add( pSubgraph, c );
+                c = new GridBagConstraints();
+                c.gridx = 0;
+                c.gridy = 1;
+                diag.add( new JLabel( "P(Edge exists)="), c );
+                c = new GridBagConstraints();
+                c.gridx = 1;
+                c.gridy = 1;
+                JTextField pEdge = new JTextField( "0.3" );
+                pEdge.setPreferredSize( new Dimension( 100, 20 ) );
+                pEdge.addFocusListener( new FocusListener() {
+                    @Override
+                    public void focusGained(FocusEvent e) {
+                        pEdge.setBackground( Color.WHITE );
+                    }
+
+                    @Override
+                    public void focusLost(FocusEvent e) {
+                        try {
+                            double d = Double.parseDouble( pEdge.getText() );
+                            if( d > 1 || d < 0 )
+                                pEdge.setBackground( Color.RED );
+                        } catch( Exception e1 )
+                        {
+                            pEdge.setBackground( Color.RED );
+                        }
+                    }
+                });
+                diag.add( pEdge, c );
+                c = new GridBagConstraints();
+                c.gridx = 0;
+                c.gridy = 2;
+                diag.add( new JLabel( "Minimal Layers="), c );
+                c = new GridBagConstraints();
+                c.gridx = 1;
+                c.gridy = 2;
+                JTextField minLayers = new JTextField( "5" );
+                JTextField maxLayers = new JTextField( "5" );
+                minLayers.setPreferredSize( new Dimension( 100, 20 ) );
+                minLayers.addFocusListener( new FocusListener() {
+                    @Override
+                    public void focusGained(FocusEvent e) {
+                        minLayers.setBackground( Color.WHITE );
+                    }
+
+                    @Override
+                    public void focusLost(FocusEvent e) {
+                        try {
+                            int i = Integer.parseInt( minLayers.getText() );
+                            int max = Integer.parseInt( maxLayers.getText() );
+                            if( i < 1 || i > max )
+                                minLayers.setBackground( Color.RED );
+                            else
+                                maxLayers.setBackground( Color.WHITE );
+                        } catch( Exception e1 )
+                        {
+                            minLayers.setBackground( Color.RED );
+                        }
+                    }
+                });
+                diag.add( minLayers, c );
+                c = new GridBagConstraints();
+                c.gridx = 0;
+                c.gridy = 3;
+                diag.add( new JLabel( "Maximal Layers="), c );
+                c = new GridBagConstraints();
+                c.gridx = 1;
+                c.gridy = 3;
+                maxLayers.setPreferredSize( new Dimension( 100, 20 ) );
+                maxLayers.addFocusListener( new FocusListener() {
+                    @Override
+                    public void focusGained(FocusEvent e) {
+                        maxLayers.setBackground( Color.WHITE );
+                    }
+
+                    @Override
+                    public void focusLost(FocusEvent e) {
+                        try {
+                            int i = Integer.parseInt( maxLayers.getText() );
+                            int min = Integer.parseInt( minLayers.getText() );
+                            if( i < min )
+                                maxLayers.setBackground( Color.RED );
+                            else if( min > 0 )
+                                minLayers.setBackground( Color.WHITE );
+                        } catch( Exception e1 )
+                        {
+                            maxLayers.setBackground( Color.RED );
+                        }
+                    }
+                });
+                diag.add( maxLayers, c );
+                c = new GridBagConstraints();
+                c.gridx = 0;
+                c.gridy = 4;
+                diag.add( new JLabel( "Minimal Nodes="), c );
+                c = new GridBagConstraints();
+                c.gridx = 1;
+                c.gridy = 4;
+                JTextField minNodes = new JTextField( "5" );
+                JTextField maxNodes = new JTextField( "5" );
+                minNodes.setPreferredSize( new Dimension( 100, 20 ) );
+                minNodes.setToolTipText( "Zwischen 1 und 'Maximal Nodes'" );
+                minNodes.addFocusListener( new FocusListener() {
+                    @Override
+                    public void focusGained(FocusEvent e) {
+                        minNodes.setBackground( Color.WHITE );
+                    }
+
+                    @Override
+                    public void focusLost(FocusEvent e) {
+                        try {
+                            int i = Integer.parseInt( minNodes.getText() );
+                            int max = Integer.parseInt( maxNodes.getText() );
+                            if( i < 1 || i > max )
+                                minNodes.setBackground( Color.RED );
+                            else
+                                minNodes.setBackground( Color.WHITE );
+                        } catch( Exception e1 )
+                        {
+                            minNodes.setBackground( Color.RED );
+                        }
+                    }
+                });
+                diag.add( minNodes, c );
+                c = new GridBagConstraints();
+                c.gridx = 0;
+                c.gridy = 5;
+                diag.add( new JLabel( "Maximal Nodes="), c );
+                c = new GridBagConstraints();
+                c.gridx = 1;
+                c.gridy = 5;
+                maxNodes.setPreferredSize( new Dimension( 100, 20 ) );
+                maxNodes.setToolTipText( "Zwischen 'Minimal Nodes' und unendlich" );
+                maxNodes.addFocusListener( new FocusListener() {
+                    @Override
+                    public void focusGained(FocusEvent e) {
+                        maxNodes.setBackground( Color.WHITE );
+                    }
+
+                    @Override
+                    public void focusLost(FocusEvent e) {
+                        try {
+                            int i = Integer.parseInt( maxNodes.getText() );
+                            int min = Integer.parseInt( minNodes.getText() );
+                            if( i < min )
+                                maxNodes.setBackground( Color.RED );
+                            else if( min > 0 )
+                                minNodes.setBackground( Color.WHITE );
+                        } catch( Exception e1 )
+                        {
+                            maxNodes.setBackground( Color.RED );
+                        }
+                    }
+                });
+                diag.add( maxNodes, c );
+                c = new GridBagConstraints();
+                c.gridx = 0;
+                c.gridy = 6;
+                diag.add( new JLabel( "Maximal depth="), c );
+                c = new GridBagConstraints();
+                c.gridx = 1;
+                c.gridy = 6;
+                JTextField maxDepth = new JTextField( "1" );
+                maxDepth.setPreferredSize( new Dimension( 100, 20 ) );
+                maxDepth.setToolTipText( "Zwischen 1 und unendlich" );
+                maxDepth.addFocusListener( new FocusListener() {
+                    @Override
+                    public void focusGained(FocusEvent e) {
+                        maxDepth.setBackground( Color.WHITE );
+                    }
+
+                    @Override
+                    public void focusLost(FocusEvent e) {
+                        try {
+                            int i = Integer.parseInt( maxDepth.getText() );
+                            if( i < 1 )
+                                maxDepth.setBackground( Color.RED );
+                        } catch( Exception e1 )
+                        {
+                            maxDepth.setBackground( Color.RED );
+                        }
+                    }
+                });
+                diag.add( maxDepth, c );
+                c = new GridBagConstraints();
+                c.gridx = 0;
+                c.gridy = 7;
+                c.gridwidth = 2;
+                JButton gen = new JButton( "generate");
+                gen.addActionListener( new ActionListener() {
+
+                    @Override
+                    public void actionPerformed(ActionEvent e) {
+                        double pSubGraphD = Double.parseDouble( pSubgraph.getText() );
+                        double pEdgeD = Double.parseDouble( pEdge.getText() );
+                        int minLayerI = Integer.parseInt( minLayers.getText() );
+                        int maxLayerI = Integer.parseInt( maxLayers.getText() );
+                        int minNodeI = Integer.parseInt( minNodes.getText() );
+                        int maxNodeI = Integer.parseInt( maxNodes.getText() );
+                        int maxDepthI = Integer.parseInt( maxDepth.getText() );
+                        boolean ok = true;
+                        if( pSubGraphD < 0 || pSubGraphD > 1 )
+                        {
+                            pSubgraph.setBackground( Color.RED );
+                            ok = false;
+                        }
+                        if( pEdgeD < 0 || pEdgeD > 1 )
+                        {
+                            pEdge.setBackground( Color.RED );
+                            ok = false;
+                        }
+                        if( minLayerI < 1 )
+                        {
+                            minLayers.setBackground( Color.RED );
+                            ok = false;
+                        }
+                        if( maxLayerI < minLayerI )
+                        {
+                            maxLayers.setBackground( Color.RED );
+                            ok = false;
+                        }
+                        if( minNodeI < 1 )
+                        {
+                            minNodes.setBackground( Color.RED );
+                            ok = false;
+                        }
+                        if( maxNodeI < minNodeI )
+                        {
+                            maxNodes.setBackground( Color.RED );
+                            ok = false;
+                        }
+                        if( maxDepthI < 1 )
+                        {
+                            maxDepth.setBackground( Color.RED );
+                            ok = false;
+                        }
+                        if( ok )
+                        {                            
+                            RandomGraphGenerator r = new RandomGraphGenerator( pSubGraphD, pEdgeD, minLayerI, maxLayerI, minNodeI, maxNodeI, maxDepthI );
+                            LayeredGraphNode graph = r.createRandomNode( null, 0 );
+                            SweepCrossingMinimizer cminzer = new SweepCrossingMinimizer();
+                            for( int i = 0; i < 10; i++ )
+                              cminzer.minimizeCrossings( graph );
+                            InitializeNodePositions.placeNodes( graph );
+                            new MainView( graph );
+                        }
+                    }
+                    
+                });
+                diag.add( gen, c );
+                diag.setSize( 270, 220 );
+                diag.setLocation( frame.getX() + frame.getWidth() / 2 - diag.getWidth() / 2, frame.getY() + frame.getHeight() / 2 - diag.getHeight() / 2 );
+                diag.setVisible( true );
             }
-            
         });
         delayText = new JLabel( "Delay (ms)" );
         delayText.setBounds( 260, 10, 80, 20 );
@@ -384,6 +671,7 @@ public class MainView {
         menue.add( stepBackwardInto );
         menue.add( stepBackwardOut );
         menue.add( runBackward );
+        menue.add( randomGraph );
 		frame.add( menue, BorderLayout.EAST );
 		frame.setSize( frame.getWidth() + 1, frame.getHeight() );
         frame.setSize( frame.getWidth() - 1, frame.getHeight() );