View Javadoc
   package edu.psu.geovista.data.condition;
   
   /***
    * Title: ConditionManager
    * Description:
    * Copyright:    Copyright (c) 2001
    * Company: GeoVISTA
    * @author Xiping
    * @version 1.0
   */
  
  import  java.awt.*;
  import  java.lang.*;
  import  java.util.*;
  import  java.awt.event.*;
  import  javax.swing.event.*;
  import  javax.swing.*;
  import  java.io.*;
  import  javax.swing.event.EventListenerList;
  import  java.awt.event.ActionEvent;
  import  java.awt.event.ActionListener;
  import  edu.psu.geovista.ui.event.*;
  
  public class ConditionManager extends JPanel implements ChangeListener, ListSelectionListener,
  		DataSetListener{
  
  	private static final int TYPE_NONE = -1;
  	private static final int TYPE_NAME = 0;
  	private static final int TYPE_DOUBLE = 1;
  	private static final int TYPE_INTEGER = 2;
  	private static final int TYPE_BOOLEAN = 3;
  
  	private Object[] dataObject;
  	//private String[] observNames;
  	private int[] dataType;
  	private double[][] doubleDataArrays = null;
  	private double[] dataConditionedOn;
  	private String[] attributesArray = null;
  	private String[] attributesDisplay;
  	private int condVarIndex;
  	private double[] conditionRanges;
  	private int[] conditionResults;
  	private JList attList;
  	private	JScrollPane attSelectPane;
  	private JComboBox conditionMethod;
  	private String[] method;
  	private String methodName;
  	private JLabel conditionSetLabel;
  	private static String conditionSetStr = "Set Conditions:";
  	private JTextField[] conditionSetField;
  	private OneVarCondition oneVarCond;
  	private OneVarCondExtremes oneVarCondEx;
  	private double[] minMaxValues;
  	private Object[] rangesTitle = new Object[2];
  	private JLabel varMin = new JLabel();
  	private JLabel varMax = new JLabel();
  	private EventListenerList listenerListAction = new EventListenerList();
          private edu.psu.geovista.data.geog.DataSetForApps dataObjTransfer;
      public ConditionManager() {
          super();
  		this.setLayout(new BorderLayout());
  		this.setSize(300, 300);
  		init();
  	}
  
  	public void setDataObject (Object[] data) {
  		dataObjTransfer = new edu.psu.geovista.data.geog.DataSetForApps();
  		dataObjTransfer.setDataObject(data);
  		this.dataObject = dataObjTransfer.getDataSetNumericAndSpatial();
  		this.attributesDisplay = dataObjTransfer.getAttributeNamesNumeric();
  		this.dataType = dataObjTransfer.getDataTypeArray();
  		//this.observNames = dataObjTransfer.getObservationNames();
  		initList();
  		this.rangesTitle[0] = this.attributesDisplay[0];
  		fireChangeEvent ();
  	}
  
  	public void setDoubleDataArrays (double[][] dataArrays) {
  		this.doubleDataArrays = (double[][])dataArrays.clone();
  		if (this.attributesArray != null && this.doubleDataArrays.length == this.attributesArray.length) {
  		    initList();
  		}
  	}
  
  	public void setAttributesArray (String[] attributesArray) {
  		this.attributesArray = (String[])attributesArray.clone();
  		if (this.doubleDataArrays != null && this.doubleDataArrays.length == this.attributesArray.length) {
  		    initList();
  		}
  	}
  
  	public void setConditionRanges (double[] ranges){
  		this.conditionRanges = ranges;
  		if (methodName.equals(method[0])){
  			oneVarCond = new OneVarCondition();
  			oneVarCond.setDataArray(this.dataConditionedOn);
  			oneVarCond.setConditionRanges(this.conditionRanges);
  	        conditionSetField[0].setText(Double.toString(conditionRanges[0]));
  		    conditionSetField[1].setText(Double.toString(conditionRanges[1]));
 			this.conditionResults = (int[])(oneVarCond.getConditionResults()).clone();
             ActionEvent e = new ActionEvent(this,1,"condition_set");
 			fireActionPerformed (e);
 			this.fireConditioningChanged (this.conditionResults);
 		} else if (methodName == method[1]){
 			oneVarCondEx = new OneVarCondExtremes();
 			oneVarCondEx.setDataArray(this.dataConditionedOn);
 			oneVarCondEx.setConditionRanges(this.conditionRanges);
 	        conditionSetField[0].setText(Double.toString(conditionRanges[0]));
 		    conditionSetField[1].setText(Double.toString(conditionRanges[1]));
 			this.conditionResults = (int[])(oneVarCondEx.getConditionResults()).clone();
             ActionEvent e = new ActionEvent(this,1,"condition_set");
 			fireActionPerformed (e);
 			this.fireConditioningChanged (this.conditionResults);
 
 		//} else {
 		}
 	}
 
 	public double getMinimumRanges(){
 	    return this.minMaxValues[0];
 	}
 
 	public double getMaximumRanges(){
 	    return this.minMaxValues[1];
 	}
 
 	public double[] getSliderRanges(){
 	//System.out.println("get ranges for slider...");
 	    return this.minMaxValues;
 	}
 
 	public String getAttributeName(){
 	    //return this.attributesArray[condVarIndex];
 		return this.attributesDisplay[condVarIndex - 1];
 	}
 
 	public Object[] getRangesTitle(){
 		//System.out.println("get rangesTitle for slider...");
 		return rangesTitle;
 	}
 
 	public int[] getConditionResults(){
 		//System.out.println("get conditioning in conditionManager");
 		return conditionResults;
 	}
 
 	public void setConditionResults(int[] conditionResults){
 		this.conditionResults = conditionResults;
 	}
 
 	void init(){
 		this.attList = new JList();
 		this.attList.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
 		this.attList.addListSelectionListener(this);
 
 		this.attSelectPane = new JScrollPane(attList);
 		this.attSelectPane.setViewportView(attList);
 
 		this.method = new String[]{"Display Focus", "Display Extreme", "Display All", "Two Var Condtion"};
 		this.conditionMethod = new JComboBox(method);
         conditionMethod.addActionListener(new ActionListener() {
             public void actionPerformed(ActionEvent e) {
                 JComboBox cb = (JComboBox)e.getSource();
                 methodName = (String)cb.getSelectedItem();
 
             }
         });
 		conditionMethod.setSelectedIndex(0);
 
 		JButton okButton;
 		JButton cancelButton;
 		okButton = new JButton("OK");
 		okButton.addActionListener(new java.awt.event.ActionListener() {
                 /***
                  * put your documentation comment here
                  * @param e
                  */
 		public void actionPerformed (ActionEvent e) {
 				okButton_actionPerformed(e);
 			}
 		});
 
 		cancelButton = new JButton("Cancel");
         cancelButton.addActionListener(new java.awt.event.ActionListener() {
         public void actionPerformed(ActionEvent e) {
                 cancelButton_actionPerformed(e);
             }
         });
 
 		conditionSetLabel = new JLabel(conditionSetStr);
 
 		varMin.setText("unknown");
 		varMax.setText("unknown");
 
 		conditionSetField = new JTextField[2];
 	    conditionSetField[0] = new JTextField(8);
  	    conditionSetField[1] = new JTextField(8);
 		//end loop
 
 		JPanel attPanel = new JPanel(new BorderLayout());
 		attPanel.add(new JLabel("Attribute Names:"), BorderLayout.NORTH);
 		attPanel.add(attSelectPane, BorderLayout.CENTER);
 
 		JPanel comboPanel = new JPanel(new BorderLayout());
 	    comboPanel.add(new JLabel("ConditionMethods:"), BorderLayout.NORTH);
 		JPanel tmpComboPanel = new JPanel(new BorderLayout());
 		tmpComboPanel.add(conditionMethod, BorderLayout.NORTH);
 			comboPanel.add(tmpComboPanel, BorderLayout.CENTER);
 
 		JPanel conditionPanel = new JPanel(new BorderLayout());
 		JPanel conditionField = new JPanel(new GridLayout(1, 4));
 		conditionField.add(varMin);                 //loop
 		conditionField.add(conditionSetField[0]);
 		conditionField.add(conditionSetField[1]);
 		conditionField.add(varMax);
 
 		conditionPanel.add(conditionSetLabel, BorderLayout.NORTH);
 		conditionPanel.add(conditionField, BorderLayout.CENTER);
 		conditionPanel.add(okButton, BorderLayout.SOUTH);
 
 		this.add(attPanel, BorderLayout.CENTER);
 		this.add(comboPanel, BorderLayout.EAST);
 		this.add(conditionPanel, BorderLayout.SOUTH);
 
 		this.validate();
 	}
 
 	void initList(){
 		int observLen = 0;
         observLen = this.dataObjTransfer.getNumObservations();
 		this.conditionResults = new int[observLen];
 
 		//this.conditionResults = new int[this.attributesArray.length]; //mistake. should be observations' #.
 		if (this.attList == null) {
 		    //this.attList = new JList(attributesArray);
 			this.attList = new JList(this.attributesDisplay);
 		} else {
 			//this.attList.setListData(attributesArray);
 			this.attList.setListData(this.attributesDisplay);
 		}
 		//this.condVarIndex = 0;
 		this.condVarIndex = 1; //first object in dataset is the variable names. So, data begins with 1.
 		//this.attList.setSelectedIndex(condVarIndex);
 		this.attList.setSelectedIndex(condVarIndex-1);
 		setMinMaxValues(condVarIndex);
 		this.validate();
 	}
 
 	void setMinMaxValues(int index) {
 		boolean[] dataBoolean;
 		int[] dataInt;
 		int len;
 		if (dataObject[index] instanceof double[]) {
 			this.dataConditionedOn = (double[])(dataObject[index]);
 		}
 		else if (dataObject[index] instanceof int[]) {
 			dataInt = (int[])dataObject[index];
 			len = dataInt.length;
 			dataConditionedOn = new double[len];
 			for (int i = 0; i < len; i++) {
 				dataConditionedOn[i] = (double)dataInt[i];
 			}
 		}
 		else if (dataObject[index] instanceof boolean[]) {
 			dataBoolean = (boolean[])dataObject[index];
 			len = dataBoolean.length;
 			dataConditionedOn = new double[len];
 			for (int i = 0; i < len; i++) {
 				if (dataBoolean[i] == true) {
 					dataConditionedOn[i] = 1;
 				}
 				else
 					dataConditionedOn[i] = 0;
 			}
 		}
 		minMaxValues = getMinMaxValues(dataConditionedOn);
 		rangesTitle[1] = minMaxValues;
 		varMin.setText(Double.toString(minMaxValues[0]));
 		varMax.setText(Double.toString(minMaxValues[1]));
 	    conditionSetField[0].setText(Double.toString(minMaxValues[0]));
 		conditionSetField[1].setText(Double.toString(minMaxValues[1]));
 	}
 
 	private void okButton_actionPerformed (ActionEvent e) {
 		if (methodName.equals(method[0])){
 			oneVarCond = new OneVarCondition();
 			oneVarCond.setDataArray(this.dataConditionedOn);
 
 			// set conditionRanges
 			if (this.conditionRanges == null) {
 				this.conditionRanges = new double[2];
 			}
 			this.conditionRanges[0] = Double.parseDouble(conditionSetField[0].getText());
 			this.conditionRanges[1] = Double.parseDouble(conditionSetField[1].getText());
 			oneVarCond.setConditionRanges(this.conditionRanges);
 			this.conditionResults = (int[])(oneVarCond.getConditionResults()).clone();
 			this.minMaxValues = this.conditionRanges;
 			this.rangesTitle[1] = minMaxValues;
             fireChangeEvent ();
 			this.fireConditioningChanged (this.conditionResults);
 			fireActionPerformed (e);
 		} else if (methodName == method[1]){
 		    this.oneVarCondEx = new OneVarCondExtremes();
 			this.oneVarCondEx.setDataArray(this.dataConditionedOn);
 			// set conditionRanges
 			if (this.conditionRanges == null) {
 				this.conditionRanges = new double[2];
 			}
 			this.conditionRanges[0] = Double.parseDouble(conditionSetField[0].getText());
 			this.conditionRanges[1] = Double.parseDouble(conditionSetField[1].getText());
 			oneVarCondEx.setConditionRanges(this.conditionRanges);
 			this.conditionResults = (int[])(oneVarCondEx.getConditionResults()).clone();
 			this.minMaxValues = this.conditionRanges;
 			this.rangesTitle[1] = this.minMaxValues;
             fireChangeEvent ();
 			this.fireConditioningChanged (this.conditionResults);
 			fireActionPerformed (e);
 		}
 		//} else {
 	}
 
 	void cancelButton_actionPerformed(ActionEvent e){
         //System.exit(0);
     }
 
 	public void valueChanged (ListSelectionEvent e) {
 		if (e.getValueIsAdjusting())
 			return;
 		JList theList = (JList)e.getSource();
 		if (theList.isSelectionEmpty()) {
 			return;
 		}
 		else {
 			condVarIndex = theList.getSelectedIndex() + 1; //dataObject[0] is attribute name array.
 			setMinMaxValues(condVarIndex);
 			this.rangesTitle[0] = this.attributesDisplay[condVarIndex - 1];
 			this.rangesTitle[1] = this.minMaxValues;
 			fireChangeEvent ();
 		}
 	}
 
 	private double[] getMinMaxValues(double[] dataArray){
 		double[] minMaxValues = new double[2];
 		minMaxValues[0] = dataArray[0];
 		minMaxValues[1] = dataArray[0];
 		for (int i = 1; i<dataArray.length; i++){
 			if (minMaxValues[0] > dataArray[i]){
 				minMaxValues[0] = dataArray[i];
 			}
 			if (minMaxValues[1] < dataArray[i]){
 				minMaxValues[1] = dataArray[i];
 			}
 		}
 		return minMaxValues;
 	}
 
 	public void stateChanged (ChangeEvent e) {
 		JButton button = (JButton)e.getSource();
 	}
 
 	public void addChangeListener (ChangeListener l) {
 		this.listenerList.add(ChangeListener.class, l);
 	}
 
     /***
      * put your documentation comment here
      * @param l
      */
 	public void removeChangeListener (ChangeListener l) {
 		this.listenerList.remove(ChangeListener.class, l);
 	}
 
     /***
      * put your documentation comment here
      */
 	private void fireChangeEvent () {
 		Object[] listeners = this.listenerList.getListenerList();
         // 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] == ChangeListener.class) {
 				((ChangeListener)listeners[i + 1]).stateChanged(new ChangeEvent(this));
 			}
 		}             // end for
 	}
 
     //Work with coordinator.
 	public void dataSetChanged(DataSetEvent e){
         this.setDataObject(e.getDataSet());
     }
 
 	/***
 	 * adds an SelectionListener.
 	 * @see EventListenerList
 	 */
 	public void addConditioningListener (ConditioningListener l) {
 
 		listenerList.add(ConditioningListener.class, l);
 	}
 	/***
 	 * removes an SelectionListener from the component.
 	 * @see EventListenerList
 	 */
 	public void removeConditioningListener (ConditioningListener l) {
 		listenerList.remove(ConditioningListener.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 fireConditioningChanged (int[] condition) {
 
 		  // Guaranteed to return a non-null array
 			  Object[] listeners = listenerList.getListenerList();
 			  ConditioningEvent 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] == ConditioningListener.class) {
 				  // Lazily create the event:
 				  if (e == null) {
 					e = new ConditioningEvent(this, condition);
 				  }
 					((ConditioningListener)listeners[i + 1]).conditioningChanged(e);
 				}
 			  }//next i
 
 	}
 	/***
      * 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 (ActionEvent e) {
         // Guaranteed to return a non-null array
 		Object[] listeners = listenerListAction.getListenerList();
         // Process the listeners last to first, notifying
         // those that are interested in this event
 		    ActionEvent e2 = new ActionEvent(this,ActionEvent.ACTION_PERFORMED,"OK");
 		for (int i = listeners.length - 2; i >= 0; i -= 2) {
 			if (listeners[i] == ActionListener.class) {
                 // Lazily create the event:
 				((ActionListener)listeners[i + 1]).actionPerformed(e2);
 			}
 		}
 	}
 }