TraceDisplay.java

package edu.udel.cis.vsl.tass.trace;

import java.awt.BorderLayout;
import java.awt.Container;
import java.util.ArrayList;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTree;
import javax.swing.tree.DefaultMutableTreeNode;

import edu.udel.cis.vsl.tass.dynamic.IF.value.ValueIF;
import edu.udel.cis.vsl.tass.morph.MorphicArray;
import edu.udel.cis.vsl.tass.search.EnablerIF;
import edu.udel.cis.vsl.tass.search.StateManagerIF;
import edu.udel.cis.vsl.tass.state.IF.ModelStateIF;
import edu.udel.cis.vsl.tass.state.IF.StateIF;

public class TraceDisplay<STATE, TRANSITION, TRANSITIONSEQUENCE> extends JFrame {

	private static final long serialVersionUID = 1L;

	EnablerIF<STATE, TRANSITION, TRANSITIONSEQUENCE> enabler;

	StateManagerIF<STATE, TRANSITION> manager;

	Trace<TRANSITIONSEQUENCE> trace;

	public TraceDisplay(
			EnablerIF<STATE, TRANSITION, TRANSITIONSEQUENCE> enabler,
			StateManagerIF<STATE, TRANSITION> manager,
			Trace<TRANSITIONSEQUENCE> trace) {

		super("Creating a Simple JTree");

		this.enabler = enabler;
		this.manager = manager;
		this.trace = trace;

		WindowUtilities.setNativeLookAndFeel();
		Container content = getContentPane();
		ArrayList<Object> hierarchyList = populateHierarchy();
		DefaultMutableTreeNode root = processHierarchy(hierarchyList);
		JTree tree = new JTree(root);
		content.add(new JScrollPane(tree), BorderLayout.CENTER);
		setSize(275, 300);
		setVisible(true);
	}

	/**
	 * Populates an ArrayList<Object> with information contained in the trace
	 * object. This ArrayList can be processed to populate the JTree.
	 * 
	 * @return ArrayList<Object>
	 */
	private ArrayList<Object> populateHierarchy() {
		ArrayList<Object> hierarchy = new ArrayList<Object>();
		hierarchy.add(0, "States");
		for (int i = 1; i < (trace.getStates().size() + 1); i++) {
			TRANSITIONSEQUENCE sequence = trace.getStates().elementAt(i - 1);
			StateIF state = (StateIF) enabler.source(sequence);
			ModelStateIF[] modelStates = state.modelStates();
			ArrayList<Object> stateInfo = new ArrayList<Object>();
			stateInfo.add(0, new String("State " + i));

			// Populate path condition information
			ArrayList<Object> pathCondition = new ArrayList<Object>();
			pathCondition.add("Path Condition");
//			pathCondition.add(manager.getPathCondition(state));
			stateInfo.add(1, pathCondition);

			// Populate Model information
			ArrayList<Object> modelInfo = new ArrayList<Object>();
			modelInfo.add("Models");
			for (int j = 0; j < modelStates.length; j++) {
				modelInfo.add(populateModelHierarchy(j, modelStates[j]));
			}

			stateInfo.add(2, modelInfo);
			hierarchy.add(i, stateInfo);
		}
		return hierarchy;
	}

	ArrayList<Object> populateModelHierarchy(int i, ModelStateIF modelState) {
		ArrayList<Object> modelData = new ArrayList<Object>();
		modelData.add("Model " + i);
		ArrayList<Object> bufferData = new ArrayList<Object>();
		bufferData.add("Buffer");
		bufferData.add(modelState.buffer());
		modelData.add(bufferData);
		ArrayList<Object> sharedVariableData = new ArrayList<Object>();
		sharedVariableData.add(populateSharedVariableHierarchy(modelState));
		modelData.add(sharedVariableData);
		return modelData;
	}

	ArrayList<Object> populateSharedVariableHierarchy(ModelStateIF modelState) {
		ArrayList<Object> sharedVariableData = new ArrayList<Object>();
		ArrayList<Object> inputData = new ArrayList<Object>();
		ArrayList<Object> outputData = new ArrayList<Object>();
		MorphicArray<ValueIF> sharedValues = modelState.sharedValues();
		inputData.add("Input Variabels");
		outputData.add("Output Variables");

		for (ValueIF value : sharedValues) {
			System.out.println(value.valueType() + " " + value);
		}
		sharedVariableData.add("Shared Variables");
		sharedVariableData.add(inputData);
		sharedVariableData.add(outputData);

		return sharedVariableData;
	}

	/**
	 * Small routine that will make node out of the first entry in the array,
	 * then make nodes out of subsequent entries and make them child nodes of
	 * the first one. The process is repeated recursively for entries that are
	 * arrays.
	 */

	@SuppressWarnings("unchecked")
	private DefaultMutableTreeNode processHierarchy(ArrayList<Object> hierarchy) {
		DefaultMutableTreeNode node = new DefaultMutableTreeNode(hierarchy
				.get(0));
		DefaultMutableTreeNode child;

		for (int i = 1; i < hierarchy.size(); i++) {
			Object nodeSpecifier = hierarchy.get(i);
			if (nodeSpecifier instanceof ArrayList<?>) // Ie node with children
				child = processHierarchy((ArrayList<Object>) nodeSpecifier);
			else
				child = new DefaultMutableTreeNode(nodeSpecifier); // Ie Leaf
			node.add(child);
		}
		return (node);
	}
}