source: branches/MetisMQI/src/main/java/weka/gui/graphvisualizer/GraphVisualizer.java

/*
 *    This program is free software; you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation; either version 2 of the License, or
 *    (at your option) any later version.
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with this program; if not, write to the Free Software
 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

/*
 *    GraphVisualizer.java
 *    Copyright (C) 2003 University of Waikato, Hamilton, New Zealand
 *
 */
package weka.gui.graphvisualizer;

import weka.core.FastVector;
import weka.gui.ExtensionFileFilter;
import weka.gui.visualize.PrintablePanel;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.LayoutManager;
import java.awt.Rectangle;
import java.awt.RenderingHints;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionAdapter;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;

import javax.swing.BorderFactory;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JDialog;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.JTextField;
import javax.swing.JToolBar;
import javax.swing.table.AbstractTableModel;

/**
 * This class displays the graph we want to visualize. It should
 * be sufficient to use only this class in weka.gui.graphvisulizer
 * package to visualize a graph. The description of a graph should
 * be provided as a string argument using readBIF or readDOT method
 * in either XMLBIF03 or DOT format. Alternatively, an InputStream
 * in XMLBIF03 can also be provided to another variation of readBIF.
 * It would be necessary in case input is in DOT format to call the
 * layoutGraph() method to display the graph correctly after the call
 * to readDOT. It is also necessary to do so if readBIF is called and
 * the graph description doesn't have x y positions for nodes.
 * <p> The graph's data is held in two FastVectors, nodes are stored as
 * objects of GraphNode class and edges as objects of GraphEdge class.
 * <p> The graph is displayed by positioning and drawing each node
 * according to its x y position and then drawing all the edges coming
 * out of it give by its edges[][] array, the arrow heads are ofcourse
 * marked in the opposite(ie original direction) or both directions if
 * the edge is reversed or is in both directions. The graph is centered
 * if it is smaller than it's display area. The edges are drawn from the
 * bottom of the current node to the top of the node given by edges[][]
 * array in GraphNode class, to avoid edges crossing over other nodes.
 * This might need to be changed if another layout engine is added or
 * the current Hierarchical engine is updated to avoid such crossings
 * over nodes.
 *
 * @author Ashraf M. Kibriya (amk14@cs.waikato.ac.nz)
 * @version $Revision: 4723 $
 */
public class GraphVisualizer
  extends JPanel
  implements GraphConstants, LayoutCompleteEventListener {

  /** for serialization */
  private static final long serialVersionUID = -2038911085935515624L;
  
  /** Vector containing nodes */
  protected FastVector m_nodes=new FastVector();
  /** Vector containing edges */
  protected FastVector m_edges=new FastVector();
  /** The current LayoutEngine  */
  protected LayoutEngine m_le;
  /** Panel actually displaying the graph */
  protected GraphPanel m_gp;
  /** String containing graph's name */
  protected String graphID;
  
  /**
   * Save button to save the current graph in DOT or XMLBIF format.
   * The graph should be layed out again to get the original form
   * if reloaded from command line, as the formats do not allow
   * saving specific information for a properly layed out graph.
   */
  protected JButton m_jBtSave;
  
  /** path for icons */
  private final String ICONPATH = "weka/gui/graphvisualizer/icons/";
  
  private FontMetrics fm = this.getFontMetrics( this.getFont() );
  private double scale = 1;   //current zoom
  private int nodeHeight = 2*fm.getHeight(), nodeWidth = 24;
  private int paddedNodeWidth = 24+8;
  /** TextField for node's width */
  private final JTextField jTfNodeWidth = new JTextField(3);
  /** TextField for nodes height */
  private final JTextField jTfNodeHeight = new JTextField(3);
  /** Button for laying out the graph again, necessary after changing node's
   * size or some other property of the layout engine
   */
  private final JButton jBtLayout;
  /** used for setting appropriate node size */
  private int maxStringWidth=0;
  /** used when using zoomIn and zoomOut buttons */
  private int [] zoomPercents = { 10, 25, 50, 75, 100, 125, 150, 175, 200, 225,
  250, 275, 300, 350, 400, 450, 500, 550, 600, 650, 700, 800, 900, 999 };
  /** this contains the m_gp GraphPanel */
  JScrollPane m_js;
  
  /**
   * Constructor<br>
   * Sets up the gui and initializes all the other previously
   * uninitialized variables.
   */
  public GraphVisualizer() {
    m_gp = new GraphPanel();
    m_js = new JScrollPane(m_gp);
    
    //creating a new layout engine and adding this class as its listener
    // to receive layoutComplete events
    m_le=new HierarchicalBCEngine(m_nodes, m_edges, 
                                  paddedNodeWidth, nodeHeight);
    m_le.addLayoutCompleteEventListener(this);
    
    m_jBtSave = new JButton();
    java.net.URL tempURL = ClassLoader.getSystemResource(ICONPATH+"save.gif");
    if(tempURL!=null)
      m_jBtSave.setIcon(new ImageIcon(tempURL) );
    else
      System.err.println(ICONPATH+
      "save.gif not found for weka.gui.graphvisualizer.Graph");
    m_jBtSave.setToolTipText("Save Graph");
    m_jBtSave.addActionListener( new ActionListener() {
      public void actionPerformed(ActionEvent ae) {
        JFileChooser fc = new JFileChooser(System.getProperty("user.dir"));
        ExtensionFileFilter ef1 = new ExtensionFileFilter(".dot", "DOT files");
        ExtensionFileFilter ef2 = new ExtensionFileFilter(".xml",
        "XML BIF files");
        fc.addChoosableFileFilter(ef1);
        fc.addChoosableFileFilter(ef2);
        fc.setDialogTitle("Save Graph As");
        int rval = fc.showSaveDialog(GraphVisualizer.this);
        
        if (rval == JFileChooser.APPROVE_OPTION) {
          //System.out.println("Saving to file \""+
          //                   f.getAbsoluteFile().toString()+"\"");
          if(fc.getFileFilter()==ef2) {
            String filename = fc.getSelectedFile().toString();
            if(!filename.endsWith(".xml"))
              filename = filename.concat(".xml");
            BIFParser.writeXMLBIF03(filename, graphID, m_nodes, m_edges);
          }
          else {
            String filename = fc.getSelectedFile().toString();
            if(!filename.endsWith(".dot"))
              filename = filename.concat(".dot");
            DotParser.writeDOT(filename, graphID, m_nodes, m_edges);
          }
        }
      }
    });
    
    final JButton jBtZoomIn = new JButton();
    tempURL = ClassLoader.getSystemResource(ICONPATH+"zoomin.gif");
    if(tempURL!=null)
      jBtZoomIn.setIcon(new ImageIcon(tempURL) );
    else
      System.err.println(ICONPATH+
      "zoomin.gif not found for weka.gui.graphvisualizer.Graph");
    jBtZoomIn.setToolTipText("Zoom In");
    
    final JButton jBtZoomOut = new JButton();
    tempURL = ClassLoader.getSystemResource(ICONPATH+"zoomout.gif");
    if(tempURL!=null)
      jBtZoomOut.setIcon(new ImageIcon(tempURL) );
    else
      System.err.println(ICONPATH+
      "zoomout.gif not found for weka.gui.graphvisualizer.Graph");
    jBtZoomOut.setToolTipText("Zoom Out");
    
    final JTextField jTfZoom = new JTextField("100%");
    jTfZoom.setMinimumSize( jTfZoom.getPreferredSize() );
    jTfZoom.setHorizontalAlignment(JTextField.CENTER);
    jTfZoom.setToolTipText("Zoom");
    
    jTfZoom.addActionListener( new ActionListener() {
      public void actionPerformed(ActionEvent ae) {
        JTextField jt = (JTextField)ae.getSource();
        try {
          int i=-1;
          i = jt.getText().indexOf('%');
          if(i==-1)
            i = Integer.parseInt(jt.getText());
          else
            i = Integer.parseInt(jt.getText().substring(0,i));
          
          if(i<=999)
            scale = i/100D;
          
          jt.setText((int)(scale*100)+"%");
          
          if(scale>0.1){
            if(!jBtZoomOut.isEnabled())
              jBtZoomOut.setEnabled(true);
          }
          else
            jBtZoomOut.setEnabled(false);
          if(scale<9.99) {
            if(!jBtZoomIn.isEnabled())
              jBtZoomIn.setEnabled(true);
          }
          else
            jBtZoomIn.setEnabled(false);
          
          setAppropriateSize();
          //m_gp.clearBuffer();
          m_gp.repaint();
          m_gp.invalidate();
          m_js.revalidate();
        } catch(NumberFormatException ne) {
          JOptionPane.showMessageDialog(GraphVisualizer.this.getParent(),
          "Invalid integer entered for zoom.",
          "Error",
          JOptionPane.ERROR_MESSAGE);
          jt.setText((scale*100)+"%");
        }
      }
    });
    
    
    jBtZoomIn.addActionListener( new ActionListener() {
      public void actionPerformed(ActionEvent ae) {
        int i=0, s = (int)(scale*100);
        if(s<300)
          i = s/25;
        else if(s<700)
          i = 6 +  s/50;
        else
          i = 13 +s/100;
        
        if(s>=999) {
          JButton b = (JButton)ae.getSource();
          b.setEnabled(false);
          return;
        }
        else if(s>=10){
          if(i>=22) {
            JButton b = (JButton)ae.getSource();
            b.setEnabled(false);
          }
          if(s==10 && !jBtZoomOut.isEnabled())
            jBtZoomOut.setEnabled(true);
          //System.out.println("i: "+i+"Zoom is: "+zoomPercents[i+1]);
          jTfZoom.setText(zoomPercents[i+1]+"%");
          scale = zoomPercents[i+1]/100D;
        }
        else {
          if(!jBtZoomOut.isEnabled())
            jBtZoomOut.setEnabled(true);
          //System.out.println("i: "+i+"Zoom is: "+zoomPercents[0]);
          jTfZoom.setText(zoomPercents[0]+"%");
          scale = zoomPercents[0]/100D;
        }
        setAppropriateSize();
        m_gp.repaint();
        m_gp.invalidate();
        m_js.revalidate();
      }
    });
    
    
    jBtZoomOut.addActionListener( new ActionListener() {
      public void actionPerformed(ActionEvent ae) {
        int i=0, s = (int)(scale*100);
        if(s<300)
          i = (int) Math.ceil(s/25D);
        else if(s<700)
          i = 6 +  (int) Math.ceil(s/50D);
        else
          i = 13 + (int) Math.ceil(s/100D);
        
        if(s<=10) {
          JButton b = (JButton)ae.getSource();
          b.setEnabled(false);
        }
        else if(s<999) {
          if(i<=1) {
            JButton b = (JButton)ae.getSource();
            b.setEnabled(false);
          }
          //System.out.println("i: "+i+"Zoom is: "+zoomPercents[i-1]);
          jTfZoom.setText(zoomPercents[i-1]+"%");
          scale = zoomPercents[i-1]/100D;
        }
        else{
          if(!jBtZoomIn.isEnabled())
            jBtZoomIn.setEnabled(true);
          //System.out.println("i: "+i+"Zoom is: "+zoomPercents[22]);
          jTfZoom.setText(zoomPercents[22]+"%");
          scale = zoomPercents[22]/100D;
        }
        setAppropriateSize();
        m_gp.repaint();
        m_gp.invalidate();
        m_js.revalidate();
      }
    });
    
    
    //This button pops out the extra controls
    JButton jBtExtraControls = new JButton();
    tempURL = ClassLoader.getSystemResource(ICONPATH+"extra.gif");
    if(tempURL!=null)
      jBtExtraControls.setIcon(new ImageIcon(tempURL) );
    else
      System.err.println(ICONPATH+
      "extra.gif not found for weka.gui.graphvisualizer.Graph");
    jBtExtraControls.setToolTipText("Show/Hide extra controls");
    
    
    final JCheckBox jCbCustomNodeSize = new JCheckBox("Custom Node Size");
    final JLabel jLbNodeWidth = new JLabel("Width");
    final JLabel jLbNodeHeight = new JLabel("Height");
    
    jTfNodeWidth.setHorizontalAlignment(JTextField.CENTER);
    jTfNodeWidth.setText(""+nodeWidth);
    jTfNodeHeight.setHorizontalAlignment(JTextField.CENTER);
    jTfNodeHeight.setText(""+nodeHeight);
    jLbNodeWidth.setEnabled(false);
    jTfNodeWidth.setEnabled(false);
    jLbNodeHeight.setEnabled(false);
    jTfNodeHeight.setEnabled(false);
    
    jCbCustomNodeSize.addActionListener( new ActionListener() {
      public void actionPerformed(ActionEvent ae) {
        if( ((JCheckBox)ae.getSource()).isSelected() ) {
          jLbNodeWidth.setEnabled(true);
          jTfNodeWidth.setEnabled(true);
          jLbNodeHeight.setEnabled(true);
          jTfNodeHeight.setEnabled(true);
        }
        else {
          jLbNodeWidth.setEnabled(false);
          jTfNodeWidth.setEnabled(false);
          jLbNodeHeight.setEnabled(false);
          jTfNodeHeight.setEnabled(false);
          setAppropriateNodeSize();
        }
      }
    });
    
    
    jBtLayout  = new JButton("Layout Graph");
    jBtLayout.addActionListener( new ActionListener() {
      public void actionPerformed(ActionEvent ae) {
        int tmpW, tmpH;
        
        if(jCbCustomNodeSize.isSelected()) {
          try{ tmpW = Integer.parseInt(jTfNodeWidth.getText()); }
          catch(NumberFormatException ne) {
            JOptionPane.showMessageDialog(GraphVisualizer.this.getParent(),
            "Invalid integer entered for node width.",
            "Error",
            JOptionPane.ERROR_MESSAGE);
            tmpW = nodeWidth;
            jTfNodeWidth.setText(""+nodeWidth);
            
          }
          try{ tmpH = Integer.parseInt(jTfNodeHeight.getText()); }
          catch(NumberFormatException ne) {
            JOptionPane.showMessageDialog(GraphVisualizer.this.getParent(),
            "Invalid integer entered for node height.",
            "Error",
            JOptionPane.ERROR_MESSAGE);
            tmpH = nodeHeight;
            jTfNodeWidth.setText(""+nodeHeight);
          }
          
          if(tmpW!=nodeWidth || tmpH!=nodeHeight) {
            nodeWidth = tmpW; paddedNodeWidth = nodeWidth+8; nodeHeight = tmpH;
          }
        }
        JButton bt = (JButton)ae.getSource();
        bt.setEnabled(false);
        m_le.setNodeSize(paddedNodeWidth, nodeHeight);
        m_le.layoutGraph();
      }
    });
    
    
    GridBagConstraints gbc = new GridBagConstraints();
    
    final JPanel p = new JPanel(new GridBagLayout());
    gbc.gridwidth = gbc.REMAINDER;
    gbc.anchor = gbc.NORTHWEST;
    gbc.fill = gbc.NONE;
    p.add( m_le.getControlPanel(), gbc);
    gbc.gridwidth = 1;
    gbc.insets = new Insets(8,0,0,0);
    gbc.anchor = gbc.NORTHWEST;
    gbc.gridwidth = gbc.REMAINDER;
    
    p.add( jCbCustomNodeSize, gbc );
    gbc.insets = new Insets(0,0,0,0);
    gbc.gridwidth = gbc.REMAINDER;
    Container c = new Container();
    c.setLayout( new GridBagLayout() );
    gbc.gridwidth = gbc.RELATIVE;
    c.add(jLbNodeWidth, gbc);
    gbc.gridwidth = gbc.REMAINDER;
    c.add(jTfNodeWidth, gbc);
    gbc.gridwidth = gbc.RELATIVE;
    c.add(jLbNodeHeight, gbc);
    gbc.gridwidth = gbc.REMAINDER;
    c.add(jTfNodeHeight, gbc);
    gbc.fill = gbc.HORIZONTAL;
    p.add( c, gbc );
    
    gbc.anchor = gbc.NORTHWEST;
    gbc.insets = new Insets(8,0,0,0);
    gbc.fill = gbc.HORIZONTAL;
    p.add( jBtLayout, gbc );
    gbc.fill = gbc.NONE;
    p.setBorder(BorderFactory.createCompoundBorder(
    BorderFactory.createTitledBorder("ExtraControls"),
    BorderFactory.createEmptyBorder(4,4,4,4)
    ) );
    p.setPreferredSize( new Dimension(0, 0) );
    
    final JToolBar jTbTools = new JToolBar();
    jTbTools.setFloatable(false);
    jTbTools.setLayout( new GridBagLayout() );
    gbc.anchor = gbc.NORTHWEST;
    gbc.gridwidth = gbc.REMAINDER;
    gbc.insets = new Insets(0,0,0,0);
    jTbTools.add(p,gbc);
    gbc.gridwidth = 1;
    jTbTools.add(m_jBtSave, gbc);
    jTbTools.addSeparator(new Dimension(2,2));
    jTbTools.add(jBtZoomIn, gbc);
    
    gbc.fill = gbc.VERTICAL;
    gbc.weighty = 1;
    JPanel p2 = new JPanel(new BorderLayout());
    p2.setPreferredSize( jTfZoom.getPreferredSize() );
    p2.setMinimumSize( jTfZoom.getPreferredSize() );
    p2.add(jTfZoom, BorderLayout.CENTER);
    jTbTools.add(p2, gbc);
    gbc.weighty =0;
    gbc.fill = gbc.NONE;
    
    jTbTools.add(jBtZoomOut, gbc);
    jTbTools.addSeparator(new Dimension(2,2));
    jTbTools.add(jBtExtraControls, gbc);
    jTbTools.addSeparator(new Dimension(4,2));
    gbc.weightx = 1;
    gbc.fill = gbc.BOTH;
    jTbTools.add(m_le.getProgressBar(), gbc);
    
    jBtExtraControls.addActionListener( new ActionListener() {
      public void actionPerformed(ActionEvent ae) {
        Dimension d = p.getPreferredSize();
        if(d.width==0 || d.height==0) {
          LayoutManager lm = p.getLayout();
          Dimension d2 = lm.preferredLayoutSize(p);
          p.setPreferredSize(d2); jTbTools.revalidate();
          /*
          // this piece of code adds in an animation
          // for popping out the extra controls panel
          Thread th = new Thread() {
            int h = 0, w = 0;
            LayoutManager lm = p.getLayout();
            Dimension d2 = lm.preferredLayoutSize(p);
           
            int tow = (int)d2.getWidth(), toh = (int)d2.getHeight();
            //toh = (int)d2.getHeight();
            //tow = (int)d2.getWidth();
           
            public void run() {
              while(h<toh || w<tow) {
                if((h+10)<toh)
                  h += 10;
                else if(h<toh)
                  h = toh;
                if((w+10)<tow)
                  w += 10;
                else if(w<tow)
                  w = tow;
                p.setPreferredSize(new Dimension(w, h));
                //p.invalidate();
                jTbTools.revalidate();
                //paint(Temp4.this.getGraphics());
                try {this.sleep(30);}
                catch(InterruptedException ie) {ie.printStackTrace(); break;}
              }
              p.setPreferredSize(new Dimension(tow,toh)); jTbTools.revalidate();
            }
          };
          th.start();
           */
        }
        else {
          p.setPreferredSize( new Dimension(0,0) );
          jTbTools.revalidate();
          /*
          Thread th = new Thread() {
            int h = p.getHeight(), w = p.getWidth();
            LayoutManager lm = p.getLayout();
            int tow = 0, toh = 0;
           
            public void run() {
              while(h>toh || w>tow) {
                if((h-10)>toh)
                  h -= 10;
                else if(h>toh)
                  h = toh;
                if((w-10)>tow)
                  w -= 10;
                else if(w>tow)
                  w = tow;
           
                p.setPreferredSize(new Dimension(w, h));
                //p.invalidate();
                jTbTools.revalidate();
                //paint(Temp4.this.getGraphics());
                try {this.sleep(30);}
                catch(InterruptedException ie) {ie.printStackTrace(); break;}
              }
              p.setPreferredSize(new Dimension(tow,toh)); jTbTools.revalidate();
            }
          };
          th.start();
           */
        }
      }
    });
    this.setLayout( new BorderLayout() );
    this.add(jTbTools, BorderLayout.NORTH);
    this.add(m_js, BorderLayout.CENTER);
  }
  
  
  /**
   * This method sets the node size that is appropriate
   * considering the maximum label size that is present.
   * It is used internally when custom node size checkbox
   * is unchecked.
   */
  protected void setAppropriateNodeSize() {
    int strWidth;
    if(maxStringWidth==0)
      for(int i=0; i<m_nodes.size(); i++) {
        strWidth = fm.stringWidth(((GraphNode)m_nodes.elementAt(i)).lbl);
        if(strWidth>maxStringWidth)
          maxStringWidth=strWidth;
      }
    nodeWidth = maxStringWidth+4;
    paddedNodeWidth = nodeWidth+8;
    jTfNodeWidth.setText(""+nodeWidth);
    
    nodeHeight = 2*fm.getHeight();
    jTfNodeHeight.setText(""+nodeHeight);
  }
  
  /**
   * Sets the preferred size for m_gp GraphPanel to the
   * minimum size that is neccessary to display the graph.
   */
  protected void setAppropriateSize() {
    int maxX=0, maxY=0;
    
    m_gp.setScale(scale, scale);
    
    for(int i=0; i<m_nodes.size(); i++) {
      GraphNode n = (GraphNode)m_nodes.elementAt(i);
      if(maxX<n.x)
        maxX=n.x;
      if(maxY<n.y)
        maxY=n.y;
    }
    //System.out.println("Scale: "+scale+" paddedWidth: "+paddedNodeWidth+
    //                   " nodeHeight: "+nodeHeight+"\nmaxX: "+maxX+" maxY: "+
    //                   maxY+" final: "+(int)((maxX+paddedNodeWidth+2)*scale)+
    //                   ","+(int)((maxY+nodeHeight+2)*scale) );
    m_gp.setPreferredSize(new Dimension((int)((maxX+paddedNodeWidth+2)*scale),
    (int)((maxY+nodeHeight+2)*scale)));
    //System.out.println("Size set to "+this.getPreferredSize());
  }
  
  
  /**
   * This method is an implementation for LayoutCompleteEventListener
   * class. It sets the size appropriate for m_gp GraphPanel and
   * and revalidates it's container JScrollPane once a
   * LayoutCompleteEvent is received from the LayoutEngine.
   */
  public void layoutCompleted(LayoutCompleteEvent le) {
    setAppropriateSize();
    //m_gp.clearBuffer();
    m_gp.invalidate();
    m_js.revalidate();
    m_gp.repaint();
    jBtLayout.setEnabled(true);
  }
  
  
  /**
   * This method lays out the graph by calling the
   * LayoutEngine's layoutGraph() method. This method
   * should be called to display the graph nicely, unless
   * the input XMLBIF03 already contains some layout
   * information (ie the x,y positions of nodes.
   */
  public void layoutGraph() {
    if(m_le!=null)
      m_le.layoutGraph();
    
  }
  
  /*********************************************************
   *
   *  BIF reader<br>
   *  Reads a graph description in XMLBIF03 from a string
   *
   *********************************************************
   */
  public void readBIF(String instring) throws BIFFormatException {
    BIFParser bp = new BIFParser(instring, m_nodes, m_edges);
    try {
      graphID = bp.parse();
    } catch(BIFFormatException bf) {
      System.out.println("BIF format error");
      bf.printStackTrace();
    }
    catch(Exception ex) { ex.printStackTrace(); return; }
    
    setAppropriateNodeSize();
    if(m_le!=null) {
      m_le.setNodeSize(paddedNodeWidth, nodeHeight);
    }
  } //end readBIF1
  
  /**
   *
   *  BIF reader<br>
   *  Reads a graph description in XMLBIF03 from an InputStrem
   *
   *
   */
  public void readBIF(InputStream instream) throws BIFFormatException {
    BIFParser bp = new BIFParser(instream, m_nodes, m_edges);
    try {
      graphID = bp.parse();
    } catch(BIFFormatException bf) {
      System.out.println("BIF format error");
      bf.printStackTrace();
    }
    catch(Exception ex) { ex.printStackTrace(); return; }
    
    setAppropriateNodeSize();
    if(m_le!=null) {
      m_le.setNodeSize(paddedNodeWidth, nodeHeight);
    }
    setAppropriateSize();
  } //end readBIF2
  
  
  /*********************************************************
   *
   *  Dot reader<br>
   *  Reads a graph description in DOT format from a string
   *
   *********************************************************
   */
  public void readDOT(Reader input) {
    DotParser dp = new DotParser(input, m_nodes, m_edges);
    graphID = dp.parse();
    
    setAppropriateNodeSize();
    if(m_le!=null) {
      m_le.setNodeSize(paddedNodeWidth, nodeHeight);
      jBtLayout.setEnabled(false);
      layoutGraph();
    }
  }
  
  /**
   * The panel which contains the actual graph.
   */
  private class GraphPanel
    extends PrintablePanel {

    /** for serialization */
    private static final long serialVersionUID = -3562813603236753173L;

    public GraphPanel() {
      super();
      this.addMouseListener( new GraphVisualizerMouseListener() );
      this.addMouseMotionListener( new GraphVisualizerMouseMotionListener() );
      this.setToolTipText("");
    }
    
    public String getToolTipText(MouseEvent me) {
      int x, y, nx, ny;
      Rectangle r;
      GraphNode n;
      Dimension d = m_gp.getPreferredSize();
      //System.out.println("Preferred Size: "+this.getPreferredSize()+
      //                   " Actual Size: "+this.getSize());
      x=y=nx=ny=0;
      
      if(d.width < m_gp.getWidth())
        nx = (int)((nx + m_gp.getWidth()/2 - d.width/2)/scale);
      if(d.height < m_gp.getHeight())
        ny = (int)((ny + m_gp.getHeight()/2 - d.height/2)/scale);
      
      r = new Rectangle(0, 0, 
                       (int)(paddedNodeWidth*scale), (int)(nodeHeight*scale));
      x += me.getX(); y += me.getY();
      
      int i;
      for(i=0; i<m_nodes.size(); i++) {
        n = (GraphNode) m_nodes.elementAt(i);
        if(n.nodeType!=NORMAL)
          return null;
        r.x = (int)((nx+n.x)*scale); r.y = (int)((ny+n.y)*scale);
        if(r.contains(x,y)) {
          if(n.probs==null)
            return n.lbl;
          else
            return n.lbl+" (click to view the probability dist. table)";
        }
      }
      return null;
    }
    
    
    public void paintComponent(Graphics gr) {
      Graphics2D g = (Graphics2D)gr;
      RenderingHints rh = new RenderingHints(RenderingHints.KEY_ANTIALIASING,
      RenderingHints.VALUE_ANTIALIAS_ON);
      rh.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_SPEED);
      g.setRenderingHints(rh);
      g.scale(scale, scale);
      Rectangle r = g.getClipBounds();
      g.clearRect(r.x,r.y,r.width,r.height);
      //g.setColor(this.getBackground());
      //g.fillRect(0, 0, width+5, height+5);
      int x=0, y=0;
      Dimension d = this.getPreferredSize();
      //System.out.println("Preferred Size: "+this.getPreferredSize()+
      //                   " Actual Size: "+this.getSize());
      
      //initializing x & y to display the graph in the middle
      //if the display area is larger than the graph
      if(d.width < this.getWidth())
        x = (int)((x + this.getWidth()/2 - d.width/2)/scale);
      if(d.height < this.getHeight())
        y = (int)((y + this.getHeight()/2 - d.height/2)/scale);
      
      for(int index=0; index<m_nodes.size(); index++) {
        GraphNode n = (GraphNode) m_nodes.elementAt(index);
        if( n.nodeType==NORMAL) {
          g.setColor( this.getBackground().darker().darker() );
          g.fillOval(x+n.x+paddedNodeWidth-nodeWidth-
                          (paddedNodeWidth-nodeWidth)/2,
                     y+n.y,
                     nodeWidth, nodeHeight);
          
          g.setColor(Color.white);
          //g.setColor(Color.black);
          //System.out.println("drawing "+
          //                   ((GraphNode)m_nodes.elementAt(index)).ID+
          //                   " at "+" x: "+ (x+n.x+paddedNodeWidth/2-
          //      fm.stringWidth( ((GraphNode)m_nodes.elementAt(index)).ID )/2)+
          //                   " y: "+(y+n.y+nodeHeight/2+fm.getHeight()/2-2) );
          
          
          //Draw the node's label if it can fit inside the node's current
          // width otherwise display its ID or otherwise just display its
          // idx in the FastVector (to distinguish it from others)
          // if any can fit in node's current width
          if(fm.stringWidth(n.lbl)<=nodeWidth)
            g.drawString( n.lbl,
            x+n.x+paddedNodeWidth/2
            -fm.stringWidth( n.lbl )/2,
            y+n.y+nodeHeight/2+fm.getHeight()/2-2 );
          else if(fm.stringWidth(n.ID)<=nodeWidth)
            g.drawString( n.ID,
            x+n.x+paddedNodeWidth/2
            -fm.stringWidth( n.ID )/2,
            y+n.y+nodeHeight/2+fm.getHeight()/2-2 );
          else if(fm.stringWidth( Integer.toString(index) )<=nodeWidth)
            g.drawString( Integer.toString(index),
            x+n.x+paddedNodeWidth/2
            -fm.stringWidth( Integer.toString(index) )/2,
            y+n.y+nodeHeight/2+fm.getHeight()/2-2 );
          
          g.setColor(Color.black);
        }
        else {
          //g.draw( new java.awt.geom.QuadCurve2D.Double(n.x+paddedNodeWidth/2, 
          //                                             n.y,
          //                            n.x+paddedNodeWidth-nodeSize
          //                                   -(paddedNodeWidth-nodeSize)/2,
          //                                  n.y+nodeHeight/2,
          //                           n.x+paddedNodeWidth/2, n.y+nodeHeight) );
          g.drawLine(x+n.x+paddedNodeWidth/2, y+n.y, 
                     x+n.x+paddedNodeWidth/2, y+n.y+nodeHeight);
          
        }
        
        GraphNode n2;
        int x1, y1, x2, y2;
        //System.out.println("Drawing edges of "+n.lbl);
        
        //Drawing all the edges coming out from the node,
        //including reversed and double ones
        if(n.edges!=null)
          for(int k=0; k<n.edges.length; k++) {
            if(n.edges[k][1]>0) {
              n2 = (GraphNode) m_nodes.elementAt(n.edges[k][0]); //m_nodes.elementAt(k);
              //System.out.println("  -->to "+n2.lbl);
              x1=n.x+paddedNodeWidth/2; y1=n.y+nodeHeight;
              x2=n2.x+paddedNodeWidth/2; y2=n2.y;
              g.drawLine(x+x1, y+y1, x+x2, y+y2);
              if(n.edges[k][1]==DIRECTED) {
                if(n2.nodeType==n2.NORMAL)
                  drawArrow(g, x+x1, y+y1, x+x2, y+y2);
              }
              else if(n.edges[k][1]==REVERSED) {
                if(n.nodeType==NORMAL)
                  drawArrow(g, x+x2, y+y2, x+x1, y+y1);
              }
              else if(n.edges[k][1]==DOUBLE) {
                if(n.nodeType==NORMAL)
                  drawArrow(g, x+x2, y+y2, x+x1, y+y1);
                if(n2.nodeType==NORMAL)
                  drawArrow(g, x+x1, y+y1, x+x2, y+y2);
              }
            }
          }
      }
    }
    
    /**
     * This method draws an arrow on a line from (x1,y1)
     * to (x2,y2). The arrow head is seated on (x2,y2) and
     * is in the direction of the line.
     * If the arrow is needed to be drawn in the opposite
     * direction then simply swap the order of (x1, y1)
     * and (x2, y2) when calling this function.
     */
    protected void drawArrow(Graphics g, int x1, int y1, int x2, int y2) {
      
      if(x1==x2) {
        if(y1<y2) {
          g.drawLine(x2, y2, x2+4, y2-8);
          g.drawLine(x2, y2, x2-4, y2-8);
        }
        else {
          g.drawLine(x2, y2, x2+4, y2+8);
          g.drawLine(x2, y2, x2-4, y2+8);
        }
      }
      else {
        //theta=line's angle from base, beta=angle of arrow's side from line
        double hyp=0, base=0, perp=0, theta, beta;
        int x3=0, y3=0;
        
        if(x2<x1) {
          base = x1-x2; hyp = Math.sqrt( (x2-x1)*(x2-x1) + (y2-y1)*(y2-y1) );
          theta = Math.acos( base/hyp );
        }
        else { //x1>x2 as we already checked x1==x2 before
          base = x1-x2; hyp = Math.sqrt( (x2-x1)*(x2-x1) + (y2-y1)*(y2-y1) );
          theta = Math.acos( base/hyp );
        }
        beta = 30*Math.PI/180;
        //System.out.println("Original base "+base+" perp "+perp+" hyp "+hyp+
        //                   "\ntheta "+theta+" beta "+beta);
        
        hyp = 8;
        base = Math.cos(theta-beta)*hyp;
        perp = Math.sin(theta-beta)*hyp;
        
        x3 = (int)(x2+base);
        if(y1<y2)
          y3 = (int)(y2-perp);
        else
          y3 = (int)(y2+perp);
        
        //System.out.println("Drawing 1 from "+x2+","+y2+" to "+x3+","+y3+
        //                   " x1,y1 is "+x1+","+y1+" base "+base+
        //                   " perp "+perp+" cos(theta-beta) "+
        //                   Math.cos(theta-beta));
        g.drawLine(x2, y2, x3, y3);
        
        base = Math.cos(theta+beta)*hyp;
        perp = Math.sin(theta+beta)*hyp;
        
        x3 = (int)(x2+base);
        if(y1<y2)
          y3 = (int)(y2-perp);
        else
          y3 = (int)(y2+perp);
        //System.out.println("Drawing 2 from "+x2+","+y2+" to "+x3+","+y3+
        //                   " x1,y1 is "+x1+","+y1+" base "+base+
        //                   " perp "+perp);
        g.drawLine(x2, y2, x3, y3);
      }
    }
    
    /**
     * This method highlights a given node and all its children
     * and the edges coming out of it.
     */
    public void highLight(GraphNode n) {
      Graphics2D g = (Graphics2D) this.getGraphics();
      RenderingHints rh = new RenderingHints(RenderingHints.KEY_ANTIALIASING,
      RenderingHints.VALUE_ANTIALIAS_ON);
      rh.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_SPEED);
      g.setRenderingHints(rh);
      g.setPaintMode();
      g.scale(scale, scale);
      int x=0, y=0;
      Dimension d = this.getPreferredSize();
      //System.out.println("Preferred Size: "+this.getPreferredSize()+
      //                   " Actual Size: "+this.getSize());
      
      //initializing x & y to display the graph in the middle
      //if the display area is larger than the graph
      if(d.width < this.getWidth())
        x = (int)((x + this.getWidth()/2 - d.width/2)/scale);
      if(d.height < this.getHeight())
        y = (int)((y + this.getHeight()/2 - d.height/2)/scale);
      
      //if the node is of type NORMAL only then highlight
      if(n.nodeType==NORMAL) {
        
        g.setXORMode(Color.green); //g.setColor(Color.green);
        
        g.fillOval(x+n.x+paddedNodeWidth-nodeWidth-
        (paddedNodeWidth-nodeWidth)/2,
        y+n.y, nodeWidth, nodeHeight);
        g.setXORMode(Color.red);
        
        //Draw the node's label if it can fit inside the node's current
        // width otherwise display its ID or otherwise just display its
        // idx in the FastVector (to distinguish it from others)
        // if any can fit in node's current width
        if(fm.stringWidth(n.lbl)<=nodeWidth)
          g.drawString( n.lbl,
          x+n.x+paddedNodeWidth/2
          -fm.stringWidth( n.lbl )/2,
          y+n.y+nodeHeight/2+fm.getHeight()/2-2 );
        else if(fm.stringWidth(n.ID)<=nodeWidth)
          g.drawString( n.ID,
          x+n.x+paddedNodeWidth/2
          -fm.stringWidth( n.ID )/2,
          y+n.y+nodeHeight/2+fm.getHeight()/2-2 );
        else if( fm.stringWidth( Integer.toString(m_nodes.indexOf(n)) ) <=
        nodeWidth )
          g.drawString( Integer.toString(m_nodes.indexOf(n)),
          x+n.x+paddedNodeWidth/2
          -fm.stringWidth( Integer.toString(m_nodes.indexOf(n)) )/2,
          y+n.y+nodeHeight/2+fm.getHeight()/2-2 );
        
        g.setXORMode(Color.green);
        
        
        GraphNode n2;
        int x1, y1, x2, y2;
        //System.out.println("Drawing edges of "+n.lbl);
        if(n.edges!=null)
          //Drawing all the edges from and upward ones coming to the node
          for(int k=0; k<n.edges.length; k++) {
            if(n.edges[k][1]==DIRECTED || n.edges[k][1]==DOUBLE) {
              n2 = (GraphNode) m_nodes.elementAt(n.edges[k][0]); //m_nodes.elementAt(k);
              //System.out.println("  -->to "+n2.lbl);
              x1=n.x+paddedNodeWidth/2; y1=n.y+nodeHeight;
              x2=n2.x+paddedNodeWidth/2; y2=n2.y;
              g.drawLine(x+x1, y+y1, x+x2, y+y2);
              if(n.edges[k][1]==DIRECTED) {
                if(n2.nodeType==n2.NORMAL) //!n2.dummy)
                  drawArrow(g, x+x1, y+y1, x+x2, y+y2);
              }
              else if(n.edges[k][1]==DOUBLE) {
                if(n.nodeType==NORMAL) //!n.dummy)
                  drawArrow(g, x+x2, y+y2, x+x1, y+y1);
                if(n2.nodeType==NORMAL) //!n2.dummy)
                  drawArrow(g, x+x1, y+y1, x+x2, y+y2);
              }
              if(n2.nodeType==NORMAL)
                g.fillOval(x+n2.x+paddedNodeWidth-nodeWidth-
                (paddedNodeWidth-nodeWidth)/2,
                y+n2.y, nodeWidth, nodeHeight);
              
              //If n2 is not of NORMAL type
              // then carry on drawing all the edges and add all the
              // dummy nodes encountered in a Vector until no
              // more dummy nodes are found and all the child nodes(node n2)
              // are of type normal
              java.util.Vector t = new java.util.Vector();
              while(n2.nodeType!=NORMAL || t.size()>0) { //n2.dummy==true) {
                //System.out.println("in while processing "+n2.ID);
                if(t.size()>0)
                { n2 = (GraphNode)t.elementAt(0);
                  t.removeElementAt(0); }
                if(n2.nodeType!=NORMAL) {
                  g.drawLine(x+n2.x+paddedNodeWidth/2, y+n2.y,
                  x+n2.x+paddedNodeWidth/2, y+n2.y+nodeHeight);
                  x1=n2.x+paddedNodeWidth/2; y1=n2.y+nodeHeight;
                  //System.out.println("Drawing from "+n2.lbl);
                  for(int m=0; m<n2.edges.length; m++) {
                    //System.out.println(" to "+n2.lbl+", "+
                    //                   graphMatrix[tmpIndex][m]);
                    if(n2.edges[m][1]>0) {
                      GraphNode n3 =
                      (GraphNode) m_nodes.elementAt(n2.edges[m][0]); //m_nodes.elementAt(m);
                      g.drawLine(x+x1, y+y1, x+n3.x+paddedNodeWidth/2, y+n3.y);
                      
                      if(n3.nodeType==NORMAL){ //!n2.dummy)
                        g.fillOval(x+n3.x+paddedNodeWidth-nodeWidth-
                        (paddedNodeWidth-nodeWidth)/2,
                        y+n3.y, nodeWidth, nodeHeight);
                        drawArrow(g, x+x1, y+y1,
                        x+n3.x+paddedNodeWidth/2, y+n3.y);
                      }
                      //if(n3.nodeType!=n3.NORMAL)
                      t.addElement(n3);
                      //break;
                    }
                  }
                }
              }
            }
            else if(n.edges[k][1]==-REVERSED || n.edges[k][1]==-DOUBLE) {
              //Drawing all the reversed and double edges which are going
              //upwards in the drawing.
              n2 = (GraphNode) m_nodes.elementAt(n.edges[k][0]); //m_nodes.elementAt(k);
              //System.out.println("  -->to "+n2.lbl);
              x1=n.x+paddedNodeWidth/2; y1=n.y;
              x2=n2.x+paddedNodeWidth/2; y2=n2.y+nodeHeight;
              g.drawLine(x+x1, y+y1, x+x2, y+y2);
              
              if(n.edges[k][1]==-DOUBLE) {
                drawArrow(g, x+x2, y+y2, x+x1, y+y1);
                if(n2.nodeType!=SINGULAR_DUMMY) //!n2.dummy)
                  drawArrow(g, x+x1, y+y1, x+x2, y+y2);
              }
              
              int tmpIndex=k;
              while(n2.nodeType!=NORMAL) { //n2.dummy==true) {
                g.drawLine(x+n2.x+paddedNodeWidth/2,
                y+n2.y+nodeHeight, x+n2.x+paddedNodeWidth/2, y+n2.y);
                x1=n2.x+paddedNodeWidth/2; y1=n2.y;
                for(int m=0; m<n2.edges.length; m++) {
                  if(n2.edges[m][1]<0) {
                    n2 = (GraphNode) m_nodes.elementAt(n2.edges[m][0]); //m_nodes.elementAt(m);
                    g.drawLine(x+x1, y+y1,
                    x+n2.x+paddedNodeWidth/2, y+n2.y+nodeHeight);
                    tmpIndex=m;
                    if(n2.nodeType!=SINGULAR_DUMMY) //!n2.dummy)
                      drawArrow(g, x+x1, y+y1,
                      x+n2.x+paddedNodeWidth/2, y+n2.y+nodeHeight);
                    break;
                  }
                }
              }
            }
          }
      }
    }
  }
  
  
  /**
   * Table Model for the Table that shows the probability
   * distribution for a node
   */
  private class GraphVisualizerTableModel
    extends AbstractTableModel {

    /** for serialization */
    private static final long serialVersionUID = -4789813491347366596L;
    
    final String[] columnNames;
    final double[][] data;
    
    
    public GraphVisualizerTableModel(double[][] d, String[] c) {
      data = d;
      columnNames = c;
    }
    
    public int getColumnCount() {
      return columnNames.length;
    }
    
    public int getRowCount() {
      return data.length;
    }
    
    public String getColumnName(int col) {
      return columnNames[col];
    }
    
    public Object getValueAt(int row, int col) {
      return new Double(data[row][col]);
    }
    
   /*
    * JTable uses this method to determine the default renderer/
    * editor for each cell.
    */
    public Class getColumnClass(int c) {
      return getValueAt(0, c).getClass();
    }
    
    /*
     * Implemented this to make sure the table is uneditable.
     */
    public boolean isCellEditable(int row, int col) {
      return false;
    }
  }
  
  
  
  /**
   * Listener class for processing mouseClicked
   */
  private class GraphVisualizerMouseListener extends MouseAdapter {
    int x, y, nx, ny; Rectangle r;
    
    /**
     * If the mouse is clicked on a node then this method
     * displays a dialog box with the probability distribution
     * table for that node IF it exists
     */
    public void mouseClicked(MouseEvent me) {
      GraphNode n;
      Dimension d = m_gp.getPreferredSize();
      //System.out.println("Preferred Size: "+this.getPreferredSize()+
      //                   " Actual Size: "+this.getSize());
      x=y=nx=ny=0;
      
      if(d.width < m_gp.getWidth())
        nx = (int)((nx + m_gp.getWidth()/2 - d.width/2)/scale);
      if(d.height < m_gp.getHeight())
        ny = (int)((ny + m_gp.getHeight()/2 - d.height/2)/scale);
      
      r=new Rectangle(0, 0, 
                     (int)(paddedNodeWidth*scale), (int)(nodeHeight*scale));
      x += me.getX(); y += me.getY();
      
      int i;
      for(i=0; i<m_nodes.size(); i++) {
        n = (GraphNode) m_nodes.elementAt(i);
        r.x = (int)((nx+n.x)*scale); r.y = (int)((ny+n.y)*scale);
        if(r.contains(x,y)) {
          if(n.probs==null)
            return;
          
          int noOfPrntsOutcomes = 1;
          if(n.prnts!=null) {
            for(int j=0; j<n.prnts.length; j++) {
              GraphNode n2 = (GraphNode)m_nodes.elementAt(n.prnts[j]);
              noOfPrntsOutcomes *= n2.outcomes.length;
            }
            if(noOfPrntsOutcomes>511) {
              System.err.println("Too many outcomes of parents ("+noOfPrntsOutcomes+
                                 ") can't display probabilities");
              return;
            }
          }
          
          GraphVisualizerTableModel tm = 
                             new GraphVisualizerTableModel(n.probs, n.outcomes);
          
          JTable jTblProbs = new JTable(tm); //JTable(probabilities, (Object[])n.outcomes);
          
          JScrollPane js = new JScrollPane(jTblProbs);
          
          if(n.prnts!=null) {
            GridBagConstraints gbc = new GridBagConstraints();
            JPanel jPlRowHeader = new JPanel( new GridBagLayout() );
            
            //indices of the parent nodes in the Vector
            int [] idx = new int[n.prnts.length]; 
            //max length of values of each parent
            int [] lengths = new int[n.prnts.length];  
            
            //System.out.println("n.probs.length "+n.probs.length+
            //                   " should be "+noOfPrntsOutcomes);
            //System.out.println("n.probs[0].length "+n.probs[0].length+
            //                   " should be "+n.outcomes.length);
            //System.out.println("probabilities are: ");
            //for(int j=0; j<probabilities.length; j++) {
            //    for(int k=0; k<probabilities[j].length; k++)
            //     System.out.print(probabilities[j][k]+" ");
            //     System.out.println("");
            //}
            
            //Adding labels for rows
            gbc.anchor = gbc.NORTHWEST;
            gbc.fill = gbc.HORIZONTAL;
            gbc.insets = new Insets(0,1,0,0);
            int addNum=0, temp=0;
            boolean dark=false;
            while(true){
              GraphNode n2;
              gbc.gridwidth = 1;
              for(int k=0; k<n.prnts.length; k++) {
                n2 = (GraphNode)m_nodes.elementAt(n.prnts[k]);
                JLabel lb = new JLabel(n2.outcomes[idx[k]]);
                lb.setFont( new Font("Dialog", Font.PLAIN, 12) );
                lb.setOpaque( true );
                lb.setBorder( BorderFactory.createEmptyBorder( 1,2,1,1 ) );
                lb.setHorizontalAlignment( JLabel.CENTER );
                if(dark) {
                  lb.setBackground( lb.getBackground().darker() );
                  lb.setForeground( Color.white );
                }
                else
                  lb.setForeground( Color.black );
                
                temp = lb.getPreferredSize().width;
                //System.out.println("Preferred width "+temp+
                //                   " for "+n2.outcomes[idx[k]]);
                lb.setPreferredSize(
                                 new Dimension(temp, jTblProbs.getRowHeight())
                                 );
                if(lengths[k]<temp)
                  lengths[k] = temp;
                temp=0;
                
                if(k==n.prnts.length-1) {
                  gbc.gridwidth = gbc.REMAINDER;
                  dark = (dark==true) ?  false:true;
                }
                jPlRowHeader.add(lb, gbc);
                addNum++;
              }
              
              for(int k=n.prnts.length-1; k>=0; k--) {
                n2 = (GraphNode) m_nodes.elementAt(n.prnts[k]);
                if(idx[k]==n2.outcomes.length-1 && k!=0) {
                  idx[k]=0;
                  continue;
                }
                else {
                  idx[k]++;
                  break;
                }
              }
              
              n2 = (GraphNode) m_nodes.elementAt(n.prnts[0]);
              if(idx[0]==n2.outcomes.length) {
                JLabel lb= (JLabel) jPlRowHeader.getComponent(addNum-1);
                jPlRowHeader.remove(addNum-1);
                lb.setPreferredSize( new Dimension(lb.getPreferredSize().width, 
                                                   jTblProbs.getRowHeight()) );
                gbc.gridwidth = gbc.REMAINDER;
                gbc.weighty = 1;
                jPlRowHeader.add(lb, gbc);
                gbc.weighty=0;
                break;
              }
            }
            
            
            gbc.gridwidth = 1;
            //The following panel contains the names of the parents
            //and is displayed above the row names to identify
            //which value belongs to which parent
            JPanel jPlRowNames = new JPanel(new GridBagLayout());
            for(int j=0; j<n.prnts.length; j++) {
              JLabel lb2;
              JLabel lb1 = 
                   new JLabel( ((GraphNode)m_nodes.elementAt(n.prnts[j])).lbl );
              lb1.setBorder( BorderFactory.createEmptyBorder( 1,2,1,1 ) );
              Dimension tempd = lb1.getPreferredSize();
              //System.out.println("lengths[j]: "+lengths[j]+
              //                   " tempd.width: "+tempd.width);
              if(tempd.width<lengths[j]) {
                lb1.setPreferredSize( new Dimension(lengths[j], tempd.height) );
                lb1.setHorizontalAlignment( JLabel.CENTER );
                lb1.setMinimumSize( new Dimension(lengths[j], tempd.height) );
              }
              else if(tempd.width>lengths[j]) {
                lb2 = (JLabel) jPlRowHeader.getComponent(j);
                lb2.setPreferredSize( new Dimension(tempd.width, 
                                               lb2.getPreferredSize().height) );
              }
              jPlRowNames.add(lb1, gbc);
              //System.out.println("After adding "+lb1.getPreferredSize());
            }
            js.setRowHeaderView(jPlRowHeader);
            js.setCorner( JScrollPane.UPPER_LEFT_CORNER, jPlRowNames );
          }
          
          
          JDialog jd = 
                new JDialog((Frame)GraphVisualizer.this.getTopLevelAncestor(),
                            "Probability Distribution Table For "+n.lbl, true);
          jd.setSize(500, 400);
          jd.setLocation(GraphVisualizer.this.getLocation().x+
                            GraphVisualizer.this.getWidth()/2-250,
                         GraphVisualizer.this.getLocation().y+
                            GraphVisualizer.this.getHeight()/2-200 );
          
          jd.getContentPane().setLayout( new BorderLayout() );
          jd.getContentPane().add(js, BorderLayout.CENTER);
          jd.setVisible(true);
          
          return;
        }
      }
    }
    
  }
  
  
  /**
   * private class for handling mouseMoved events
   * to highlight nodes if the the mouse is moved on
   * one
   */
  private class GraphVisualizerMouseMotionListener extends MouseMotionAdapter {
    int x, y, nx, ny; Rectangle r;
    GraphNode lastNode;
    
    public void mouseMoved(MouseEvent me) {
      GraphNode n;
      Dimension d = m_gp.getPreferredSize();
      //System.out.println("Preferred Size: "+this.getPreferredSize()+
      //                   " Actual Size: "+this.getSize());
      x=y=nx=ny=0;
      
      if(d.width < m_gp.getWidth())
        nx = (int)((nx + m_gp.getWidth()/2 - d.width/2)/scale);
      if(d.height < m_gp.getHeight())
        ny = (int)((ny + m_gp.getHeight()/2 - d.height/2)/scale);
      
      r=new Rectangle(0, 0, 
                     (int)(paddedNodeWidth*scale), (int)(nodeHeight*scale));
      x += me.getX(); y += me.getY();
      
      int i;
      for(i=0; i<m_nodes.size(); i++) {
        n = (GraphNode) m_nodes.elementAt(i);
        r.x = (int)((nx+n.x)*scale); r.y = (int)((ny+n.y)*scale);
        if(r.contains(x,y)) {
          if(n!=lastNode) {
            m_gp.highLight(n);
            if(lastNode!=null)
              m_gp.highLight(lastNode);
            lastNode = n; //lastIndex = i;
          }
          break;
        }
      }
      if(i==m_nodes.size()  && lastNode!=null) {
        m_gp.repaint();
        //m_gp.highLight(lastNode);
        lastNode=null;
      }
    }
  }
  
  /**
   * Main method to load a text file with the
   * description of a graph from the command
   * line
   */
  public static void main(String [] args) {
    weka.core.logging.Logger.log(weka.core.logging.Logger.Level.INFO, "Logging started");
    JFrame jf = new JFrame("Graph Visualizer");
    GraphVisualizer g = new GraphVisualizer();
    
    try{
      if(args[0].endsWith(".xml")) {
        //StringBuffer sb = new StringBuffer();
        //FileReader infile = new FileReader(args[0]);
        //int i;
        //while( (i=infile.read())!=-1) {
        //    sb.append((char)i);
        //}
        //System.out.println(sb.toString());
        //g.readBIF(sb.toString() );
        g.readBIF( new FileInputStream(args[0]) );
      }
      else {
        //BufferedReader infile=new BufferedReader();
        g.readDOT(new FileReader(args[0])); //infile);
      }
    }
    catch(IOException ex) { ex.printStackTrace(); }
    catch(BIFFormatException bf) { bf.printStackTrace(); System.exit(-1); }
    
    jf.getContentPane().add(g);
    //RepaintManager.currentManager(jf.getRootPane()).setDoubleBufferingEnabled(false);
    jf.setDefaultCloseOperation( jf.EXIT_ON_CLOSE );
    jf.setSize(800,600);
    //jf.pack();
    jf.setVisible(true);
  }
}