/*
* 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.
*/
/*
* TreeVisualizer.java
* Copyright (C) 1999 University of Waikato, Hamilton, New Zealand
*
*/
package weka.gui.treevisualizer;
import weka.core.Instances;
import weka.core.Utils;
import weka.gui.visualize.PrintablePanel;
import weka.gui.visualize.VisualizePanel;
import weka.gui.visualize.VisualizeUtils;
import java.awt.Color;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.io.FileReader;
import java.io.IOException;
import java.io.StringReader;
import java.util.Properties;
import javax.swing.BorderFactory;
import javax.swing.ButtonGroup;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JPopupMenu;
import javax.swing.JRadioButton;
import javax.swing.JRadioButtonMenuItem;
import javax.swing.JTextField;
import javax.swing.Timer;
/**
* Class for displaying a Node structure in Swing. <p>
*
* To work this class simply create an instance of it.<p>
*
* Assign it to a window or other such object.<p>
*
* Resize it to the desired size.<p>
*
*
* When using the Displayer hold the left mouse button to drag the
* tree around. <p>
*
* Click the left mouse button with ctrl to shrink the size of the tree
* by half. <p>
*
* Click and drag with the left mouse button and shift to draw a box,
* when the left mouse button is released the contents of the box
* will be magnified
* to fill the screen. <p> <p>
*
* Click the right mouse button to bring up a menu. <p>
* Most options are self explanatory.<p>
*
* Select Auto Scale to set the tree to it's optimal display size.
*
* @author Malcolm Ware (mfw4@cs.waikato.ac.nz)
* @version $Revision: 4960 $
*/
public class TreeVisualizer
extends PrintablePanel
implements MouseMotionListener, MouseListener, ActionListener, ItemListener {
/** for serialization */
private static final long serialVersionUID = -8668637962504080749L;
/** the props file. */
public final static String PROPERTIES_FILE = "weka/gui/treevisualizer/TreeVisualizer.props";
/** The placement algorithm for the Node structure. */
private NodePlace m_placer;
/** The top Node. */
private Node m_topNode;
/** The postion of the view relative to the tree. */
private Dimension m_viewPos;
/** The size of the tree in pixels. */
private Dimension m_viewSize;
/** The font used to display the tree. */
private Font m_currentFont;
/** The size information for the current font. */
private FontMetrics m_fontSize;
/** The number of Nodes in the tree. */
private int m_numNodes;
/** The number of levels in the tree. */
private int m_numLevels;
/** An array with the Nodes sorted into it and display information
* about the Nodes. */
private NodeInfo[] m_nodes;
/** An array with the Edges sorted into it and display information
* about the Edges. */
private EdgeInfo[] m_edges;
/** A timer to keep the frame rate constant. */
private Timer m_frameLimiter;
/** Describes the action the user is performing. */
private int m_mouseState;
/** A variable used to tag the start pos of a user action. */
private Dimension m_oldMousePos;
/** A variable used to tag the most current point of a user action. */
private Dimension m_newMousePos;
/** A variable used to determine for the clicked method if any other
* mouse state has already taken place. */
private boolean m_clickAvailable;
/** A variable used to remember the desired view pos. */
private Dimension m_nViewPos;
/** A variable used to remember the desired tree size. */
private Dimension m_nViewSize;
/** The number of frames left to calculate. */
private int m_scaling;
/** A right (or middle) click popup menu. */
private JPopupMenu m_winMenu;
/** An option on the win_menu */
private JMenuItem m_topN;
/** An option on the win_menu*/
private JMenuItem m_fitToScreen;
/** An option on the win_menu */
private JMenuItem m_autoScale;
/** A sub group on the win_menu */
private JMenu m_selectFont;
/** A grouping for the font choices */
private ButtonGroup m_selectFontGroup;
/** A font choice. */
private JRadioButtonMenuItem m_size24;
/** A font choice. */
private JRadioButtonMenuItem m_size22;
/** A font choice. */
private JRadioButtonMenuItem m_size20;
/** A font choice. */
private JRadioButtonMenuItem m_size18;
/** A font choice. */
private JRadioButtonMenuItem m_size16;
/** A font choice. */
private JRadioButtonMenuItem m_size14;
/** A font choice. */
private JRadioButtonMenuItem m_size12;
/** A font choice. */
private JRadioButtonMenuItem m_size10;
/** A font choice. */
private JRadioButtonMenuItem m_size8;
/** A font choice. */
private JRadioButtonMenuItem m_size6;
/** A font choice. */
private JRadioButtonMenuItem m_size4;
/** A font choice. */
private JRadioButtonMenuItem m_size2;
/** A font choice. */
private JRadioButtonMenuItem m_size1;
/** An option on the win menu. */
private JMenuItem m_accept;
/** A right or middle click popup menu for nodes. */
private JPopupMenu m_nodeMenu;
/** A visualize choice for the node, may not be available. */
private JMenuItem m_visualise;
/**
* An add children to Node choice, This is only available if the tree
* display has a treedisplay listerner added to it.
*/
private JMenuItem m_addChildren;
/** Similar to add children but now it removes children. */
private JMenuItem m_remChildren;
/** Use this to have J48 classify this node. */
private JMenuItem m_classifyChild;
/** Use this to dump the instances from this node to the vis panel. */
private JMenuItem m_sendInstances;
/** The subscript for the currently selected node (this is an internal
* thing, so the user is unaware of this). */
private int m_focusNode;
/**
* The Node the user is currently focused on , this is similar to
* focus node except that it is used by other
* classes rather than this one.
*/
private int m_highlightNode;
/* A pointer to this tree's classifier if a classifier is using it. */
//private UserClassifier classer;
private TreeDisplayListener m_listener;
private JTextField m_searchString;
private JDialog m_searchWin;
private JRadioButton m_caseSen;
/** the font color. */
protected Color m_FontColor = null;
/** the background color. */
protected Color m_BackgroundColor = null;
/** the node color. */
protected Color m_NodeColor = null;
/** the line color. */
protected Color m_LineColor = null;
/** the color of the zoombox. */
protected Color m_ZoomBoxColor = null;
/** the XOR color of the zoombox. */
protected Color m_ZoomBoxXORColor = null;
/** whether to show the border or not. */
protected boolean m_ShowBorder = true;
///////////////////
//this is the event fireing stuff
/**
* Constructs Displayer to display a tree provided in a dot format.
* Uses the NodePlacer to place the Nodes.
* @param tdl listener
* @param dot string containing the dot representation of the tree to
* display
* @param p the algorithm to be used to position the nodes.
*/
public TreeVisualizer(TreeDisplayListener tdl, String dot, NodePlace p) {
super();
initialize();
//generate the node structure in here
if (m_ShowBorder)
setBorder(BorderFactory.createTitledBorder("Tree View"));
m_listener = tdl;
TreeBuild builder = new TreeBuild();
Node n = null;
NodePlace arrange = new PlaceNode2();
n = builder.create(new StringReader(dot));
// System.out.println(n.getCount(n, 0));
//if the size needs to be automatically alocated I will do it here
m_highlightNode = 5;
m_topNode = n;
m_placer = p;
m_placer.place(m_topNode);
m_viewPos = new Dimension(0, 0); //will be adjusted
m_viewSize = new Dimension(800, 600); //I allocate this now so that
//the tree will be visible
//when the panel is enlarged
m_nViewPos = new Dimension(0, 0);
m_nViewSize = new Dimension(800, 600);
m_scaling = 0;
m_numNodes = m_topNode.getCount(m_topNode,0); //note the second
//argument must be a zero, this is a
//recursive function
m_numLevels = m_topNode.getHeight(m_topNode,0);
m_nodes = new NodeInfo[m_numNodes];
m_edges = new EdgeInfo[m_numNodes-1];
arrayFill(m_topNode, m_nodes, m_edges);
changeFontSize(12);
m_mouseState = 0;
m_oldMousePos = new Dimension(0, 0);
m_newMousePos = new Dimension(0, 0);
m_frameLimiter = new Timer(120, this);
m_winMenu = new JPopupMenu();
m_topN = new JMenuItem("Center on Top Node"); //note to change
//language change this line
m_topN.setActionCommand("Center on Top Node"); //but not this one,
//same for all menu items
m_fitToScreen = new JMenuItem("Fit to Screen");
m_fitToScreen.setActionCommand("Fit to Screen");
//unhide = new JMenuItem("Unhide all Nodes");
m_selectFont = new JMenu("Select Font");
m_selectFont.setActionCommand("Select Font");
m_autoScale = new JMenuItem("Auto Scale");
m_autoScale.setActionCommand("Auto Scale");
m_selectFontGroup = new ButtonGroup();
m_accept = new JMenuItem("Accept The Tree");
m_accept.setActionCommand("Accept The Tree");
m_winMenu.add(m_topN);
m_winMenu.addSeparator();
m_winMenu.add(m_fitToScreen);
m_winMenu.add(m_autoScale);
//m_winMenu.addSeparator();
//m_winMenu.add(unhide);
m_winMenu.addSeparator();
m_winMenu.add(m_selectFont);
if (m_listener != null) {
m_winMenu.addSeparator();
m_winMenu.add(m_accept);
}
m_topN.addActionListener(this);
m_fitToScreen.addActionListener(this);
//unhide.addActionListener(this);
m_autoScale.addActionListener(this);
m_accept.addActionListener(this);
m_size24 = new JRadioButtonMenuItem("Size 24",false);//,select_font_group);
m_size22 = new JRadioButtonMenuItem("Size 22",false);//,select_font_group);
m_size20 = new JRadioButtonMenuItem("Size 20",false);//,select_font_group);
m_size18 = new JRadioButtonMenuItem("Size 18",false);//,select_font_group);
m_size16 = new JRadioButtonMenuItem("Size 16",false);//,select_font_group);
m_size14 = new JRadioButtonMenuItem("Size 14",false);//,select_font_group);
m_size12 = new JRadioButtonMenuItem("Size 12",true);//,select_font_group);
m_size10 = new JRadioButtonMenuItem("Size 10",false);//,select_font_group);
m_size8 = new JRadioButtonMenuItem("Size 8",false);//,select_font_group);
m_size6 = new JRadioButtonMenuItem("Size 6",false);//,select_font_group);
m_size4 = new JRadioButtonMenuItem("Size 4",false);//,select_font_group);
m_size2 = new JRadioButtonMenuItem("Size 2",false);//,select_font_group);
m_size1 = new JRadioButtonMenuItem("Size 1",false);//,select_font_group);
m_size24.setActionCommand("Size 24");//,select_font_group);
m_size22.setActionCommand("Size 22");//,select_font_group);
m_size20.setActionCommand("Size 20");//,select_font_group);
m_size18.setActionCommand("Size 18");//,select_font_group);
m_size16.setActionCommand("Size 16");//,select_font_group);
m_size14.setActionCommand("Size 14");//,select_font_group);
m_size12.setActionCommand("Size 12");//,select_font_group);
m_size10.setActionCommand("Size 10");//,select_font_group);
m_size8.setActionCommand("Size 8");//,select_font_group);
m_size6.setActionCommand("Size 6");//,select_font_group);
m_size4.setActionCommand("Size 4");//,select_font_group);
m_size2.setActionCommand("Size 2");//,select_font_group);
m_size1.setActionCommand("Size 1");//,select_font_group);
m_selectFontGroup.add(m_size24);
m_selectFontGroup.add(m_size22);
m_selectFontGroup.add(m_size20);
m_selectFontGroup.add(m_size18);
m_selectFontGroup.add(m_size16);
m_selectFontGroup.add(m_size14);
m_selectFontGroup.add(m_size12);
m_selectFontGroup.add(m_size10);
m_selectFontGroup.add(m_size8);
m_selectFontGroup.add(m_size6);
m_selectFontGroup.add(m_size4);
m_selectFontGroup.add(m_size2);
m_selectFontGroup.add(m_size1);
m_selectFont.add(m_size24);
m_selectFont.add(m_size22);
m_selectFont.add(m_size20);
m_selectFont.add(m_size18);
m_selectFont.add(m_size16);
m_selectFont.add(m_size14);
m_selectFont.add(m_size12);
m_selectFont.add(m_size10);
m_selectFont.add(m_size8);
m_selectFont.add(m_size6);
m_selectFont.add(m_size4);
m_selectFont.add(m_size2);
m_selectFont.add(m_size1);
m_size24.addItemListener(this);
m_size22.addItemListener(this);
m_size20.addItemListener(this);
m_size18.addItemListener(this);
m_size16.addItemListener(this);
m_size14.addItemListener(this);
m_size12.addItemListener(this);
m_size10.addItemListener(this);
m_size8.addItemListener(this);
m_size6.addItemListener(this);
m_size4.addItemListener(this);
m_size2.addItemListener(this);
m_size1.addItemListener(this);
/*
search_string = new JTextField(22);
search_win = new JDialog();
case_sen = new JRadioButton("Case Sensitive");
search_win.getContentPane().setLayout(null);
search_win.setSize(300, 200);
search_win.getContentPane().add(search_string);
search_win.getContentPane().add(case_sen);
search_string.setLocation(50, 70);
case_sen.setLocation(50, 120);
case_sen.setSize(100, 24);
search_string.setSize(100, 24);
//search_string.setVisible(true);
//case_sen.setVisible(true);
//search_win.setVisible(true);
*/
m_nodeMenu = new JPopupMenu();
/* A visualize choice for the node, may not be available. */
m_visualise = new JMenuItem("Visualize The Node");
m_visualise.setActionCommand("Visualize The Node");
m_visualise.addActionListener(this);
m_nodeMenu.add(m_visualise);
if (m_listener != null) {
m_remChildren = new JMenuItem("Remove Child Nodes");
m_remChildren.setActionCommand("Remove Child Nodes");
m_remChildren.addActionListener(this);
m_nodeMenu.add(m_remChildren);
m_classifyChild = new JMenuItem("Use Classifier...");
m_classifyChild.setActionCommand("classify_child");
m_classifyChild.addActionListener(this);
m_nodeMenu.add(m_classifyChild);
/*m_sendInstances = new JMenuItem("Add Instances To Viewer");
m_sendInstances.setActionCommand("send_instances");
m_sendInstances.addActionListener(this);
m_nodeMenu.add(m_sendInstances); */
}
m_focusNode = -1;
m_highlightNode = -1;
addMouseMotionListener(this);
addMouseListener(this);
//repaint();
//frame_limiter.setInitialDelay();
m_frameLimiter.setRepeats(false);
m_frameLimiter.start();
}
/**
* Constructs Displayer with the specified Node as the top
* of the tree, and uses the NodePlacer to place the Nodes.
* @param tdl listener.
* @param n the top Node of the tree to be displayed.
* @param p the algorithm to be used to position the nodes.
*/
public TreeVisualizer(TreeDisplayListener tdl, Node n, NodePlace p) {
super();
initialize();
//if the size needs to be automatically alocated I will do it here
if (m_ShowBorder)
setBorder(BorderFactory.createTitledBorder("Tree View"));
m_listener = tdl;
m_topNode = n;
m_placer = p;
m_placer.place(m_topNode);
m_viewPos = new Dimension(0, 0); //will be adjusted
m_viewSize = new Dimension(800, 600); //I allocate this now so that
//the tree will be visible
//when the panel is enlarged
m_nViewPos = new Dimension(0, 0);
m_nViewSize = new Dimension(800, 600);
m_scaling = 0;
m_numNodes = m_topNode.getCount(m_topNode,0); //note the second argument
//must be a zero, this is a
//recursive function
m_numLevels = m_topNode.getHeight(m_topNode,0);
m_nodes = new NodeInfo[m_numNodes];
m_edges = new EdgeInfo[m_numNodes-1];
arrayFill(m_topNode, m_nodes, m_edges);
changeFontSize(12);
m_mouseState = 0;
m_oldMousePos = new Dimension(0, 0);
m_newMousePos = new Dimension(0, 0);
m_frameLimiter = new Timer(120, this);
m_winMenu = new JPopupMenu();
m_topN = new JMenuItem("Center on Top Node"); //note to change
//language change this line
m_topN.setActionCommand("Center on Top Node"); //but not this
//one, same for all menu items
m_fitToScreen = new JMenuItem("Fit to Screen");
m_fitToScreen.setActionCommand("Fit to Screen");
//unhide = new JMenuItem("Unhide all Nodes");
m_selectFont = new JMenu("Select Font");
m_selectFont.setActionCommand("Select Font");
m_autoScale = new JMenuItem("Auto Scale");
m_autoScale.setActionCommand("Auto Scale");
m_selectFontGroup = new ButtonGroup();
m_accept = new JMenuItem("Accept The Tree");
m_accept.setActionCommand("Accept The Tree");
m_winMenu.add(m_topN);
m_winMenu.addSeparator();
m_winMenu.add(m_fitToScreen);
m_winMenu.add(m_autoScale);
m_winMenu.addSeparator();
//m_winMenu.add(unhide);
m_winMenu.addSeparator();
m_winMenu.add(m_selectFont);
m_winMenu.addSeparator();
if (m_listener != null) {
m_winMenu.add(m_accept);
}
m_topN.addActionListener(this);
m_fitToScreen.addActionListener(this);
//unhide.addActionListener(this);
m_autoScale.addActionListener(this);
m_accept.addActionListener(this);
m_size24 = new JRadioButtonMenuItem("Size 24",false);//,select_font_group);
m_size22 = new JRadioButtonMenuItem("Size 22",false);//,select_font_group);
m_size20 = new JRadioButtonMenuItem("Size 20",false);//,select_font_group);
m_size18 = new JRadioButtonMenuItem("Size 18",false);//,select_font_group);
m_size16 = new JRadioButtonMenuItem("Size 16",false);//,select_font_group);
m_size14 = new JRadioButtonMenuItem("Size 14",false);//,select_font_group);
m_size12 = new JRadioButtonMenuItem("Size 12",true);//,select_font_group);
m_size10 = new JRadioButtonMenuItem("Size 10",false);//,select_font_group);
m_size8 = new JRadioButtonMenuItem("Size 8",false);//,select_font_group);
m_size6 = new JRadioButtonMenuItem("Size 6",false);//,select_font_group);
m_size4 = new JRadioButtonMenuItem("Size 4",false);//,select_font_group);
m_size2 = new JRadioButtonMenuItem("Size 2",false);//,select_font_group);
m_size1 = new JRadioButtonMenuItem("Size 1",false);//,select_font_group);
m_size24.setActionCommand("Size 24");//,select_font_group);
m_size22.setActionCommand("Size 22");//,select_font_group);
m_size20.setActionCommand("Size 20");//,select_font_group);
m_size18.setActionCommand("Size 18");//,select_font_group);
m_size16.setActionCommand("Size 16");//,select_font_group);
m_size14.setActionCommand("Size 14");//,select_font_group);
m_size12.setActionCommand("Size 12");//,select_font_group);
m_size10.setActionCommand("Size 10");//,select_font_group);
m_size8.setActionCommand("Size 8");//,select_font_group);
m_size6.setActionCommand("Size 6");//,select_font_group);
m_size4.setActionCommand("Size 4");//,select_font_group);
m_size2.setActionCommand("Size 2");//,select_font_group);
m_size1.setActionCommand("Size 1");//,select_font_group);
m_selectFontGroup.add(m_size24);
m_selectFontGroup.add(m_size22);
m_selectFontGroup.add(m_size20);
m_selectFontGroup.add(m_size18);
m_selectFontGroup.add(m_size16);
m_selectFontGroup.add(m_size14);
m_selectFontGroup.add(m_size12);
m_selectFontGroup.add(m_size10);
m_selectFontGroup.add(m_size8);
m_selectFontGroup.add(m_size6);
m_selectFontGroup.add(m_size4);
m_selectFontGroup.add(m_size2);
m_selectFontGroup.add(m_size1);
m_selectFont.add(m_size24);
m_selectFont.add(m_size22);
m_selectFont.add(m_size20);
m_selectFont.add(m_size18);
m_selectFont.add(m_size16);
m_selectFont.add(m_size14);
m_selectFont.add(m_size12);
m_selectFont.add(m_size10);
m_selectFont.add(m_size8);
m_selectFont.add(m_size6);
m_selectFont.add(m_size4);
m_selectFont.add(m_size2);
m_selectFont.add(m_size1);
m_size24.addItemListener(this);
m_size22.addItemListener(this);
m_size20.addItemListener(this);
m_size18.addItemListener(this);
m_size16.addItemListener(this);
m_size14.addItemListener(this);
m_size12.addItemListener(this);
m_size10.addItemListener(this);
m_size8.addItemListener(this);
m_size6.addItemListener(this);
m_size4.addItemListener(this);
m_size2.addItemListener(this);
m_size1.addItemListener(this);
/*
search_string = new JTextField(22);
search_win = new JDialog();
case_sen = new JRadioButton("Case Sensitive");
search_win.getContentPane().setLayout(null);
search_win.setSize(300, 200);
search_win.getContentPane().add(search_string);
search_win.getContentPane().add(case_sen);
search_string.setLocation(50, 70);
case_sen.setLocation(50, 120);
case_sen.setSize(100, 24);
search_string.setSize(100, 24);
//search_string.setVisible(true);
//case_sen.setVisible(true);
search_win.setVisible(true);
*/
m_nodeMenu = new JPopupMenu();
/* A visualize choice for the node, may not be available. */
m_visualise = new JMenuItem("Visualize The Node");
m_visualise.setActionCommand("Visualize The Node");
m_visualise.addActionListener(this);
m_nodeMenu.add(m_visualise);
if (m_listener != null) {
m_remChildren = new JMenuItem("Remove Child Nodes");
m_remChildren.setActionCommand("Remove Child Nodes");
m_remChildren.addActionListener(this);
m_nodeMenu.add(m_remChildren);
m_classifyChild = new JMenuItem("Use Classifier...");
m_classifyChild.setActionCommand("classify_child");
m_classifyChild.addActionListener(this);
m_nodeMenu.add(m_classifyChild);
m_sendInstances = new JMenuItem("Add Instances To Viewer");
m_sendInstances.setActionCommand("send_instances");
m_sendInstances.addActionListener(this);
m_nodeMenu.add(m_sendInstances);
}
m_focusNode = -1;
m_highlightNode = -1;
addMouseMotionListener(this);
addMouseListener(this);
//repaint();
//frame_limiter.setInitialDelay();
m_frameLimiter.setRepeats(false);
m_frameLimiter.start();
}
/**
* Processes the color string. Returns null if empty.
*
* @param colorStr the string to process
* @return the processed color or null
*/
protected Color getColor(String colorStr) {
Color result;
result = null;
if ((colorStr != null) && (colorStr.length() > 0))
result = VisualizeUtils.processColour(colorStr, result);
return result;
}
/**
* Performs some initialization.
*/
protected void initialize() {
Properties props;
try {
props = Utils.readProperties(PROPERTIES_FILE);
}
catch (Exception e) {
e.printStackTrace();
props = new Properties();
}
m_FontColor = getColor(props.getProperty("FontColor", ""));
m_BackgroundColor = getColor(props.getProperty("BackgroundColor", ""));
m_NodeColor = getColor(props.getProperty("NodeColor", ""));
m_LineColor = getColor(props.getProperty("LineColor", ""));
m_ZoomBoxColor = getColor(props.getProperty("ZoomBoxColor", ""));
m_ZoomBoxXORColor = getColor(props.getProperty("ZoomBoxXORColor", ""));
m_ShowBorder = Boolean.parseBoolean(props.getProperty("ShowBorder", "true"));
}
/**
* Fits the tree to the current screen size. Call this after
* window has been created to get the entrire tree to be in view
* upon launch.
*/
public void fitToScreen() {
getScreenFit(m_viewPos, m_viewSize);
repaint();
}
/**
* Calculates the dimensions needed to fit the entire tree into view.
*/
private void getScreenFit(Dimension np, Dimension ns) {
int leftmost = 1000000, rightmost = -1000000;
int leftCenter = 1000000, rightCenter = -1000000, rightNode = 0;
int highest = -1000000, highTop = -1000000;
for (int noa = 0; noa < m_numNodes; noa++) {
calcScreenCoords(noa);
if (m_nodes[noa].m_center - m_nodes[noa].m_side < leftmost) {
leftmost = m_nodes[noa].m_center - m_nodes[noa].m_side;
}
if (m_nodes[noa].m_center < leftCenter) {
leftCenter = m_nodes[noa].m_center;
}
if (m_nodes[noa].m_center + m_nodes[noa].m_side > rightmost) {
rightmost = m_nodes[noa].m_center + m_nodes[noa].m_side;
}
if (m_nodes[noa].m_center > rightCenter) {
rightCenter = m_nodes[noa].m_center;
rightNode = noa;
}
if (m_nodes[noa].m_top + m_nodes[noa].m_height > highest) {
highest = m_nodes[noa].m_top + m_nodes[noa].m_height;
}
if (m_nodes[noa].m_top > highTop) {
highTop = m_nodes[noa].m_top;
}
}
ns.width = getWidth();
ns.width -= leftCenter - leftmost + rightmost - rightCenter + 30;
ns.height = getHeight() - highest + highTop - 40;
if (m_nodes[rightNode].m_node.getCenter() != 0
&& leftCenter != rightCenter) {
ns.width /= m_nodes[rightNode].m_node.getCenter();
}
if (ns.width < 10)
{
ns.width = 10;
}
if (ns.height < 10)
{
ns.height = 10;
}
np.width = (leftCenter - leftmost + rightmost - rightCenter) / 2 + 15;
np.height = (highest - highTop) / 2 + 20;
}
/**
* Performs the action associated with the ActionEvent.
*
* @param e the action event.
*/
public void actionPerformed(ActionEvent e) {
//JMenuItem m = (JMenuItem)e.getSource();
if (e.getActionCommand() == null) {
if (m_scaling == 0) {
repaint();
}
else {
animateScaling(m_nViewPos, m_nViewSize, m_scaling);
}
}
else if (e.getActionCommand().equals("Fit to Screen")) {
Dimension np = new Dimension();
Dimension ns = new Dimension();
getScreenFit(np, ns);
animateScaling(np, ns, 10);
}
else if (e.getActionCommand().equals("Center on Top Node")) {
int tpx = (int)(m_topNode.getCenter() * m_viewSize.width); //calculate
//the top nodes postion but don't adjust for where
int tpy = (int)(m_topNode.getTop() * m_viewSize.height); //view is
Dimension np = new Dimension(getSize().width / 2 - tpx,
getSize().width / 6 - tpy);
animateScaling(np, m_viewSize, 10);
}
else if (e.getActionCommand().equals("Auto Scale")) {
autoScale(); //this will figure the best scale value
//keep the focus on the middle of the screen and call animate
}
else if (e.getActionCommand().equals("Visualize The Node")) {
//send the node data to the visualizer
if (m_focusNode >= 0) {
Instances inst;
if ((inst = m_nodes[m_focusNode].m_node.getInstances()) != null) {
VisualizePanel pan = new VisualizePanel();
pan.setInstances(inst);
JFrame nf = new JFrame();
nf.setSize(400, 300);
nf.getContentPane().add(pan);
nf.setVisible(true);
}
else {
JOptionPane.showMessageDialog(this, "Sorry, there is no " +
"available Instances data for " +
"this Node.", "Sorry!",
JOptionPane.WARNING_MESSAGE);
}
}
else {
JOptionPane.showMessageDialog(this, "Error, there is no " +
"selected Node to perform " +
"this operation on.", "Error!",
JOptionPane.ERROR_MESSAGE);
}
}
else if (e.getActionCommand().equals("Create Child Nodes")) {
if (m_focusNode >= 0) {
if (m_listener != null) {
//then send message to the listener
m_listener.userCommand(new TreeDisplayEvent
(TreeDisplayEvent.ADD_CHILDREN,
m_nodes[m_focusNode].m_node.getRefer()));
}
else {
JOptionPane.showMessageDialog(this, "Sorry, there is no " +
"available Decision Tree to " +
"perform this operation on.",
"Sorry!",
JOptionPane.WARNING_MESSAGE);
}
}
else {
JOptionPane.showMessageDialog(this, "Error, there is no " +
"selected Node to perform this " +
"operation on.", "Error!",
JOptionPane.ERROR_MESSAGE);
}
}
else if (e.getActionCommand().equals("Remove Child Nodes")) {
if (m_focusNode >= 0) {
if (m_listener != null) {
//then send message to the listener
m_listener.userCommand(new
TreeDisplayEvent(TreeDisplayEvent.REMOVE_CHILDREN,
m_nodes[m_focusNode].m_node.getRefer()));
}
else {
JOptionPane.showMessageDialog(this, "Sorry, there is no " +
"available Decsion Tree to " +
"perform this operation on.",
"Sorry!",
JOptionPane.WARNING_MESSAGE);
}
}
else {
JOptionPane.showMessageDialog(this, "Error, there is no " +
"selected Node to perform this " +
"operation on.", "Error!",
JOptionPane.ERROR_MESSAGE);
}
}
else if (e.getActionCommand().equals("classify_child")) {
if (m_focusNode >= 0) {
if (m_listener != null) {
//then send message to the listener
m_listener.userCommand(new TreeDisplayEvent
(TreeDisplayEvent.CLASSIFY_CHILD,
m_nodes[m_focusNode].m_node.getRefer()));
}
else {
JOptionPane.showMessageDialog(this, "Sorry, there is no " +
"available Decsion Tree to " +
"perform this operation on.",
"Sorry!",
JOptionPane.WARNING_MESSAGE);
}
}
else {
JOptionPane.showMessageDialog(this, "Error, there is no " +
"selected Node to perform this " +
"operation on.", "Error!",
JOptionPane.ERROR_MESSAGE);
}
}
else if (e.getActionCommand().equals("send_instances")) {
if (m_focusNode >= 0) {
if (m_listener != null) {
//then send message to the listener
m_listener.userCommand(new TreeDisplayEvent
(TreeDisplayEvent.SEND_INSTANCES,
m_nodes[m_focusNode].m_node.getRefer()));
}
else {
JOptionPane.showMessageDialog(this, "Sorry, there is no " +
"available Decsion Tree to " +
"perform this operation on.",
"Sorry!",
JOptionPane.WARNING_MESSAGE);
}
}
else {
JOptionPane.showMessageDialog(this, "Error, there is no " +
"selected Node to perform this " +
"operation on.", "Error!",
JOptionPane.ERROR_MESSAGE);
}
}
else if (e.getActionCommand().equals("Accept The Tree")) {
if (m_listener != null) {
//then send message to the listener saying that the tree is done
m_listener.userCommand(new TreeDisplayEvent(TreeDisplayEvent.ACCEPT,
null));
}
else {
JOptionPane.showMessageDialog(this, "Sorry, there is no " +
"available Decision Tree to " +
"perform this operation on.",
"Sorry!",
JOptionPane.WARNING_MESSAGE);
}
}
}
/**
* Performs the action associated with the ItemEvent.
*
* @param e the item event.
*/
public void itemStateChanged(ItemEvent e)
{
JRadioButtonMenuItem c = (JRadioButtonMenuItem)e.getSource();
if (c.getActionCommand().equals("Size 24")) {
changeFontSize(24);
}
else if (c.getActionCommand().equals("Size 22")) {
changeFontSize(22);
}
else if (c.getActionCommand().equals("Size 20")) {
changeFontSize(20);
}
else if (c.getActionCommand().equals("Size 18")) {
changeFontSize(18);
}
else if (c.getActionCommand().equals("Size 16")) {
changeFontSize(16);
}
else if (c.getActionCommand().equals("Size 14")) {
changeFontSize(14);
}
else if (c.getActionCommand().equals("Size 12")) {
changeFontSize(12);
}
else if (c.getActionCommand().equals("Size 10")) {
changeFontSize(10);
}
else if (c.getActionCommand().equals("Size 8")) {
changeFontSize(8);
}
else if (c.getActionCommand().equals("Size 6")) {
changeFontSize(6);
}
else if (c.getActionCommand().equals("Size 4")) {
changeFontSize(4);
}
else if (c.getActionCommand().equals("Size 2")) {
changeFontSize(2);
}
else if (c.getActionCommand().equals("Size 1")) {
changeFontSize(1);
}
else if (c.getActionCommand().equals("Hide Descendants")) {
//focus_node.setCVisible(!c.isSelected());
//no longer used...
}
}
/**
* Does nothing.
* @param e the mouse event.
*/
public void mouseClicked(MouseEvent e) {
//if the mouse was left clicked on
//the node then
if (m_clickAvailable) {
//determine if the click was on a node or not
int s = -1;
for (int noa = 0; noa < m_numNodes;noa++) {
if (m_nodes[noa].m_quad == 18) {
//then is on the screen
calcScreenCoords(noa);
if (e.getX() <= m_nodes[noa].m_center + m_nodes[noa].m_side
&& e.getX()
>= m_nodes[noa].m_center - m_nodes[noa].m_side &&
e.getY() >= m_nodes[noa].m_top && e.getY()
<= m_nodes[noa].m_top + m_nodes[noa].m_height) {
//then it is this node that the mouse was clicked on
s = noa;
}
m_nodes[noa].m_top = 32000;
}
}
m_focusNode = s;
if (m_focusNode != -1) {
if (m_listener != null) {
//then set this to be the selected node for editing
actionPerformed(new ActionEvent(this, 32000, "Create Child Nodes"));
}
else {
//then open a visualize to display this nodes instances if possible
actionPerformed(new ActionEvent(this, 32000, "Visualize The Node"));
}
}
}
}
/**
* Determines what action the user wants to perform.
*
* @param e the mouse event.
*/
public void mousePressed(MouseEvent e) {
m_frameLimiter.setRepeats(true);
if ((e.getModifiers() & e.BUTTON1_MASK) != 0 && !e.isAltDown() &&
m_mouseState == 0
&& m_scaling == 0) {
//then the left mouse button has been pressed
//check for modifiers
if (((e.getModifiers() & e.CTRL_MASK) != 0) && ((e.getModifiers() & e.SHIFT_MASK) == 0)) {
//then is in zoom out mode
m_mouseState = 2;
}
else if (((e.getModifiers() & e.SHIFT_MASK) != 0) && ((e.getModifiers() & e.CTRL_MASK) == 0)) {
//then is in zoom mode
//note if both are pressed default action is to zoom out
m_oldMousePos.width = e.getX();
m_oldMousePos.height = e.getY();
m_newMousePos.width = e.getX();
m_newMousePos.height = e.getY();
m_mouseState = 3;
Graphics g = getGraphics();
if (m_ZoomBoxColor == null)
g.setColor(Color.black);
else
g.setColor(m_ZoomBoxColor);
if (m_ZoomBoxXORColor == null)
g.setXORMode(Color.white);
else
g.setXORMode(m_ZoomBoxXORColor);
g.drawRect(m_oldMousePos.width, m_oldMousePos.height,
m_newMousePos.width - m_oldMousePos.width,
m_newMousePos.height - m_oldMousePos.height);
g.dispose();
}
else {
//no modifiers drag area around
m_oldMousePos.width = e.getX();
m_oldMousePos.height = e.getY();
m_newMousePos.width = e.getX();
m_newMousePos.height = e.getY();
m_mouseState = 1;
m_frameLimiter.start();
}
}
// pop up save dialog explicitly (is somehow overridden...)
else if ( (e.getButton() == MouseEvent.BUTTON1) && e.isAltDown() && e.isShiftDown() && !e.isControlDown() ) {
saveComponent();
}
else if (m_mouseState == 0 && m_scaling == 0) {
//either middle or right mouse button pushed
//determine menu to use
}
}
/**
* Performs the final stages of what the user wants to perform.
*
* @param e the mouse event.
*/
public void mouseReleased(MouseEvent e) {
if (m_mouseState == 1) {
//this is used by mouseClicked to determine if it is alright to do
//something
m_clickAvailable = true;
//note that a standard click with the left mouse is pretty much the
//only safe input left to be assigned anything.
}
else {
m_clickAvailable = false;
}
if (m_mouseState == 2 && mouseInBounds(e)) {
//then zoom out;
m_mouseState = 0;
Dimension ns = new Dimension(m_viewSize.width / 2, m_viewSize.height
/ 2);
if (ns.width < 10) {
ns.width = 10;
}
if (ns.height < 10) {
ns.height = 10;
}
Dimension d = getSize();
Dimension np = new Dimension((int)(d.width / 2
- ((double)d.width / 2
- m_viewPos.width) / 2),
(int)(d.height / 2
- ((double)d.height / 2
- m_viewPos.height) / 2));
animateScaling(np, ns, 10);
//view_pos.width += view_size.width / 2;
//view_pos.height += view_size.height / 2;
}
else if (m_mouseState == 3) {
//then zoom in
m_mouseState = 0;
Graphics g = getGraphics();
if (m_ZoomBoxColor == null)
g.setColor(Color.black);
else
g.setColor(m_ZoomBoxColor);
if (m_ZoomBoxXORColor == null)
g.setXORMode(Color.white);
else
g.setXORMode(m_ZoomBoxXORColor);
g.drawRect(m_oldMousePos.width, m_oldMousePos.height,
m_newMousePos.width - m_oldMousePos.width,
m_newMousePos.height - m_oldMousePos.height);
g.dispose();
int cw = m_newMousePos.width - m_oldMousePos.width;
int ch = m_newMousePos.height - m_oldMousePos.height;
if (cw >= 1 && ch >= 1) {
if (mouseInBounds(e) &&
(getSize().width / cw) <= 6 &&
(getSize().height / ch) <= 6) {
//now calculate new position and size
Dimension ns = new Dimension();
Dimension np = new Dimension();
double nvsw = getSize().width / (double)(cw);
double nvsh = getSize().height / (double)(ch);
np.width = (int)((m_oldMousePos.width - m_viewPos.width) * -nvsw);
np.height = (int)((m_oldMousePos.height - m_viewPos.height) * -nvsh);
ns.width = (int)(m_viewSize.width * nvsw);
ns.height = (int)(m_viewSize.height * nvsh);
animateScaling(np, ns, 10);
}
}
}
else if (m_mouseState == 0 && m_scaling == 0) {
//menu
m_mouseState = 0;
setFont(new Font("A Name", 0, 12));
//determine if the click was on a node or not
int s = -1;
for (int noa = 0; noa < m_numNodes;noa++) {
if (m_nodes[noa].m_quad == 18) {
//then is on the screen
calcScreenCoords(noa);
if (e.getX() <= m_nodes[noa].m_center + m_nodes[noa].m_side
&& e.getX()
>= m_nodes[noa].m_center - m_nodes[noa].m_side &&
e.getY() >= m_nodes[noa].m_top && e.getY()
<= m_nodes[noa].m_top + m_nodes[noa].m_height) {
//then it is this node that the mouse was clicked on
s = noa;
}
m_nodes[noa].m_top = 32000;
}
}
if (s == -1) {
//the mouse wasn't clicked on a node
m_winMenu.show(this,e.getX(),e.getY());
}
else {
//the mouse was clicked on a node
m_focusNode = s;
m_nodeMenu.show(this, e.getX(), e.getY());
}
setFont(m_currentFont);
}
else if (m_mouseState == 1) {
//dragging
m_mouseState = 0;
m_frameLimiter.stop();
repaint();
}
}
/**
* Checks to see if the coordinates of the mouse lie on this JPanel.
*
* @param e the mouse event.
* @return true if the mouse lies on this JPanel.
*/
private boolean mouseInBounds(MouseEvent e) {
//this returns true if the mouse is currently over the canvas otherwise
//false
if (e.getX() < 0 || e.getY() < 0 || e.getX() > getSize().width
|| e.getY() > getSize().height) {
return false;
}
return true;
}
/**
* Performs intermediate updates to what the user wishes to do.
*
* @param e the mouse event.
*/
public void mouseDragged(MouseEvent e) {
//use mouse state to determine what to do to the view of the tree
if (m_mouseState == 1) {
//then dragging view
m_oldMousePos.width = m_newMousePos.width;
m_oldMousePos.height = m_newMousePos.height;
m_newMousePos.width = e.getX();
m_newMousePos.height = e.getY();
m_viewPos.width += m_newMousePos.width - m_oldMousePos.width;
m_viewPos.height += m_newMousePos.height - m_oldMousePos.height;
}
else if (m_mouseState == 3) {
//then zoom box being created
//redraw the zoom box
Graphics g = getGraphics();
if (m_ZoomBoxColor == null)
g.setColor(Color.black);
else
g.setColor(m_ZoomBoxColor);
if (m_ZoomBoxXORColor == null)
g.setXORMode(Color.white);
else
g.setXORMode(m_ZoomBoxXORColor);
g.drawRect(m_oldMousePos.width, m_oldMousePos.height,
m_newMousePos.width - m_oldMousePos.width,
m_newMousePos.height - m_oldMousePos.height);
m_newMousePos.width = e.getX();
m_newMousePos.height = e.getY();
g.drawRect(m_oldMousePos.width, m_oldMousePos.height,
m_newMousePos.width - m_oldMousePos.width,
m_newMousePos.height - m_oldMousePos.height);
g.dispose();
}
}
/**
* Does nothing.
*
* @param e the mouse event.
*/
public void mouseMoved(MouseEvent e) {
}
/**
* Does nothing.
*
* @param e the mouse event.
*/
public void mouseEntered(MouseEvent e) {
}
/**
* Does nothing.
*
* @param e the mouse event.
*/
public void mouseExited(MouseEvent e) {
}
/**
* Set the highlight for the node with the given id
* @param id the id of the node to set the highlight for
*/
public void setHighlight(String id) {
//set the highlight for the node with the given id
for (int noa = 0; noa < m_numNodes; noa++) {
if (id.equals(m_nodes[noa].m_node.getRefer())) {
//then highlight this node
m_highlightNode = noa;
}
}
//System.out.println("ahuh " + highlight_node + " " +
//nodes[0].node.getRefer());
repaint();
}
/**
* Updates the screen contents.
*
* @param g the drawing surface.
*/
public void paintComponent(Graphics g) {
Color oldBackground = ((Graphics2D) g).getBackground();
if (m_BackgroundColor != null)
((Graphics2D) g).setBackground(m_BackgroundColor);
g.clearRect(0, 0, getSize().width, getSize().height);
((Graphics2D) g).setBackground(oldBackground);
g.setClip(3, 7, getWidth() - 6, getHeight() - 10);
painter(g);
g.setClip(0, 0, getWidth(), getHeight());
}
/**
* Draws the tree to the graphics context
*
* @param g the drawing surface.
*/
private void painter(Graphics g) {
//I have moved what would normally be in the paintComponent
//function to here
//for now so that if I do in fact need to do double
//buffering or the like it will be easier
//this will go through the table of edges and draw the edge if it deems the
//two nodes attached to it could cause it to cut the screen or be on it.
//in the process flagging all nodes so that they can quickly be put to the
//screen if they lie on it
//I do it in this order because in some circumstances I have seen a line
//cut through a node , to make things look better the line will
//be drawn under the node
//converting the screen edges to the node scale so that they
//can be positioned relative to the screen
//note I give a buffer around the edges of the screen.
//when seeing
//if a node is on screen I only bother to check the nodes top centre
//if it has large enough size it may still fall onto the screen
double left_clip = (double)(-m_viewPos.width - 50) / m_viewSize.width;
double right_clip = (double)(getSize().width - m_viewPos.width + 50) /
m_viewSize.width;
double top_clip = (double)(-m_viewPos.height - 50) / m_viewSize.height;
double bottom_clip = (double)(getSize().height - m_viewPos.height + 50) /
m_viewSize.height;
// 12 10 9 //the quadrants
// 20 18 17
// 36 34 33
//first the edges must be rendered
Edge e;
Node r,s;
double ncent,ntop;
int row = 0, col = 0, pq, cq;
for (int noa = 0 ; noa < m_numNodes ; noa++) {
r = m_nodes[noa].m_node;
if (m_nodes[noa].m_change) {
//then recalc row component of quadrant
ntop = r.getTop();
if (ntop < top_clip) {
row = 8;
}
else if (ntop > bottom_clip) {
row = 32;
}
else {
row = 16;
}
}
//calc the column the node falls in for the quadrant
ncent = r.getCenter();
if (ncent < left_clip) {
col = 4;
}
else if (ncent > right_clip) {
col = 1;
}
else {
col = 2;
}
m_nodes[noa].m_quad = row | col;
if (m_nodes[noa].m_parent >= 0) {
//this will draw the edge if it should be drawn
//It will do this by eliminating all edges that definitely won't enter
//the screen and then draw the rest
pq = m_nodes[m_edges[m_nodes[noa].m_parent].m_parent].m_quad;
cq = m_nodes[noa].m_quad;
//note that this will need to be altered if more than 1 parent exists
if ((cq & 8) == 8) {
//then child exists above screen
}
else if ((pq & 32) == 32) {
//then parent exists below screen
}
else if ((cq & 4) == 4 && (pq & 4) == 4) {
//then both child and parent exist to the left of the screen
}
else if ((cq & 1) == 1 && (pq & 1) == 1) {
//then both child and parent exist to the right of the screen
}
else {
//then draw the line
drawLine(m_nodes[noa].m_parent, g);
}
}
//now draw the nodes
}
for (int noa = 0 ;noa < m_numNodes; noa++) {
if (m_nodes[noa].m_quad == 18) {
//then the node is on the screen , draw it
drawNode(noa, g);
}
}
if (m_highlightNode >= 0 && m_highlightNode < m_numNodes) {
//then draw outline
if (m_nodes[m_highlightNode].m_quad == 18) {
Color acol;
if (m_NodeColor == null)
acol = m_nodes[m_highlightNode].m_node.getColor();
else
acol = m_NodeColor;
g.setColor(new Color((acol.getRed() + 125) % 256,
(acol.getGreen() + 125) % 256,
(acol.getBlue() + 125) % 256));
//g.setXORMode(Color.white);
if (m_nodes[m_highlightNode].m_node.getShape() == 1) {
g.drawRect(m_nodes[m_highlightNode].m_center
- m_nodes[m_highlightNode].m_side,
m_nodes[m_highlightNode].m_top,
m_nodes[m_highlightNode].m_width,
m_nodes[m_highlightNode].m_height);
g.drawRect(m_nodes[m_highlightNode].m_center
- m_nodes[m_highlightNode].m_side
+ 1, m_nodes[m_highlightNode].m_top + 1,
m_nodes[m_highlightNode].m_width - 2,
m_nodes[m_highlightNode].m_height - 2);
}
else if (m_nodes[m_highlightNode].m_node.getShape() == 2) {
g.drawOval(m_nodes[m_highlightNode].m_center
- m_nodes[m_highlightNode].m_side,
m_nodes[m_highlightNode].m_top,
m_nodes[m_highlightNode].m_width,
m_nodes[m_highlightNode].m_height);
g.drawOval(m_nodes[m_highlightNode].m_center
- m_nodes[m_highlightNode].m_side
+ 1, m_nodes[m_highlightNode].m_top + 1,
m_nodes[m_highlightNode].m_width - 2,
m_nodes[m_highlightNode].m_height - 2);
}
}
}
for (int noa = 0;noa < m_numNodes;noa++) {
//this resets the coords so that next time a refresh occurs
//they don't accidentally get used
//I will use 32000 to signify that they are invalid, even if this
//coordinate occurs it doesn't
//matter as it is only for the sake of the caching
m_nodes[noa].m_top = 32000;
}
}
/**
* Determines the attributes of the node and draws it.
*
* @param n A subscript identifying the node in <i>nodes</i> array
* @param g The drawing surface
*/
private void drawNode(int n, Graphics g) {
//this will draw a node and then print text on it
if (m_NodeColor == null)
g.setColor(m_nodes[n].m_node.getColor());
else
g.setColor(m_NodeColor);
g.setPaintMode();
calcScreenCoords(n);
int x = m_nodes[n].m_center - m_nodes[n].m_side;
int y = m_nodes[n].m_top;
if (m_nodes[n].m_node.getShape() == 1) {
g.fill3DRect(x, y, m_nodes[n].m_width, m_nodes[n].m_height, true);
drawText(x, y, n, false, g);
}
else if (m_nodes[n].m_node.getShape() == 2) {
g.fillOval(x, y, m_nodes[n].m_width, m_nodes[n].m_height);
drawText(x, y + (int)(m_nodes[n].m_height * .15), n, false, g);
}
}
/**
* Determines the attributes of the edge and draws it.
*
* @param e A subscript identifying the edge in <i>edges</i> array.
* @param g The drawing surface.
*/
private void drawLine(int e, Graphics g) {
//this will draw a line taking in the edge number and then getting
//the nodes subscript for the parent and child entries
//this will draw a line that has been broken in the middle
//for the edge text to be displayed
//if applicable
//first convert both parent and child node coords to screen coords
int p = m_edges[e].m_parent;
int c = m_edges[e].m_child;
calcScreenCoords(c);
calcScreenCoords(p);
if (m_LineColor == null)
g.setColor(Color.black);
else
g.setColor(m_LineColor);
g.setPaintMode();
if (m_currentFont.getSize() < 2) {
//text to small to bother cutting the edge
g.drawLine(m_nodes[p].m_center, m_nodes[p].m_top + m_nodes[p].m_height,
m_nodes[c].m_center, m_nodes[c].m_top);
}
else {
//find where to cut the edge to insert text
int e_width = m_nodes[c].m_center - m_nodes[p].m_center;
int e_height = m_nodes[c].m_top - (m_nodes[p].m_top
+ m_nodes[p].m_height);
int e_width2 = e_width / 2;
int e_height2 = e_height / 2;
int e_centerx = m_nodes[p].m_center + e_width2;
int e_centery = m_nodes[p].m_top + m_nodes[p].m_height + e_height2;
int e_offset = m_edges[e].m_tb;
int tmp = (int)(((double)e_width / e_height) *
(e_height2 - e_offset)) + m_nodes[p].m_center;
//System.out.println(edges[e].m_height);
//draw text now
drawText(e_centerx - m_edges[e].m_side, e_centery - e_offset, e, true
, g);
if (tmp > (e_centerx - m_edges[e].m_side) && tmp
< (e_centerx + m_edges[e].m_side)) {
//then cut line on top and bottom of text
g.drawLine(m_nodes[p].m_center, m_nodes[p].m_top + m_nodes[p].m_height
, tmp, e_centery - e_offset); //first segment
g.drawLine(e_centerx * 2 - tmp, e_centery + e_offset,
m_nodes[c].m_center, m_nodes[c].m_top); //second segment
}
else {
e_offset = m_edges[e].m_side;
if (e_width < 0) {
e_offset *= -1; //adjusting for direction which could otherwise
//screw up the calculation
}
tmp = (int)(((double)e_height / e_width) * (e_width2 - e_offset)) +
m_nodes[p].m_top + m_nodes[p].m_height;
g.drawLine(m_nodes[p].m_center, m_nodes[p].m_top + m_nodes[p].m_height
, e_centerx - e_offset, tmp); //first segment
g.drawLine(e_centerx + e_offset, e_centery * 2 - tmp,
m_nodes[c].m_center, m_nodes[c].m_top); //second segment
}
}
//System.out.println("here" + nodes[p].center);
}
/**
* Draws the text for either an Edge or a Node.
*
* @param x1 the left side of the text area.
* @param y1 the top of the text area.
* @param s A subscript identifying either a Node or Edge.
* @param e_or_n Distinguishes whether it is a node or edge.
* @param g The drawing surface.
*/
private void drawText(int x1, int y1, int s, boolean e_or_n, Graphics g) {
//this function will take in the rectangle that the text should be
//drawn in as well as the subscript
//for either the edge or node and a boolean variable to tell which
// backup color
Color oldColor = g.getColor();
g.setPaintMode();
if (m_FontColor == null)
g.setColor(Color.black);
else
g.setColor(m_FontColor);
String st;
if (e_or_n) {
//then paint for edge
Edge e = m_edges[s].m_edge;
for (int noa = 0;(st = e.getLine(noa)) != null; noa++) {
g.drawString(st, (m_edges[s].m_width - m_fontSize.stringWidth(st)) / 2
+ x1,
y1 + (noa + 1) * m_fontSize.getHeight());
}
}
else {
//then paint for node
Node e = m_nodes[s].m_node;
for (int noa = 0;(st = e.getLine(noa)) != null; noa++) {
g.drawString(st, (m_nodes[s].m_width - m_fontSize.stringWidth(st)) / 2
+ x1,
y1 + (noa + 1) * m_fontSize.getHeight());
}
}
// restore color
g.setColor(oldColor);
}
/**
* Converts the internal coordinates of the node found from <i>n</i>
* and converts them to the actual screen coordinates.
*
* @param n A subscript identifying the Node.
*/
private void calcScreenCoords(int n) {
//this converts the coordinate system the Node uses into screen coordinates
// System.out.println(n + " " + view_pos.height + " " +
//nodes[n].node.getCenter());
if (m_nodes[n].m_top == 32000) {
m_nodes[n].m_top = ((int)(m_nodes[n].m_node.getTop()
* m_viewSize.height)) + m_viewPos.height;
m_nodes[n].m_center = ((int)(m_nodes[n].m_node.getCenter()
* m_viewSize.width)) + m_viewPos.width;
}
}
/**
* This Calculates the minimum size of the tree which will prevent any text
* overlapping and make it readable, and then set the size of the tree to
* this.
*/
private void autoScale() {
//this function will determine the smallest scale value that keeps the text
//from overlapping
//it will leave the view centered
int dist;
Node ln,rn;
Dimension temp = new Dimension(10, 10);
if (m_numNodes <= 1) {
return;
}
//calc height needed by first node
dist = (m_nodes[0].m_height + 40) * m_numLevels;
if (dist > temp.height) {
temp.height = dist;
}
for (int noa = 0;noa < m_numNodes - 1;noa++) {
calcScreenCoords(noa);
calcScreenCoords(noa+1);
if (m_nodes[noa+1].m_change) {
//then on a new level so don't check width this time round
}
else {
dist = m_nodes[noa+1].m_center - m_nodes[noa].m_center;
//the distance between the node centers, along horiz
if (dist <= 0) {
dist = 1;
}
dist = ((6 + m_nodes[noa].m_side + m_nodes[noa+1].m_side)
* m_viewSize.width) / dist; //calc optimal size for width
if (dist > temp.width) {
temp.width = dist;
}
}
//now calc.. minimun hieght needed by nodes
dist = (m_nodes[noa+1].m_height + 40) * m_numLevels;
if (dist > temp.height) {
temp.height = dist;
}
}
int y1, y2, xa, xb;
y1 = m_nodes[m_edges[0].m_parent].m_top;
y2 = m_nodes[m_edges[0].m_child].m_top;
dist = y2 - y1;
if (dist <= 0) {
dist = 1;
}
dist = ((60 + m_edges[0].m_height + m_nodes[m_edges[0].m_parent].m_height)
* m_viewSize.height) / dist;
if (dist > temp.height) {
temp.height = dist;
}
for (int noa = 0;noa < m_numNodes - 2; noa++) {
//check the edges now
if (m_nodes[m_edges[noa+1].m_child].m_change) {
//then edge is on a different level , so skip this one
}
else {
//calc the width requirements of this pair of edges
xa = m_nodes[m_edges[noa].m_child].m_center
- m_nodes[m_edges[noa].m_parent].m_center;
xa /= 2;
xa += m_nodes[m_edges[noa].m_parent].m_center;
xb = m_nodes[m_edges[noa+1].m_child].m_center -
m_nodes[m_edges[noa+1].m_parent].m_center;
xb /= 2;
xb += m_nodes[m_edges[noa+1].m_parent].m_center;
dist = xb - xa;
if (dist <= 0) {
dist = 1;
}
dist = ((12 + m_edges[noa].m_side + m_edges[noa+1].m_side)
* m_viewSize.width)
/ dist;
if (dist > temp.width) {
temp.width = dist;
}
}
//now calc height need by the edges
y1 = m_nodes[m_edges[noa+1].m_parent].m_top;
y2 = m_nodes[m_edges[noa+1].m_child].m_top;
dist = y2 - y1;
if (dist <= 0) {
dist = 1;
}
dist = ((60 + m_edges[noa+1].m_height
+ m_nodes[m_edges[noa+1].m_parent].m_height)
* m_viewSize.height) / dist;
if (dist > temp.height) {
temp.height = dist;
}
}
Dimension e = getSize();
Dimension np = new Dimension();
np.width = (int)(e.width / 2 - (((double)e.width / 2) - m_viewPos.width) /
((double)m_viewSize.width) * (double)temp.width);
np.height = (int)(e.height / 2 - (((double)e.height / 2) -
m_viewPos.height) /
((double)m_viewSize.height) * (double)temp.height);
//animate_scaling(c_size,c_pos,25);
for (int noa = 0;noa < m_numNodes;noa++) {
//this resets the coords so that next time a refresh occurs they don't
//accidentally get used
//I will use 32000 to signify that they are invalid, even if this
//coordinate occurs it doesn't
//matter as it is only for the sake of the caching
m_nodes[noa].m_top = 32000;
}
animateScaling(np, temp, 10);
}
/**
* This will increment the size and position of the tree towards the
* desired size and position
* a little (depending on the value of <i>frames</i>) everytime it is called.
*
* @param n_pos The final position of the tree wanted.
* @param n_size The final size of the tree wanted.
* @param frames The number of frames that shall occur before the final
* size and pos is reached.
*/
private void animateScaling(Dimension n_pos,Dimension n_size,int frames) {
//this function will take new size and position coords , and incrementally
//scale the view to these
//since I will be tying it in with the framelimiter I will simply call
//this function and increment it once
//I will have to use a global variable since I am doing it proportionally
if (frames == 0) {
System.out.println("the timer didn't end in time");
m_scaling = 0;
}
else {
if (m_scaling == 0) {
//new animate session
//start timer and set scaling
m_frameLimiter.start();
m_nViewPos.width = n_pos.width;
m_nViewPos.height = n_pos.height;
m_nViewSize.width = n_size.width;
m_nViewSize.height = n_size.height;
m_scaling = frames;
}
int s_w = (n_size.width - m_viewSize.width) / frames;
int s_h = (n_size.height - m_viewSize.height) / frames;
int p_w = (n_pos.width - m_viewPos.width) / frames;
int p_h = (n_pos.height - m_viewPos.height) / frames;
m_viewSize.width += s_w;
m_viewSize.height += s_h;
m_viewPos.width += p_w;
m_viewPos.height += p_h;
repaint();
m_scaling--;
if (m_scaling == 0) {
//all done
m_frameLimiter.stop();
}
}
}
/**
* This will change the font size for displaying the tree to the one
* specified.
*
* @param s The new pointsize of the font.
*/
private void changeFontSize(int s) {
//this will set up the new font that shall be used
//it will also recalculate the size of the nodes as these will change as
//a result of
//the new font size
setFont(m_currentFont = new Font("A Name", 0, s));
m_fontSize = getFontMetrics(getFont());
Dimension d;
for (int noa = 0; noa < m_numNodes; noa++) {
//this will set the size info for each node and edge
d = m_nodes[noa].m_node.stringSize(m_fontSize);
if (m_nodes[noa].m_node.getShape() == 1) {
m_nodes[noa].m_height = d.height + 10;
m_nodes[noa].m_width = d.width + 8;
m_nodes[noa].m_side = m_nodes[noa].m_width / 2;
}
else if (m_nodes[noa].m_node.getShape() == 2) {
m_nodes[noa].m_height = (int)((d.height + 2) * 1.6);
m_nodes[noa].m_width = (int)((d.width + 2) * 1.6);
m_nodes[noa].m_side = m_nodes[noa].m_width / 2;
}
if (noa < m_numNodes - 1) {
//this will do the same for edges
d = m_edges[noa].m_edge.stringSize(m_fontSize);
m_edges[noa].m_height = d.height + 8;
m_edges[noa].m_width = d.width + 8;
m_edges[noa].m_side = m_edges[noa].m_width / 2;
m_edges[noa].m_tb = m_edges[noa].m_height / 2;
}
}
}
/**
* This will fill two arrays with the Nodes and Edges from the tree
* into a particular order.
*
* @param t The top Node of the tree.
* @param l An array that has already been allocated, to be filled.
* @param k An array that has already been allocated, to be filled.
*/
private void arrayFill(Node t, NodeInfo[] l, EdgeInfo[] k) {
//this will take the top node and the array to fill
//it will go through the tree structure and and fill the array with the
//nodes
//from top to bottom left to right
//note I do not believe this function will be able to deal with multiple
//parents
if (t == null || l == null) {
System.exit(1); //this is just a preliminary safety check
//(i shouldn' need it)
}
Edge e;
Node r,s;
l[0] = new NodeInfo();
l[0].m_node = t;
l[0].m_parent = -1;
l[0].m_change = true;
int floater; //this will point at a node that has previously been
//put in the list
//all of the children that this node has shall be put in the list ,
//once this is done the floater shall point at the next node in the list
//this will allow the nodes to be put into order from closest to top node
//to furtherest from top node
int free_space = 1; //the next empty array position
double height = t.getTop(); //this will be used to determine if the node
//has a
//new height compared to the
//previous one
for (floater = 0;floater < free_space;floater++) {
r = l[floater].m_node;
for (int noa = 0;(e = r.getChild(noa)) != null;noa++) {
//this loop pulls out each child of r
//e points to a child edge, getTarget will return that edges child node
s = e.getTarget();
l[free_space] = new NodeInfo();
l[free_space].m_node = s;
l[free_space].m_parent = free_space - 1;
k[free_space - 1] = new EdgeInfo();
k[free_space - 1].m_edge = e;
k[free_space - 1].m_parent = floater;
k[free_space - 1].m_child = free_space; //note although it's child
//will always have a subscript
//of 1 more , I may not nessecarily have access to that
//and it will need the subscr.. for multiple parents
//determine if level of node has changed from previous one
if (height != s.getTop()) {
l[free_space].m_change = true;
height = s.getTop();
}
else {
l[free_space].m_change = false;
}
free_space++;
}
}
}
/**
* Internal Class for containing display information about a Node.
*/
private class NodeInfo {
//this class contains a pointer to the node itself along with extra
//information
//about the node used by the Displayer class
/** The y pos of the node on screen. */
int m_top = 32000; //the main node coords calculated out
/** The x pos of the node on screen. */
int m_center; // these coords will probably change each refresh
//and are the positioning coords
//which the rest of the offsets use
/** The offset to get to the left or right of the node. */
int m_side; //these are the screen offset for the dimensions of
//the node relative to the nodes
//internal top and center values (after they have been converted to
//screen coords
/** The width of the node. */
int m_width;
/** The height of the node. */
int m_height;
/** True if the node is at the start (left) of a new level (not sibling
* group). */
boolean m_change; //this is quickly used to identify whether the node
//has chenged height from the
//previous one to help speed up the calculation of what row it lies in
/** The subscript number of the Nodes parent. */
int m_parent; //this is the index of the nodes parent edge in an array
/** The rough position of the node relative to the screen. */
int m_quad; //what of nine quadrants is it in
/*
12 10 9
20 18 17 //18 being the screen
36 34 33 //this arrangement uses 6 bits, each bit represents a
row or column
*/
/** The Node itself. */
Node m_node;
}
/**
* Internal Class for containing display information about an Edge.
*/
private class EdgeInfo {
//this class contains a pointer to the edge along with all the other
//extra info about the edge
/** The parent subscript (for a Node). */
int m_parent; //array indexs for its two connections
/** The child subscript (for a Node). */
int m_child;
/** The distance from the center of the text to either side. */
int m_side; //these are used to describe the dimensions of the
//text
/** The distance from the center of the text to top or bottom. */
int m_tb; //tb stands for top , bottom, this is simply the
//distance from the middle to top bottom
/** The width of the text. */
int m_width;
/** The height of the text. */
int m_height;
/** The Edge itself. */
Edge m_edge;
}
/**
* Main method for testing this class.
* @param args first argument should be the name of a file that contains
* a tree discription in dot format.
*/
public static void main(String[] args) {
try {
weka.core.logging.Logger.log(weka.core.logging.Logger.Level.INFO, "Logging started");
//put in the random data generator right here
// this call with import java.lang gives me between 0 and 1 Math.random
TreeBuild builder = new TreeBuild();
Node top = null;
NodePlace arrange = new PlaceNode2();
//top = builder.create(new StringReader("digraph atree { top [label=\"the top\"] a [label=\"the first node\"] b [label=\"the second nodes\"] c [label=\"comes off of first\"] top->a top->b b->c }"));
top = builder.create(new FileReader(args[0]));
int num = top.getCount(top,0);
//System.out.println("counter counted " + num + " nodes");
//System.out.println("there are " + num + " nodes");
TreeVisualizer a = new TreeVisualizer(null, top, arrange);
a.setSize(800 ,600);
//a.setTree(top);
JFrame f;
f = new JFrame();
//a.addMouseMotionListener(a);
//a.addMouseListener(a);
//f.add(a);
Container contentPane = f.getContentPane();
contentPane.add(a);
f.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
f.setSize(800,600);
f.setVisible(true);
//f.
//find_prop(top);
//a.setTree(top,arrange);//,(num + 1000), num / 2 + 1000);
}
catch(IOException e) {
// ignored
}
}
}