package genegui;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Vector;
import javax.swing.event.InternalFrameAdapter;
import javax.swing.event.InternalFrameEvent;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import main.AffectorTemplate;
import main.GeneNet;
import main.Model;
import main.NodeTemplate;

/** TimeGraph.java
 A spanking new GUI component for collection and displaying time vs concentration
 graphs. TimeGraph will collect all data from a run and store it. The user then
 can select which data they want to display on the graph.
 @author WJS
 */
public class TimeGraph extends JInternalFrame implements GuiInterface, ModelStateChangeListener, OptionsPanelInterface {
	
	/** JToggleButton for turning auto-resizing function on and off */
	private	JToggleButton             AutoResizeJButton;
	/** Debounce timer used for auto-resizing */
	private javax.swing.Timer         AutoResizeDebounceTimer;
	/** Preferred dimension for the CellPaintPanel */
	private Dimension                 CellPaintPanelDimension;
	/** Stores the base cell shapes and locations */
	private Polygon[]                 CellShapeArray;
	/** An ArrayList of matricies corresponding to each time step. X coordinant
	 are cell # and Y coordinant node # */
	private ArrayList                 DataArrays;
	/** When true allows data points to be added */
	private boolean                   DataCollectionEnable = true;
	/** A collection of DataArrays for each model run */
	private ArrayList                 DataSets;
	/** JLabel for showing the number of data sets */
	private JLabel                    DataSetsDisplay;
	/** An ArrayList of Boolean which indicates if the graph hold button is on */
	private ArrayList                 DataSetHoldArray;
	/** Hold button for indicating that a graph should be kept displayed
	 despite value of DataSetIndex */
	private JToggleButton             DataSetHoldButton;
	/** The currently displayed data set index */
	private int                       DataSetIndex = -1;
	/** Field for displaying and changing the current DataSet index */
  private JTextField                DataSetIndexDisplay;
	/** Global grid spacing */
	private int                       GlobalGridSpacing = 10;
  /** Global legend setting */
	private boolean                   GlobalLegendEnabled = true;
  /** Global show grid setting */
	private boolean                   GlobalShowGrid = false;
  /** Global show range setting */
	private boolean                   GlobalShowRange = true;
  /** Global graph XScale (width) setting (pixels/unit time) */
	private float                     GlobalXScale = 1f;
  /** Global graph YScale (height) setting (pixels/unit value) */
	private float                     GlobalYScale = 100f;
	/** The JPanel for storing GraphPanels */
	private JPanel                    GraphsPanel;
	/** The ScrollPane that holds the GraphsPanel */
	private	JScrollPane               GraphsScrollPane;
	/** The Main JMenuBar */
  private JMenuBar                  MainMenu;
	/** The MainPanel is the content pane for the InternalFrame */
	private JPanel                    MainPanel;
	/** The number of cells in the model */
	private int                       NumberOfCells;
	/** The number of nodes in the network */
	private int                       NumberOfNodes;
	/** If set successive data sets will not be accumulated, but will be over-
	 write the current one and the data re-displayed.
	 */
	private JToggleButton             OverWriteDataButton;
	/** Self reference */
	private TimeGraph                 SaveThis = this;
	/** The scale at which to draw the cell shape objects */
	private double                    Scale = 5.0;
	/** If set to true, simple display mode is used which just shows values */
	private boolean                   SimpleDisplay = false;
	/** The GraphSurceSelector JFrame shared by all GraphPanels */
	private GraphSourceSelector       SourceSelector;
	/** The MainGui object that this belongs to */
	private MainGui                   TheMainGui;
	/** A pointer to the Model being graphed */
	private Model		                  TheModel = null;
	/** A pointer to the ModelState used to pass information */
	private ModelState                TheModelState = null;
	/** An ArrayList of Floats with time values corresponsing to set of values in the DataArray */
	private ArrayList                 TimeArray;
	/** Field for displaying number of datasets collected */
	private JLabel                    TimePointsDisplay;
	/** A collection of TimeArrays for each model run */
	private ArrayList                 TimeSets;
	/** Translation for drawing of cells */
	private Point                     Translation = new Point(5,5);
	
	/** Main Constructor
	 * @param Model model
	 * @param MainGui theMainGui
	 @author WJS
	 */
	public TimeGraph(Model model, MainGui theMainGui) {
		
		super("Time Graph",true,true,true,true);
		
		DataSets = new ArrayList();
		TimeSets = new ArrayList();
		DataArrays = new ArrayList();
		TimeArray = new ArrayList();
		DataSetHoldArray = new ArrayList();
		TheModel = model;
		TheMainGui = theMainGui;
		NumberOfCells = TheModel.numCells;
		NumberOfNodes = TheModel.getNetwork().numNodes;
		TheModelState = TheModel.getModelState();
		
		// Build the main panel
		MainPanel = new JPanel();
		MainPanel.setLayout(new BorderLayout());
		setContentPane(MainPanel);
		
		GraphsPanel = new JPanel();
		GraphsPanel.setBackground(Color.white);
		GraphsPanel.setLayout(new BoxLayout(GraphsPanel,BoxLayout.Y_AXIS));
		
		// Add one GraphPanel to the MainPanel to get the party started
		GraphPanel graph = new GraphPanel();
		GraphsPanel.add(graph,BorderLayout.CENTER);
		
		// Add the GraphsPanel
		GraphsScrollPane = new JScrollPane(GraphsPanel);
		MainPanel.add(GraphsScrollPane);
		
		// Build the cell shape array for use by paint panels
		CellShapeArray = new Polygon[TheModelState.getNumberOfCells()];
		Polygon p;
		Polygon q;
		for (int i=0;i<TheModelState.getNumberOfCells();i++) {
			p = TheModelState.getModel().cells[i].getCellShape();
			q = new Polygon();
			for (int n=0;n<p.npoints;n++) {
				q.addPoint((int)(p.xpoints[n]*Scale+Translation.x),(int)(p.ypoints[n]*Scale+Translation.y));
			}
			CellShapeArray[i] = q;
		}
		// Determine the best size for CellPaint panels by going through
		// all the shapes and finding the max points. Allow some head room
		// on right and left sides
		double maxX = 0;
		double maxY = 0;
		for (int i=0;i<CellShapeArray.length;i++) {
			Rectangle2D rect = CellShapeArray[i].getBounds2D();
			if ((rect.getX()+rect.getWidth())>maxX) maxX = rect.getX()+rect.getWidth();
			if ((rect.getY()+rect.getHeight())>maxY) maxY = rect.getY()+rect.getHeight();
		}
		CellPaintPanelDimension = new Dimension((int)maxX+20,(int)maxY+4);
		
		// Build the JMenuBar for the TimeGraph
		MainMenu = new JMenuBar();
		MainMenu.setBackground(Color.lightGray);
		
		JMenuItem item;

		// File control
		JMenu fileMenu = new JMenu("File");
		fileMenu.setBackground(Color.lightGray);
		item = new JMenuItem("Save Data Set");
		item.addActionListener(new ActionListener() {
					public void actionPerformed(ActionEvent ae) {
						FileDialog chooser = new FileDialog(GeneNet.TheMainGui,"Choose File");
						chooser.setDirectory(GeneNet.TheMainGui.getConfiguration().getLastSavedDir());
						chooser.show();
						if (chooser.getFile()!=null) {
						  File file = new File(chooser.getDirectory()+chooser.getFile());
							saveDataSets(file);
							GeneNet.TheMainGui.getConfiguration().setLastSavedDir(chooser.getDirectory());
						}
					}
				});
		fileMenu.add(item);
		MainMenu.add(fileMenu);
		
		// Graph control
		JMenu graphMenu = new JMenu("Graph");
		graphMenu.setBackground(Color.lightGray);
		item = new JMenuItem("Add New Graph");
		item.addActionListener(new ActionListener() {
					public void actionPerformed(ActionEvent ae) {
						GraphPanel graph = new GraphPanel();
						GraphsPanel.add(graph);
						pack();
					}
				});
		graphMenu.add(item);
		item = new JMenuItem("Rebuild Graph");
		item.addActionListener(new ActionListener() {
					public void actionPerformed(ActionEvent ae) {
						buildAll();
						validate();
						repaint();
					}
				});
		graphMenu.add(item);
		
		item = new JMenuItem("Remove All Graphs");
		item.addActionListener(new ActionListener() {
					public void actionPerformed(ActionEvent ae) {
						GraphsPanel.removeAll();
						repaint();
					}
				});
		graphMenu.add(item);
		
		graphMenu.addSeparator();
		
		item = new JMenuItem("Clear Current Data Set");
		item.addActionListener(new ActionListener() {
					public void actionPerformed(ActionEvent ae) {
						clearData();
						buildAll();
						repaint();
					}
				});
		graphMenu.add(item);
		
		item = new JMenuItem("Clear All Data Sets");
		item.addActionListener(new ActionListener() {
					public void actionPerformed(ActionEvent ae) {
						clearAllDataSets();
						buildAll();
						repaint();
					}
				});
		graphMenu.add(item);
		
		item = new JMenuItem("Disable Data Collection");
		item.addActionListener(new ActionListener() {
					public void actionPerformed(ActionEvent ae) {
						if (DataCollectionEnable)
								((JMenuItem)ae.getSource()).setText("Enable Data Collection");
						else
								((JMenuItem)ae.getSource()).setText("Disable Data Collection");
						DataCollectionEnable = !DataCollectionEnable;
					}
				});
		graphMenu.add(item);
		
		graphMenu.addSeparator();
		
		item = new JMenuItem("Options");
		item.addActionListener(new ActionListener() {
					public void actionPerformed(ActionEvent ae) {
						OptionsPanel opt = new OptionsPanel(SaveThis,GlobalShowGrid,GlobalGridSpacing,GlobalLegendEnabled,GlobalShowRange,GlobalXScale,GlobalYScale);
						opt.setLocation(SaveThis.getLocationOnScreen());
					}
				});
		graphMenu.add(item);
		
		graphMenu.addSeparator();
		
		item = new JMenuItem("Close");
		item.addActionListener(new ActionListener() {
					public void actionPerformed(ActionEvent ae) {
						close();
					}
				});
		graphMenu.add(item);
		MainMenu.add(graphMenu);
		
		// Autographing functions control
		JMenu autoGraphMenu = new JMenu("Auto-graphs");
		autoGraphMenu.setBackground(Color.lightGray);
		item = new JMenuItem("Graph Wizard");
		item.addActionListener(new ActionListener() {
					public void actionPerformed(ActionEvent ae) {
						GraphWizard wizard = new GraphWizard();
					}
				});
		autoGraphMenu.add(item);
		JMenu quickSubMenu = new JMenu("Quick Graphs");
		item = new JMenuItem("All nodes for one cell on one graph");
		item.addActionListener(new ActionListener() {
					public void actionPerformed(ActionEvent ae) {
					}
				});
//		quickSubMenu.add(item);
		item = new JMenuItem("All nodes for one cell on separate graphs");
		item.addActionListener(new ActionListener() {
					public void actionPerformed(ActionEvent ae) {
					}
				});
//		quickSubMenu.add(item);
		item = new JMenuItem("One node for all cells on one graph");
		item.addActionListener(new ActionListener() {
					public void actionPerformed(ActionEvent ae) {
					}
				});
//		quickSubMenu.add(item);
		item = new JMenuItem("One node for all cells on separate graphs");
		item.addActionListener(new ActionListener() {
					public void actionPerformed(ActionEvent ae) {
					}
				});
//		quickSubMenu.add(item);
		item = new JMenuItem("All nodes/All cells, one cell per graph");
		item.addActionListener(new ActionListener() {
					public void actionPerformed(ActionEvent ae) {
						GraphsPanel.removeAll();
						GraphPanel graph;
						// Loop through all cells and create a graph panel for each
						for (int i=0;i<NumberOfCells;i++) {
						  graph = new GraphPanel();
						  GraphsPanel.add(graph,BorderLayout.CENTER);
							// Loop through all nodes and add a graph for each node using
							// the nodes default color.
							for (int j=0;j<NumberOfNodes;j++) {
								graph.addDataPointer(i,j,TheModel.getNetwork().getNode(j).getColor(),"Cell"+Integer.toString(i)+TheModel.getNetwork().getNode(j).getName());
							}
						  graph.buildGraph();
						}
					  pack();
						repaint();
					}
				});
		quickSubMenu.add(item);
		item = new JMenuItem("All nodes/All cells, one node per graph");
		item.addActionListener(new ActionListener() {
					public void actionPerformed(ActionEvent ae) {
						GraphsPanel.removeAll();
						GraphPanel graph;
						// Create a psuedo color progression from red to blue based upon
						// the number of cells.
						Color[] colors = pseudoColors(NumberOfCells);
						// Loop through all nodes and create a graph panel for each
						for (int i=0;i<NumberOfNodes;i++) {
						  graph = new GraphPanel();
						  GraphsPanel.add(graph,BorderLayout.CENTER);
							// Loop through all cells and add a graph for each cell
							for (int j=0;j<NumberOfCells;j++) {
								graph.addDataPointer(j,i,colors[j],"Cell"+Integer.toString(j)+TheModel.getNetwork().getNode(i).getName());
							}
						  graph.buildGraph();
						}
					}
				});
		quickSubMenu.add(item);
		autoGraphMenu.add(quickSubMenu);
		MainMenu.add(autoGraphMenu);
		
		setJMenuBar(MainMenu);
		
		
		// Build the JToolBar
		JToolBar MainToolBar = new JToolBar();
		MainToolBar.setBackground(Color.lightGray);
		
		Font f = new Font("Arial",Font.PLAIN,10);
		
		OverWriteDataButton = new JToggleButton("Over Write");
		OverWriteDataButton.setFont(f);
		OverWriteDataButton.setOpaque(false);
		MainToolBar.add(OverWriteDataButton);
		
		// Add in the DataSets and TimePoints counters
		JLabel l = new JLabel(" Data Sets: ");
		l.setFont(f);
		MainToolBar.add(l);
		DataSetsDisplay = new JLabel("0");
		DataSetsDisplay.setFont(f);
	  MainToolBar.add(DataSetsDisplay);
		
		JButton LeftJButton = new JButton(new ImageIcon("icons/ArrowLeft13.gif"));
		LeftJButton.setContentAreaFilled(false);
		LeftJButton.setBorderPainted(false);
		LeftJButton.setFocusPainted(false);
		LeftJButton.addActionListener(new ActionListener() {
					public void actionPerformed(ActionEvent ae) {
						DataSetIndex--;
						if (DataSetIndex<0)
							DataSetIndex++;
						else setGraphIndex(DataSetIndex);
					}
				});
		MainToolBar.add(LeftJButton);
		
		DataSetIndexDisplay = new JTextField(2);
		DataSetIndexDisplay.setFont(f);
		DataSetIndexDisplay.setText("0");
		MainToolBar.add(DataSetIndexDisplay);
		
		JButton RightJButton = new JButton(new ImageIcon("icons/ArrowRight13.gif"));
		RightJButton.setContentAreaFilled(false);
		RightJButton.setBorderPainted(false);
		RightJButton.setFocusPainted(false);
		RightJButton.addActionListener(new ActionListener() {
					public void actionPerformed(ActionEvent ae) {
						DataSetIndex++;
						if (DataSetIndex==DataSets.size())
							DataSetIndex--;
						else setGraphIndex(DataSetIndex);
					}
				});
		MainToolBar.add(RightJButton);
		
		l = new JLabel("Time Points: ");
		l.setFont(f);
		MainToolBar.add(l);
		TimePointsDisplay = new JLabel("0");
		TimePointsDisplay.setFont(f);
		MainToolBar.add(TimePointsDisplay);
		
		DataSetHoldButton = new JToggleButton("Hold");
		DataSetHoldButton.setFont(f);
		DataSetHoldButton.setOpaque(false);
		DataSetHoldButton.addActionListener(new ActionListener() {
					public void actionPerformed(ActionEvent ae) {
						DataSetHoldArray.set(DataSetIndex,new Boolean(DataSetHoldButton.isSelected()));
					}
				});
		MainToolBar.add(DataSetHoldButton);
		
		JButton clearAllHolds = new JButton("Clear Holds");
		clearAllHolds.setFont(f);
		clearAllHolds.setOpaque(true);
		clearAllHolds.addActionListener(new ActionListener() {
					public void actionPerformed(ActionEvent ae) {
						for (int i=0;i<DataSetHoldArray.size();i++)
							DataSetHoldArray.set(i,new Boolean(false));
						GraphsPanel.repaint();
					}
				});
		MainToolBar.add(clearAllHolds);
		
		JPanel filler = new JPanel();
		filler.setOpaque(false);
		MainToolBar.add(filler);
		
		JButton reSizeJButton = new JButton("Resize");
		reSizeJButton.setFont(f);
		reSizeJButton.setOpaque(false);
		reSizeJButton.addActionListener(new ActionListener() {
					public void actionPerformed(ActionEvent ae) {
						reSizeGraphs();
					}
				});
		MainToolBar.add(reSizeJButton);
		
		AutoResizeJButton = new JToggleButton("Auto-Resize");
		AutoResizeJButton.setFont(f);
		AutoResizeJButton.setOpaque(false);
		AutoResizeJButton.addActionListener(new ActionListener() {
					public void actionPerformed(ActionEvent ae) {
						reSizeGraphs();
					}
				});
		MainToolBar.add(AutoResizeJButton);
		
		MainPanel.add(MainToolBar,BorderLayout.NORTH);
		
		// Make the GraphSourceSelector JFrame shared by all Graphics Panels
		SourceSelector = new GraphSourceSelector();
		
		// Add an internal frame listener for capturing frame closing events
		addInternalFrameListener(new InternalFrameAdapter() {
					public void internalFrameClosing(InternalFrameEvent ife) {
						close();
					}
				});
		
		pack();
		setSize(800,getHeight());
		setVisible(true);
		
		AutoResizeDebounceTimer = new javax.swing.Timer(500,new ActionListener() {
					public void actionPerformed(ActionEvent ae) {
						reSizeGraphs();
					}
				});
		AutoResizeDebounceTimer.setRepeats(false);
		
		addComponentListener(new ComponentAdapter() {
					public void componentResized(ComponentEvent ce) {
						if (AutoResizeJButton.isSelected()) {
							if (AutoResizeDebounceTimer.isRunning())
								AutoResizeDebounceTimer.restart();
							else
								AutoResizeDebounceTimer.start();
						}
					}
				});
		
		setIconifiable(true);
		
	}
	
	/** Rebuilds all the GraphPanels
	 @author WJS
	 */
	private void buildAll() {
		
		Component c[] = GraphsPanel.getComponents();
		for (int i =0;i<c.length;i++)
				((GraphPanel)c[i]).buildGraph();
		
		GraphsScrollPane.validate();
		repaint();
		
	}
	
	/** Clears all the stored data sets.
	 @author WJS
	 */
	private void clearAllDataSets() {
		
		DataSets = new ArrayList();
		TimeSets = new ArrayList();
		DataSetHoldArray = new ArrayList();
		DataSetIndex = -1;
		DataSetIndexDisplay.setText("0");
		DataSetsDisplay.setText("0");
		
	}
	
	/** Clears out all the data and wipes Graph Panels
	 @author WJS
	 */
	private void clearData() {
		
		DataArrays = new ArrayList();
		TimeArray = new ArrayList();
		TimePointsDisplay.setText("0");
		
	}
	
	/** Close up the JFrame properly, and disconnect fromlistener lists.
	 @author WJS
	 */
	private void close() {
		
		TheModelState.removeModelStateChangeListener(this);
		dispose();
		GeneNet.TheMainGui.removeInternalFrame(this);
		GeneNet.TheMainGui.removeGUIListener(this);
		
	}
	
	/** Find the cell which contains point p. This is implemented in a slower
	 but more general way to allow for different/multiple cells shapes and cell
	 positions. It searche through the list of cell shapes and uses the contains
	 method to identify the cell.
	 @param Point p - A point in the ModelStateViewPane.
	 @return int - The index of the cell or -1 if the point is not in a cell.
	 @author WJS
	 */
	private int findCellAt(Point p) {
		
		for (int i=0;i<CellShapeArray.length;i++) {
			if (CellShapeArray[i].contains(p)) return(i);
		}
		
		return(-1);
		
	}
	
	/** Returns an array of Y values for the data set, cell and node numbers
	 specified by the past data pointer.
	 @param int set - DataSet index
	 @param DataPointer p
	 @return float[]
	 @author WJS
	 */
	private float[] getDataArray(int set, DataPointer p) {
		
		ArrayList dataArrays = (ArrayList)DataSets.get(set);
		float[] dataArray = new float[dataArrays.size()];
		
		for (int i=0;i<dataArray.length;i++)
			dataArray[i] = ((float[][])dataArrays.get(i))[p.Cell][p.Node];
		
		return(dataArray);
		
	}
	
	/** Returns the array of time values
	 @param int set - DataSet index
	 @return float[]
	 @author WJS
	 */
	private float[] getTimeArray(int set) {
		
		ArrayList timeArrays = (ArrayList)TimeSets.get(set);
		float[] timeArray = new float[timeArrays.size()];
		
		for (int i=0;i<timeArray.length;i++)
			timeArray[i] = ((Float)timeArrays.get(i)).floatValue();
		
		return(timeArray);
		
	}
	
	/** Moves GraphPanel down a space.
	 @param GraphPanel p - Panel to move.
	 @author WJS
	 */
	private void moveGraphPanelDown(GraphPanel p) {
		
		Component[] c = GraphsPanel.getComponents();
		for (int i=0;i<c.length-1;i++) {
			if (c[i]==p) {
				if (c[i+1] instanceof GraphPanel) {
					GraphsPanel.remove(i);
					GraphsPanel.add(p,i+1);
					break;
				}
			}
		}
		GraphsPanel.validate();
		GraphsPanel.repaint();
		
	}
	
	/** Moves GraphPanel up a space
	 @param GraphPanel p - Panel to move.
	 @author WJS
	 */
	private void moveGraphPanelUp(GraphPanel p) {
		
		Component[] c = GraphsPanel.getComponents();
		for (int i=1;i<c.length;i++) {
			if (c[i]==p) {
				if (c[i-1] instanceof GraphPanel) {
					GraphsPanel.remove(i-1);
					GraphsPanel.add(c[i-1],i);
					break;
				}
			}
		}
		GraphsPanel.validate();
		GraphsPanel.repaint();
		
	}
	
	/** Create a psuedo color progression from red to blue with green in the
	 middle. Number of colors is determined by argument n.
	 @param int n - Number of colors to generate.
	 @author WJS
	 */
	private Color[] pseudoColors(int n) {
		
		Color[] colors = new Color[n];
		float x = 0;
		for (int i=0;i<n;i++) {
			float red = 1-x*2;
			if (red<0) red=0;
			float green = 4f*x-1f;
			if (green>1) green = 3f-4f*x;
			if (green<0) green = 0;
			float blue = x*2-1;
			if (blue<0) blue = 0;
			colors[i] = new Color((int)(255*red),(int)(255*green),(int)(255*blue));
			x += 1f/(float)(n+1);
		}
		return(colors);
		
	}
	
	/** Removes a GraphPanel.
	 @param GraphPanel panel - GraphPanel to be removed
	 @author WJS
	 */
	private void removeGraphPanel(GraphPanel panel) {
		
		int height = GraphsPanel.getHeight()-panel.getHeight();
		int width = GraphsPanel.getWidth();
		GraphsPanel.remove(panel);
		GraphsPanel.setSize(width,height);
		GraphsPanel.validate();
		GraphsPanel.repaint();
		
	}
	
	/** Rescales X axis of all Graph panels to make them fit into the display
	 windows current width.
	 @author WJS
	 */
	private void reSizeGraphs() {
		
		if (TimeArray.size()==0) return;
		
		// Determine the maximum value for the time scale
		float MaxX = 0;
		for (int i=0;i<TimeArray.size();i++)
			MaxX = Math.max(MaxX,((Float)TimeArray.get(i)).floatValue());
		
		// Find the visible width of the first GraphPanel (same for all)
	  int width = GraphsScrollPane.getViewport().getWidth()-((GraphPanel)GraphsPanel.getComponent(0)).getControlPanelWidth();
		// And calculated the new GlobalXscale
		GlobalXScale = width/MaxX;
		
		buildAll();
		
		GraphsScrollPane.validate();
		GraphsScrollPane.repaint();
		
	}
	
	/** Over-ride pack to keep current width settings and to keep display
	 from getting to tall for the screen.
	 @author WJS
	 */
	public void pack() {
		
		int width = getWidth();
		super.pack();
		int height = getHeight();
		if (height>TheMainGui.getContentPane().getHeight()-20) height = TheMainGui.getContentPane().getHeight()-20;
		setSize(width,height);
		
	}
	
	/** Reinitializes all the SingleNodeViewerPanels
	 @author WJS
	 */
	private void reinitPanels() {
		
		Component c[] = GraphsPanel.getComponents();
		for (int i=0;i<c.length;i++) {
			try {
				GraphPanel p = (GraphPanel)c[i];
				p.reinit();
			} catch (ClassCastException cce) {}
		}
		
	}
	
	/** Sets the DataSetIndex, which determines which DataSet is being displayed.
	 @param int index - The new DataSet index.
	 @author WJS
	 */
	public void setGraphIndex(int index) {
		
		DataSetIndex = index;
		DataSetIndexDisplay.setText(Integer.toString(index+1));
		TimePointsDisplay.setText(Integer.toString(((ArrayList)TimeSets.get(index)).size()));
		DataSetHoldButton.setSelected(((Boolean)DataSetHoldArray.get(index)).booleanValue());
		GraphsPanel.repaint();
		
	}
	
	/** Saves all Data from all data sets to an external file
	@author WJS
	*/
	public void saveDataSets(File file) {
		
		try {
		  FileOutputStream out = new FileOutputStream(file);
			for (int i=0;i<DataSets.size();i++) {
				ArrayList timeArray = (ArrayList)TimeSets.get(i);
				ArrayList dataArray = (ArrayList)DataSets.get(i);
				for (int j=0;j<timeArray.size();j++) {
					float time =  ((Float)timeArray.get(j)).floatValue();
					float[][] data = (float[][])dataArray.get(j);
					for (int k=0;k<data.length;k++) {
						for (int l=0;l<data[k].length;l++) {
					    String s = new String(i+" "+time+" "+k+" "+l+" "+data[k][l]+"\n");
							out.write(s.getBytes());
						}
					}
				}
			}
			out.close();
		} catch (IOException ioex) {};
		
	}
	
	/** Over-ride native method to allow the small version of the window
	 @param boolean simple - If true sets simple display mode
	 @author WJS
	 */
	public void setIcon(boolean simple) {
		
		SimpleDisplay = simple;
		setJMenuBar(null);
		reinitPanels();
		pack();
		
	}
	
	/** Over-ride native method to allow the normal version of the window
	 @param boolean normal - If true sets normal display mode
	 @author WJS
	 */
	public void setMaximum(boolean normal) {
		
		SimpleDisplay = !normal;
		setJMenuBar(MainMenu);
		reinitPanels();
		pack();
		
	}
	
	/** Sets the ModelState that this CellViewer reads from when painting. The
	 ModelState must have been generated from the associated Model/Network.
	 @param ModelState modelState - A ModelState
	 @author WJS
	 */
	public void setModelState(ModelState modelState) {
		
		TheModelState = modelState;
		repaint();
		
	}
	
	/** Implementation of ModelStateChangeListener
	 @author WJS
	 */
	public void updateAll() {
		
		// If data collection is disabled return
		if (!DataCollectionEnable) return;
		
		// Create a new data matrix
		float data[][] = new float[NumberOfCells][NumberOfNodes];
		
		// Load the Data from the Model state
		CellState state;
		float[] nodes;
		for (int i=0;i<NumberOfCells;i++) {
		  state = TheModelState.getCellState(i);
			nodes = state.getNodeValueArray();
			for (int j=0;j<NumberOfNodes;j++) {
				data[i][j] = nodes[j];
			}
		}
		
		// Add the data matrix to the ArrayList
		DataArrays.add(data);
		TimeArray.add(new Float(TheModelState.getTime()));
		
		// Update the time points display
		TimePointsDisplay.setText(Integer.toString(DataArrays.size()));
		
	}
	
	/** Updates only the indicated node.
	 @param int cellIndex - The index of the cell with the node to be changed.
	 @param int nodeIndex - The index of the node to be changed.
	 @param float value - Thhe new value for the node.
	 */
	public void updateNode(int cellIndex, int nodeIndex, float value) {
		
		
	}
	
	/******************** GUItoNet Interface implementation *********************/
	
	
	/** Called when a change is made to the passed AffectorTemplate
	 @param int operation
	 @param AffectorTemplate affectorTemplate
	 @param GuiInterface source - Originator of this interface change.
	 @author WJS
	 */
	public void affectorTemplateChanged(int operation, AffectorTemplate affectorTemplate, GuiInterface source) {
		
	}
	
	/** Method for invoking general network IO operations.
	 @param int operation - The network IO operation code.
	 @param File file - The file if needed, else don't care.
	 @author WJS
	 */
	public boolean networkIO(int operation, File file) {
		
		boolean result = true;
		
		return(result);
		
	}
	
	/** Called when a change is made to the passed NodeTemplate
	 @param int operation
	 @param NodeTemplate nodeTemplate
	 @param GuiInterface source - Originator of this interface change.
	 @author WJS
	 */
	public void nodeTemplateChanged(int operation, NodeTemplate nodeTemplate, GuiInterface source) {
		
		switch (operation) {
			case GuiInterface.ADDED:
				// TODO
				break;
			case GuiInterface.CHANGED:
				// TODO
				break;
			case GuiInterface.REMOVED:
				// TODO
				break;
				
		}
		
	}
	
	/** Called when a change is made to a parameter or the whole parameter set
	 @param int operation
	 @param int parameterNumber
	 @param GuiInterface source - Originator of this interface change.
	 @author WJS
	 */
	public void parameterSetChanged(int operation, int parameterNumber, GuiInterface source) {
		
	}
	
	/** Method for controling model/iterator runs.
	 @param int operation - Run control code.
	 @author WJS
	 */
	public void runControl(int operation) {
		
	}
	
	/** Method for reporting status of the model/iterator runs
	 @param int operation - Run status code.
	 @author WJS
	 */
	public void runStatus(int operation) {
		
		switch (operation) {
			case MODEL_STARTED:
				if (DataCollectionEnable) {
					clearData();
				}
				break;
			case MODEL_STOPPED:
				if (DataCollectionEnable) {
					if (OverWriteDataButton.isSelected()) {
						clearAllDataSets();
					}
					DataSets.add(DataArrays);
					TimeSets.add(TimeArray);
					DataSetHoldArray.add(new Boolean(DataSetHoldButton.isSelected()));
					DataSetsDisplay.setText(Integer.toString(DataSets.size()));
					DataSetIndex = DataSets.size()-1;
					buildAll();
					setGraphIndex(DataSetIndex);
				}
				break;
			case ITERATOR_STARTED:
				break;
			case ITERATOR_STOPPED:
				break;
		}
		
	}
	
	/******************  Implementation of OptionsPanelInterface ********************/
	
	/** Turns grid display on or off.
	 @param boolean b
	 @author WJS
	 */
	public void setGridOn(boolean b) {
		
		GlobalShowGrid = b;
		Component[] c = GraphsPanel.getComponents();
		for (int i=0;i<c.length;i++) {
			if (c[i] instanceof GraphPanel) {
				((GraphPanel)c[i]).setGridOn(b);
			}
		}
		repaint();
		
	}
	
	/** Set spacing for grid pattern.
	 @param int spacing
	 @author WJS
	 */
	public void setGridSpacing(int spacing) {
		
		GlobalGridSpacing = spacing;
		Component[] c = GraphsPanel.getComponents();
		for (int i=0;i<c.length;i++) {
			if (c[i] instanceof GraphPanel) {
				((GraphPanel)c[i]).setGridSpacing(spacing);
			}
		}
		repaint();
		
	}
	
	/** Turns legend display on or off.
	 @param boolean b
	 @author WJS
	 */
	public void setLegendOn(boolean b) {
		
		GlobalLegendEnabled = b;
		Component[] c = GraphsPanel.getComponents();
		for (int i=0;i<c.length;i++) {
			if (c[i] instanceof GraphPanel) {
				((GraphPanel)c[i]).setLegendOn(b);
			}
		}
		repaint();
		
	}
	
	/** Turns range display on or off.
	 @param boolean b
	 @author WJS
	 */
	public void setRangeOn(boolean b) {
		
		GlobalShowRange = b;
		Component[] c = GraphsPanel.getComponents();
		for (int i=0;i<c.length;i++) {
			if (c[i] instanceof GraphPanel) {
				((GraphPanel)c[i]).setRangeOn(b);
			}
		}
		repaint();
		
	}
	
	/** Resets the XScale for all panels
	 @param float scale
	 @author WJS
	 */
	public void setXScale(float scale) {
		
		// XScale is the same for all graphs
		GlobalXScale = scale;
		buildAll();
		
		repaint();
		
	}
	
	/** Resets the YScale for all panels
	 @param float scale
	 @author WJS
	 */
	public void setYScale(float scale) {
		
		// YScale can vary from Graph to Graph
		GlobalYScale = scale;
		
		Component[] c = GraphsPanel.getComponents();
		for (int i=0;i<c.length;i++) {
			if (c[i] instanceof GraphPanel) {
				((GraphPanel)c[i]).setYScale(scale);
			}
		}
		repaint();
		
	}
	
	/** GraphPanel.java
	 A JPanel for displaying multiple line graphs. Includes controls for modifying,
	 moving and deleting the GraphPanel. Graphs themselves are painted by the
	 GraphPaintPanel class.
	 @author WJS
	 */
	private class GraphPanel extends JPanel implements OptionsPanelInterface {
		
		/** Blank space to leave at the top */
		private int                        TOP_SPACE = 10;
		
		/** The Index of the cell that is presently selected */
		private int                       CellIndex = 0;
		/** An ArrayList of Color objects corresponding to each line graph */
		private ArrayList                 Colors;
		/** An ArrayList of Points that specify the cell and node index numbers
		 being displayed on this graph */
		private ArrayList                 DataPointers;
		/** Color for drawing grids and/or range bound lines */
		private Color                     GridColor = Color.lightGray;
		/** Distance between lines when a grid is drawn */
		private int                       GridSpacing = 10;
		/** An ArrayList of labels corresponding to each line graph */
		private ArrayList                 Labels;
		/** A line graph chooser */
		private LineGraphChooser          LChooser;
	  /** An array of rectanges that correspond to the legends */
	  private ArrayList                 LegendAreas;
		/** Set to true to enable painting of legend at bottom of graph */
		private boolean                   LegendEnabled = true;
		/** The height to allow for the legend area underneath the graph */
		private int                       LegendHeight = 40;
		/** The Index of the node that is presently selected */
		private int                       NodeIndex = 0;
		/** If mouse clicks are greater from an line graph than this distance, then
		 the findLine method returns -1 */
		private int                       RejectLimit = 10;
		/** Self Reference */
		private GraphPanel                SaveThis = this;
		/** The line graph that has been selected for a change operation */
		private int                       SelectedLine = -1;
		/** If true a background grid is drawn to the delight of the user */
		private boolean                   ShowGrid = false;
		/** If true the upper and lower range bounds are drawn */
		private boolean                   ShowRange = true;
		/** The GraphPaintPanel the the graphs are drawn on */
		private GraphPaintPanel           ThePaintPanel;
		/** An ArrayList of data arrays that have been scaled and integered for painting */
		private ArrayList                 XPaintArrays;
		/** An ArrayList of ArraysLists of data arrays that have been scaled and
		 integered for painting. */
		private ArrayList                 YPaintArrays;
		/** Height of graph display area */
		private float                     YScale = 100f;
		
		public GraphPanel() {
			
			super();
			
			setOpaque(true);
			setBackground(Color.lightGray);
			
			// Set up ArrayLists
			Colors = new ArrayList();
			DataPointers = new ArrayList();
			Labels = new ArrayList();
			LegendAreas = new ArrayList();
			XPaintArrays = new ArrayList();
			YPaintArrays = new ArrayList();
			for (int s=0;s<DataSets.size();s++)
				YPaintArrays.add(new ArrayList());
			
			setLayout(new BoxLayout(this,BoxLayout.X_AXIS));
			setBorder(BorderFactory.createLineBorder(Color.black,1));
			
			// Allocate the GraphicPaintPanel, put it in a scroll pane and add it to the middle
			ThePaintPanel = new GraphPaintPanel();
			
			init();
			
			pack();
			
		}
		
		/**
		 */
		private void init() {
			
			if (!SimpleDisplay) {
				// Make control panel for left side of panel. This allows deleting
				// and moving up and down through the list.
				JPanel p = new JPanel();
				p.setLayout(new BoxLayout(p,BoxLayout.Y_AXIS));
				p.setBorder(BorderFactory.createMatteBorder(0,0,0,1,Color.black));
				p.setBackground(Color.lightGray);
				
				// Make button for removing the graph panel
				Icon closeIcon = new ImageIcon("icons/MSECloseIcon.gif");
				JButton closeButton = new JButton(closeIcon);
				Dimension d = new Dimension(closeIcon.getIconWidth(),closeIcon.getIconHeight());
				closeButton.setMaximumSize(d);
				closeButton.setMinimumSize(d);
				closeButton.setPreferredSize(d);
				closeButton.addActionListener(new ActionListener() {
							public void actionPerformed(ActionEvent ae) {
								removeGraphPanel(SaveThis);
							}
						});
				p.add(closeButton);
				
				JPanel filler = new JPanel();
				filler.setOpaque(false);
				p.add(filler);
				
				// Make button for moving the panel up
				Icon upIcon = new ImageIcon("icons/MSEUpIcon.gif");
				JButton upButton = new JButton(upIcon);
				upButton.setMaximumSize(d);
				upButton.setMinimumSize(d);
				upButton.setPreferredSize(d);
				upButton.addActionListener(new ActionListener() {
							public void actionPerformed(ActionEvent ae) {
								moveGraphPanelUp(SaveThis);
							}
						});
				p.add(upButton);
				
				// Make button for moving the panel down
				Icon downIcon = new ImageIcon("icons/MSEDownIcon.gif");
				JButton downButton = new JButton(downIcon);
				downButton.setMaximumSize(d);
				downButton.setMinimumSize(d);
				downButton.setPreferredSize(d);
				downButton.addActionListener(new ActionListener() {
							public void actionPerformed(ActionEvent ae) {
								moveGraphPanelDown(SaveThis);
							}
						});
				p.add(downButton);
				
				// Fix the width of the panel
				p.setSize(20,(int)YScale+LegendHeight);
				p.setPreferredSize(new Dimension(20,(int)YScale+LegendHeight));
				p.setMinimumSize(new Dimension(20,1));
				p.setMaximumSize(new Dimension(20,1024));
				
				add(p);
				
				// Make control panel for the left side of panel. This allows adding,
				// deleting and changing line Graphs.
				p = new JPanel();
				p.setLayout(new BoxLayout(p,BoxLayout.Y_AXIS));
				p.setBorder(BorderFactory.createMatteBorder(0,0,0,1,Color.black));
				p.setOpaque(true);
				p.setBackground(Color.lightGray);
				
				// Make button for adding a new line graph
				final JButton newGraphButton = new JButton("New");
				d = new Dimension(64,20);
				newGraphButton.setMaximumSize(d);
				newGraphButton.setMinimumSize(d);
				newGraphButton.setPreferredSize(d);
				newGraphButton.addActionListener(new ActionListener() {
							public void actionPerformed(ActionEvent ae) {
								SourceSelector.setMode("Add");
								SourceSelector.setActionListener(new ActionListener() {
											public void actionPerformed(ActionEvent ae2) {
												SourceSelector.setVisible(false);
												if (ae2.getActionCommand().equals("Add")) {
													CellIndex = SourceSelector.getCellIndex();
													NodeIndex = SourceSelector.getNodeIndex();
													Color lineColor = SourceSelector.getLineColor();
													String lineLabel = "Cell"+Integer.toString(CellIndex)+"."+TheModel.getNetwork().getNode(NodeIndex).getName();
													addDataPointer(CellIndex,NodeIndex,lineColor,lineLabel);
													buildGraph();
													validate();
													repaint();
												}
											}
										});
								SourceSelector.setCellIndex(CellIndex);
								SourceSelector.setNodeIndex(NodeIndex);
								SourceSelector.setLineColor(Color.black);
								SourceSelector.setLocation(newGraphButton.getLocationOnScreen());
								SourceSelector.pack();
								SourceSelector.setVisible(true);
							}
						});
				p.add(newGraphButton);
				
				// Make button for changing a line graph
				final JButton changeGraphButton = new JButton("Chg");
				changeGraphButton.setMaximumSize(d);
				changeGraphButton.setMinimumSize(d);
				changeGraphButton.setPreferredSize(d);
				changeGraphButton.addActionListener(new ActionListener() {
							public void actionPerformed(ActionEvent ae) {
								// Create a quick JFrame for displaying a list of line graphs to choose
								// from.
								LChooser = new LineGraphChooser(Labels, Colors,new ActionListener() {
											public void actionPerformed(ActionEvent ae2) {
												Point lChooserLocation = LChooser.getLocationOnScreen();
												LChooser.dispose();
												SelectedLine = ae2.getID();
												repaint();
												if ((SelectedLine>=0)&&(ae2.getActionCommand().equals("Selected"))) {
													SourceSelector.setMode("Change");
													SourceSelector.setActionListener(new ActionListener() {
																public void actionPerformed(ActionEvent ae3) {
																	SourceSelector.setVisible(false);
																	if (ae3.getActionCommand().equals("Change")) {
																		CellIndex = SourceSelector.getCellIndex();
																		NodeIndex = SourceSelector.getNodeIndex();
																		Color lineColor = SourceSelector.getLineColor();
																		String lineLabel = SourceSelector.getLineLabel();
																		DataPointers.set(SelectedLine,new DataPointer(CellIndex,NodeIndex));
																		Colors.set(SelectedLine,lineColor);
																		Labels.set(SelectedLine,lineLabel);
																		buildGraph();
																	} else if (ae3.getActionCommand().equals("Delete")) {
																		removeDataPointer(SelectedLine);
																	}
																	SelectedLine = -1;
																	validate();
																	repaint();
																}
															});
													DataPointer p = (DataPointer)DataPointers.get(SelectedLine);
													SourceSelector.setCellIndex(p.Cell);
													SourceSelector.setNodeIndex(p.Node);
													SourceSelector.setLineColor((Color)Colors.get(SelectedLine));
													SourceSelector.setLineLabel((String)Labels.get(SelectedLine));
													SourceSelector.setLocation(lChooserLocation);
													SourceSelector.pack();
													SourceSelector.setVisible(true);
												}
											}
										});
								LChooser.setLocation(changeGraphButton.getLocationOnScreen());
								LChooser.setVisible(true);
							}
						});
				p.add(changeGraphButton);
				
				// Make button for deleting a line graph
				final JButton deleteGraphButton = new JButton("Del");
				deleteGraphButton.setMaximumSize(d);
				deleteGraphButton.setMinimumSize(d);
				deleteGraphButton.setPreferredSize(d);
				deleteGraphButton.addActionListener(new ActionListener() {
							public void actionPerformed(ActionEvent ae) {
								// Create a quick JFrame for displaying a list of line graphs to choose
								// from.
								LChooser = new LineGraphChooser(Labels, Colors, new ActionListener() {
											public void actionPerformed(ActionEvent ae) {
												LChooser.dispose();
												SelectedLine = ae.getID();
												repaint();
												if ((SelectedLine>=0)&&(ae.getActionCommand().equals("Selected"))) {
													removeDataPointer(SelectedLine);
													SelectedLine = -1;
													repaint();
												}
											}
										});
								LChooser.setLocation(deleteGraphButton.getLocationOnScreen());
								LChooser.setVisible(true);
							}
						});
				p.add(deleteGraphButton);
				
				// Make button for choosing graph options
				JButton optionsGraphButton = new JButton("Opt");
				optionsGraphButton.setMaximumSize(d);
				optionsGraphButton.setMinimumSize(d);
				optionsGraphButton.setPreferredSize(d);
				optionsGraphButton.addActionListener(new ActionListener() {
							public void actionPerformed(ActionEvent ae) {
								OptionsPanel opt = new OptionsPanel(SaveThis,ShowGrid,GridSpacing,LegendEnabled,ShowRange,GlobalXScale,YScale);
								opt.setLocation(((JButton)ae.getSource()).getLocationOnScreen());
							}
						});
				p.add(optionsGraphButton);
				
				// Make button for clearing all line graphs
				JButton clearButton = new JButton("Clr");
				clearButton.setMaximumSize(d);
				clearButton.setMinimumSize(d);
				clearButton.setPreferredSize(d);
				clearButton.addActionListener(new ActionListener() {
							public void actionPerformed(ActionEvent ae) {
								Colors = new ArrayList();
								DataPointers = new ArrayList();
								Labels = new ArrayList();
								LegendAreas = new ArrayList();
								YPaintArrays = new ArrayList();
								for (int s=0;s<DataSets.size();s++)
									YPaintArrays.add(new ArrayList());
								repaint();
							}
						});
				p.add(clearButton);
				
				// Add a filler panel that pushes all the buttons up
				filler = new JPanel();
				filler.setOpaque(false);
				filler.setMaximumSize(new Dimension(10,1200));
				filler.setMinimumSize(new Dimension(10,1));
				filler.setPreferredSize(new Dimension(10,30));
				filler.setSize(10,30);
				p.add(filler);
				
				add(p);
				
			}
			
			add(ThePaintPanel);
			
		}
		
		/** Reinitializes the GraphPanel
		 @author WJS
		 */
		public void reinit() {
			
			removeAll();
			
			init();
			
			repaint();
			
		}
		
		/** Adds a new data array to the graph.
		 @param int cellIndex - The index of the cell.
		 @param int nodeIndex - The index of the node.
		 @param Color color - The color for the line to be drawn in.
		 @param String label - The graph label.
		 @author WJS
		 */
		public void addDataPointer(int cellIndex, int nodeIndex, Color color, String label) {
			
			DataPointer p = new DataPointer(cellIndex, nodeIndex);
			DataPointers.add(p);
			Colors.add(color);
			Labels.add(label);
			LegendAreas.add(new Rectangle(0,0,0,0));
			
		}
		
		/** Builds the graph, loading new data from the stored raw data
		 @author WJS
		 */
		public void buildGraph() {
			
			// Clear the paint arrays and reload them
			XPaintArrays.clear();
			YPaintArrays.clear();
			
			int MaxX = 0;
			
			// For each data set, wether visible or not, create a YPaintArray for
			// each DataPointer (cell, node pair) and one XPaintArray (time). This
			// Makes YPaintArrays an ArrayList of ArrayLists of int[] and
			// XPaintArraya an ArrayList of int[].
			ArrayList yArrays;
		  int scaledXArray[];
			for (int s=0;s<DataSets.size();s++) {
				yArrays = new ArrayList();
				for (int i=0;i<DataPointers.size();i++)
				  yArrays.add(scaleY(getDataArray(s,(DataPointer)DataPointers.get(i))));
				YPaintArrays.add(yArrays);
				scaledXArray = scaleX(getTimeArray(s));
				XPaintArrays.add(scaledXArray);
				// Need to find the greatest X values of all the scales. I'm asuming
				// the greatest value is always the last element in the area which
				// should hold true as long as time never goes backwards.
				MaxX = Math.max(MaxX,scaledXArray[scaledXArray.length-1]);
			}
			
			// Re-size the PaintPanel
			Dimension d = new Dimension(MaxX,TOP_SPACE+(int)YScale+LegendHeight);
			ThePaintPanel.setSize(d);
			ThePaintPanel.setPreferredSize(d);
			ThePaintPanel.setMinimumSize(d);
			
			ThePaintPanel.repaint();
			
		}
		
		/** Returns the index of the nearest line graph to the passed point. If distance
		 of nearest line is less than RejectLimit a -1 is returned. If not close to
		 a line, then searches the LegendAreas to see if click was on a legend.
		 @param Point p - A point on the GraphPaintPanel.
		 @result int - Index of line graph or -1.
		 @author WJS
		 */
		public int findLine(Point p) {
			
			int index = -1;
			
			int xScaleArray[] = (int[])XPaintArrays.get(DataSetIndex);
			
			if (p.y>YScale+TOP_SPACE) { // Scan legends
				for (int i=0;i<LegendAreas.size();i++) {
					if (((Rectangle)LegendAreas.get(i)).contains(p)) {
						return(i);
					}
				}
			} else { // Scan line graphs
				// Find nearest x coordinant.
				int l;
				// First make a reasonable guess
				int x = (p.x*xScaleArray.length)/ThePaintPanel.getWidth();
			  while (true) {
					l = xScaleArray[x];
					if (l==p.x) break;
					if (l>p.x) {
						while (l>p.x) {
							x--;
							l = xScaleArray[x];
						}
						if ((xScaleArray[x+1]-p.x)<(p.x-l))
							x++;
						break;
					}
					if (l<p.x) {
						while (l<p.x) {
						  x++;
							l = xScaleArray[x];
						}
						if ((p.x-xScaleArray[x-1])<(l-p.x))
							x--;
						break;
					}
				}
				
				// Find nearest y coordinant
			  ArrayList yPaintArrays = (ArrayList)YPaintArrays.get(DataSetIndex);
				int y = 0;
				int[] v;
				for (int i=0;i<yPaintArrays.size();i++) {
					v = (int[])yPaintArrays.get(i);
					if (Math.abs(v[x]-p.y)<Math.abs(y-p.y)) {
						y = v[x];
						index = i;
					}
				}
				
				// If point was to far away then say nothing found (-1)
				if (Math.abs(y-p.y)>RejectLimit) index = -1;
			}
			
			return(index);
			
		}
		
		/** Returns the visible width of the Graphic PaintPanel.
		 @author WJS
		 */
		public int getControlPanelWidth() {
			
			int width = ThePaintPanel.getLocation().x;
			
			return(width);
			
		}
		
		/** Removes a data pointer from the graph.
		 @param int index - The DataPointer/Line index.
		 @author WJS
		 */
		public void removeDataPointer(int index) {
			
			
			Colors.remove(index);
			DataPointers.remove(index);
			Labels.remove(index);
			LegendAreas.remove(index);
			ArrayList yArrays;
			for (int s=0;s<DataSets.size();s++) {
				yArrays = (ArrayList)YPaintArrays.get(s);
				yArrays.remove(index);
			}
			
		}
		
		/** Scales a data array X (time) axis
		 @param float[] dataArray - The raw float data array.
		 @return int[]
		 @author WJS
		 */
		public int[] scaleX(float[] dataArray) {
			
			int[] scaledArray = new int[dataArray.length];
			for (int i=0;i<dataArray.length;i++)
				scaledArray[i] = (int)(dataArray[i]*GlobalXScale);
			
			return(scaledArray);
			
		}
		
		/** Scales a data array Y (value) axis
		 @param float[] dataArray - The raw float data array.
		 @return int[]
		 @author WJS
		 */
		public int[] scaleY(float[] dataArray) {
			
			int[] scaledArray = new int[dataArray.length];
			for (int i=0;i<dataArray.length;i++)
				scaledArray[i] = (int)(YScale-(dataArray[i]*YScale)+TOP_SPACE);
			
			return(scaledArray);
			
		}
		
		/******************  Implementation of OptionsPanelInterface ********************/
		
		/** Turns grid display on or off.
		 @param boolean b
		 @author WJS
		 */
		public void setGridOn(boolean b) {
			
			ShowGrid = b;
			repaint();
			
		}
		
		/** Set spacing for grid pattern.
		 @param int spacing
		 @author WJS
		 */
		public void setGridSpacing(int spacing) {
			
			GridSpacing = spacing;
			repaint();
			
		}
		
		/** Turns legend display on or off.
		 @param boolean b
		 @author WJS
		 */
		public void setLegendOn(boolean b) {
			
			LegendEnabled = b;
			repaint();
			
		}
		
		/** Turns range display on or off.
		 @param boolean b
		 @author WJS
		 */
		public void setRangeOn(boolean b) {
			
			ShowRange = b;
			repaint();
			
		}
		
		/** Set size of X axis
		 @param int spacing
		 @author WJS
		 */
		public void setXScale(float xScale) {
			
			GlobalXScale = xScale;
			buildAll();
			repaint();
			
		}
		
		/** Set size of Y axis
		 @param int spacing
		 @author WJS
		 */
		public void setYScale(float yScale) {
			
			YScale = yScale;
			buildGraph();
			repaint();
			
		}
		
		/** GraphPaintPanel.java
		 A JPanel for drawing one or more Line Graphs.
		 @author WJS
		 */
		private class GraphPaintPanel extends JPanel {
			
			/** Simple constructor.
			 @author WJS
			 */
			public GraphPaintPanel() {
				
				super();
				setBackground(Color.white);
				setOpaque(true);
				
				// Create a mouse listener for invoking single-click functions.
				addMouseListener(new MouseAdapter() {
							public void mouseClicked(MouseEvent me) {
								// Check for a user click on one of the line graphs
								SelectedLine = findLine(me.getPoint());
								repaint();
								if (SelectedLine>=0) {
									SourceSelector.setMode("Change");
									SourceSelector.setActionListener(new ActionListener() {
												public void actionPerformed(ActionEvent ae3) {
													SourceSelector.setVisible(false);
													if (ae3.getActionCommand().equals("Change")) {
														CellIndex = SourceSelector.getCellIndex();
														NodeIndex = SourceSelector.getNodeIndex();
														Color lineColor = SourceSelector.getLineColor();
														String lineLabel = SourceSelector.getLineLabel();
														DataPointers.set(SelectedLine,new DataPointer(CellIndex,NodeIndex));
														Colors.set(SelectedLine,lineColor);
														Labels.set(SelectedLine,lineLabel);
														buildGraph();
													} else if (ae3.getActionCommand().equals("Delete")) {
														removeDataPointer(SelectedLine);
													}
													SelectedLine = -1;
													GraphsPanel.validate();
													GraphsPanel.repaint();
												}
											});
									DataPointer p = (DataPointer)DataPointers.get(SelectedLine);
									SourceSelector.setCellIndex(p.Cell);
									SourceSelector.setNodeIndex(p.Node);
									SourceSelector.setLineColor((Color)Colors.get(SelectedLine));
									SourceSelector.setLineLabel((String)Labels.get(SelectedLine));
									Point clickLocation = me.getPoint();
									Point q = getLocationOnScreen();
									clickLocation.translate(q.x,q.y);
									SourceSelector.setLocation(clickLocation);
									SourceSelector.pack();
									SourceSelector.setVisible(true);
								}
							}
						});
				
				// Set a default start size
				Dimension d = new Dimension((int)GlobalXScale*200,(int)YScale+LegendHeight);
				setSize(d);
				setPreferredSize(d);
				setMinimumSize(d);
				
			}
			
			/** Over-ride paint routine to allow painting of the lines graphs
			 @param Graphics g0
			 @author WJS
			 */
			public void paint(Graphics g0) {
				
				super.paint(g0);
				
				Graphics2D g = (Graphics2D)g0;
				g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
				
				// Draw any Grids
				if (ShowGrid) {
					g0.setColor(GridColor);
					for (int i=0;i<getWidth();i+=GridSpacing) {
						g0.drawLine(i,0,i,(int)YScale+TOP_SPACE);
					}
					for (int i=0;i<=(int)YScale+TOP_SPACE;i+=GridSpacing) {
						g0.drawLine(0,i,getWidth(),i);
					}
				} else if (ShowRange) {
					g0.setColor(GridColor);
					g0.drawLine(0,TOP_SPACE,getWidth(),TOP_SPACE);
					g0.drawLine(0,(int)YScale+TOP_SPACE,getWidth(),(int)YScale+TOP_SPACE);
				}
				
				// Draw the Graphs
				if (XPaintArrays.size()>0) {
					int[] dataX;
					int[] dataY;
					ArrayList yPaintArrays;
					for (int s=0;s<DataSets.size();s++) {
						if (((Boolean)DataSetHoldArray.get(s)).booleanValue()||(s==DataSetIndex)) {
							dataX = (int[])XPaintArrays.get(s);
							yPaintArrays = (ArrayList)YPaintArrays.get(s);
							for (int i=0;i<yPaintArrays.size();i++) {
								g.setColor((Color)Colors.get(i));
								dataY = (int[])yPaintArrays.get(i);
								if ((s==DataSetIndex)&&(i==SelectedLine))
									g.setStroke(new BasicStroke(2));
								else
									g.setStroke(new BasicStroke(1));
								g.drawPolyline(dataX, dataY, dataX.length);
							}
						}
					}
				}
				
				if (DataSets.size()>0) {
					// Draw the legend if so desired
					if (LegendEnabled) {
						g.setStroke(new BasicStroke(1));
						FontMetrics fm = g0.getFontMetrics();
						int x = 4;
						int xl = x;
						int y = (int)YScale+TOP_SPACE+20;
						Rectangle2D r;
						String s;
						for (int i=0;i<((ArrayList)YPaintArrays.get(DataSetIndex)).size();i++) {
							// Paint a square box with the color swatch in it
							g.setColor((Color)Colors.get(i));
							g.fillRect(x,y-12,12,12);
							g.setColor(Color.black);
							g.drawRect(x,y-12,12,12);
							x = x+14;
							// Paint the label
							s = (String)Labels.get(i);
							g0.drawString(s,x,y);
						  r = fm.getStringBounds(s,g0);
							x += r.getWidth()+4;
							// Set the click area for the legend
							LegendAreas.set(i,new Rectangle(xl,y-12,x-xl,12));
							xl = x;
						}
					}
					
				}
				
			}
			
		}
		
		
	}
	
	/** DataPointer.java
	 Class for defining a pointer into the DataSets
	 @author WJS
	 */
	private class DataPointer {
		
		/** The Cell Index */
		public int              Cell = 0;
		/** The Node Index */
		public int              Node = 0;
		
		public DataPointer() {
			
		}
		
		public DataPointer(int cell, int node) {
			
			Cell = cell;
			Node = node;
			
		}
		
	}
	
	/** LineGraphChooser.java
	 JFrame that allows users to select a line graph from the list of line graphs.
	 @author WJS
	 */
	private class LineGraphChooser extends JFrame {
		
		/** ArrayList of colors for line graphs */
		private ArrayList                 Colors;
		/** ActionListener */
		private ActionListener            Listener;
		/** ArrayList of labels for Line graphs */
		private ArrayList                 Names;
		/** Self Reference */
		private LineGraphChooser          SaveThis = this;
		
		public LineGraphChooser(ArrayList names, ArrayList colors, ActionListener listener) {
			
			super("Line Graphs");
			setResizable(false);
			setIconifiable(false);
			
			Listener = listener;
			Colors = colors;
			Names = names;
			
			JPanel mainFrame = new JPanel();
			mainFrame.setLayout(new BoxLayout(mainFrame,BoxLayout.Y_AXIS));
			
			Vector vList = new Vector(names);
			final JList graphList = new JList(vList);
			graphList.setCellRenderer(new LineGraphChooserCellRenderer());
			graphList.addListSelectionListener(new ListSelectionListener() {
						public void valueChanged(ListSelectionEvent lse) {
							int index = graphList.getSelectedIndex();
							Listener.actionPerformed(new ActionEvent(SaveThis,index,"Selected"));
							dispose();
						}
					});
			JScrollPane scrollPane = new JScrollPane(graphList);
			mainFrame.add(scrollPane);
			
			setContentPane(mainFrame);
			
			// Add a focus change listener to close the LineGraphChooser
			addWindowFocusListener(new WindowAdapter() {
						public void windowLostFocus(WindowEvent we) {
							dispose();
						}
					});
			
			setSize(200,200);
			setVisible(true);
			
		}
		
		/** LineGraphChooserCellRenderer.java
		 Implementation of a ListCellRender for drawing elements in a LineGraphChooser
		 JList.
		 @author WJS
		 */
		private class LineGraphChooserCellRenderer extends JLabel implements ListCellRenderer {
			
			public LineGraphChooserCellRenderer() {
				
				setOpaque(true);
				setBackground(Color.white);
				
			}
			
			public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
				
				setText((String)Names.get(index));
				BufferedImage colorSwatchImage = new BufferedImage(14,14,BufferedImage.TYPE_INT_RGB);
				Graphics g = colorSwatchImage.getGraphics();
				g.setColor((Color)Colors.get(index));
				g.fillRect(0,0,14,14);
				g.setColor(Color.black);
				g.drawRect(0,0,13,13);
				ImageIcon colorSwatch = new ImageIcon(colorSwatchImage);
				setIcon(colorSwatch);
				
				return(this);
				
			}
			
		}
		
	}
	
	/** GraphSourceSelector.java
	 Internal class produces a JFrame that permits the user to select a cell and
	 node Index. User may also select the drawing color for the line and chooose
	 a display label.
	 @author WJS
	 */
	private class GraphSourceSelector extends JFrame {
		
		/** The index of the selected cell */
		private int                       CellIndex = -1;
		/** ColorSwatch shows the current color for the line graph */
		private JPanel                    ColorSwatch;
		/** The user selected color for the line graph */
		private Color                     LineColor = Color.black;
		/** Users supplied label for line graph */
		private String                    LineLabel = "";
		/** ActionListener */
		private ActionListener            Listener;
		/** Mode Button used to complete operation */
		private JButton                   ModeButton;
		/** The index of the selected node */
		private int                       NodeIndex = -1;
		/** The JCombobox for selecting the node beging graphed */
		private JComboBox                 NodeSelectionBox;
		/** Self reference */
		private JFrame                    SaveThis = this;
		/** Set to true to prevent frame closing when focus lost */
		private boolean                   SquelchCloseOnFocusLost = false;
		/** The panel the cell outlines are painted onto */
		private CellPaintPanel            TheCellPaintPanel;
		
		/** Simple constructor.
		 @author WJS
		 */
		public GraphSourceSelector() {
			
			super("Graph Source");
			setResizable(false);
			setIconifiable(false);
			
			JPanel mainPanel = new JPanel();
			mainPanel.setLayout(new BoxLayout(mainPanel,BoxLayout.Y_AXIS));
			setContentPane(mainPanel);
			
			// Make panel that shows the selected cell
			TheCellPaintPanel = new CellPaintPanel();
			mainPanel.add(TheCellPaintPanel);
			
			// Create a JComboBox to allow users to select a node to be displayed
			NodeSelectionBox = new JComboBox();
			NodeTemplate node;
			for (int i=0;i<TheModel.getNetwork().getNumNodes();i++) {
				node = TheModel.getNetwork().getNode(i);
				NodeSelectionBox.addItem(node.getName());
				if (node.getNodeNum()==NodeIndex)
					NodeSelectionBox.setSelectedIndex(i);
			}
			NodeSelectionBox.addActionListener(new ActionListener() {
						public void actionPerformed(ActionEvent ae) {
							NodeIndex = NodeSelectionBox.getSelectedIndex();
							repaint();
						}
					});
			mainPanel.add(NodeSelectionBox);
			
			// Add color control panel
			JPanel colorControl = new JPanel();
			colorControl.setLayout(new BoxLayout(colorControl,BoxLayout.X_AXIS));
			
			// Make color selection button
			JButton colorSelect = new JButton("Color");
			colorSelect.addActionListener(new ActionListener() {
						public void actionPerformed(ActionEvent ae) {
							SquelchCloseOnFocusLost = true;
							setLineColor(JColorChooser.showDialog(SaveThis,"Select Line Color",LineColor));
							SquelchCloseOnFocusLost = false;
						}
					});
			colorControl.add(colorSelect);
			
			ColorSwatch = new JPanel();
			ColorSwatch.setBorder(BorderFactory.createLineBorder(Color.black,1));
			ColorSwatch.setOpaque(true);
			ColorSwatch.setBackground(Color.black);
			colorControl.add(ColorSwatch);
			
			mainPanel.add(colorControl);
			
			// Add the color/change/cancel button panel
			JPanel control = new JPanel();
			control.setLayout(new BoxLayout(control,BoxLayout.X_AXIS));
			
			// Make Add/Change button
			ModeButton = new JButton("Add");
			ModeButton.addActionListener(new ActionListener() {
						public void actionPerformed(ActionEvent ae) {
							Listener.actionPerformed(new ActionEvent(this,0,ModeButton.getText()));
						}
					});
			control.add(ModeButton);
			
			// Make Cancel button
			JButton cancelButton = new JButton("Cancel");
			cancelButton.addActionListener(new ActionListener() {
						public void actionPerformed(ActionEvent ae) {
							Listener.actionPerformed(new ActionEvent(this,0,"Cancel"));
						}
					});
			control.add(cancelButton);
			// Make Delete button
			JButton deleteButton = new JButton("Delete");
			deleteButton.addActionListener(new ActionListener() {
						public void actionPerformed(ActionEvent ae) {
							Listener.actionPerformed(new ActionEvent(this,0,"Delete"));
						}
					});
			control.add(deleteButton);
			
			mainPanel.add(control);
			
			// Add a focus change listener to close the GraphSourceSelector
			addWindowFocusListener(new WindowAdapter() {
						public void windowLostFocus(WindowEvent we) {
							if (!SquelchCloseOnFocusLost) {
							  Listener.actionPerformed(new ActionEvent(this,0,"Cancel"));
							  setVisible(false);
							}
						}
					});
			
			pack();
			setVisible(false);
			
		}
		
		/** Returns the index of the selected cell
		 @return int - Index of cell.
		 @author WJS
		 */
		public int getCellIndex() {
			
			return(CellIndex);
			
		}
		
		/** Returns the user-selected line color
		 @return Color
		 @author WJS
		 */
		public Color getLineColor() {
			
			return(LineColor);
			
		}
		
		/** Returns the user-selected line label
		 @return String
		 @author WJS
		 */
		public String getLineLabel() {
			
			return(LineLabel);
			
		}
		
		/** Returns the index of the selected node
		 @return int - Index of node.
		 @author WJS
		 */
		public int getNodeIndex() {
			
			return(NodeIndex);
			
		}
		
		/** Sets the only allowed ActionListener.
		 @param ActionListener listener - The ActionListener
		 @author WJS
		 */
		public void setActionListener(ActionListener listener) {
			
			Listener = listener;
			
		}
		
		/** Sets the mode for the mode button the completes the operation. Mode
		 must be either "Add" or "Change".
		 @param String mode - Mode string.
		 @author WJS
		 */
		public void setMode(String mode) {
			
			ModeButton.setText(mode);
			
		}
		
		/** Sets the selected cell
		 @param int index - Index of cell.
		 @author WJS
		 */
		public void setCellIndex(int index) {
			
			CellIndex = index;
			
		}
		
		/** Sets the line color
		 @param Color color
		 @author WJS
		 */
		public void setLineColor(Color color) {
			
			LineColor = color;
			ColorSwatch.setBackground(color);
			
		}
		
		/** Set the line label
		 @param String label
		 @author WJS
		 */
		public void setLineLabel(String label) {
			
			LineLabel = label;
			
		}
		
		/** Sets the selected Node
		 @param int index - Index of node.
		 @author WJS
		 */
		public void setNodeIndex(int index) {
			
			NodeIndex = index;
			NodeSelectionBox.setSelectedIndex(NodeIndex);
			
		}
		
		/** CellPaintPanel.java
		 Panel for painting all the cells on the cell surface. The selected cell
		 is painted solid black. ALl other cells are just painted in outline. Panel
		 also handles click events that allows the user to select which cell's nodes
		 are being viewed.
		 @author WJS
		 */
		private class CellPaintPanel extends JPanel {
			
			/** Simple constructor.
			 @author WJS
			 */
			public CellPaintPanel() {
				
				super();
				setBackground(Color.lightGray);
				
				// Set the size of the panel based upon size calculated earlier.
				setMaximumSize(CellPaintPanelDimension);
				setMinimumSize(CellPaintPanelDimension);
				setPreferredSize(CellPaintPanelDimension);
				setSize(CellPaintPanelDimension);
				
				// Create a mouse listener for detecting user mouse clicks on cells
				addMouseListener(new MouseAdapter() {
							public void mouseClicked(MouseEvent me) {
								CellIndex = findCellAt(me.getPoint());
								repaint();
							}
						});
				
			}
			
			/** Over-ride the paint method to draw cells and such.
			 @param Graphics g0
			 @author WJS
			 */
			public void paint(Graphics g0) {
				
				super.paint(g0);
				
				Graphics2D g = (Graphics2D)g0;
				g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
				for (int i=0;i<CellShapeArray.length;i++) {
					if (CellIndex == i)
						g.fill(CellShapeArray[i]);
					else
						g.draw(CellShapeArray[i]);
				}
				
			}
			
		}
		
	}
	
	
	/** OptionsPanel.java
	 Implements an options panel that is used both by the TimeGraph class as a whole
	 and by each individual GraphPane.
	 @author WJS
	 */
	private class OptionsPanel extends JFrame {
		
		/** Button for turning grid on/off */
		private JToggleButton             GridButton;
		/** TextField for entering grid spacing */
		private JTextField                GridSpacing;
		/** Button for turning legend on/off*/
		private JToggleButton             LegendButton;
		/** The object that invoked the OptionsPanel */
		private OptionsPanelInterface     Listener;
		/** Button for range bounds on/off */
		private JToggleButton             RangeButton;
		/** Button for invoking autofit */
		private JButton                   FitButton;
		/** TextField for entering XSize (width) of graph */
		private JTextField                XScaleField;
		/** TextField for entering YSize (height) of graph */
		private JTextField                YScaleField;
		
		/**
		 @author WJS
		 */
		public OptionsPanel(OptionsPanelInterface listener, boolean gridOn, int gridSpacing, boolean legendOn, boolean rangeOn, float xScale, float yScale) {
			
			super("Options");
			setResizable(false);
			setIconifiable(false);
			
			JPanel mainPanel = new JPanel();
			mainPanel.setLayout(new BoxLayout(mainPanel,BoxLayout.Y_AXIS));
			
			Listener = listener;
			
			JPanel p;
			JLabel l;
			
			p = new JPanel();
			p.setLayout(new BoxLayout(p,BoxLayout.X_AXIS));
			GridButton = new JToggleButton("Grid On");
			GridButton.addActionListener(new ActionListener() {
						public void actionPerformed(ActionEvent e) {
							Listener.setGridOn(((JToggleButton)e.getSource()).isSelected());
						}
					});
			p.add(GridButton);
			GridButton.setSelected(gridOn);
			
			RangeButton = new JToggleButton("Range Lines On");
			RangeButton.addActionListener(new ActionListener() {
						public void actionPerformed(ActionEvent e) {
							Listener.setRangeOn(((JToggleButton)e.getSource()).isSelected());
						}
					});
			p.add(RangeButton);
			RangeButton.setSelected(rangeOn);
			
			LegendButton = new JToggleButton("Legend On");
			LegendButton.addActionListener(new ActionListener() {
						public void actionPerformed(ActionEvent e) {
							Listener.setLegendOn(((JToggleButton)e.getSource()).isSelected());
						}
					});
			p.add(LegendButton);
			LegendButton.setSelected(legendOn);
			FitButton = new JButton("Fit to Window");
			FitButton.addActionListener(new ActionListener() {
						public void actionPerformed(ActionEvent e) {
							// TODO
						}
					});
			p.add(FitButton);
			
			mainPanel.add(p);
			
			Dimension d = new Dimension(120,16);
			p = new JPanel();
			p.setLayout(new BoxLayout(p,BoxLayout.X_AXIS));
			l = new JLabel("Grid Spacing");
			l.setPreferredSize(d);
			l.setMaximumSize(d);
			l.setMinimumSize(d);
			p.add(l);
			GridSpacing = new JTextField();
			GridSpacing.addActionListener(new ActionListener() {
						public void actionPerformed(ActionEvent ae) {
							try {
							  Listener.setGridSpacing(Integer.parseInt(((JTextField)ae.getSource()).getText()));
							} catch (NumberFormatException nfe) {
							}
						}
					});
			p.add(GridSpacing);
			GridSpacing.setText(Integer.toString(gridSpacing));
			mainPanel.add(p);
			
			p = new JPanel();
			p.setLayout(new BoxLayout(p,BoxLayout.X_AXIS));
			l = new JLabel("X Scale");
			l.setPreferredSize(d);
			l.setMaximumSize(d);
			l.setMinimumSize(d);
			p.add(l);
			XScaleField = new JTextField();
			XScaleField.addActionListener(new ActionListener() {
						public void actionPerformed(ActionEvent ae) {
							try {
							  Listener.setXScale(Float.parseFloat(((JTextField)ae.getSource()).getText()));
							} catch (NumberFormatException nfe) {
							}
						}
					});
			p.add(XScaleField);
			XScaleField.setText(Float.toString(xScale));
			mainPanel.add(p);
			
			p = new JPanel();
			p.setLayout(new BoxLayout(p,BoxLayout.X_AXIS));
			l = new JLabel("Y Scale");
			l.setPreferredSize(d);
			l.setMaximumSize(d);
			l.setMinimumSize(d);
			p.add(l);
			YScaleField = new JTextField();
			YScaleField.addActionListener(new ActionListener() {
						public void actionPerformed(ActionEvent ae) {
							try {
							  Listener.setYScale(Float.parseFloat(((JTextField)ae.getSource()).getText()));
							} catch (NumberFormatException nfe) {
							}
						}
					});
			p.add(YScaleField);
			YScaleField.setText(Float.toString(yScale));
			mainPanel.add(p);
			
			setContentPane(mainPanel);
			
			// Add a focus change listener to close the GraphSourceSelector
			addWindowFocusListener(new WindowAdapter() {
						public void windowLostFocus(WindowEvent we) {
							dispose();
						}
					});
			
			pack();
			setVisible(true);
			
		}
		
	}
	
	/** GraphWizard.java
	 @author WJS
	 */
	private class GraphWizard extends JFrame {
		
		/** */
		private JRadioButton                AllOnOneButton;
		/** */
	  private JRadioButton			          AutoColorsButton;
		/** */
	  private boolean[]                   CellSelectionArray;
		/** */
		private JRadioButton                ClearGraphsButton;
		/** */
		private JRadioButton			          DefaultNodeColorsButton;
		/** */
		private JRadioButton                OneCellPerGraphButton;
		/** */
		private JRadioButton                OneNodePerGraphButton;
		/** */
		private boolean[]                   NodeSelectionArray;
		/** The panel the cell outlines are painted onto */
		private CellPaintPanel              TheCellPaintPanel;
		/** */
		private MultipleNodeSelectionPanel  TheNodeSelectionPanel;
		
		
		/** Constructor **/
		public GraphWizard() {
			
			super("Graph Wizard");
			setResizable(false);
			setIconifiable(false);
			
			// Initialize selection arrays
			CellSelectionArray = new boolean[NumberOfCells];
			for (int i=0;i<NumberOfCells;i++)
				CellSelectionArray[i] = false;
			NodeSelectionArray = new boolean[NumberOfNodes];
			for (int i=0;i<NumberOfNodes;i++)
				NodeSelectionArray[i] = false;
			
			JPanel mainPanel = new JPanel();
			mainPanel.setLayout(new BoxLayout(mainPanel,BoxLayout.Y_AXIS));
			setContentPane(mainPanel);
			
			JLabel label;
			
			// Add a CellPaintPanel
			label = new JLabel("Select cell(s)");
			mainPanel.add(label);
			TheCellPaintPanel = new CellPaintPanel();
			mainPanel.add(TheCellPaintPanel);
			
			JPanel p = new JPanel();
			p.setLayout(new BoxLayout(p,BoxLayout.X_AXIS));
			
			// Add select all cells button
			JButton selectAllCells = new JButton("Select all cells");
			selectAllCells.addActionListener(new ActionListener() {
						public void actionPerformed(ActionEvent ae) {
							for (int i=0;i<NumberOfCells;i++)
								CellSelectionArray[i] = true;
							TheCellPaintPanel.repaint();
						}
					});
			p.add(selectAllCells);
			// Add unselect all cells button
			JButton unSelectAllCells = new JButton("De-select all cells");
			unSelectAllCells.addActionListener(new ActionListener() {
						public void actionPerformed(ActionEvent ae) {
							for (int i=0;i<NumberOfCells;i++)
								CellSelectionArray[i] = false;
							TheCellPaintPanel.repaint();
						}
					});
			p.add(unSelectAllCells);
			
			mainPanel.add(p);
			
			p = new JPanel();
			p.setLayout(new BoxLayout(p,BoxLayout.X_AXIS));
			
			// Add NodeSelectionPanel
			label = new JLabel("Select node(s)");
			mainPanel.add(label);
			TheNodeSelectionPanel = new MultipleNodeSelectionPanel();
			mainPanel.add(TheNodeSelectionPanel);
			
			// Add seleect all nodes button
			JButton selectAllNodes = new JButton("Select all nodes");
			selectAllNodes.addActionListener(new ActionListener() {
						public void actionPerformed(ActionEvent ae) {
							for (int i=0;i<NumberOfNodes;i++)
								NodeSelectionArray[i] = true;
							TheNodeSelectionPanel.repaint();
						}
					});
			p.add(selectAllNodes);
			// Add unselect all cells button
			JButton unSelectAllNodes = new JButton("De-select all nodes");
			unSelectAllNodes.addActionListener(new ActionListener() {
						public void actionPerformed(ActionEvent ae) {
							for (int i=0;i<NumberOfNodes;i++)
								NodeSelectionArray[i] = false;
							TheNodeSelectionPanel.repaint();
						}
					});
			p.add(unSelectAllNodes);
			
			mainPanel.add(p);
			
			// Create layout controls
			label = new JLabel("Select Layout");
			mainPanel.add(label);
			
			ClearGraphsButton = new JRadioButton("Clear graphs first");
			mainPanel.add(ClearGraphsButton);
			
			JPanel layoutPanel1 = new JPanel();
			layoutPanel1.setLayout(new BoxLayout(layoutPanel1,BoxLayout.Y_AXIS));
			AllOnOneButton = new JRadioButton("All on one graph");
			layoutPanel1.add(AllOnOneButton);
			OneCellPerGraphButton = new JRadioButton("One cell per graph");
			layoutPanel1.add(OneCellPerGraphButton);
			OneNodePerGraphButton = new JRadioButton("One node per graph");
			layoutPanel1.add(OneNodePerGraphButton);
			ButtonGroup group1 = new ButtonGroup();
			group1.add(AllOnOneButton);
			group1.add(OneCellPerGraphButton);
			group1.add(OneNodePerGraphButton);
			mainPanel.add(layoutPanel1);
			
			
			JPanel layoutPanel2 = new JPanel();
			layoutPanel2.setLayout(new BoxLayout(layoutPanel2,BoxLayout.Y_AXIS));
			DefaultNodeColorsButton = new JRadioButton("Use default node colors");
			layoutPanel2.add(DefaultNodeColorsButton);
			AutoColorsButton = new JRadioButton("Auto-generate colors");
			layoutPanel2.add(AutoColorsButton);
			ButtonGroup group2 = new ButtonGroup();
			group2.add(DefaultNodeColorsButton);
			group2.add(AutoColorsButton);
			mainPanel.add(layoutPanel2);
			
			// Set defaults
			AllOnOneButton.setSelected(true);
			DefaultNodeColorsButton.setSelected(true);
			
			// Create build button
			JButton buildButton = new JButton("Build Graph(s)");
			buildButton.addActionListener(new ActionListener() {
						public void actionPerformed(ActionEvent ae) {
							buildGraphs();
						}
					});
			mainPanel.add(buildButton);
			
			pack();
			setVisible(true);
			
		}
		
		/** Builds the graph(s) accroding to the user selected parameters above.
		 @author WJS
		 */
		private void buildGraphs() {
			
			// If clear graphs button was selected, then remove all the existing
			// graphs
			if (ClearGraphsButton.isSelected())
			  GraphsPanel.removeAll();
			
			// All on one graph
			if (AllOnOneButton.isSelected()) {
				// Generate one graph panel
				GraphPanel graph = new GraphPanel();
				GraphsPanel.add(graph);
				// Generate array of colors
				int n1 = 0;
				for (int k=0;k<NumberOfCells;k++)
					if (CellSelectionArray[k]) n1++;
				int n2 = 0;
				for (int k=0;k<NumberOfNodes;k++)
				  if (NodeSelectionArray[k]) n2++;
				int n = n1*n2;
				Color[] colors = new Color[n];
				if (AutoColorsButton.isSelected())
					colors = pseudoColors(n);
				else
					for (int k=0;k<n;k++)
						colors[k] = null;
			  // Loop through all cells and see which are selected
				n = 0;
				for (int i=0;i<NumberOfCells;i++) {
					if (CellSelectionArray[i]) {
						// Loop through all nodes and add a graph for each node that is selected
						Color c;
						for (int j=0;j<NumberOfNodes;j++) {
							if (NodeSelectionArray[j]) {
								c = colors[n++];
								if (c==null) c = TheModel.getNetwork().getNode(j).getColor();
								graph.addDataPointer(i,j,c,"Cell"+Integer.toString(i)+TheModel.getNetwork().getNode(j).getName());
							}
						}
					}
				  graph.buildGraph();
				}
			}
			
			// One cell per graph
			if (OneCellPerGraphButton.isSelected()) {
			  // Loop through all cells and create a graph panel for each selected one
				for (int i=0;i<NumberOfCells;i++) {
					if (CellSelectionArray[i]) {
						GraphPanel graph = new GraphPanel();
						GraphsPanel.add(graph);
						// Generate array of colors
						int n = 0;
						for (int k=0;k<NumberOfNodes;k++)
							if (NodeSelectionArray[k]) n++;
						Color[] colors = new Color[n];
						if (AutoColorsButton.isSelected())
							colors = pseudoColors(n);
						else
							for (int k=0;k<n;k++)
								colors[k] = null;
						// Loop through all nodes and add a graph for each node that is selected
						n = 0;
						Color c;
						for (int j=0;j<NumberOfNodes;j++) {
							if (NodeSelectionArray[j]) {
								c = colors[n++];
								if (c==null) c = TheModel.getNetwork().getNode(j).getColor();
								graph.addDataPointer(i,j,c,"Cell"+Integer.toString(i)+TheModel.getNetwork().getNode(j).getName());
							}
						}
						graph.buildGraph();
					}
				}
			}
			
			// One node per graph
			if (OneNodePerGraphButton.isSelected()) {
				// Loop through all nodes and add a graph panel for each node that is selected
				for (int j=0;j<NumberOfNodes;j++) {
					if (NodeSelectionArray[j]) {
						GraphPanel graph = new GraphPanel();
						GraphsPanel.add(graph);
						// Generate array of colors
						int n = 0;
						for (int k=0;k<NumberOfCells;k++)
							if (CellSelectionArray[k]) n++;
						Color[] colors = new Color[n];
						if (AutoColorsButton.isSelected())
							colors = pseudoColors(n);
						else
							for (int k=0;k<n;k++)
								colors[k] = TheModel.getNetwork().getNode(j).getColor();
						// Loop through all cells and add a graph for each cell that is selected
						n = 0;
						for (int i=0;i<NumberOfCells;i++) {
							if (CellSelectionArray[i]) {
								graph.addDataPointer(i,j,colors[n++],"Cell"+Integer.toString(i)+TheModel.getNetwork().getNode(j).getName());
							}
						}
						graph.buildGraph();
					}
				}
			}
			SaveThis.pack(); // Refers back to TimeGraph JFrame
			
		}
		
		/** CellPaintPanel.java
		 Panel for painting all the cells on the cell surface. The selected cell
		 is painted solid black. ALl other cells are just painted in outline. Panel
		 also handles click events that allows the user to select which cell's nodes
		 are being viewed.
		 @author WJS
		 */
		private class CellPaintPanel extends JPanel {
			
			/** Simple constructor.
			 @author WJS
			 */
			public CellPaintPanel() {
				
				super();
				setBackground(Color.lightGray);
				
				// Set the size of the panel based upon size calculated earlier.
				setMaximumSize(CellPaintPanelDimension);
				setMinimumSize(CellPaintPanelDimension);
				setPreferredSize(CellPaintPanelDimension);
				setSize(CellPaintPanelDimension);
				
				// Create a mouse listener for detecting user mouse clicks on cells
				addMouseListener(new MouseAdapter() {
							public void mouseClicked(MouseEvent me) {
								int i = findCellAt(me.getPoint());
								if (i!=-1)
									CellSelectionArray[i] = !CellSelectionArray[i];
								repaint();
							}
						});
				
			}
			
			/** Over-ride the paint method to draw cells and such.
			 @param Graphics g0
			 @author WJS
			 */
			public void paint(Graphics g0) {
				
				super.paint(g0);
				
				Graphics2D g = (Graphics2D)g0;
				g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
				for (int i=0;i<CellShapeArray.length;i++) {
					if (CellSelectionArray[i])
						g.fill(CellShapeArray[i]);
					else
						g.draw(CellShapeArray[i]);
				}
				
			}
			
		}
		
		/** MultipleNodeSelectionPanel.java
		 @author WJS
		 */
		private class MultipleNodeSelectionPanel extends JPanel {
			
		  /** JList for holding all nodes */
			private JList                     NodeSelectionList;
			
			public MultipleNodeSelectionPanel() {
				
				super();
				setLayout(new BorderLayout());
				
				Vector nodes = new Vector();
				NodeTemplate node;
				for (int i=0;i<TheModel.getNetwork().getNumNodes();i++) {
					node = TheModel.getNetwork().getNode(i);
					nodes.add(node.getName());
				}
				
				NodeSelectionList = new JList(nodes);
				NodeSelectionList.addMouseListener(new MouseAdapter() {
							public void mouseClicked(MouseEvent me) {
								int index = NodeSelectionList.getSelectedIndex();
								NodeSelectionArray[index] = !NodeSelectionArray[index];
								NodeSelectionList.validate();
								NodeSelectionList.repaint();
							}
						});
				
				NodeSelectionList.setCellRenderer(new NodeSelectionListCellRenderer());
				JScrollPane scrollPane = new JScrollPane(NodeSelectionList);
				add(scrollPane,BorderLayout.CENTER);
				
			}
			
			/** NodeSelectionListCellRenderer.java
			 Implementation of a NodeSelectionListCellRender for drawing elements in a
			 NodeSelectionList.
			 @author WJS
			 */
			private class NodeSelectionListCellRenderer extends JLabel implements ListCellRenderer {
				
				/** Highlight color for selected entries */
				private Color                SelectedColor = new Color(204,204,255);
				
				public NodeSelectionListCellRenderer() {
					
					setOpaque(true);
					setBackground(Color.white);
					
				}
				
				/** CellRenderer implementation for the NodeSelectionList
				 @author WJS
				 */
				public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
					
					setText((String)value);
					if (NodeSelectionArray[index])
						setBackground(SelectedColor);
					else
						setBackground((Color.white));
					
					return(this);
					
				}
				
			}
			
		}
		
	}
	
}