View Javadoc
   package  edu.psu.geovista.app.scatterplot;
   
   /***
    * Title: ScatterPlot
    * Description: construct a scatterplot
    * Copyright:    Copyright (c) 2001
    * Company: GeoVISTA Center
    * @author Xiping Dai
    * @version 1.0
   */
  import  java.lang.*;
  import  java.awt.*;
  import  java.awt.geom.*;
  import javax.swing.border.*;
  import  java.util.*;
  import  java.io.*;
  import  javax.swing.JPanel;
  import  javax.swing.BorderFactory;
  import  java.awt.event.*;
  import  javax.swing.JFrame;
  import  javax.swing.JLabel;
  import  javax.swing.JTextField;
  import  javax.swing.JButton;
  import  javax.swing.JPopupMenu;
  import  javax.swing.JMenuItem;
  import  javax.swing.JDialog;
  import  javax.swing.event.EventListenerList;
  import  java.awt.event.ActionEvent;
  import  java.awt.event.ActionListener;
  
  import edu.psu.geovista.symbolization.*;
  import edu.psu.geovista.classification.BoundaryClassifier;
  
  import edu.psu.geovista.app.matrix.MatrixElement;
  import edu.psu.geovista.ui.event.*;
  import edu.psu.geovista.ui.*;
  
  
  /***
   * put your documentation comment here
   */
  public class ScatterPlot extends JPanel
  		implements ComponentListener, MouseListener, MouseMotionListener, MatrixElement, Serializable, ExcentricLabelClient {
  
  	public static double AXISSPACEPORTION = 1.0/6.0;
  	public static final String COMMAND_POINT_SELECTED = "cmdSel";
  	public static final String COMMAND_DATARANGE_SET = "cmdset";
  	private static int RADIUS = 3; //Glyph size
  	transient private int pointSize = RADIUS;
  	transient private int plotOriginX;
  	transient private int plotOriginY;
  	transient private int plotEndX;
  	transient private int plotEndY;
  	transient private Object[] dataObject;
  	transient private double[][] doubleDataArrays;
  	transient private int[] dataIndices;
  	transient private double[] dataX;
  	transient private double[] dataY;
  	transient private int[] exsint;
  	transient private int[] whyint;
  	transient private String[] attributeArrays;
  	transient private String[] observNames;
  	transient private String attributeX;
  	transient private String attributeY;
  	transient private boolean axisOn;
  	transient private Dimension size;
  	transient private Color background;
  	transient private Color foreground;
  	transient private Color selectionColor = Color.blue;
  	private transient boolean selOriginalColorMode = true;
  	transient private Color[] multipleSelectionColors;
  	transient private Color[] colorArrayForObs;
  	transient private DataArray dataArrayX;
  	transient private DataArray dataArrayY;
  	transient private double[] xAxisExtents = new double[2];
  	transient private double[] yAxisExtents = new double[2];
  	//private MaxMinCoordinateValue MMexs;
  	//private MaxMinCoordinateValue MMwhy;
  	transient private int selectX = 0;
  	transient private int selectY = 0;
  	transient private int selectWidth = 0;
  	transient private int selectHeight = 0;
  	transient private BasicStroke strokeDashed;
  	transient private Vector selRecords = new Vector();//retiring
  	transient private int[] selections;
  	transient boolean pointSelected = false;
  	transient private int[] conditionArray;
  	transient private int mouseX1, mouseX2, mouseY1, mouseY2;
  	transient private JPopupMenu popup;
  	transient private JTextField xAxisMinField = new JTextField(16);
  	transient private JTextField xAxisMaxField = new JTextField(16);
  	transient private JTextField yAxisMinField = new JTextField(16);
  	transient private JTextField yAxisMaxField = new JTextField(16);
  	transient private EventListenerList listenerListAction = new EventListenerList();
  
      //stuff added for colors
      transient private Color[] pointColors;
      transient private BivariateColorSymbolClassification bivarColorClasser =
                                  new BivariateColorSymbolClassificationSimple();
 	transient private Histogram histogram = new Histogram();
 	transient private ExcentricLabels exLabels;
 	transient private BoundaryClassifier xClasser = null;
 	transient private BoundaryClassifier yClasser = null;
 	transient private double[] xBoundaries;
 	transient private double[] yBoundaries;
 	transient private int[] xBoundariesInt;
 	transient private int[] yBoundariesInt;
 	transient private Color[][] classColors;
 	transient int count = 0;
 
 	transient int firstBar;
 	transient int lastBar;
 	transient double yBarDistance;
 	transient double xBarDistance;
 
 	transient private ScatterPlot detailSP;
 	transient private JFrame dummyFrame;
 	transient private JDialog dlgSP;
     /***
      * put your documentation comment here
      */
 	public ScatterPlot () {
 		super();
 		//this.setBorder(BorderFactory.createRaisedBevelBorder());
 		this.setPreferredSize(new Dimension(300,300));
         //...where the GUI is constructed:
         //Create the popup menu.
 		popup = new JPopupMenu();
 		JMenuItem menuItem = new JMenuItem("Set Range");
         //  menuItem.addActionListener(this);
 		popup.add(menuItem);
 		menuItem.addActionListener(new ActionListener() {
 
             /***
              * put your documentation comment here
              * @param e
              */
 			public void actionPerformed (ActionEvent e) {
 				showDialog(400, 400);
 			}
 		});
 		menuItem = new JMenuItem("Edit");
         //  menuItem.addActionListener(this);
 		popup.add(menuItem);
 		this.addComponentListener(this);
 		addMouseListener(this);
 		addMouseMotionListener(this);
 	}
 
     /***
      * put your documentation comment here
      * @param 	String attributeX
      * @param 	String attributeY
      * @param 	double[] dataX
      * @param 	double[] dataY
      * @param 	boolean axisOn
      */
 	public ScatterPlot (Object[] dataObject, int[] dataIndices, boolean axisOn, Color c) {
 		//System.out.println("go into scatterplot...");
 		//this.doubleDataArrays = doubleDataArrays;
 		//this.attributeArrays = (String[])attributeArrays.clone();
 		this.dataObject = dataObject;
 		this.attributeArrays = (String[])dataObject[0];
 		int len = attributeArrays.length;
 		if (dataObject[len + 1] == null) {
 			this.observNames = null;
 		}
 		else {
 			this.observNames = (String[])dataObject[len + 1];
 		}
 		this.dataIndices = (int[])dataIndices;
 		//convert Object array to double arrays.
 		AxisDataSetup ();
 		//initialize();
 		this.axisOn = axisOn;
 		this.background = c;
 		if (c == Color.black)
 			this.foreground = Color.white;
 		else
 			this.foreground = Color.black;
 		initialize();
 	}
 
 	/***
 	 * Set up data.
 	 * @param data
 	 */
 	public void setDataObject (Object[] data) {
 		if (data == null)
 			System.out.println("data null!");
 		this.dataObject = data;
 		this.attributeArrays = (String[])dataObject[0];
 		int len = attributeArrays.length;
 		if (dataObject[len + 1] == null) {
 			this.observNames = null;
 		}
 		else {
 			this.observNames = (String[])dataObject[len + 1];
 		}
 		this.initExcentricLabels();
 	}
 
 	/***
 	 * put your documentation comment here
 	 * @param doubleDataArrays
 	 */
 	public void setDoubleDataArrays (double[][] doubleDataArrays) {
 		this.doubleDataArrays = doubleDataArrays;
 	}
 
 	/***
 	 * Not used in dataObject version.
 	 * @param dataIndices
 	 */
 	public void setDataIndices (int[] dataIndices) {
 		this.dataIndices = (int[])dataIndices.clone();
 		this.dataX = doubleDataArrays[dataIndices[0]];
 		this.dataY = doubleDataArrays[dataIndices[1]];
 		this.attributeX = attributeArrays[dataIndices[0]];
 		this.attributeY = attributeArrays[dataIndices[1]];
 		initialize();
 	}
 
 	/***
 	 * Set up x and y axises in each element by setting the attributes displayed.
 	 * @param indices
 	 */
 	public void setElementPosition (int[] indices) {
 		this.dataIndices = (int[])indices;
 		AxisDataSetup ();
 		initialize();
 	}
 
 	private void AxisDataSetup () {
 		boolean[] dataBoolean;
 		int[] dataInt;
 		int len = 0;
 		if (dataObject[dataIndices[0]] instanceof double[]) {
 			this.dataX = (double[])(dataObject[dataIndices[0]]);
 			len = dataX.length;
 		}
 		else if (dataObject[dataIndices[0]] instanceof int[]) {
 			dataInt = (int[])dataObject[dataIndices[0]];
 			len = dataInt.length;
 			dataX = new double[len];
 			for (int i = 0; i < len; i++) {
 				dataX[i] = (double)dataInt[i];
 			}
 		}
 		else if (dataObject[dataIndices[0]] instanceof boolean[]) {
 			dataBoolean = (boolean[])dataObject[dataIndices[0]];
 			len = dataBoolean.length;
 			dataX = new double[len];
 			for (int i = 0; i < len; i++) {
 				if (dataBoolean[i] == true) {
 					dataX[i] = 1;
 				}
 				else
 					dataX[i] = 0;
 			}
 		}
 		if (dataObject[dataIndices[1]] instanceof double[]) {
 			this.dataY = (double[])dataObject[dataIndices[1]];
 			len = this.dataY.length;
 		}
 		else if (dataObject[dataIndices[1]] instanceof int[]) {
 			dataInt = (int[])dataObject[dataIndices[1]];
 			len = dataInt.length;
 			dataY = new double[len];
 			for (int i = 0; i < len; i++) {
 				dataY[i] = (double)dataInt[i];
 			}
 		}
 		else if (dataObject[dataIndices[1]] instanceof boolean[]) {
 			dataBoolean = (boolean[])dataObject[dataIndices[1]];
 			len = dataBoolean.length;
 			dataY = new double[len];
 			for (int i = 0; i < len; i++) {
 				if (dataBoolean[i] == true) {
 					dataY[i] = 1;
 				}
 				else
 					dataY[i] = 0;
 			}
 		}
 		this.attributeX = attributeArrays[dataIndices[0] - 1];        //Minus 1 because dataObject[0] is attribute names.
 		this.attributeY = attributeArrays[dataIndices[1] - 1];        //and real data begin from dataObject[1].
 		this.selections = new int[len];
 		this.exsint = new int[len];
 		this.whyint = new int[len];
 	}
 	/***
 	 * put your documentation comment here
 	 * @return
 	 */
 	public int[] getElementPosition () {
 		return  this.dataIndices;
 	}
 
 	/***
 	 * put your documentation comment here
 	 * @param attributeArrays
 	 */
 	public void setAttributeArrays (String[] attributeArrays) {
 		this.attributeArrays = attributeArrays;
 	}
 
     /***
      * put your documentation comment here
      * @param dataX
      */
 	public void setX (double[] dataX) {
 		this.dataX = dataX;
 	}
 
     /***
      * put your documentation comment here
      * @param dataY
      */
 	public void setY (double[] dataY) {
 		this.dataY = dataY;
 	}
 
     //  public void setCoordinate (double[][] coordinate){
     //    this.dataX = coordinate[0][];
     //   this.dataY = coordinate[1][];
     //  }
 	public void setAxisOn (boolean axisOn) {
 		this.axisOn = axisOn;
 	}
 
     /***
      * Minimum and maximum values for xAxis. xAxisExtents[0] = min, xAxisExtents[1] = max.
      * @param xAxisExtents
      */
 	public void setXAxisExtents (double[] xAxisExtents) {
 	    //System.out.println("set up axis ..." + xAxisExtents[0]);
 		this.xAxisExtents = (double[])xAxisExtents.clone();
 		//System.out.println("set up axis ..." + xAxisExtents[0]);
 		this.setupDataforDisplay();
 		repaint();
 	}
 
 	/***
 	 * put your documentation comment here
 	 * @param yAxisExtents
 	 */
 	public void setYAxisExtents (double[] yAxisExtents) {
 		//System.out.println("set up axis ...");
 		this.yAxisExtents = (double[])yAxisExtents.clone();
 		this.setupDataforDisplay();
 		repaint();
 	}
 
 	/***
 	 * put your documentation comment here
 	 * @return
 	 */
 	public double[] getXAxisExtents () {
 		return  this.xAxisExtents;
 	}
 
 	/***
 	 * put your documentation comment here
 	 * @return
 	 */
 	public double[] getYAxisExtents () {
 		return  this.yAxisExtents;
 	}
 
 	/***
 	 * put your documentation comment here
 	 * @param conditionArray
 	 */
 	public void setConditionArray (int[] conditionArray) {
 		this.conditionArray = conditionArray;
 	}
 
 	public void setColorArrayForObs(Color[] colorArray){
 		this.colorArrayForObs = colorArray;
 	}
 
     /***
      * put your documentation comment here
      * @param c
      */
 	public void setBackground (Color c) {
 		if (c == null)
 			return;
 		this.background = c;
 		int colorTotal = c.getRed() + c.getGreen() + c.getBlue();
 		int greyColor = 128 * 3;
 		if (colorTotal < greyColor)
 			this.foreground = Color.white;
 		else
 			this.foreground = Color.black;
 		this.repaint();
 	}
 
 	public void setSelectionColor (Color c){
 	    this.selectionColor = c;
 		this.repaint();
 	}
 
 	public Color getSelectionColor (){
 		return this.selectionColor;
 	}
 
 	public boolean getSelOriginalColorMode() {
 		return selOriginalColorMode;
 	}
 
 	public void setSelOriginalColorMode(boolean selOriginalColorMode) {
 		this.selOriginalColorMode = selOriginalColorMode;
 		repaint();
 	}
 
 	public void setPointSelected(boolean pointselected){
 		this.pointSelected = pointSelected;
 	}
 
 	public void setMultipleSelectionColors (Color[] c){
 		this.multipleSelectionColors = c;
 	}
 
 	public Color[] getColors(){
 		return this.pointColors;
 	}
 
 	/***
 	 * Return itself.
 	 * @return
 	 */
 	public MatrixElement getThis () {
 		return  this;
 	}
 
 	public String getShortDiscription(){
 	    return "XYP";
 	}
     /***
      * Set up data and axis for drawing the scatter plot.
      */
 	private void initialize () {
 		this.setBackground(background);
 		this.dataArrayX = new DataArray(dataX);
 		this.dataArrayY = new DataArray(dataY);
 		this.conditionArray = new int[dataX.length];
 		this.setBorder(BorderFactory.createLineBorder(Color.gray));
 		if (axisOn) {
 			xAxisExtents = (double[])this.dataArrayX.getMaxMinCoorValue().clone();
 			yAxisExtents = (double[])this.dataArrayY.getMaxMinCoorValue().clone();
 		}
 		else {
 			xAxisExtents[0] = dataArrayX.getExtent()[0];
 			xAxisExtents[1] = dataArrayX.getExtent()[1];
 			yAxisExtents[0] = dataArrayY.getExtent()[0];
 			yAxisExtents[1] = dataArrayY.getExtent()[1];
 		}
 
 		size = this.getSize();
         //added for colors
         this.makeColors();
 		this.setupDataforDisplay();
 	}
 
     /***
      * Set the size of plot area for both axis on and axis off situations.
      * @param axisOn
      */
 	private void setVisibleAxis (boolean axisOn) {
           if(this.dataArrayX == null){
             return;
           }
 		if (axisOn) {
 			plotOriginX = (int)(this.getWidth()*AXISSPACEPORTION);
 			plotOriginY = (int)(this.getHeight()*(1 - AXISSPACEPORTION));
 			plotEndX = (int)(this.getSize().getWidth()) - (int)(this.getSize().getWidth()*AXISSPACEPORTION/2);
 			plotEndY = (int)(this.getSize().getHeight()/12);
             //System.out.println("size width: " + this.getSize().getWidth());
             //System.out.println("plot Origin X: " + plotOriginX);
 		}
 		else {
 			plotOriginX = 3;
 			plotOriginY = (int)(this.getSize().getHeight() - 3);
 			plotEndX = (int)(this.getSize().getWidth()) - 3;
 			plotEndY = 3;
 		}
 
 		//set the location of bars and Strings.
 		//firstBar = (int)(yAxisExtents[0]/(this.dataArrayY.getMajorTick()));
 		//lastBar = (int)(yAxisExtents[1]/(this.dataArrayY.getMajorTick()));
 		//double yBarNumber = (yAxisExtents[1] - yAxisExtents[0])/(this.dataArrayY.getMajorTick());
 		//yBarDistance = ((plotOriginY - plotEndY)/yBarNumber);
 		//double xBarNumber = (xAxisExtents[1] - xAxisExtents[0])/(this.dataArrayX.getMajorTick());
 		//xBarDistance = ((plotEndX - plotOriginX)/xBarNumber);
 	}
 
     /***
      * Draw the scatter plot.
      * @param g
      */
 	public void paintComponent (Graphics g) {
 		//System.out.println("paint track..." + count ++);
         // draw a black border and a white background
 		if (this.dataIndices == null)
 			return;
 		g.setColor(background);
 		g.fillRect(0, 0, getSize().width, getSize().height);
 		g.setColor(foreground);
 		this.paintBorder(g);
 		//size = this.getSize();
 		//setVisibleAxis(axisOn);
         //   if(DefaultBackground == null) DefaultBackground = this.getBackground();
 		if (axisOn) {
 			drawAxis(g);
 		}
 		drawPlot(g);
 		Graphics2D g2 = (Graphics2D)g;
 		if (exLabels != null && this.axisOn == true) {
 			this.setToolTipText("");
 			exLabels.paint(g2, getBounds());
 		}
 
 	}
 
     /***
      * Draw pot (points) on the screen.
      * @param g
      */
 	private void drawPlot (Graphics g) {
 		int plotWidth, plotHeight;
 		plotWidth = (int)this.getWidth();
 		plotHeight = (int)this.getHeight();
 		int size;
 		size = (plotWidth < plotHeight) ? plotWidth : plotHeight;
 		this.pointSize = (size < 360) ? size/36 : 10;
 		this.pointSize = (this.pointSize < 3) ? 4 : this.pointSize+1;
         //System.out.println("attribute equal? " + attributeX.equals(attributeY));
 		if (this.dataIndices[0] == this.dataIndices[1]) {
 			//draw histogram.
 		    histogram.setAxisOn(false);
 			histogram.setVariableName(this.attributeX);
 			histogram.setData(this.dataX);
 			histogram.setXAxisExtents(this.xAxisExtents);
 			histogram.setBackground(background);
 			histogram.setSize(this.getWidth(),this.getHeight());
 			//histogram.setSelection(this.selRecords);
 			histogram.setSelections(this.selections);
 			histogram.paintComponent(g);
 			Graphics2D g2 = (Graphics2D)g;
             Color half = new Color(255,255,255,100);
             g2.setColor(half);
 			g.fillRect(0, 0, getSize().width, getSize().height);
 			g2.setColor(foreground);
 			Font font = new Font("", Font.PLAIN, (int)size/8);
 			g.setFont(font);
 			/*if (attributeX.length()>12){
 			    g.drawString(attributeX, 2, plotHeight/2);
 			}else if (attributeX.length()<=7){
 			    g.drawString(attributeX, plotWidth/4, plotHeight/2);
 			}else {
 			    g.drawString(attributeX, plotWidth/8, plotHeight/2);
 			}*/
             //font.this.getSize() = (int)plotWidth/12;
 			Font font1 = new Font("", Font.PLAIN, (int)size/12);
 			g.setFont(font1);
 			g.drawLine(0, 0, 5, 5);
 			String maxString = Float.toString((float)(xAxisExtents[1]));
 			g.drawString(maxString, 6, (int)(plotHeight*AXISSPACEPORTION/2) + 2);
 			g.drawLine(0, plotHeight, 5, plotHeight - 5);
 			String minString = Float.toString((float)(xAxisExtents[0]));
 			g.drawString(minString, 6, plotHeight - 5);
 			g.drawLine(plotWidth, plotHeight, plotWidth - 5, plotHeight - 5);
 			g.drawString(maxString, plotWidth - (int)(plotWidth*AXISSPACEPORTION + 5),
 					plotHeight - 5);
 
 		}
 		else {
 			int len = dataArrayX.length();
 
             // draw the points
 			if (this.colorArrayForObs != null){ //draw the points with colors getting from setColorArray event.
 				this.drawSlections(g, this.colorArrayForObs, len);
 
 		    }else{ //Draw points with colors coming from bivariate color scheme.
 				//Tried to draw background in colors, not working yet.
 //				if (this.xClasser != null){
 //					//System.out.println("classer is not null");
 //					for(int i = 0; i < this.classColors.length; i ++){
 //						for(int j = 0; j < this.classColors[0].length; j ++){
 //							g.setColor(this.classColors[i][j]);
 //							g.drawRect(this.xBoundariesInt[i], this.yBoundariesInt[j],
 //									   this.xBoundariesInt[i+1]-this.xBoundariesInt[i], this.yBoundariesInt[j+1]-this.yBoundariesInt[j]);
 //						}
 //					}
 //				}
 				this.drawSlections(g, this.pointColors, len);
 			}
 
 			Rectangle rec = new Rectangle(selectX, selectY, selectWidth, selectHeight);
 			Graphics2D g2d = (Graphics2D)g;
 			this.drawSelectRectangle(g2d, rec);
 			if (this.multipleSelectionColors != null){
 				for (int i = 0; i < this.dataX.length; i++) {
 					if (this.multipleSelectionColors[i] != null){
 						g.setColor(multipleSelectionColors[i]);
 						g.drawOval(exsint[i] - 1, whyint[i] - 1, pointSize, pointSize);
 						g.fillOval(exsint[i] - 1, whyint[i] -1 , pointSize, pointSize);
 					}
 				}
 		    }
 		}
 	}
 
 	private void drawSlections(Graphics g, Color[] colorNonSelected, int len){
 		if (this.pointSelected == false){ //only draw original points.
 			for (int i = 0; i < len; i++) {
 				if ((exsint[i] <= this.plotEndX) && (exsint[i] >= plotOriginX) && (whyint[i] <= plotOriginY)
 					&& (whyint[i] >= plotEndY) && (conditionArray[i] > -1)){
 
 					g.setColor(colorNonSelected[i]);
 						//g.drawOval(exsint[i] - 1, whyint[i] - 1, pointSize, pointSize);
 					g.fillOval(exsint[i] - 2, whyint[i] - 2, pointSize, pointSize);
 				}
 			}
 		}else{  //draw original points and selected points.
 			//according to the color mode, draw selected points and non-selected points.
 			if (this.selOriginalColorMode == false){
 				for (int i = 0; i < len; i++) {
 					if ((exsint[i] <= this.plotEndX) && (exsint[i] >= plotOriginX) && (whyint[i] <= plotOriginY)
 						&& (whyint[i] >= plotEndY) && (conditionArray[i] > -1)){
 
 						g.setColor(colorNonSelected[i]);
 							//g.drawOval(exsint[i] - 1, whyint[i] - 1, pointSize, pointSize);
 						g.fillOval(exsint[i] - 2, whyint[i] - 2, pointSize, pointSize);
 					}
 				}
 				for (int i = 0; i < len; i++) {
 					g.setColor(this.selectionColor);
 					if ((exsint[i] <= this.plotEndX) && (exsint[i] >= plotOriginX) && (whyint[i] <= plotOriginY)
 						&& (whyint[i] >= plotEndY) && (conditionArray[i] > -1)){
 
 						if (this.selections[i] == 1){
 							//g.drawOval(exsint[i] - 1, whyint[i] - 1, pointSize, pointSize);
 							g.fillOval(exsint[i] - 2, whyint[i] - 2, pointSize, pointSize);
 						}
 					}
 				}
 			}else{
 				for (int i = 0; i < len; i++) {
 					if ((exsint[i] <= this.plotEndX) && (exsint[i] >= plotOriginX) && (whyint[i] <= plotOriginY)
 							&& (whyint[i] >= plotEndY) && (conditionArray[i] > -1)){
 
 						g.setColor(colorNonSelected[i]);
 						g.drawOval(exsint[i] - 2, whyint[i] - 2, pointSize-2, pointSize-2);
 					}
 				}
 				for (int i = 0; i < len; i++) {
 					if ((exsint[i] <= this.plotEndX) && (exsint[i] >= plotOriginX) && (whyint[i] <= plotOriginY)
 							&& (whyint[i] >= plotEndY) && (conditionArray[i] > -1)){
 						g.setColor(colorNonSelected[i]);
 						if (this.selections[i] == 1){
 								//g2.drawOval(exsint[i] - 1, whyint[i] - 1, pointSize, pointSize);
 								g.fillOval(exsint[i] - 2, whyint[i] - 2, pointSize, pointSize);
 								//g2.fillRect(exsint[i] - 1, whyint[i] - 1, pointSize, pointSize);
 								//g.drawOval(exsint[i] - 1, whyint[i] - 1, pointSize+1, pointSize+1);
 						}
 					}
 				}
 			}
 		}
 	}
     /***
      * Draw axises for scatterplot.
      * @param g
      */
 	private void drawAxis (Graphics g) {
 		int plotWidth, plotHeight;
 		plotWidth = (int)this.getWidth();
 		plotHeight = (int)this.getHeight();
         //System.out.println(plotHeight);
 		if (this.dataIndices[0] == this.dataIndices[1]) {
 			/*Font font;
 			if (plotWidth < plotHeight){
 			    font = new Font("", Font.PLAIN, (int)plotWidth/10);
 			}else{
 			    font = new Font("", Font.PLAIN, (int)plotHeight/10);
 			}
 			g.setFont(font);
 			g.drawString(attributeX, plotWidth/3, plotHeight/2);*/
 		}
 		else {
             //System.out.println(plotOriginX);
             // draw the lines
 			g.setColor(foreground);
 			g.drawLine(plotOriginX, plotEndY, plotOriginX, plotOriginY);
 			g.drawLine(plotOriginX, plotOriginY, plotEndX, plotOriginY);
             // draw tick bars for scales on Y coordinate
 			int fontSize;
 			fontSize = (plotWidth < plotHeight) ? plotWidth : plotHeight;
 	    	fontSize = ((int)(fontSize/32) < 9) ? 9 : fontSize/32;
 			/*if (plotWidth < plotHeight){
 				if (plotWidth < 300){
 			        fontSize = 9;
 			    } else {
 			        fontSize = (int)(plotWidth/32);
 			    }
 			}else {
 				if (plotHeight < 300){
 			        fontSize = 9;
 			    } else {
 			        fontSize = (int)(plotHeight/32);
 			    }
 			}*/
 			Font font = new Font("", Font.PLAIN, fontSize);
 			g.setFont(font);
 			String scaleStringY;
 			int i;
 			int realBarNum = 0;
 			double barNumber = this.dataArrayY.getTickNumber();
 			int firstBar = (int)(yAxisExtents[0]/(this.dataArrayY.getMajorTick()));
 			int lastBar = (int)(yAxisExtents[1]/(this.dataArrayY.getMajorTick()));
 			//double barNumber = (yAxisExtents[1] - yAxisExtents[0])/(this.dataArrayY.getMajorTick());
 			double yBarDistance = ((plotOriginY - plotEndY)/barNumber);
 			for (i = firstBar; i <= lastBar + 0.00001; i++) {
 			//for (i = 0; i <= barNumber; i++) {
 				g.drawLine(plotOriginX - 3, plotEndY + (int)(realBarNum*yBarDistance), plotOriginX,
 						plotEndY + (int)(realBarNum*yBarDistance));
 				if (Math.abs(this.dataArrayY.getMajorTick()) <= 1) {
 					scaleStringY = Float.toString((float)(yAxisExtents[1] - realBarNum*this.dataArrayY.getMajorTick()));
 				}
 				else {
 					scaleStringY = Integer.toString((int)(yAxisExtents[1] - realBarNum*this.dataArrayY.getMajorTick()));
 				}
 				g.drawString(scaleStringY, plotOriginX - (int)(plotWidth*AXISSPACEPORTION/2),
 						plotEndY + (int)(realBarNum*yBarDistance + yBarDistance*1/6));
 
 				//draw background grid
 				g.setColor(Color.lightGray);
 				g.drawLine(plotOriginX, plotEndY + (int)(realBarNum*yBarDistance), plotEndX,
 						plotEndY + (int)(realBarNum*yBarDistance));
 				g.setColor(this.foreground);
 				realBarNum ++;
 			}
             // draw tick bars for scales on X coordinate
 			realBarNum = 0;
 			barNumber = this.dataArrayX.getTickNumber();
 			//barNumber = (xAxisExtents[1] - xAxisExtents[0])/(this.dataArrayX.getMajorTick());
 			double xBarDistance = ((plotEndX - plotOriginX)/barNumber);
 			String scaleStringX;
 			for (i = (int)(xAxisExtents[0]/(this.dataArrayX.getMajorTick())); i <= (int)(xAxisExtents[1]/(this.dataArrayX.getMajorTick())) + 0.0001; i++) {
 			//for (i = 0; i <= barNumber; i++) {
 				g.drawLine(plotOriginX + (int)(realBarNum*xBarDistance), plotOriginY, plotOriginX
 						+ (int)(realBarNum*xBarDistance), plotOriginY + 3);
 				if (Math.abs(this.dataArrayX.getMajorTick()) <= 1) {
 					scaleStringX = Float.toString((float)(xAxisExtents[0] + realBarNum*this.dataArrayX.getMajorTick()));
 				}
 				else {
 					scaleStringX = Integer.toString((int)(xAxisExtents[0] + realBarNum*this.dataArrayX.getMajorTick()));
 				}
 				Graphics2D g2d = (Graphics2D)g;
 				g2d.rotate(-Math.PI/2, plotOriginX - 2 + (int)(realBarNum*xBarDistance), plotOriginY
 						+ plotHeight*AXISSPACEPORTION*2/3);
 				g.drawString(scaleStringX, plotOriginX - 2 + (int)(realBarNum*xBarDistance),
 						plotOriginY + (int)(plotHeight*AXISSPACEPORTION*2/3 - 1));
 				g2d.rotate(Math.PI/2, plotOriginX - 2 + (int)(realBarNum*xBarDistance), plotOriginY
 						+ plotHeight*AXISSPACEPORTION*2/3);
 				//graw background grid
 				g.setColor(Color.lightGray);
 				g.drawLine(plotOriginX + (int)(realBarNum*xBarDistance), plotOriginY, plotOriginX
 						+ (int)(realBarNum*xBarDistance), plotEndY);
 				g.setColor(this.foreground);
 				realBarNum ++;
 			}
 			font = new Font("", Font.PLAIN, fontSize + 3);
 			g.setFont(font);
             //draw X axis attribute string
 			g.drawString(attributeX, plotOriginX + (plotEndX - plotOriginX)/2 - plotWidth/12,
 					plotOriginY + plotHeight/6 - 5);
             //draw Y axis attribute string. Need rotation for drawing the string vertically.
 			Graphics2D g2d = (Graphics2D)g;
 			g2d.rotate(-Math.PI/2, plotOriginX - plotWidth/9, plotOriginY - (plotOriginY
 					- plotEndY)/3);
 			g2d.drawString(attributeY, plotOriginX - plotWidth/9, plotOriginY - (plotOriginY
 					- plotEndY)/3);
 			g2d.rotate(+Math.PI/2, plotOriginX - plotWidth/9, plotOriginY - (plotOriginY
 					- plotEndY)/3);
 		}
 	}
 
     /***
      * Return selections from this scatterplot.
      * @return
      */
 	public Vector getSelectedObservations () {
 		return  selRecords;
 	}
 
     /***
      * Set up selections from other components.
      * @param selectedObservations
      */
 	public void setSelectedObservations (Vector selectedObservations) {
 		selRecords = selectedObservations;
 	}
 
 	public void setSelections (int[] selectedObservations) {
 		System.out.println("in SP setSelections");
 		if (selections == null || selectedObservations == null){
 			return;
 		}
 		if (selections.length != selectedObservations.length){
 			for (int i = 0; i < selections.length; i++){
                     selections[i] = 0;
             }
             for (int i = 0; i < selectedObservations.length; i++){
                    selections[selectedObservations[i]] = -1;
             }
         } else {
 			selections = selectedObservations;
         }
 		this.pointSelected = false;
 		for (int i = 0; i < selections.length; i++){
 			if (selections[i] ==1){
 				this.pointSelected = true;
 				return;
 			}
 		}
 	}
 
 	/***
 	 * Return selections from this scatterplot.
 	 * @return
 	 */
 	public int[] getSelections () {
 		return  this.selections;
 	}
 
         public void setIndication(int indication){
           //noop
         }
     /***
      * Calculate scale between real data and integer data for showing up on screen.
      * @param min
      * @param max
      * @param dataMin
      * @param dataMax
      * @return scale
      */
 	private double getScale (int min, int max, double dataMin, double dataMax) {
 		double scale;
 		scale = (max - min)/(dataMax - dataMin);
 		return  scale;
 	}
 
     /***
      * Convert the single value to integer value worked on screen.
      * @param data
      * @param scale
      * @param min
      * @param dataMin
      * @return valueScreen
      */
 	private int getValueScreen (double data, double scale, int min, double dataMin) {
 		int valueScreen;
 		if (Double.isNaN(data)) {
 			valueScreen = Integer.MIN_VALUE;
 		}
 		else {
 			valueScreen = (int)((data - dataMin)*scale + min);
 		}
 		return  valueScreen;
 	}
 
     /***
      * Convert the numeric values of observations to integer value worked on screen.
      * @param dataArray
      * @param scale
      * @param min
      * @param dataMin
      * @return valueScreen
      */
 	private int[] getValueScreen (double[] dataArray, double scale, int min, double dataMin) {
 		int[] valueScreen = new int[dataArray.length];
 		for (int i = 0; i < dataArray.length; i++) {
 			if (Double.isNaN(dataArray[i])) {
 				valueScreen[i] = Integer.MIN_VALUE;
 			}
 			else {
 				valueScreen[i] = (int)((dataArray[i] - dataMin)*scale + min);
 			}
 		}
 		return  valueScreen;
 	}
 
 	private void setupDataforDisplay(){
 		//System.out.println("In setup data for display ..." + xAxisExtents[0]);
 		    this.setVisibleAxis(axisOn);
 		    if (dataArrayX == null) return;
 			int len = dataArrayX.length();
 			if (len != dataArrayY.length())
 				return;
 			//exsint = new int[len];
 			//whyint = new int[len];
             //get positions on screen
 			double xScale;
 			double yScale;
 			xScale = getScale(plotOriginX, plotEndX, xAxisExtents[0], xAxisExtents[1]);
 			exsint = getValueScreen(dataX, xScale, plotOriginX, xAxisExtents[0]);
 			yScale = getScale(plotOriginY, plotEndY, yAxisExtents[0], yAxisExtents[1]);
 			whyint = getValueScreen(dataY, yScale, plotOriginY, yAxisExtents[0]);
 			//get class boundaries' positions on screen
 			if(this.xBoundaries != null && this.yBoundaries != null){
 				System.out.println("x and y boundaries are not null.");
 				this.xBoundariesInt = new int[this.xBoundaries.length];
 				this.yBoundariesInt = new int[this.yBoundaries.length];
 				this.xBoundariesInt = getValueScreen(this.xBoundaries, xScale, plotOriginX, xAxisExtents[0]);
 				this.yBoundariesInt = getValueScreen(this.yBoundaries, yScale, plotOriginY, yAxisExtents[0]);
 			}
 	}
 	//start excentric labeling stuff
 	private void initExcentricLabels(){
 	  this.exLabels = new ExcentricLabels();
 	  exLabels.setComponent(this);
 	  exLabels.setOpaque(true);
 	  Color halfWhite = new Color(255,255,255,123);
 	  exLabels.setBackgroundColor(halfWhite);
 	  this.addMouseListener(exLabels);
 
 	}
 	public String getObservationLabel(int i){
 	  String[] labels = this.observNames;
 	  String label = labels[i];
 	  return label;
 	}
 
 	public Shape getShapeAt(int i){
 	  int x = this.exsint[i];
 	  int y = this.whyint[i];
 	  Ellipse2D circle = new Ellipse2D.Float(x,y,this.pointSize,this.pointSize);
 
 	  return circle;
 	}
 	public int[] pickAll(Rectangle2D hitBox){
 		Vector hits = new Vector();
 		for (int i = 0; i < dataX.length; i++) {
 			if (hitBox.contains(exsint[i], whyint[i]) && (conditionArray[i] > -1)) {
 				Integer bigI = new Integer(i);
 				hits.add(bigI);
 			}
 		}
 		int[] intHits = new int[hits.size()];
 		for (int i = 0; i < hits.size(); i++){
 
 			intHits[i] = ((Integer)hits.get(i)).intValue();
 		}
 		return intHits;
 	}
 	  //end excentric labeling stuff
 
     public void componentHidden(ComponentEvent e) {
 
     }
 
     public void componentMoved(ComponentEvent e) {
 
     }
 
     public void componentResized(ComponentEvent e) {
 		//System.out.println("in component resized");
 		this.setupDataforDisplay();
 		this.repaint();
     }
 
     public void componentShown(ComponentEvent e) {
     }
 
 
     /***
      * Begin the drawing of selection region (box).
      * @param e
      */
 	public void mousePressed (MouseEvent e) {
 		if (dataIndices[0] == dataIndices[1])
 			return;
 		if (e.isPopupTrigger())
 			maybeShowPopup(e);
 		//selRecords.clear();
 		mouseX1 = e.getX();
 		mouseY1 = e.getY();
 	}
 
     /***
      * Work with mouseDragged to draw a selection region (box) for selection.
      * @param e
      */
 	public void mouseReleased (MouseEvent e) {
 		if (dataIndices[0] == dataIndices[1])
 			return;
 		if (e.isPopupTrigger())
 			maybeShowPopup(e);
 		mouseX2 = e.getX();
 		mouseY2 = e.getY();
 		if ((Math.abs(mouseX1-mouseX2) < 3) && (Math.abs(mouseY1-mouseY2) < 3)){
 			return;
 		}
 		//With shift pressed, it will continue to select.
 		if (!(e.isShiftDown())){
 		    //selRecords.clear();
 			//zero all selection indication to deselect them.
 			for (int i = 0; i < this.selections.length; i ++){
 				this.selections[i] = 0;
 			}
 		}
 		if (mouseX1 <= mouseX2 && mouseY1 <= mouseY2) {
 			selectX = mouseX1;
 			selectY = mouseY1;
 			selectWidth = mouseX2 - mouseX1;
 			selectHeight = mouseY2 - mouseY1;
 		}
 		if (mouseX2 < mouseX1 && mouseY1 <= mouseY2) {
 			selectX = mouseX2;
 			selectY = mouseY1;
 			selectWidth = mouseX1 - mouseX2;
 			selectHeight = mouseY2 - mouseY1;
 		}
 		if (mouseX1 <= mouseX2 && mouseY2 < mouseY1) {
 			selectX = mouseX1;
 			selectY = mouseY2;
 			selectWidth = mouseX2 - mouseX1;
 			selectHeight = mouseY1 - mouseY2;
 		}
 		if (mouseX2 < mouseX1 && mouseY2 < mouseY1) {
 			selectX = mouseX2;
 			selectY = mouseY2;
 			selectWidth = mouseX1 - mouseX2;
 			selectHeight = mouseY1 - mouseY2;
 		}
 		Rectangle rec = new Rectangle(selectX, selectY, selectWidth, selectHeight);
 		pointSelected = false;
 		int j = 0;
 		for (int i = 0; i < dataX.length; i++) {
 			if (rec.contains(exsint[i], whyint[i]) && (conditionArray[i] > -1)) {
 				Integer bigI = new Integer(i);
 				//selRecords.add(bigI);
 				this.selections[i] = 1;//new selection struction int[]
 				pointSelected = true;
 				j++;
 			}
 		}
 		selectWidth = 0;
 		selectHeight = 0;
 		//selRecords.trimToSize();
 		this.multipleSelectionColors = null;
 		//this.drawSelectRectangle(rec);
 		repaint();
         //System.out.println("about to fire mouse released");
 		fireActionPerformed(COMMAND_POINT_SELECTED);
 	}
 
     /***
      * put your documentation comment here
      * @param e
      */
 	public void mouseExited (MouseEvent e) {
     //System.out.println("mouse exited: ");
 	}
 
     /***
      * Work with mouseReleased to draw a selection region (box) for selection.
      * @param e
      */
 	public void mouseDragged (MouseEvent e) {
 		if (dataIndices[0] == dataIndices[1])
 			return;
 		//if (e.isPopupTrigger())
 		//	maybeShowPopup(e);
 		mouseX2 = e.getX();
 		mouseY2 = e.getY();
 		if ((Math.abs(mouseX1-mouseX2) < 3) && (Math.abs(mouseY1-mouseY2) < 3)){
 			return;
 		}
         //System.out.println("mouse released: " + "mouseX2" + mouseX2 + "mouseY2" + mouseY2);
 		if (mouseX1 <= mouseX2 && mouseY1 <= mouseY2) {
 			selectX = mouseX1;
 			selectY = mouseY1;
 			selectWidth = mouseX2 - mouseX1;
 			selectHeight = mouseY2 - mouseY1;
 		}
 		if (mouseX2 < mouseX1 && mouseY1 <= mouseY2) {
 			selectX = mouseX2;
 			selectY = mouseY1;
 			selectWidth = mouseX1 - mouseX2;
 			selectHeight = mouseY2 - mouseY1;
 		}
 		if (mouseX1 <= mouseX2 && mouseY2 < mouseY1) {
 			selectX = mouseX1;
 			selectY = mouseY2;
 			selectWidth = mouseX2 - mouseX1;
 			selectHeight = mouseY1 - mouseY2;
 		}
 		if (mouseX2 < mouseX1 && mouseY2 < mouseY1) {
 			selectX = mouseX2;
 			selectY = mouseY2;
 			selectWidth = mouseX1 - mouseX2;
 			selectHeight = mouseY1 - mouseY2;
 		}
 		Rectangle rec = new Rectangle(selectX, selectY, selectWidth, selectHeight);
 		//this.drawSelectRectangle(rec);
 		repaint();
 	}
 
 	/***
 	 * Mouse over, it will show the values for current point by tool tip.
 	 * @param e
 	 */
 	public void mouseMoved (MouseEvent e) {
             if (e != null&&this.axisOn==false){
 			    this.makeToolTip(e.getX(),e.getY());
 		        e.consume();
 			}
 	}
 
     /***
      * put your documentation comment here
      * @param e
      */
 	public void mouseEntered (MouseEvent e) {
 	}
 
     /***
      * Mouse click for selecting or brushing points (observations).
      * @param e
      */
 	public void mouseClicked (MouseEvent e) {
         //System.out.println("mouse clicked: ");
 		int count = e.getClickCount();
         //moduleBody.selected(true);
 		int[] mousePos = new int[2];
 		mousePos[0] = e.getX();
 		mousePos[1] = e.getY();
         //single click, select performed.
 		Integer bigI;
 		if (count == 1) {
 			boolean pointSelected = false;
 			if (dataIndices[0] != dataIndices[1]) {
 				for (int i = 0; i < dataX.length; i++) {
 					if ((exsint[i] - 5 < mousePos[0]) && (mousePos[0] < exsint[i] + 5) &&
 							(whyint[i] - 5 < mousePos[1]) && (mousePos[1] < whyint[i] + 5) && (conditionArray[i] > -1)) {
 						bigI = new Integer(i);
 						//selRecords.add(bigI);
 						this.selections[i] = 1;
 						pointSelected = true;
 					}
 				}
 				//while (e.isShiftDown());
 				fireActionPerformed(COMMAND_POINT_SELECTED);
 			}
 		}
         //double click, pop up a detail scatter plot.
 		if (count == 2)                // This is a double-click or triple...
 		{
 			if (dataIndices[0] != dataIndices[1]) {
 				//ScatterPlot detailSP = new ScatterPlot(dataObject,
 				//		dataIndices, true, background);
                 //JFrame f = new JFrame("Detailed Scatter Plot");
 				//if (detailSP == null){
 					ScatterPlot detailSP = new ScatterPlot();
 					detailSP.setDataObject(dataObject);
 					detailSP.setAxisOn(true);
 					detailSP.setElementPosition(dataIndices);
 					dummyFrame = new JFrame("Detailed Scatter Plot");
 					dlgSP = new JDialog(dummyFrame, "Detailed Scatter Plot", true);
 					dlgSP.setLocation(300, 300);
 					dlgSP.setSize(300, 300);
 					dlgSP.getContentPane().setLayout(new BorderLayout());
 					dlgSP.getContentPane().add(detailSP, BorderLayout.CENTER);
 				//}
 
 				detailSP.setBackground(background);
 				detailSP.setBivarColorClasser(this.bivarColorClasser, false);
 				detailSP.setColorArrayForObs(this.colorArrayForObs);
 				//detailSP.setSelectedObservations(selRecords);
 				detailSP.setSelectionColor(this.selectionColor);
 				detailSP.setSelOriginalColorMode(this.selOriginalColorMode);
 				detailSP.setSelections(this.selections);
 				detailSP.setXAxisExtents(this.xAxisExtents);//?
 				detailSP.setYAxisExtents(this.yAxisExtents);
 
 
 //				dummyFrame.setLocation(300, 300);
 //				dummyFrame.setSize(300, 300);
 //				dummyFrame.getContentPane().setLayout(new BorderLayout());
 //				dummyFrame.getContentPane().add(detailSP, BorderLayout.CENTER);
 				detailSP.addActionListener(new ActionListener() {
 
 					/***
 					 * put your documentation comment here
 					 * @param e
 					 */
 					public void actionPerformed (ActionEvent e) {
 						//System.out.println("something came from detailed one.");
 						ScatterPlot detailSP = (ScatterPlot)e.getSource();
 						String command = e.getActionCommand();
 						if (command.compareTo(ScatterPlot.COMMAND_POINT_SELECTED) == 0) {
 							//System.out.println("SPMC.plotUnitPanel.actionPerformed(), point selected");
 							//Vector selRecords = detailSP.getSelectedObservations();
 							int[] selections = detailSP.getSelections();
                             // Don't recall the scatterplot which generated the original event
 							//ScatterPlot.this.setSelectedObservations(selRecords);
 							ScatterPlot.this.setSelections(selections);
 							ScatterPlot.this.fireActionPerformed(COMMAND_POINT_SELECTED);
 						}
 						else if(command.compareTo(ScatterPlot.COMMAND_DATARANGE_SET)==0){
 							double[] dataArrayX = detailSP.getXAxisExtents();
 							double[] dataArrayY = detailSP.getYAxisExtents();
 							ScatterPlot.this.setXAxisExtents(dataArrayX);
 							ScatterPlot.this.setYAxisExtents(dataArrayY);
 							fireActionPerformed(COMMAND_DATARANGE_SET);
 						}
 							//System.err.println("Unknown command! = " + command);
 					}
 				});
 				dlgSP.show();
 			} else {
 				Histogram histogram = new Histogram();
 				histogram.setVariableName(this.attributeX);
 				histogram.setData(this.dataX);
 				//histogram.setSelections(this.selections);
 				histogram.setBackground(background);
 				JFrame dummyFrame = new JFrame();
 				JDialog dlgSP = new JDialog(dummyFrame, "Histogram", true);
 				dlgSP.setLocation(300, 300);
 				dlgSP.setSize(300, 300);
 				dlgSP.getContentPane().setLayout(new BorderLayout());
 				dlgSP.getContentPane().add(histogram, BorderLayout.CENTER);
 				histogram.addActionListener(new ActionListener() {
 
 					/***
 					 * put your documentation comment here
 					 * @param e
 					 */
 					public void actionPerformed (ActionEvent e) {
 						Histogram histogram = (Histogram)e.getSource();
 						//Vector selRecords = histogram.getSelection();
 						int[] selection = histogram.getSelections();
 						//ScatterPlot.this.setSelectedObservations(selRecords);
 						ScatterPlot.this.setSelections(selection);
 						ScatterPlot.this.fireActionPerformed(COMMAND_POINT_SELECTED);
 					}
 				});
 				dlgSP.show();
 			}
 		}
 	}
 
 	private void drawSelectRectangle(Graphics2D g2d, Rectangle rec) {
 
 		Stroke tempStroke = g2d.getStroke();
 		float[] dash = new float[3];
 		dash[0] = (float)5.0;
 		dash[1] = (float)7.0;
 		dash[2] = (float)5.0;
 		BasicStroke dashStroke = new BasicStroke((float)1.0, BasicStroke.CAP_SQUARE,
 				BasicStroke.JOIN_MITER, (float)10.0, dash, 0);
 		g2d.setStroke(dashStroke);
 		g2d.setPaintMode();
 		g2d.setColor(foreground);
 		g2d.drawRect(selectX, selectY, selectWidth, selectHeight);
 		// Draw selected observations.
 		//if (!selRecords.isEmpty()) {
 			//g2d.setXORMode(background);
 			g2d.drawRect(selectX, selectY, selectWidth, selectHeight);
 			g2d.setStroke(tempStroke);
 			//g2d.setColor(selectionColor);
 			//int i = 0;
 			//for (Enumeration selEnum = selRecords.elements(); selEnum.hasMoreElements();) {
 			//	i = ((Integer)selEnum.nextElement()).intValue();
 			//	if ((exsint[i] != Integer.MIN_VALUE) && (whyint[i] != Integer.MIN_VALUE)
 			//			&& (conditionArray[i] > -1)) {
 					//g.drawOval(exsint[i] - 1, whyint[i] - 1, pointSize, pointSize);
 					//g.fillOval(exsint[i] - 1, whyint[i] -1 , pointSize, pointSize);
 			//    }
 			//}
 			//g.setColor(foreground);
 		//}
 
 /*		if (g == null) {
 			return;
 		}
 		BasicStroke strokeSave = (BasicStroke) g.getStroke();
 
 		float[] dash = new float[3];
 		dash[0] = (float)5.0;
 		dash[1] = (float)7.0;
 		dash[2] = (float)5.0;
 		if (strokeDashed == null) {
 			// We only need to create this once.	We can't do it in our initialize(), since
 			// we don't have a Graphics2D yet
 			strokeDashed = new BasicStroke(
 												strokeSave.getLineWidth(),
 												strokeSave.getEndCap(),
 												strokeSave.getLineJoin(),
 												strokeSave.getMiterLimit(),
 												dash, 0);
 		}
 
 		// Now, set our stroke to a dashed line
 		g.setStroke(strokeDashed);
 
 		g.setColor(this.foreground);
 		g.setXORMode(this.background);
 
 		// Actually draw the rectangle
 		g.drawRect(rec.x, rec.y, rec.width, rec.height);
 
 		// Restore our original stroke
 		g.setStroke(strokeSave);*/
 	}
 
 	private void makeToolTip(int x, int y) {
 		    int arrayIndex = -1;
 		    //boolean pointMove = false;
 			if (dataIndices == null){
 				return;
 			}
 			if (exsint == null){
 				return;
 			}
 			if ((dataIndices[0] != dataIndices[1])&&(exsint != null) && (whyint != null)) {
 				for (int i = 0; i < dataX.length; i++) {
 					if ((exsint[i] - 3 < x) && (x < exsint[i] + 3) &&
 							(whyint[i] - 3 < y) && (y < whyint[i] + 3) && (conditionArray[i] > -1)) {
 						//pointMove = true;
 						arrayIndex = i;
 					}
 				}
 			}
 		    if (arrayIndex >=0){
                 //setting multi-line tool tip
                 //b.setToolTipText("<html>ToolTip : 1st Line<br>2nd Line<br> 3rd Line </html>");
                 String xVal = Double.toString(dataX[arrayIndex]);
                 String yVal = Double.toString(dataY[arrayIndex]);
                 String s = "<html> ";
 				//s = s + "Idx: " + new Integer(arrayIndex).toString() + " ";
                 if (this.observNames != null) {
                   s = s + "Name = "
                         + observNames[arrayIndex] + "<br>";
                 }
 
                 s = s + attributeX
                   + " = " + xVal + "<br>"
                   + attributeY
                   + " = " + yVal + "</html>";
 
                 this.setToolTipText(s);
 			} //end if
     }
     /***
      * New data ranges setup dialog.
      * @param x
      * @param y
      */
 	private void showDialog (int x, int y) {
 		JFrame dummyFrame = new JFrame();
 		JDialog dialog = new JDialog(dummyFrame, "Data Range Configuer", true);
 		JButton actionButton;
 		JButton resetButton;
 		dialog.setLocation(x, y);
 		dialog.setSize(300, 150);
 		dialog.getContentPane().setLayout(new GridLayout(5, 2));
 		xAxisMinField.setText(Double.toString(xAxisExtents[0]));
 		xAxisMaxField.setText(Double.toString(xAxisExtents[1]));
 		yAxisMinField.setText(Double.toString(yAxisExtents[0]));
 		yAxisMaxField.setText(Double.toString(yAxisExtents[1]));
         //create buttons for action
 		actionButton = new JButton("OK");
 		actionButton.addActionListener(new java.awt.event.ActionListener() {
 
             /***
              * Button to set up new data ranges shown up in scatter plot.
              * @param e
              */
 			public void actionPerformed (ActionEvent e) {
 				try {
 					actionButton_actionPerformed(e);
 				} catch (Exception exception) {}
 			}
 		});
 		resetButton = new JButton("Reset");
 		resetButton.addActionListener(new java.awt.event.ActionListener() {
 
             /***
              * put your documentation comment here
              * @param e
              */
 			public void actionPerformed (ActionEvent e) {
 				resetButton_actionPerformed(e);
 			}
 		});
 		//dialog.getContentPane().add(new JLabel("X Range Min:"));
 		dialog.getContentPane().add(new JLabel((this.attributeX + " Min")));
 		dialog.getContentPane().add(xAxisMinField);
 		dialog.getContentPane().add(new JLabel((this.attributeX + " Max")));
 		dialog.getContentPane().add(xAxisMaxField);
 		dialog.getContentPane().add(new JLabel((this.attributeY + " Min")));
 		dialog.getContentPane().add(yAxisMinField);
 		dialog.getContentPane().add(new JLabel((this.attributeY + " Max")));
 		dialog.getContentPane().add(yAxisMaxField);
 		dialog.getContentPane().add(actionButton);
 		dialog.getContentPane().add(resetButton);
 		dialog.show();
 	}
 
     /***
      * put your documentation comment here
      * @param e
      */
 	private void maybeShowPopup (MouseEvent e) {
 		{
 			popup.show(e.getComponent(), e.getX(), e.getY());
 		}
 	}
 
     /***
      * Set up new data ranges to show.
      * @param e
      */
 	private void actionButton_actionPerformed (ActionEvent e) {
         //get the input data from text field
 		xAxisExtents[0] = Double.parseDouble(xAxisMinField.getText());
 		xAxisExtents[1] = Double.parseDouble(xAxisMaxField.getText());
 		yAxisExtents[0] = Double.parseDouble(yAxisMinField.getText());
 		yAxisExtents[1] = Double.parseDouble(yAxisMaxField.getText());
 		this.dataArrayX.setExtent(xAxisExtents);
 		this.dataArrayY.setExtent(yAxisExtents);
 		this.setupDataforDisplay();
 		fireActionPerformed(COMMAND_DATARANGE_SET);
 		//System.out.println("ok, fire event.");
 		repaint();
 	}
 
     /***
      * put your documentation comment here
      * @param e
      */
 	private void resetButton_actionPerformed (ActionEvent e) {
 		this.dataArrayX.setDataExtent();
 		this.dataArrayY.setDataExtent();
 		if (axisOn) {
 			xAxisExtents = (double[])this.dataArrayX.getMaxMinCoorValue().clone();
 			yAxisExtents = (double[])this.dataArrayY.getMaxMinCoorValue().clone();
 		}
 		else {
 			xAxisExtents[0] = dataArrayX.getExtent()[0];
 			xAxisExtents[1] = dataArrayX.getExtent()[1];
 			yAxisExtents[0] = dataArrayY.getExtent()[0];
 			yAxisExtents[1] = dataArrayY.getExtent()[1];
 		}
 		xAxisMinField.setText(Double.toString(xAxisExtents[0]));
 		xAxisMaxField.setText(Double.toString(xAxisExtents[1]));
 		yAxisMinField.setText(Double.toString(yAxisExtents[0]));
 		yAxisMaxField.setText(Double.toString(yAxisExtents[1]));
 		this.setupDataforDisplay();
 		fireActionPerformed(COMMAND_DATARANGE_SET);
 		repaint();
 	}
         /***
          * adds an IndicationListener to the button
          */
             public void addIndicationListener (IndicationListener l) {
                     listenerList.add(IndicationListener.class, l);
             }
 
         /***
          * removes an IndicationListener from the button
          */
             public void removeIndicationListener (IndicationListener l) {
                     listenerList.remove(IndicationListener.class, l);
 	}
     /***
      * adds an ActionListener to the button
      */
 	public void addActionListener (ActionListener l) {
 		listenerListAction.add(ActionListener.class, l);
 	}
 
     /***
      * removes an ActionListener from the button
      */
 	public void removeActionListener (ActionListener l) {
 		listenerListAction.remove(ActionListener.class, l);
 	}
 
     /***
      * Notify all listeners that have registered interest for
      * notification on this event type. The event instance
      * is lazily created using the parameters passed into
      * the fire method.
      * @see EventListenerList
      */
 	public void fireActionPerformed (String command) {
         // Guaranteed to return a non-null array
 		Object[] listeners = listenerListAction.getListenerList();
 		ActionEvent e = null;
         // Process the listeners last to first, notifying
         // those that are interested in this event
 		for (int i = listeners.length - 2; i >= 0; i -= 2) {
 			if (listeners[i] == ActionListener.class) {
                 // Lazily create the event:
 				if (e == null) {
 					e = new ActionEvent(this, ActionEvent.ACTION_PERFORMED, command);
 				}
 				((ActionListener)listeners[i + 1]).actionPerformed(e);
 			}
 		}
 	}
 
 	/***
 	 * If AxisOn is true, it will be a detailed version of scatterplot with axises.
 	 * @return
 	 */
 	public boolean isAxisOn () {
 		return  axisOn;
 	}
 
 	/***
 	 * Sets colors for the current data.
 	 */
      public void setBivarColorClasser (BivariateColorSymbolClassification bivarColorClasser, boolean reverseColor) {
        this.bivarColorClasser = bivarColorClasser;
       this.makeColors();
 	  classColors = this.bivarColorClasser.getClassColors();
 	  int numClasses;
 
 	  try {
 		xClasser = (BoundaryClassifier)this.bivarColorClasser.getClasserX();
 		numClasses = this.bivarColorClasser.getXColorSymbolizer().getNumClasses();
 		System.out.println("num classes" + numClasses);
 		xBoundaries = xClasser.getBoundaries(this.dataX,numClasses);
 		yClasser = (BoundaryClassifier)this.bivarColorClasser.getClasserY();
 		numClasses = this.bivarColorClasser.getYColorSymbolizer().getNumClasses();
 		yBoundaries = yClasser.getBoundaries(this.dataY,numClasses);
 	  }
 	  catch (ClassCastException ex) {
 
 	  }
 	  repaint();
     }
 
     public BivariateColorSymbolClassification getBivarColorClasser(){
       return this.bivarColorClasser;
     }
 
     public void makeColors(){
       if (this.dataX != null && this.dataY != null) {
         this.pointColors = this.bivarColorClasser.symbolize(dataX,dataY);
       }
     }
 	/***
 	 * Test file.
 	 * @param args
 	 */
 	public static void main (String[] args) {
 		JFrame app = new JFrame();
 		ScatterPlot sp = new ScatterPlot();
 		app.getContentPane().add(sp);
 		app.show();
 	}
 }