// $Header: /home/cvs/jakarta-jmeter/src/protocol/jndi/config/gui/MethodConfigGui.java,v 1.6 2004/02/13 02:40:53 sebb Exp $
/*
 * Copyright 2001-2004 The Apache Software Foundation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * 
*/

package org.apache.jmeter.ejb.jndi.config.gui;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Frame;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTree;
import javax.swing.border.Border;
import javax.swing.border.EmptyBorder;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.event.TreeSelectionListener;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreePath;
import javax.swing.tree.TreeSelectionModel;
import org.apache.jmeter.gui.GuiPackage;
import org.apache.jmeter.gui.NamePanel;
import org.apache.jmeter.gui.util.VerticalLayout;
import org.apache.jmeter.testelement.TestPlan;
import org.apache.jmeter.threads.ThreadGroup;
import org.apache.jmeter.util.JMeterUtils;
import org.apache.jorphan.logging.LoggingManager;
import org.apache.log.Logger;
/**
 * Provides the gui interface to configure remote method execution
 * @author	Khor Soon Hin
 * @version	$Revision: 1.6 $ Last Updated: $Date: 2004/02/13 02:40:53 $
 * Created	2001 Dec 24
 */
public class MethodConfigGui
	extends JPanel
	implements ModelSupported, ActionListener, TreeSelectionListener
{
	transient private static Logger log = LoggingManager.getLoggerForClass();
	protected static final String REFLECT = "MethodConfigGui.reflect";
	protected static final String INVOKE = "MethodConfigGui.invoke";
	protected static final String STRING_CLASS = "java.lang.String";
	protected JComboBox methodHomeNameBox;
	protected JComboBox methodRemoteNameBox;
	protected JComboBox remoteInterfaceBox;
	protected DefaultMutableTreeNode rootHome;
	protected DefaultMutableTreeNode rootRemote;
	protected DefaultTreeModel treeModelHome;
	protected DefaultTreeModel treeModelRemote;
	protected NamePanel namePanel;
	protected JPanel methodHomeNamePanel;
	protected JPanel methodHomeParmsPanel;
	protected JPanel remoteInterfaceListPanel;
	protected JPanel methodRemoteNamePanel;
	protected JPanel methodRemoteParmsPanel;
	protected JPanel controlPanel;
	protected JButton actionButton;
	protected JTree jTreeHome;
	protected JTree jTreeRemote;
	protected boolean displayName;
	protected MethodConfig model;
	protected Frame frame;
	// The frame is required because the JDialog we create must be modal
	// and to be modal it must be modal relative to a frame.  We want
	// the dialog boxes to be modal so that user must fill them up before
	// they can do anything with jmeter
	public MethodConfigGui()
	{
		displayName = true;
	}
	public MethodConfigGui(boolean displayName)
	{
		this.displayName = displayName;
	}
	//----- ModelSupported interface : start -----
	public void setModel(Object model)
	{
		this.model = (MethodConfig) model;
		init();
	}
	public void updateGui()
	{
		log.debug("Start : updateGui1");
		log.info("updateGui1");
		// the method name box will always be displayed regardless of the state
		// of the MethodConfig of this gui
		String methodName = model.getMethodHomeName();
		log.debug("updateGui1 : home method name - " + methodName);
		String[] strings = model.getMethodHomeList();
		setupPullDown(methodHomeNameBox, methodName, strings);
		// if methodName is null set the home method to be the first entry
		// as setup in the home method name JComboBox by setupPullDown
		// This is to ensure that if the user does not change the JComboBox
		// the first value is set anyway.
		if (methodName == null && strings != null)
		{
			model.setMethodHomeName(strings[0]);
		}
		// if the state of the MethodConfig of this gui after 
		// MethodConfig.METHOD_GET_HOME_NAMES, display panel to get
		// parms of the selected method
		int childCount = treeModelHome.getChildCount(rootHome);
		if (log.isDebugEnabled())
		{
			log.debug("updateGui1 : state - " + model.getState());
			log.debug("updateGui1 : METHOD_GET_HOME_NAMES");
			log.debug("updateGui1 : rootHome child count - " + childCount);
		}
		// if model is in state after getting home method name AND
		// rootHome(method) has no child(parms set) yet then get them
		if (model.getState() > MethodConfig.METHOD_GET_HOME_PARMS
			&& childCount == 0)
		{
			log.debug("updateGui1 : METHOD_GET_HOME_PARMS");
			rootHome.setUserObject(model.getMethodHomeName());
			//      methodParmsPanel.setVisible(true);
			// get all the parms
			Class[] parmTypes = model.getMethodHomeParms();
			// add all the parms into a JTree
			for (int i = 0; i < parmTypes.length; i++)
			{
				log.debug("updateGui1 : parmType #" + i + " - " + parmTypes[i]);
				recurseParm(parmTypes[i], rootHome, i, treeModelHome);
			}
			// if the chosen method has no parms then updating the value of
			// root node with the method name doesn't seem to trigger a redraw of
			// the tree so call treeDidChange()
			if (parmTypes.length == 0)
			{
				jTreeHome.treeDidChange();
			}
		}
		// if model is in state after getting home method name and
		// all home method parms gave been obtained then get list of
		// remote interfaces
		if (model.getState() > MethodConfig.METHOD_SELECT_REMOTE_INTERFACE)
		{
			log.debug("METHOD_SELECT_REMOTE_INTERFACE");
			// remoteInterfaceType is the remote interface selected by the user
			// remoteInterfaces contains the list of remote interfaces returned
			// by home method
			Object remoteInterfaceType = model.getRemoteInterfaceType();
			String interfaceName = null;
			if (remoteInterfaceType != null)
			{
				interfaceName = remoteInterfaceType.toString();
			}
			ArrayList remoteInterfaces = (ArrayList) model.getRemoteInterfaceList();
			if (log.isDebugEnabled())
			{
				log.debug("updateGui1 : remote interfaces - " + remoteInterfaces);
				log.debug(
					"updateGui1 : remoteInterfacesType - " + remoteInterfaces.getClass());
			}
			// prepare variable strings to contain a list of all the names of
			// the remote interfaces
			Object[] remoteInterfacesArray = remoteInterfaces.toArray();
			strings = new String[remoteInterfacesArray.length];
			for (int i = 0; i < remoteInterfacesArray.length; i++)
			{
				strings[i] = remoteInterfacesArray[i].toString();
			}
			setupPullDown(remoteInterfaceBox, interfaceName, strings);
			// if interfaceName is null set the remote interface to be the first 
			// entry as setup in the remote interface name JComboBox by setupPullDown.
			// This is to ensure that if the user does not change the JComboBox
			// the first value is set anyway.
			if (interfaceName == null && remoteInterfacesArray != null)
			{
				model.setRemoteInterfaceType(remoteInterfacesArray[0]);
			}
		}
		// if model is in state after user selects the list of remote interface
		// then get a list of remote method names
		if (model.getState() > MethodConfig.METHOD_GET_REMOTE_NAMES)
		{
			log.debug("METHOD_GET_REMOTE_NAMES");
			methodName = model.getMethodRemoteName();
			log.debug("updateGui1 : remote method name - " + methodName);
			strings = model.getMethodRemoteList();
			setupPullDown(methodRemoteNameBox, methodName, strings);
			childCount = treeModelRemote.getChildCount(rootRemote);
			if (log.isDebugEnabled())
			{
				log.debug("updateGui1 : rootRemote child count - " + childCount);
			}
		}
		// if model is in state after getting remote interface AND
		// rootRemote(method) has no child(parms set) yet then get them
		if (model.getState() > MethodConfig.METHOD_GET_REMOTE_PARMS
			&& childCount == 0)
		{
			log.debug("METHOD_GET_REMOTE_PARMS");
			rootRemote.setUserObject(model.getMethodRemoteName());
			//      methodParmsPanel.setVisible(true);
			// get all the parms
			Class[] parmTypes = model.getMethodRemoteParms();
			// add all the parms into a JTree
			for (int i = 0; i < parmTypes.length; i++)
			{
				log.debug("updateGui1 : parmType #" + i + " - " + parmTypes[i]);
				recurseParm(parmTypes[i], rootHome, i, treeModelHome);
			}
			// if the chosen method has no parms then updating the value of
			// root node with the method name doesn't seem to trigger a redraw of
			// the tree so call treeDidChange()
			if (parmTypes.length == 0)
			{
				jTreeRemote.treeDidChange();
			}
		}
		// if the state of the MethodConfig of this gui is
		// MethodConfig.METHOD_GET_HOME_PARMS, display panel
		if (displayName)
		{
			namePanel.updateGui();
		}
		log.debug("End : updateGui1");
	}
	//----- ModelSupported interface : end -----
	protected void init()
	{
		log.info("Start : init1");
		// The frame is required because the JDialog we create must be modal
		// and to be modal it must be modal relative to a frame.  We want
		// the dialog boxes to be modal so that user must fill them up before
		// they can do anything with jmeter
		GuiPackage guiPkg = GuiPackage.getInstance();
		frame = guiPkg.getMainFrame();
		model.setState(MethodConfig.METHOD_GET_HOME_NAMES);
		model.setGui(this);
		methodHomeNameBox = new JComboBox();
		methodHomeNameBox.setEditable(false);
		methodHomeNameBox.setAlignmentX(Component.LEFT_ALIGNMENT);
		methodHomeNameBox.addActionListener(new ActionListener()
		{
			public void actionPerformed(ActionEvent e)
			{
				log.debug("actionPerformed1 : Home name method JComboBox changed");
				// change in method name so do the following
				JComboBox comboBox = (JComboBox) e.getSource();
				String method = (String) methodHomeNameBox.getSelectedItem();
				model.setMethodHomeName(method);
				model.setState(MethodConfig.METHOD_GET_HOME_PARMS);
				resetHomeMethodParms();
				resetRemoteInterfaceList();
				resetRemoteMethodName();
				resetRemoteMethodParms();
				//            methodParmsPanel.setVisible(false);
				actionButton.setText(
					JMeterUtils.getResString("jndi_method_button_reflect"));
				updateGui();
			}
		});
		remoteInterfaceBox = new JComboBox();
		remoteInterfaceBox.setEditable(false);
		remoteInterfaceBox.setAlignmentX(Component.LEFT_ALIGNMENT);
		remoteInterfaceBox.addActionListener(new ActionListener()
		{
			public void actionPerformed(ActionEvent e)
			{
				log.debug("actionPerformed1 : Remote Interface JComboBox changed");
				JComboBox comboBox = (JComboBox) e.getSource();
				String interfaceName = (String) remoteInterfaceBox.getSelectedItem();
				// compare interface selected with the ones in the remote interface
				// list and store the corresponding object in MethodConfig
				ArrayList remoteInterfaceList =
					(ArrayList) model.getRemoteInterfaceList();
				if (remoteInterfaceList != null)
				{
					Object[] remoteInterfaceListArray = remoteInterfaceList.toArray();
					int i = 0;
					boolean found = false;
					String remoteInterfaceListName = null;
					Object selectedInterface = null;
					while (i < remoteInterfaceListArray.length && !found)
					{
						remoteInterfaceListName = remoteInterfaceListArray[i].toString();
						if (remoteInterfaceListName.equals(interfaceName))
						{
							found = true;
							selectedInterface = remoteInterfaceListArray[i];
						}
						i++;
					}
					model.setRemoteInterfaceType(selectedInterface);
					model.setState(MethodConfig.METHOD_GET_REMOTE_NAMES);
				}
				resetRemoteMethodName();
				resetRemoteMethodParms();
				//            methodParmsPanel.setVisible(false);
				actionButton.setText(
					JMeterUtils.getResString("jndi_method_button_reflect"));
				updateGui();
			}
		});
		methodRemoteNameBox = new JComboBox();
		methodRemoteNameBox.setEditable(false);
		methodRemoteNameBox.setAlignmentX(Component.LEFT_ALIGNMENT);
		methodRemoteNameBox.addActionListener(new ActionListener()
		{
			public void actionPerformed(ActionEvent e)
			{
				log.debug("actionPerformed1 : Remote method name JComboBox changed");
				// change in method name so do the following
				JComboBox comboBox = (JComboBox) e.getSource();
				String method = (String) methodRemoteNameBox.getSelectedItem();
				model.setMethodRemoteName(method);
				model.setState(MethodConfig.METHOD_GET_REMOTE_PARMS);
				resetRemoteMethodParms();
				//            methodParmsPanel.setVisible(false);
				actionButton.setText(
					JMeterUtils.getResString("jndi_method_button_reflect"));
				updateGui();
			}
		});
		//rootHome = new DefaultMutableTreeNode("Root");
		//treeModelHome = new DefaultTreeModel(rootHome);
		this.setLayout(
			new VerticalLayout(5, VerticalLayout.LEFT, VerticalLayout.TOP));
		JPanel mainPanel = new JPanel();
		Border margin = new EmptyBorder(10, 10, 5, 10);
		mainPanel.setBorder(margin);
		mainPanel.setLayout(new VerticalLayout(5, VerticalLayout.LEFT));
		// title
		JLabel panelTitleLabel =
			new JLabel(JMeterUtils.getResString("jndi_method_title"));
		Font curFont = panelTitleLabel.getFont();
		int curFontSize = curFont.getSize();
		curFontSize += 4;
		panelTitleLabel.setFont(
			new Font(curFont.getFontName(), curFont.getStyle(), curFontSize));
		mainPanel.add(panelTitleLabel);
		// name
		namePanel = new NamePanel(model);
		mainPanel.add(namePanel);
		// method properties
		JPanel jndiPanel = new JPanel();
		jndiPanel.setLayout(new VerticalLayout(5, VerticalLayout.LEFT));
		jndiPanel.setBorder(
			BorderFactory.createTitledBorder(
				JMeterUtils.getResString("jndi_method_name")));
		methodHomeNamePanel = getMethodHomeNamePanel();
		methodHomeParmsPanel = getMethodHomeParmsPanel();
		remoteInterfaceListPanel = getRemoteInterfaceListPanel();
		methodRemoteNamePanel = getMethodRemoteNamePanel();
		methodRemoteParmsPanel = getMethodRemoteParmsPanel();
		jndiPanel.add(methodHomeNamePanel);
		jndiPanel.add(methodHomeParmsPanel);
		jndiPanel.add(remoteInterfaceListPanel);
		jndiPanel.add(methodRemoteNamePanel);
		jndiPanel.add(methodRemoteParmsPanel);
		controlPanel = new JPanel();
		actionButton =
			new JButton(JMeterUtils.getResString("jndi_method_button_reflect"));
		actionButton.addActionListener(this);
		actionButton.setActionCommand(REFLECT);
		controlPanel.add(actionButton);
		jndiPanel.add(controlPanel);
		mainPanel.add(jndiPanel);
		this.add(mainPanel);
		//methodHomeParmsPanel.setVisible(false);
		log.info("End : init1");
	}
	/**
	 * Given a parameter type of a method, this method will find out
	 * if the parm type is a primitive.  If so, it'll just add the parm type
	 * as a node into the tree model (used to store all parm types of the method).
	 * If however, the parm type is not a primitive, then the parm type will be
	 * further recursed i.e. a reflection of all the fields is obtained
	 * and each of which will be examined to determined if they are primitives.
	 * For those which are primitives, they'll be added to the tree model
	 * and those otherwise will be further recursed.
	 *
	 * @param parmType	the parmType of a method which will be examined
	 * @param parentNode	the node under which the parmType will be added to
	 * @param childIndex	the index of the this parmType if it were to be added
	 *			under the parent node
	 */
	protected void recurseParm(
		Class parmType,
		DefaultMutableTreeNode parentNode,
		int childIndex,
		DefaultTreeModel treeModel)
	{
		log.debug("Start - recurseParm1");
		DefaultMutableTreeNode node = new DefaultMutableTreeNode(parmType);
		treeModel.insertNodeInto(node, parentNode, childIndex);
		log.info("recurseParm1 - parent : " + parentNode);
		log.info("recurseParm1 - parent : " + treeModel.getChildCount(parentNode));
		log.info("recurseParm1 - child : " + treeModel.getChildCount(node));
		if (parmType.isPrimitive())
		{
			// if parmType is primitive then no need to recurse the parm
		}
		else if (parmType.getName().equals(STRING_CLASS))
		{
			// consider String as a primitive i.e. there is not need to recurse parm
		}
		else if (parmType.isArray())
		{
			// if parmType is array then need to handle differently
		}
		else
		{
			// if parmType is NOT primitive then need to recurse the parm since
			// it's an object.
			// to recurse the object, use reflections to get all fields
			Field[] fields = parmType.getFields();
			for (int i = 0; i < fields.length; i++)
			{
				Class fieldClass = fields[i].getType();
				log.debug("recurseParm1 : field #" + i + " - " + fieldClass);
				recurseParm(fieldClass, node, i, treeModel);
			}
		}
		log.debug("End - recurseParm1");
	}
	protected JPanel getMethodHomeNamePanel()
	{
		log.info("Start : getMethodHomeNamePanel1");
		JPanel panel = new JPanel();
		panel.add(new JLabel(JMeterUtils.getResString("jndi_method_home_name")));
		String methodName = model.getMethodHomeName();
		if (methodName != null)
		{
			methodHomeNameBox.setSelectedItem(methodName);
		}
		panel.add(methodHomeNameBox);
		log.info("End : getMethodHomeNamePanel1");
		return panel;
	}
	protected JPanel getRemoteInterfaceListPanel()
	{
		log.info("Start : getRemoteInterfaceListPanel1");
		JPanel panel = new JPanel();
		panel.add(
			new JLabel(
				JMeterUtils.getResString("jndi_method_remote_interface_list")));
		Object remoteInterfaceType = model.getRemoteInterfaceType();
		if (remoteInterfaceType != null)
		{
			remoteInterfaceBox.setSelectedItem(remoteInterfaceType.toString());
		}
		panel.add(remoteInterfaceBox);
		log.info("End : getRemoteInterfaceListPanel1");
		return panel;
	}
	protected JPanel getMethodRemoteNamePanel()
	{
		log.info("Start : getMethodRemoteNamePanel1");
		JPanel panel = new JPanel();
		panel.add(new JLabel(JMeterUtils.getResString("jndi_method_remote_name")));
		String methodName = model.getMethodRemoteName();
		if (methodName != null)
		{
			methodRemoteNameBox.setSelectedItem(methodName);
		}
		panel.add(methodRemoteNameBox);
		log.info("End : getMethodRemoteNamePanel1");
		return panel;
	}
	protected JPanel getMethodHomeParmsPanel()
	{
		log.info("Start : getMethodHomeParmsPanel1");
		JPanel panel = new JPanel();
		panel.add(new JLabel(JMeterUtils.getResString("jndi_method_home_parms")));
		rootHome = new DefaultMutableTreeNode("Root");
		treeModelHome = new DefaultTreeModel(rootHome);
		jTreeHome = new JTree(treeModelHome);
		jTreeHome.getSelectionModel().setSelectionMode(
			TreeSelectionModel.SINGLE_TREE_SELECTION);
		jTreeHome.addTreeSelectionListener(this);
		jTreeHome.setPreferredSize(new Dimension(200, 50));
		JPanel jTreePanel = new JPanel();
		jTreePanel.add(jTreeHome);
		panel.add(jTreePanel);
		// set mouse listener to listen for double clicks
		MouseListener ml = new MouseAdapter()
		{
			public void mousePressed(MouseEvent e)
			{
				TreePath selPath = jTreeHome.getPathForLocation(e.getX(), e.getY());
				if (e.getClickCount() == 2)
				{
					log.info("Double clicked on - " + selPath.getLastPathComponent());
					DefaultMutableTreeNode node =
						(DefaultMutableTreeNode) selPath.getLastPathComponent();
					int childCount = node.getChildCount();
					// if node is a leaf and has a parent (i.e. not root)
					// then node is a parm which needs a value so pop out
					// dialog for user to fill in
					if (childCount == 0 && node.getParent() != null)
					{
						log.info("Pop!!!");
						Object userObject = node.getUserObject();
						Class type = null;
						if (userObject instanceof Class)
						{
							type = (Class) userObject;
						}
						else if (userObject instanceof MethodConfigUserObject)
						{
							type = (Class) ((MethodConfigUserObject) userObject).getType();
						}
						MethodConfigDialog dialog = new MethodConfigDialog(frame, type);
						dialog.pack();
						dialog.setVisible(true);
						MethodConfigUserObject input = dialog.getValidatedInput();
						log.info("input - " + input);
						if (input != null)
						{
							node.setUserObject(input);
						}
					}
				}
			}
		};
		jTreeHome.addMouseListener(ml);
		log.info("End : getMethodHomeParmsPanel1");
		return panel;
	}
	protected JPanel getMethodRemoteParmsPanel()
	{
		log.info("Start : getMethodRemoteParmsPanel1");
		JPanel panel = new JPanel();
		panel.add(new JLabel(JMeterUtils.getResString("jndi_method_remote_parms")));
		rootRemote = new DefaultMutableTreeNode("Root");
		treeModelRemote = new DefaultTreeModel(rootRemote);
		jTreeRemote = new JTree(treeModelRemote);
		jTreeRemote.getSelectionModel().setSelectionMode(
			TreeSelectionModel.SINGLE_TREE_SELECTION);
		jTreeRemote.addTreeSelectionListener(this);
		jTreeRemote.setPreferredSize(new Dimension(200, 50));
		JPanel jTreePanel = new JPanel();
		jTreePanel.add(jTreeRemote);
		panel.add(jTreePanel);
		// set mouse listener to listen for double clicks
		MouseListener ml = new MouseAdapter()
		{
			public void mousePressed(MouseEvent e)
			{
				TreePath selPath = jTreeRemote.getPathForLocation(e.getX(), e.getY());
				if (e.getClickCount() == 2)
				{
					log.info("Double clicked on - " + selPath.getLastPathComponent());
					DefaultMutableTreeNode node =
						(DefaultMutableTreeNode) selPath.getLastPathComponent();
					int childCount = node.getChildCount();
					if (childCount == 0)
					{
						log.info("Pop!!!");
						Object userObject = node.getUserObject();
						Class type = null;
						if (userObject instanceof Class)
						{
							type = (Class) userObject;
						}
						else if (userObject instanceof MethodConfigUserObject)
						{
							type = (Class) ((MethodConfigUserObject) userObject).getType();
						}
						MethodConfigDialog dialog = new MethodConfigDialog(frame, type);
						dialog.pack();
						dialog.setVisible(true);
						MethodConfigUserObject input = dialog.getValidatedInput();
						log.info("input - " + input);
						if (input != null)
						{
							node.setUserObject(input);
						}
					}
				}
			}
		};
		jTreeRemote.addMouseListener(ml);
		log.info("End : getMethodHomeParmsPanel1");
		return panel;
	}
	public MethodConfig getModel()
	{
		return model;
	}
	/**
	 * Caller needs to be able to get Method Parms for both the Home Method
	 * and Remote Method.  Based on the state this method will call
	 * getMethodParmsValues witht the appropriate root.  NOTE :
	 * parms for Home and Remote Methods are stored under different roots.
	 */
	public Object[] getMethodParmsValues(int state)
		throws MethodConfigUserObjectException
	{
		Object[] objects = null;
		if (state == MethodConfig.METHOD_INVOKE_HOME)
		{
			objects = getMethodParmsValues(rootHome);
		}
		else if (state == MethodConfig.METHOD_INVOKE_REMOTE)
		{
			objects = getMethodParmsValues(rootRemote);
		}
		return objects;
	}
	public Object[] getMethodParmsValues(DefaultMutableTreeNode root)
		throws MethodConfigUserObjectException
	{
		log.info("Start : getMethodParmsValues1");
		// go through jTree to get all arguments
		int childCount = root.getChildCount();
		Object[] parmsValues = new Object[childCount];
		for (int i = 0; i < childCount; i++)
		{
			parmsValues[i] =
				formObject((DefaultMutableTreeNode) treeModelHome.getChild(root, i));
		}
		log.info("End : getMethodParmsValues1");
		return parmsValues;
	}
	protected Object formObject(DefaultMutableTreeNode node)
		throws MethodConfigUserObjectException
	{
		log.info("Start : formObject1");
		Object obj = node.getUserObject();
		Object returnVal = null;
		if (obj instanceof MethodConfigUserObject)
		{
			// then node contains a primitive so just get the object
			MethodConfigUserObject userObject = (MethodConfigUserObject) obj;
			returnVal = userObject.getObject();
			if (log.isDebugEnabled())
			{
				log.debug("formObject1 : primitive - " + userObject);
			}
		}
		else if (obj instanceof Class)
		{
			// there are cases when the tree node will contain only class
			// and not MethodConfigUserObject -
			// 1. its value has not been input by the user but it's a primitive
			// 2. it's not a primitive but an object
			Class type = (Class) obj;
			if (type.isPrimitive())
			{
				// it's a primitive but the user has not input a value for it
				String errorStr =
					type.getName() + " is a primitive with uninitialized values";
				log.error("formObject1 : " + errorStr);
				throw new MethodConfigUserObjectException(errorStr);
			}
			else
			{
				// then node is an object which contains other primitives
				if (log.isDebugEnabled())
				{
					log.debug("formObject1 : Creating object - " + type);
				}
				int childCount = node.getChildCount();
				Object[] constituents = new Object[childCount];
				for (int i = 0; i < childCount; i++)
				{
					constituents[i] =
						formObject(
							(DefaultMutableTreeNode) treeModelHome.getChild(node, i));
				}
				// get the fields of the class
				// gather all constituents to form object
				Field[] fields = type.getFields();
				try
				{
					for (int i = 0; i < constituents.length; i++)
					{
						log.debug("formObject1 : setting - " + fields[i].getName());
						log.debug(
							"formObject1 : to value - "
								+ constituents[i]
								+ " of - "
								+ constituents[i].getClass());
						returnVal = type.newInstance();
						fields[i].set(returnVal, constituents[i]);
					}
				}
				catch (IllegalAccessException e)
				{
					log.error(e);
					throw new MethodConfigUserObjectException(e.getMessage());
				}
				catch (InstantiationException e)
				{
					log.error(e);
					throw new MethodConfigUserObjectException(e.getMessage());
				}
			}
		}
		log.info("End : formObject1");
		return returnVal;
	}
	/**
	 * Sets up the pull-down menus to contain all the Strings
	 * passed in as well as displaying the user's selection.
	 *
	 * @param methodNameBox	the JComboBox to be manipulated
	 * @param methodName		the user's selection
	 * @param strings		the list of Strings to be added
	 *				into the JComboBox
	 */
	protected void setupPullDown(
		JComboBox methodNameBox,
		String methodName,
		String[] strings)
	{
		log.info("Start : setupPullDown1");
		// if the list is empty then try to fill it
		if (methodNameBox.getItemCount() == 0)
		{
			if (strings != null)
			{
				for (int i = 0; i < strings.length; i++)
				{
					log.debug("setupPullDown1 :  adding method - " + strings[i]);
					methodNameBox.addItem(strings[i]);
				}
			}
		}
		// change the methodBox selected item only if there's a change in the
		// methodName to avoid triggering actionPerformed each time
		String methodNameBoxSelected = (String) methodNameBox.getSelectedItem();
		if ((methodName != null) && !methodName.equals(methodNameBoxSelected))
		{
			methodNameBox.setSelectedItem(methodName);
		}
		log.info("End : setupPullDown1");
	}
	/**
	 * Resets the home method parms.  This method will be called when the user
	 * makes any changes which requires the resetting the method home parms
	 * e.g. when user decides to call another home method.
	 */
	protected void resetHomeMethodParms()
	{
		log.info("Start : resetHomeMethodParms1");
		// remove all parms of the old method
		int totalChild = rootHome.getChildCount();
		for (int i = 0; i < totalChild; i++)
		{
			// the child to be removed will always be 0 'cos as the child
			// is removed the nth node will become (n-1)th
			treeModelHome.removeNodeFromParent(
				(DefaultMutableTreeNode) rootHome.getChildAt(0));
		}
		rootHome.setUserObject("Root");
		log.info("End : resetHomeMethodParms1");
	}
	/**
	 * Resets the remote interface list returned by the home method.  This method
	 * will be called when the user makes any changes which requires the 
	 * remote interface list to be modified e.g. when user decides to call 
	 * another home method.
	 */
	protected void resetRemoteInterfaceList()
	{
		log.info("Start : resetRemoteInterfaceList1");
		model.setRemoteInterfaceList(null);
		model.setRemoteInterfaceType(null);
		remoteInterfaceBox.removeAllItems();
		log.info("End : resetRemoteInterfaceList1");
	}
	/**
	 * Resets the selected remote interface.  This method will be called when 
	 * the user makes any changes which requires the resetting the selected
	 * remote interface e.g. when user decides to call another home method,
	 * when the user decides to change the remote interface to be executed.
	 */
	protected void resetRemoteMethodName()
	{
		log.info("Start : resetRemoteMethodName1");
		model.setMethodRemoteName(null);
		methodRemoteNameBox.removeAllItems();
		log.info("End : resetRemoteMethodName1");
	}
	/** 
	  * Resets the remote method parms.  This method will be called when the user 
	  * makes any changes which requires the resetting the method remote parms
	  * e.g. when user decides to call another home method, when user changes the
	  * remote interface to be executed, when user changes the remote method
	  * to be run.
	  */
	protected void resetRemoteMethodParms()
	{
		log.info("Start : resetRemoteMethodParms1");
		// remove all parms of the old method
		int totalChild = rootRemote.getChildCount();
		for (int i = 0; i < totalChild; i++)
		{
			// the child to be removed will always be 0 'cos as the child
			// is removed the nth node will become (n-1)th
			treeModelRemote.removeNodeFromParent(
				(DefaultMutableTreeNode) rootRemote.getChildAt(0));
		}
		rootRemote.setUserObject("Root");
		log.info("End : resetRemoteMethodParms1");
	}
	//----- ActionListener interface : start -----
	public void actionPerformed(ActionEvent e)
	{
		String command = e.getActionCommand();
		ReflectionJMeterEngine engine = null;
		GuiPackage guiPackage = null;
		if (log.isDebugEnabled())
		{
			log.debug("actionPerformed1 : command - " + command);
		}
		if (command.equals(REFLECT))
		{
			guiPackage = GuiPackage.getInstance();
			Collection groups = TestPlan.createTestPlan(null).compileTestPlan();
			engine = new ReflectionJMeterEngine();
			for (Iterator i = groups.iterator(); i.hasNext();)
			{
				ThreadGroup tg = (ThreadGroup) i.next();
				if (log.isDebugEnabled())
				{
					log.debug("actionPerformed1 : threadgroup - " + tg);
				}
				engine.addThreadGroup(tg);
			}
			guiPackage.getMainFrame().setRunning(true);
			model.setReflectionStatus(true);
			engine.runTest();
			guiPackage.getMainFrame().setRunning(false);
			model.setReflectionStatus(false);
			updateGui();
		}
		if (command.equals(INVOKE))
		{
		}
	}
	//----- ActionListener interface : end -----
	//----- TreeSelectionListener interface : start -----
	public void valueChanged(TreeSelectionEvent e)
	{
		log.debug("Start : valueChanged1");
		log.debug("End : valueChanged1");
	}
	//----- TreeSelectionListener interface : end -----
}