package genegui;

import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.io.*;
import java.util.*;
import javax.swing.*;
import javax.swing.event.*;

import main.*;

/** CellViewer.java
 This is a re-write of the CellViewer class to make it more efficient and
 possibly less silly.
 <p>
 The viewer is composed on a series verticaly arrayed panels. The first panel
 will always be used to display time step and other information. Each additional
 panel is a CellViewerPanel which can be configured to display the color
 information collected from one or more nodes.
 @author WJS
 */
public class CellSurfaceViewer extends JInternalFrame implements ModelStateChangeListener,GuiInterface  {
	
	public static final int           GRAPH_CELL = 0;
	public static final int           GRAPH_BAR = 1;
	public static final int           GRAPH_FUNCTION_LINEAR=0;
	public static final int           GRAPH_FUNCTION_LOG=1;
	public static final int           GRAPH_FUNCTION_EXP=2;
	public static final int           GRAPH_FUNCTION_THRESH=3;
	public static final int           GRAPH_FUNCTION_PSUEDO=4;
	
	
	/** A pointer to the attached NodeStateViewer if there is one */
	private NodeStateViewer           AttachedNodeStateViewer;
	/** Stores the cell shapes including scale and translation - speeds up painting */
	private Polygon[]                 CellShapeArray;
	/** Stores the base cell shapes and locations */
	private Polygon[]                 CellShapeArrayBase;
	/** Multiplier used for exp color maping*/
	private float                     ExpMultiplier = 1f;
	/** Sets the type of graph being displayed */
	private int                       GraphMode = GRAPH_CELL;
	/** Specifies what transformation function should be applied to the graph color */
	private int                       GraphFunction = GRAPH_FUNCTION_LINEAR;
	/** Multiplier used for log color maping*/
	private float                     LogMultiplier = 1f;
	/** The Main JMenuBar */
  private JMenuBar                  MainMenu;
	/** The main panel */
	private JPanel                    MainPanel;
	/** The unique instance of the optionspanel */
	private	CellViewOptionsPanel      OptionsPanel;
	/** An array list of all the SingleNodeNodeViewerPaintPaenls */
	private ArrayList                 PaintPanels = new ArrayList();
	/** Controls the rate at which the display refreshes by rejecting changes in size below the RefreshReject */
	private float                     RefreshReject = .03125f;
	/** Self Reference */
	private CellSurfaceViewer         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;
	/** Preferred dimension for the SingleNodeViewerPanels */
	private Dimension                 SingleNodeViewerPanelDimension;
	/** The MainGui object that this belongs to */
	private MainGui                   TheMainGui;
	/** A pointer to the Model being displayed */
	private Model		                  TheModel = null;
	/** A pointer to the ModelState used to pass information to the CellViewer */
	private ModelState                TheModelState = null;
	/** A pointer to the network found in each cell */
	private Network		                TheNetwork = null;
	/** The threshold value used by the threshold colormap */
	private float                     ThresholdValue = 0.5f;
	/** Translation for drawing of cells */
	private Point                     Translation = new Point(5,5);
	
	
	
	/** Simple constructor.
	 @author WJS
	 */
	public CellSurfaceViewer(Model model, MainGui theMainGUI, String title, boolean simpleDisplay)	 {
		
		super(title,false,true,true,true);
		
		TheMainGui = theMainGUI;
		SimpleDisplay = simpleDisplay;
		
		MainPanel = new JPanel();
		setContentPane(MainPanel);
		MainPanel.setLayout(new BoxLayout(MainPanel,BoxLayout.Y_AXIS));
		
		setModel(model);
		setNetwork(model.net);
		
		// Build the unique copy of the options panel
		OptionsPanel = new CellViewOptionsPanel();
		OptionsPanel.setLocation(getLocation());
		OptionsPanel.setVisible(false);
		
		// Build the JMenuBar for the CellViewer
		MainMenu = new JMenuBar();
		MainMenu.setBackground(Color.lightGray);
		
		JMenuItem item;
		
		// Displays
		JMenu displays = new JMenu("Displays");
		displays.setBackground(Color.lightGray);
		item = new JMenuItem("Add New Node");
		item.addActionListener(new ActionListener()  {
					public void actionPerformed(ActionEvent ae)  {
						addNewNode();
					}
				});
		displays.add(item);
		item = new JMenuItem("Remove All Nodes");
		item.addActionListener(new ActionListener()  {
					public void actionPerformed(ActionEvent ae)  {
						removeAllNodes();
					}
				});
		displays.add(item);
		
		displays.addSeparator();
		
		item = new JMenuItem("Options");
		item.addActionListener(new ActionListener()  {
					public void actionPerformed(ActionEvent ae)  {
						OptionsPanel.toFront();
						OptionsPanel.setLocation(getLocation());
						OptionsPanel.setVisible(true);
						OptionsPanel.pack();
					}
				});
		displays.add(item);
		
		displays.addSeparator();
		
		item = new JMenuItem("Close");
		item.addActionListener(new ActionListener()  {
					public void actionPerformed(ActionEvent ae)  {
						close();
					}
				});
		displays.add(item);
		MainMenu.add(displays);
		
		final JMenu graphs = new JMenu("Graphs");
		graphs.setBackground(Color.lightGray);
		item = new JMenuItem("Cell Graph",new ImageIcon("icons/CSVChecked.gif"));
		item.setHorizontalTextPosition(SwingConstants.LEFT);
		item.addActionListener(new ActionListener()  {
					public void actionPerformed(ActionEvent ae)  {
						unCheckJMenuItem(graphs,GraphFunction);
						GraphMode = GRAPH_CELL;
						checkMenuItem(graphs,GraphFunction);
						repaint();
					}
				});
		graphs.add(item);
		item = new JMenuItem("Bar Graph");
		item.setHorizontalTextPosition(SwingConstants.LEFT);
		item.addActionListener(new ActionListener()  {
					public void actionPerformed(ActionEvent ae)  {
						// TODO Implement bar graph deal
//						unCheckJMenuItem(graphs,GraphFunction);
//						GraphMode = GRAPH_BAR;
//						checkMenuItem(graphs,GraphFunction);
//						repaint();
					}
				});
		graphs.add(item);
		MainMenu.add(graphs);
		
		
		// Color maps menu
		final JMenu colorMaps = new JMenu("ColorMaps");
		colorMaps.setBackground(Color.lightGray);
		item = new JMenuItem("Linear",new ImageIcon("icons/CSVChecked.gif"));
		item.setHorizontalTextPosition(SwingConstants.LEFT);
		item.addActionListener(new ActionListener()  {
					public void actionPerformed(ActionEvent ae)  {
						unCheckJMenuItem(colorMaps,GraphFunction);
						GraphFunction = GRAPH_FUNCTION_LINEAR;
						checkMenuItem(colorMaps,GraphFunction);
						paintAll();
						repaint();
					}
				});
		colorMaps.add(item);
		item = new JMenuItem("Logarithmic");
		item.setHorizontalTextPosition(SwingConstants.LEFT);
		item.addActionListener(new ActionListener()  {
					public void actionPerformed(ActionEvent ae)  {
						unCheckJMenuItem(colorMaps,GraphFunction);
						GraphFunction = GRAPH_FUNCTION_LOG;
						checkMenuItem(colorMaps,GraphFunction);
						CellViewerLogControl viewer = new CellViewerLogControl();
						Point p = SaveThis.getLocation();
						// TODO - Autoposition
						viewer.setLocation(p);
						paintAll();
						repaint();
					}
				});
		colorMaps.add(item);
		item = new JMenuItem("Exponential");
		item.setHorizontalTextPosition(SwingConstants.LEFT);
		item.addActionListener(new ActionListener()  {
					public void actionPerformed(ActionEvent ae)  {
						unCheckJMenuItem(colorMaps,GraphFunction);
						GraphFunction = GRAPH_FUNCTION_EXP;
						checkMenuItem(colorMaps,GraphFunction);
						CellViewerExpControl viewer = new CellViewerExpControl();
						Point p = SaveThis.getLocation();
						// TODO - Autoposition
						viewer.setLocation(p);
						paintAll();
						repaint();
					}
				});
		colorMaps.add(item);
		item = new JMenuItem("Linear Threshold");
		item.setHorizontalTextPosition(SwingConstants.LEFT);
		item.addActionListener(new ActionListener()  {
					public void actionPerformed(ActionEvent ae)  {
						unCheckJMenuItem(colorMaps,GraphFunction);
						GraphFunction = GRAPH_FUNCTION_THRESH;
						checkMenuItem(colorMaps,GraphFunction);
						CellViewerThresholdControl viewer = new CellViewerThresholdControl();
						Point p = SaveThis.getLocation();
						// TODO - Autoposition
						viewer.setLocation(p);
						paintAll();
						repaint();
					}
				});
		colorMaps.add(item);
		item = new JMenuItem("PseudoColor");
		item.setHorizontalTextPosition(SwingConstants.LEFT);
		item.addActionListener(new ActionListener()  {
					public void actionPerformed(ActionEvent ae)  {
						unCheckJMenuItem(colorMaps,GraphFunction);
						GraphFunction = GRAPH_FUNCTION_PSUEDO;
						checkMenuItem(colorMaps,GraphFunction);
						paintAll();
						repaint();
					}
				});
		colorMaps.add(item);
		MainMenu.add(colorMaps);
		
		setJMenuBar(MainMenu);
		
		// Add an internal frame listener for capturing frame closing events
		addInternalFrameListener(new InternalFrameAdapter()  {
					public void internalFrameClosing(InternalFrameEvent ife)  {
						close();
					}
				});
		
		pack();
		setVisible(true);
		
		setIconifiable(true);
		
	}
	
	/** Adds a new node display panel to the viewer. The new panel is put at
	 the top of the display and its value is set to that of the first node in
	 the list ofall nodes.
	 @author WJS
	 */
	private void addNewNode()  {
		
		// At the node panel
		NodeTemplate node = TheNetwork.getNode(0);
		SingleNodeViewerPanel p = new SingleNodeViewerPanel(node);
		MainPanel.add(p,0);
		
		// Keep track of the node pamel's paint panel for fast paint operations
		SingleNodeViewerPanel.SingleNodeViewerPaintPanel pp = p.getPaintPanel();
		PaintPanels.add(pp);
		pp.paintOffScreen(true);
		pp.repaint();
		
		pack();
		
	}
	
	/** Checks the selected menu item.
	 @param JMenu menu
	 @param int index
	 @author WJS
	 */
	private void checkMenuItem(JMenu menu, int index)  {
		
		menu.getItem(index).setIcon(new ImageIcon("icons/CSVChecked.gif"));
		
	}
	
	/** 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);
		OptionsPanel.dispose();
		
	}
	
	/** 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);
		
	}
	
	/** Moves nodeViewerPanel down a space.
	 @param SingleNodeViewerPanel p - Panel to move.
	 @author WJS
	 */
	public void moveViewerPanelDown(SingleNodeViewerPanel p)  {
		
		Component[] c = MainPanel.getComponents();
		for (int i=0;i<c.length;i++)  {
			if (c[i]==p)  {
				if (c[i] instanceof SingleNodeViewerPanel)  {
					MainPanel.remove(i);
					if ((i+1)==c.length)
						MainPanel.add(p,0);
					else
						MainPanel.add(p,i+1);
					break;
				}
			}
		}
		pack();
		
	}
	
	/** Moves nodeViewerPanel up a space
	 @param SingleNodeViewerPanel p - Panel to move.
	 @author WJS
	 */
	public void moveViewerPanelUp(SingleNodeViewerPanel p)  {
		
		Component[] c = MainPanel.getComponents();
		for (int i=0;i<c.length;i++)  {
			if (c[i]==p)  {
				if (c[i] instanceof SingleNodeViewerPanel)  {
					MainPanel.remove(i);
					MainPanel.add(c[i],i-1);
					break;
				}
			}
		}
		pack();
		
	}
	
	/** Forces all panels to repaint.
	 @author WJS
	 */
	public void paintAll() {
		
		SingleNodeViewerPanel.SingleNodeViewerPaintPanel p;
		for (int i=0;i<PaintPanels.size();i++)  {
			p = (SingleNodeViewerPanel.SingleNodeViewerPaintPanel)PaintPanels.get(i);
			if (p.paintOffScreen(true)) p.repaint();
		}
		
	}
	
	/** Removes all the node panels from the CellViewer.
	 @author WJS
	 */
	private void removeAllNodes()  {
		
		MainPanel.removeAll();
		PaintPanels.clear();
		pack();
		
	}
	
	/** Removes a SingleNodeViewerPanel from the CellViewer. Takes care of
	 proper repainting etc.
	 @param SingleNodeViewerPanel panel - NodePanel to be removed
	 @author WJS
	 */
	public void removeNodeViewerPanel(SingleNodeViewerPanel panel)  {
		
		MainPanel.remove(panel);
		// And remove its paint panel from the list so we don't kepp repainting it
		SingleNodeViewerPanel.SingleNodeViewerPaintPanel pp = panel.getPaintPanel();
		PaintPanels.remove(pp);
		
		pack();
		
	}
	
	/** 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 model.
	 @param Model model - The new model to be displayed.
	 @author WJS
	 */
	public void setModel(Model model)  {
		
		TheModel = model;
		
		// Build the cell shape array
		CellShapeArray = new Polygon[TheModel.numCells];
		CellShapeArrayBase = new Polygon[TheModel.numCells];
		for (int i=0;i<TheModel.numCells;i++)  {
			CellShapeArrayBase[i] = TheModel.cells[i].getCellShape();
		}
		setScaleAndTranslation(Scale,Translation);
		
	}
	
	/** 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;
		
		for (int i=0;i<PaintPanels.size();i++) {
		  SingleNodeViewerPanel.SingleNodeViewerPaintPanel pp	= (SingleNodeViewerPanel.SingleNodeViewerPaintPanel)PaintPanels.get(i);
		  pp.paintOffScreen(true);
		  pp.repaint();
		}
		
	}
	
	/** Sets the network used by all cells.
	 @param Network network -
	 */
	public void setNetwork(Network network)  {
		
		TheNetwork = network;
		
		// Clean out everything in the MainPanel and rebuild it adding a
		// SingleNodeViewerPanel for each type of visible node.
		MainPanel.removeAll();
		PaintPanels.clear();
		for (int i=0;i<TheNetwork.getNumNodes();i++)  {
			NodeTemplate node = TheNetwork.getNode(i);
			if (node.getShow())  {
				SingleNodeViewerPanel p = new SingleNodeViewerPanel(node);
				PaintPanels.add(p.getPaintPanel());
				MainPanel.add(p);
				// Paint the panel
				SingleNodeViewerPanel.SingleNodeViewerPaintPanel pp = p.getPaintPanel();
				pp.paintOffScreen(true);
				pp.repaint();
			}
		}
		
	}
	
	/** Sets scale and translation for CellShapeArray used in painting operations.
	 @param double scale - The magnification factor for the cell.
	 @param Point translation - the Translation for the cell shape - not subjected to scale factor.
	 @author WJS
	 */
	public void setScaleAndTranslation(double scale, Point translation)  {
		
		Scale = scale;
		Translation = translation;
		
		Polygon p;
		Polygon q;
		for (int i=0;i<CellShapeArrayBase.length;i++)  {
			p = CellShapeArrayBase[i];
			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 the SingleNodeViewerPanels 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();
		}
		SingleNodeViewerPanelDimension = new Dimension((int)maxX+20,(int)maxY+4);
		
	}
	
	/** Reinitializes all the SingleNodeViewerPanels
	 @author WJS
	 */
	private void reinitPanels() {
		
		Component c[] = MainPanel.getComponents();
		for (int i=0;i<c.length;i++) {
			try {
				SingleNodeViewerPanel p = (SingleNodeViewerPanel)c[i];
				p.reinit();
			} catch (ClassCastException cce) {}
		}
		
	}
	
	/** Implementation of ModelStateChangeListener
	 Causes entire display to be repainted.
	 @author WJS
	 */
	public void updateAll()  {
		
		SingleNodeViewerPanel.SingleNodeViewerPaintPanel p;
		for (int i=0;i<PaintPanels.size();i++)  {
			p = (SingleNodeViewerPanel.SingleNodeViewerPaintPanel)PaintPanels.get(i);
			if (p.paintOffScreen(false)) p.repaint();
		}
		
	}
	
	/** Unchecks the menu item by index
	 @param JMenu menu
	 @param int index
	 @author WJS
	 */
	private void unCheckJMenuItem(JMenu menu, int index)  {
		
		menu.getItem(index).setIcon(null);
		
	}
	
	/** 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)  {
		
		// Check to see if the node is being viewed by any of the NodePanels
		SingleNodeViewerPanel p;
		Component c[] = MainPanel.getComponents();
		for (int i=0;i<c.length;i++)  {
			if (c[i] instanceof SingleNodeViewerPanel)  {
				p = (SingleNodeViewerPanel)c[i];
				if (p.getNodeIndex()==nodeIndex)
					p.repaint();
				
			}
		}
	}
	
	/******************** 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:
				Component c[] = MainPanel.getComponents();
				for (int i=0;i<c.length;i++)  {
					if ((c[i] instanceof SingleNodeViewerPanel)&&((SingleNodeViewerPanel)c[i]).getNodeTemplate()==nodeTemplate)  {
						c[i].repaint();
						break;
					}
				}
				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) {
		
	}
	
	/** SingleNodeViewerPanel internal class
	 This is an extension of JPanel to be used for painting all the cells in the
	 model. The cells should be painted as efficiently as possible. All cell shapes
	 are stored in the global CellShapeArray
	 <p>
	 This was designed largely for backward compatibility to the original CellView.
	 @author WJS
	 */
	private class SingleNodeViewerPanel extends JPanel  {
		
		/** A pointer to the panel used to paint the cells */
		private SingleNodeViewerPaintPanel    PaintPanel;
		/** Selection box that allows the user to choose which node they are viewing */
		private JComboBox                     NodeSelectionBox;
		/** Self reference */
		private SingleNodeViewerPanel         SaveThis = this;
		/** The Node Template this is attached to */
		private NodeTemplate                  TheNodeTemplate;
		
		public SingleNodeViewerPanel(NodeTemplate theNodeTemplate)  {
			
			super();
			
			TheNodeTemplate = theNodeTemplate;
			
			// Set up panel for holding label and paint panel
			setBorder(BorderFactory.createLineBorder(Color.black,1));
			setLayout(new BoxLayout(this,BoxLayout.X_AXIS));
			setBackground(Color.lightGray);
			
			// Create the panel that the cell images will be painted into
			PaintPanel = new SingleNodeViewerPaintPanel();
			// Create a mouse listener for detecting user mouse clicks on cells
			PaintPanel.addMouseListener(new MouseAdapter()  {
						public void mouseClicked(MouseEvent me)  {
							int cell = findCellAt(me.getPoint());
							if ((AttachedNodeStateViewer==null)||(AttachedNodeStateViewer.isClosed()))  {
								AttachedNodeStateViewer = new NodeStateViewer(TheModelState,TheMainGui,"Node Viewer");
								TheModelState.addModelStateChangeListener(AttachedNodeStateViewer);
								GeneNet.TheMainGui.addInternalFrame(AttachedNodeStateViewer);
							}
							GeneNet.TheMainGui.showInternalFrame(AttachedNodeStateViewer);
							AttachedNodeStateViewer.setCell(cell);
						}
					});
			
			init();
			
		}
		
		
		private void init() {
			
			Dimension d;
			
			if (!SimpleDisplay) {
				// Build the JComboBox that shows which node is being displayed and
				// allows the user to change it.
				d = new Dimension(80,20);
				NodeSelectionBox = new JComboBox();
				NodeSelectionBox.setPreferredSize(d);
				NodeSelectionBox.setMaximumSize(d);
				NodeSelectionBox.setMinimumSize(d);
				NodeSelectionBox.setBackground(Color.lightGray);
				NodeTemplate node;
				for (int i=0;i<TheNetwork.getNumNodes();i++)  {
					node = TheNetwork.getNode(i);
					NodeSelectionBox.addItem(node.getName());
					if (node.getName().equals(TheNodeTemplate.getName()))
						NodeSelectionBox.setSelectedIndex(i);
				}
				NodeSelectionBox.addActionListener(new ActionListener()  {
							public void actionPerformed(ActionEvent ae)  {
								int index = NodeSelectionBox.getSelectedIndex();
								TheNodeTemplate = TheNetwork.getNode(index);
								PaintPanel.paintOffScreen(true);
								PaintPanel.repaint();
							}
						});
				
				add(NodeSelectionBox);
				
			}
			add(PaintPanel);
			
			if (!SimpleDisplay) {
				
				// Make control panel for right 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,1,0,0,Color.black));
				p.setBackground(Color.lightGray);
				
				// Make button for removing the node panel
				Icon closeIcon = new ImageIcon("icons/MSECloseIcon.gif");
				JButton closeButton = new JButton(closeIcon);
				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)  {
								removeNodeViewerPanel(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)  {
								moveViewerPanelUp(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)  {
								moveViewerPanelDown(SaveThis);
							}
						});
				p.add(downButton);
				
				add(p);
			}
			
		}
		
		public void reinit() {
			
			removeAll();
			init();
			
		}
		
		/** Returns the NodeTemplate's index number.
		 @return int
		 @author WJS
		 */
		public int getNodeIndex()  {
			
			return(TheNodeTemplate.getNodeNum());
			
		}
		
		/** Returns the NodeTemplate that this panel displays
		 @return NodeTemplate
		 @author WJS
		 */
		public NodeTemplate getNodeTemplate()  {
			
			return(TheNodeTemplate);
			
		}
		
		/** Returns the single built in panel used for painting the cells
		 @return SingleNodeViewerPaintPanel
		 @author WJS
		 */
		public SingleNodeViewerPaintPanel getPaintPanel()  {
			
			return(PaintPanel);
			
		}
		
		/**
		 @author WJS
		 */
		public void resizePanel()  {
			
			PaintPanel.resizePanel(SingleNodeViewerPanelDimension);
			
		}
				
		/** Class extends JPanel and over-rides paint method for painting cell shapes
		 in their enabled nodes colors according to the values foind in the ModelState.
		 @author WJS
		 */
		private  class SingleNodeViewerPaintPanel extends JPanel  {
			
			/** An array of the last values that invoked a paint for the cell shapes */
			private float[]               LastPaintedValues;
			/** The offscreen image that the display is painted into */
			private Image                 OffScreenImage;
			/** True if the paintOffScreen method is running */
			public boolean                Redrawing = true;
			
			/** Main constructor.
			 @author WJS
			 */
			public SingleNodeViewerPaintPanel()  {
				
				super();
				
				// Set up array of last painted values?and set all to 0.
				LastPaintedValues = new float[CellShapeArray.length];
				for (int i=0;i<CellShapeArray.length;i++)
					LastPaintedValues[i] = 0;
				
				// Set the size of the panel based upon size caculated earlier.
				resizePanel(SingleNodeViewerPanelDimension);
				
			}
			
			/** Called when the panel is explicitly resized by the slider in the
			 options panel.
			 @author WJS
			 */
			public void resizePanel(Dimension d)  {
				
				if (d==null) return;
				
				setMaximumSize(d);
				setMinimumSize(d);
				setPreferredSize(d);
				setSize(d);
				
				OffScreenImage = createImage(d.width,d.height);
				paintOffScreen(true);
				repaint();
				
				
			}
			
			/** Over-ride the paint method to paint the offscreen image.
			 @author WJS
			 */
			public void paint(Graphics g0)  {
				
				if (OffScreenImage==null||(OffScreenImage.getWidth(this)!=getWidth())||(OffScreenImage.getHeight(this)!=getHeight())) {
					OffScreenImage = createImage(getWidth(),getHeight());
					paintOffScreen(true);
				}
				
				// This line will cause the paint thread to yield if the paintOffScreen
				// method is running. It is crucial to making sure painting doesn't
				// mess up especially when the viewer is being dragged around.
				if (Redrawing) Thread.yield();
				
				g0.drawImage(OffScreenImage,0,0,this);
				
			}
			
			/** Draws the cells in the off screen image buffer.
			 @param paintAll boolean - If true forces all the cells to be redrawn.
			 @return boolean - Returns true if any of the cells were redrawn
			 @author WJS
			 */
			public boolean paintOffScreen(boolean paintAll)  {
				
				// This will happen if the paint panel isn't visible
				if (OffScreenImage==null) return(false);
				
				boolean dirty = false;
				
				if (TheModelState!=null)  {
					
					Redrawing = true;
					
					Graphics2D g = (Graphics2D)OffScreenImage.getGraphics();
					g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
					if (paintAll) {
						g.setColor(Color.lightGray);
						g.fillRect(0,0,getWidth(),getHeight());
					}
					float v;
					Color c;
					int red = 0;
					int green = 0;
					int blue = 0;
					for (int i=0;i<CellShapeArray.length;i++)  {
						v = TheModelState.getCellState(i).getNodeValue(TheNodeTemplate.getNodeNum());
						if (v<0) v=0;
						else if (v>1.0) v=1;
						switch (GraphFunction)  {
							case GRAPH_FUNCTION_LOG:
								try  {
									v = (float)((Math.log(v*LogMultiplier)+1.0)/(Math.log(LogMultiplier)+1));
									if (v>1) v = 1f;
									else if (v<0) v = 0f;
								}
								catch (Exception ex)  {
									v = 0;
								}
								break;
							case GRAPH_FUNCTION_EXP:
								v = (float)(Math.exp(ExpMultiplier*v)/Math.exp(ExpMultiplier));
								break;
							case GRAPH_FUNCTION_THRESH:
								if (v>ThresholdValue) v = 1;
								else v = 0;
								break;
						}
						if ((Math.abs(v-LastPaintedValues[i])>RefreshReject)||paintAll) {
							dirty = true;
							LastPaintedValues[i] = v;
							if (GraphFunction==GRAPH_FUNCTION_PSUEDO) {
								// TODO Math not quite right. Find proper LUT functions.
								red = (int)((1-v)*255);
								if (v<0.5) green = (int)(v*511);
								else green = (int)((1-v)*511);
								blue = (int)(v*255);
							} else {
								c = TheNodeTemplate.getColor();
								red = (int)(v*c.getRed());
								green = (int)(v*c.getGreen());
								blue = (int)(v*c.getBlue());
							}
							
							g.setColor(new Color(red,green,blue));
							g.fillPolygon(CellShapeArray[i]);
						}
					}
					Redrawing = false;
					
				  g.dispose();
					
				}
				
				
				return(dirty);
				
			}
			
		}
		
	}
	
	
	/** CellViewerExpControl.java
	 @author WJS
	 */
	private class CellViewerExpControl extends JFrame  {
		
		private ExpGraphPanel             TheGraph;
		
		public CellViewerExpControl()  {
			
			super("Exponential Multiplier: "+ExpMultiplier);
			setIconifiable(false);
			setResizable(false);
			
			JPanel mainPanel = new JPanel();
			mainPanel.setLayout(new BoxLayout(mainPanel,BoxLayout.Y_AXIS));
			setContentPane(mainPanel);
			
			// Make panel for size slider and its label
			JPanel thresholdSliderPanel = new JPanel();
			thresholdSliderPanel.setLayout(new BoxLayout(thresholdSliderPanel,BoxLayout.X_AXIS));
			
			// Make slider for controling size of the display
			final JSlider thresholdSlider = new JSlider(JSlider.HORIZONTAL,1,10,(int)ExpMultiplier);
			thresholdSlider.setMinorTickSpacing(1);
			thresholdSlider.setMajorTickSpacing(1);
			thresholdSlider.setPaintTicks(true);
			thresholdSlider.setPaintLabels(true);
			thresholdSlider.setSnapToTicks(true);
			thresholdSlider.addChangeListener(new ChangeListener()  {
						public void stateChanged(ChangeEvent ce)  {
							ExpMultiplier = thresholdSlider.getValue();
							setTitle("Exponential Multiplier: "+ExpMultiplier);
							TheGraph.repaint();
							SaveThis.paintAll();
						}
					});
			
			thresholdSliderPanel.add(thresholdSlider);
			mainPanel.add(thresholdSliderPanel);
			
			// Make JPanel for drawing ColorMap graph
			TheGraph = new ExpGraphPanel();
			TheGraph.setSize(300,300);
			mainPanel.add(TheGraph);
			
			// Add a WindowListener that will close down the control window if it
			// is de-activtaed or loses focus
			addWindowListener(new WindowAdapter()  {
						public void windowLostFocus(WindowEvent we)  {
							setVisible(false);
						}
						public void windowDeactivated(WindowEvent we)  {
							if (!System.getProperty("os.name").startsWith("Mac")) setVisible(false);
						}
					});
			
			setSize(300,370);
			setVisible(true);
			
		}
		
		/** ExpGraphPanel.java
		 Extends JPanel to draw an exp graph
		 @author WJS
		 */
		public class ExpGraphPanel extends JPanel  {
			
			public ExpGraphPanel()  {
				
				super();
				setBorder(BorderFactory.createLineBorder(Color.black,1));
				
			}
			
			/** Over-ride paint operation to draw the graph
			 @author WJS
			 */
			public void paint(Graphics g)  {
				
				super.paint(g);
				
				float v =.05f;
				int	x1 = (int)(v*getWidth());
				int	y1 = getHeight()-(int)(Math.exp(v*ExpMultiplier)/Math.exp(ExpMultiplier)*getHeight());
				int x2 = 0;
				int y2 = 0;
				for (int i=1;i<20;i++)  {
					v += .05f;
					x2 = (int)(v*getWidth());
					y2 = getHeight()-(int)(Math.exp(v*ExpMultiplier)/Math.exp(ExpMultiplier)*getHeight());
					g.drawLine(x1,y1,x2,y2);
					x1 = x2;
					y1 = y2;
				}
				
			}
			
		}
		
	}
	
	
	/** CellViewerLogControl.java
	 @author WJS
	 */
	private class CellViewerLogControl extends JFrame  {
		
		private LogGraphPanel             TheGraph;
		
		public CellViewerLogControl()  {
			
			super("Log Multiplier: "+LogMultiplier);
			setIconifiable(false);
			setResizable(false);
			
			JPanel mainPanel = new JPanel();
			mainPanel.setLayout(new BoxLayout(mainPanel,BoxLayout.Y_AXIS));
			setContentPane(mainPanel);
			
			// Make panel for size slider and its label
			JPanel thresholdSliderPanel = new JPanel();
			thresholdSliderPanel.setLayout(new BoxLayout(thresholdSliderPanel,BoxLayout.X_AXIS));
			
			// Make slider for controling size of the display
			final JSlider thresholdSlider = new JSlider(JSlider.HORIZONTAL,1,10,(int)LogMultiplier);
			thresholdSlider.setMinorTickSpacing(1);
			thresholdSlider.setMajorTickSpacing(1);
			thresholdSlider.setPaintTicks(true);
			thresholdSlider.setPaintLabels(true);
			thresholdSlider.setSnapToTicks(true);
			thresholdSlider.addChangeListener(new ChangeListener()  {
						public void stateChanged(ChangeEvent ce)  {
							LogMultiplier = thresholdSlider.getValue();
							setTitle("Log Multiplier: "+LogMultiplier);
							TheGraph.repaint();
							SaveThis.paintAll();
						}
					});
			
			thresholdSliderPanel.add(thresholdSlider);
			mainPanel.add(thresholdSliderPanel);
			
			// Make JPanel for drawing ColorMap graph
			TheGraph = new LogGraphPanel();
			TheGraph.setSize(300,300);
			mainPanel.add(TheGraph);
			
			// Add a WindowListener that will close down the control window if it
			// is de-activtaed or loses focus
			addWindowListener(new WindowAdapter()  {
						public void windowLostFocus(WindowEvent we)  {
							setVisible(false);
						}
						public void windowDeactivated(WindowEvent we)  {
							if (!System.getProperty("os.name").startsWith("Mac")) setVisible(false);
						}
					});
			
			setSize(300,370);
			setVisible(true);
			
		}
		
		/** LogGraphPanel.java
		 Extends JPanel to draw a log graph
		 @author WJS
		 */
		public class LogGraphPanel extends JPanel  {
			
			public LogGraphPanel()  {
				
				super();
				setBorder(BorderFactory.createLineBorder(Color.black,1));
				
			}
			
			/** Over-ride paint operation to draw the graph
			 @author WJS
			 */
			public void paint(Graphics g)  {
				
				super.paint(g);
				
				float temp = (float)(Math.log(LogMultiplier)+1);
				float v =.05f;
				int	x1 = (int)(v*getWidth());
				int	y1 = getHeight()-(int)(((Math.log(v*LogMultiplier)+1)/temp)*getHeight());
				int x2 = 0;
				int y2 = 0;
				for (int i=1;i<20;i++)  {
					v += .05f;
					x2 = (int)(v*getWidth());
					y2 = getHeight()-(int)(((Math.log(v*LogMultiplier)+1)/temp)*getHeight());
					g.drawLine(x1,y1,x2,y2);
					x1 = x2;
					y1 = y2;
				}
				
			}
			
		}
		
	}
	
	/** CellViewerLinearControl.java
	 @author WJS
	 */
	private class CellViewerThresholdControl extends JFrame  {
		
		public CellViewerThresholdControl()  {
			
			super("Threshhold Level: "+(int)(ThresholdValue*100f));
			setIconifiable(false);
			setResizable(false);
			
			JPanel mainPanel = new JPanel();
			mainPanel.setLayout(new BoxLayout(mainPanel,BoxLayout.Y_AXIS));
			setContentPane(mainPanel);
			
			// Make panel for size slider and its label
			JPanel thresholdSliderPanel = new JPanel();
			thresholdSliderPanel.setLayout(new BoxLayout(thresholdSliderPanel,BoxLayout.X_AXIS));
			
			// Make slider for controling size of the display
			final JSlider thresholdSlider = new JSlider(JSlider.HORIZONTAL,0,100,(int)(ThresholdValue*100f));
			thresholdSlider.setMinorTickSpacing(5);
			thresholdSlider.setMajorTickSpacing(25);
			thresholdSlider.setPaintTicks(true);
			thresholdSlider.setPaintLabels(true);
			thresholdSlider.addChangeListener(new ChangeListener()  {
						public void stateChanged(ChangeEvent ce)  {
							ThresholdValue = (float)thresholdSlider.getValue()/100f;
							setTitle("Threshhold Level: "+(int)(ThresholdValue*100f));
							SaveThis.paintAll();
						}
					});
			
			thresholdSliderPanel.add(thresholdSlider);
			mainPanel.add(thresholdSliderPanel);
			
			// Add a WindowListener that will close down the control window if it
			// is de-activtaed or loses focus
			addWindowListener(new WindowAdapter()  {
						public void windowLostFocus(WindowEvent we)  {
							setVisible(false);
						}
						public void windowDeactivated(WindowEvent we)  {
							if (!System.getProperty("os.name").startsWith("Mac")) setVisible(false);
						}
					});
			
			setSize(350,70);
			setVisible(true);
			
		}
		
	}
	
	/** CellViewOptionsPanel.java
	 @author WJS
	 */
	private class CellViewOptionsPanel extends JFrame  {
		
		public CellViewOptionsPanel()  {
			
			super("Cell View Options");
			setIconifiable(false);
			setResizable(false);
			
			JPanel mainPanel = new JPanel();
			mainPanel.setLayout(new BoxLayout(mainPanel,BoxLayout.Y_AXIS));
			setContentPane(mainPanel);
			
			// Make panel for size slider and its label
			JPanel sizeSliderPanel = new JPanel();
			sizeSliderPanel.setLayout(new BoxLayout(sizeSliderPanel,BoxLayout.X_AXIS));
			
			
			// Make a label
			JLabel scaleLabel = new JLabel("Scale");
			sizeSliderPanel.add(scaleLabel);
			
			// Make slider for controling size of the display
			final JSlider sizeSlider = new JSlider(JSlider.HORIZONTAL,0,25,(int)Scale);
			sizeSlider.setMinorTickSpacing(1);
			sizeSlider.setMajorTickSpacing(5);
			sizeSlider.setPaintTicks(true);
			sizeSlider.setPaintLabels(true);
			sizeSlider.addChangeListener(new ChangeListener()  {
						public void stateChanged(ChangeEvent ce)  {
							setScaleAndTranslation(sizeSlider.getValue(),Translation);
							Component[] c = MainPanel.getComponents();
							for (int i=0;i<c.length;i++)  {
								if (c[i] instanceof SingleNodeViewerPanel)  {
									((SingleNodeViewerPanel)c[i]).resizePanel();
								}
							}
							SaveThis.pack();
						}
					});
			
			sizeSliderPanel.add(sizeSlider);
			mainPanel.add(sizeSliderPanel);
			
			// Make a JTextField for changing the refresh reject rate
			JPanel refreshRatePanel = new JPanel();
			refreshRatePanel.setBackground(Color.lightGray);
			refreshRatePanel.setOpaque(true);
			refreshRatePanel.setLayout(new BoxLayout(refreshRatePanel,BoxLayout.X_AXIS));
			JLabel refreshLabel = new JLabel("Refresh Reject Rate: ");
			refreshRatePanel.add(refreshLabel);
			final JTextField refreshRejectJTextBox = new JTextField(Float.toString(RefreshReject));
			refreshRejectJTextBox.addActionListener(new ActionListener() {
						public void actionPerformed(ActionEvent ae) {
							try {
								RefreshReject = Float.parseFloat(refreshRejectJTextBox.getText());
							} catch (NumberFormatException nfe) {
								refreshRejectJTextBox.setText(Float.toString(RefreshReject));
							}
						}
					});
			refreshRejectJTextBox.addFocusListener(new FocusAdapter() {
						public void focusLost(FocusEvent ae) {
							try {
								RefreshReject = Float.parseFloat(refreshRejectJTextBox.getText());
							} catch (NumberFormatException nfe) {
								refreshRejectJTextBox.setText(Float.toString(RefreshReject));
							}
						}
					});
			refreshRatePanel.add(refreshRejectJTextBox);
			mainPanel.add(refreshRatePanel);
			
			
			// Add a WindowListener that will close down the options window if it
			// is de-activtaed or loses focus
			addWindowListener(new WindowAdapter()  {
						public void windowLostFocus(WindowEvent we)  {
							setVisible(false);
						}
						public void windowDeactivated(WindowEvent we)  {
							if (!System.getProperty("os.name").startsWith("Mac")) setVisible(false);
						}
					});
			
			pack();
			
		}
		
	}
	
}