KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > jmeter > ejb > jndi > config > gui > MethodConfigGui


1 // $Header: /home/cvs/jakarta-jmeter/src/protocol/jndi/config/gui/MethodConfigGui.java,v 1.6 2004/02/13 02:40:53 sebb Exp $
2 /*
3  * Copyright 2001-2004 The Apache Software Foundation.
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  *
17 */
18
19 package org.apache.jmeter.ejb.jndi.config.gui;
20 import java.awt.Component JavaDoc;
21 import java.awt.Dimension JavaDoc;
22 import java.awt.Font JavaDoc;
23 import java.awt.Frame JavaDoc;
24 import java.awt.event.ActionEvent JavaDoc;
25 import java.awt.event.ActionListener JavaDoc;
26 import java.awt.event.MouseAdapter JavaDoc;
27 import java.awt.event.MouseEvent JavaDoc;
28 import java.awt.event.MouseListener JavaDoc;
29 import java.lang.reflect.Field JavaDoc;
30 import java.util.ArrayList JavaDoc;
31 import java.util.Collection JavaDoc;
32 import java.util.Iterator JavaDoc;
33 import javax.swing.BorderFactory JavaDoc;
34 import javax.swing.JButton JavaDoc;
35 import javax.swing.JComboBox JavaDoc;
36 import javax.swing.JLabel JavaDoc;
37 import javax.swing.JPanel JavaDoc;
38 import javax.swing.JTree JavaDoc;
39 import javax.swing.border.Border JavaDoc;
40 import javax.swing.border.EmptyBorder JavaDoc;
41 import javax.swing.event.TreeSelectionEvent JavaDoc;
42 import javax.swing.event.TreeSelectionListener JavaDoc;
43 import javax.swing.tree.DefaultMutableTreeNode JavaDoc;
44 import javax.swing.tree.DefaultTreeModel JavaDoc;
45 import javax.swing.tree.TreePath JavaDoc;
46 import javax.swing.tree.TreeSelectionModel JavaDoc;
47 import org.apache.jmeter.gui.GuiPackage;
48 import org.apache.jmeter.gui.NamePanel;
49 import org.apache.jmeter.gui.util.VerticalLayout;
50 import org.apache.jmeter.testelement.TestPlan;
51 import org.apache.jmeter.threads.ThreadGroup;
52 import org.apache.jmeter.util.JMeterUtils;
53 import org.apache.jorphan.logging.LoggingManager;
54 import org.apache.log.Logger;
55 /**
56  * Provides the gui interface to configure remote method execution
57  * @author Khor Soon Hin
58  * @version $Revision: 1.6 $ Last Updated: $Date: 2004/02/13 02:40:53 $
59  * Created 2001 Dec 24
60  */
61 public class MethodConfigGui
62     extends JPanel JavaDoc
63     implements ModelSupported, ActionListener JavaDoc, TreeSelectionListener JavaDoc
64 {
65     transient private static Logger log = LoggingManager.getLoggerForClass();
66     protected static final String JavaDoc REFLECT = "MethodConfigGui.reflect";
67     protected static final String JavaDoc INVOKE = "MethodConfigGui.invoke";
68     protected static final String JavaDoc STRING_CLASS = "java.lang.String";
69     protected JComboBox JavaDoc methodHomeNameBox;
70     protected JComboBox JavaDoc methodRemoteNameBox;
71     protected JComboBox JavaDoc remoteInterfaceBox;
72     protected DefaultMutableTreeNode JavaDoc rootHome;
73     protected DefaultMutableTreeNode JavaDoc rootRemote;
74     protected DefaultTreeModel JavaDoc treeModelHome;
75     protected DefaultTreeModel JavaDoc treeModelRemote;
76     protected NamePanel namePanel;
77     protected JPanel JavaDoc methodHomeNamePanel;
78     protected JPanel JavaDoc methodHomeParmsPanel;
79     protected JPanel JavaDoc remoteInterfaceListPanel;
80     protected JPanel JavaDoc methodRemoteNamePanel;
81     protected JPanel JavaDoc methodRemoteParmsPanel;
82     protected JPanel JavaDoc controlPanel;
83     protected JButton JavaDoc actionButton;
84     protected JTree JavaDoc jTreeHome;
85     protected JTree JavaDoc jTreeRemote;
86     protected boolean displayName;
87     protected MethodConfig model;
88     protected Frame JavaDoc frame;
89     // The frame is required because the JDialog we create must be modal
90 // and to be modal it must be modal relative to a frame. We want
91 // the dialog boxes to be modal so that user must fill them up before
92 // they can do anything with jmeter
93 public MethodConfigGui()
94     {
95         displayName = true;
96     }
97     public MethodConfigGui(boolean displayName)
98     {
99         this.displayName = displayName;
100     }
101     //----- ModelSupported interface : start -----
102 public void setModel(Object JavaDoc model)
103     {
104         this.model = (MethodConfig) model;
105         init();
106     }
107     public void updateGui()
108     {
109         log.debug("Start : updateGui1");
110         log.info("updateGui1");
111         // the method name box will always be displayed regardless of the state
112 // of the MethodConfig of this gui
113 String JavaDoc methodName = model.getMethodHomeName();
114         log.debug("updateGui1 : home method name - " + methodName);
115         String JavaDoc[] strings = model.getMethodHomeList();
116         setupPullDown(methodHomeNameBox, methodName, strings);
117         // if methodName is null set the home method to be the first entry
118 // as setup in the home method name JComboBox by setupPullDown
119 // This is to ensure that if the user does not change the JComboBox
120 // the first value is set anyway.
121 if (methodName == null && strings != null)
122         {
123             model.setMethodHomeName(strings[0]);
124         }
125         // if the state of the MethodConfig of this gui after
126 // MethodConfig.METHOD_GET_HOME_NAMES, display panel to get
127 // parms of the selected method
128 int childCount = treeModelHome.getChildCount(rootHome);
129         if (log.isDebugEnabled())
130         {
131             log.debug("updateGui1 : state - " + model.getState());
132             log.debug("updateGui1 : METHOD_GET_HOME_NAMES");
133             log.debug("updateGui1 : rootHome child count - " + childCount);
134         }
135         // if model is in state after getting home method name AND
136 // rootHome(method) has no child(parms set) yet then get them
137 if (model.getState() > MethodConfig.METHOD_GET_HOME_PARMS
138             && childCount == 0)
139         {
140             log.debug("updateGui1 : METHOD_GET_HOME_PARMS");
141             rootHome.setUserObject(model.getMethodHomeName());
142             // methodParmsPanel.setVisible(true);
143 // get all the parms
144 Class JavaDoc[] parmTypes = model.getMethodHomeParms();
145             // add all the parms into a JTree
146 for (int i = 0; i < parmTypes.length; i++)
147             {
148                 log.debug("updateGui1 : parmType #" + i + " - " + parmTypes[i]);
149                 recurseParm(parmTypes[i], rootHome, i, treeModelHome);
150             }
151             // if the chosen method has no parms then updating the value of
152 // root node with the method name doesn't seem to trigger a redraw of
153 // the tree so call treeDidChange()
154 if (parmTypes.length == 0)
155             {
156                 jTreeHome.treeDidChange();
157             }
158         }
159         // if model is in state after getting home method name and
160 // all home method parms gave been obtained then get list of
161 // remote interfaces
162 if (model.getState() > MethodConfig.METHOD_SELECT_REMOTE_INTERFACE)
163         {
164             log.debug("METHOD_SELECT_REMOTE_INTERFACE");
165             // remoteInterfaceType is the remote interface selected by the user
166 // remoteInterfaces contains the list of remote interfaces returned
167 // by home method
168 Object JavaDoc remoteInterfaceType = model.getRemoteInterfaceType();
169             String JavaDoc interfaceName = null;
170             if (remoteInterfaceType != null)
171             {
172                 interfaceName = remoteInterfaceType.toString();
173             }
174             ArrayList JavaDoc remoteInterfaces = (ArrayList JavaDoc) model.getRemoteInterfaceList();
175             if (log.isDebugEnabled())
176             {
177                 log.debug("updateGui1 : remote interfaces - " + remoteInterfaces);
178                 log.debug(
179                     "updateGui1 : remoteInterfacesType - " + remoteInterfaces.getClass());
180             }
181             // prepare variable strings to contain a list of all the names of
182 // the remote interfaces
183 Object JavaDoc[] remoteInterfacesArray = remoteInterfaces.toArray();
184             strings = new String JavaDoc[remoteInterfacesArray.length];
185             for (int i = 0; i < remoteInterfacesArray.length; i++)
186             {
187                 strings[i] = remoteInterfacesArray[i].toString();
188             }
189             setupPullDown(remoteInterfaceBox, interfaceName, strings);
190             // if interfaceName is null set the remote interface to be the first
191 // entry as setup in the remote interface name JComboBox by setupPullDown.
192 // This is to ensure that if the user does not change the JComboBox
193 // the first value is set anyway.
194 if (interfaceName == null && remoteInterfacesArray != null)
195             {
196                 model.setRemoteInterfaceType(remoteInterfacesArray[0]);
197             }
198         }
199         // if model is in state after user selects the list of remote interface
200 // then get a list of remote method names
201 if (model.getState() > MethodConfig.METHOD_GET_REMOTE_NAMES)
202         {
203             log.debug("METHOD_GET_REMOTE_NAMES");
204             methodName = model.getMethodRemoteName();
205             log.debug("updateGui1 : remote method name - " + methodName);
206             strings = model.getMethodRemoteList();
207             setupPullDown(methodRemoteNameBox, methodName, strings);
208             childCount = treeModelRemote.getChildCount(rootRemote);
209             if (log.isDebugEnabled())
210             {
211                 log.debug("updateGui1 : rootRemote child count - " + childCount);
212             }
213         }
214         // if model is in state after getting remote interface AND
215 // rootRemote(method) has no child(parms set) yet then get them
216 if (model.getState() > MethodConfig.METHOD_GET_REMOTE_PARMS
217             && childCount == 0)
218         {
219             log.debug("METHOD_GET_REMOTE_PARMS");
220             rootRemote.setUserObject(model.getMethodRemoteName());
221             // methodParmsPanel.setVisible(true);
222 // get all the parms
223 Class JavaDoc[] parmTypes = model.getMethodRemoteParms();
224             // add all the parms into a JTree
225 for (int i = 0; i < parmTypes.length; i++)
226             {
227                 log.debug("updateGui1 : parmType #" + i + " - " + parmTypes[i]);
228                 recurseParm(parmTypes[i], rootHome, i, treeModelHome);
229             }
230             // if the chosen method has no parms then updating the value of
231 // root node with the method name doesn't seem to trigger a redraw of
232 // the tree so call treeDidChange()
233 if (parmTypes.length == 0)
234             {
235                 jTreeRemote.treeDidChange();
236             }
237         }
238         // if the state of the MethodConfig of this gui is
239 // MethodConfig.METHOD_GET_HOME_PARMS, display panel
240 if (displayName)
241         {
242             namePanel.updateGui();
243         }
244         log.debug("End : updateGui1");
245     }
246     //----- ModelSupported interface : end -----
247 protected void init()
248     {
249         log.info("Start : init1");
250         // The frame is required because the JDialog we create must be modal
251 // and to be modal it must be modal relative to a frame. We want
252 // the dialog boxes to be modal so that user must fill them up before
253 // they can do anything with jmeter
254 GuiPackage guiPkg = GuiPackage.getInstance();
255         frame = guiPkg.getMainFrame();
256         model.setState(MethodConfig.METHOD_GET_HOME_NAMES);
257         model.setGui(this);
258         methodHomeNameBox = new JComboBox JavaDoc();
259         methodHomeNameBox.setEditable(false);
260         methodHomeNameBox.setAlignmentX(Component.LEFT_ALIGNMENT);
261         methodHomeNameBox.addActionListener(new ActionListener JavaDoc()
262         {
263             public void actionPerformed(ActionEvent JavaDoc e)
264             {
265                 log.debug("actionPerformed1 : Home name method JComboBox changed");
266                 // change in method name so do the following
267 JComboBox JavaDoc comboBox = (JComboBox JavaDoc) e.getSource();
268                 String JavaDoc method = (String JavaDoc) methodHomeNameBox.getSelectedItem();
269                 model.setMethodHomeName(method);
270                 model.setState(MethodConfig.METHOD_GET_HOME_PARMS);
271                 resetHomeMethodParms();
272                 resetRemoteInterfaceList();
273                 resetRemoteMethodName();
274                 resetRemoteMethodParms();
275                 // methodParmsPanel.setVisible(false);
276 actionButton.setText(
277                     JMeterUtils.getResString("jndi_method_button_reflect"));
278                 updateGui();
279             }
280         });
281         remoteInterfaceBox = new JComboBox JavaDoc();
282         remoteInterfaceBox.setEditable(false);
283         remoteInterfaceBox.setAlignmentX(Component.LEFT_ALIGNMENT);
284         remoteInterfaceBox.addActionListener(new ActionListener JavaDoc()
285         {
286             public void actionPerformed(ActionEvent JavaDoc e)
287             {
288                 log.debug("actionPerformed1 : Remote Interface JComboBox changed");
289                 JComboBox JavaDoc comboBox = (JComboBox JavaDoc) e.getSource();
290                 String JavaDoc interfaceName = (String JavaDoc) remoteInterfaceBox.getSelectedItem();
291                 // compare interface selected with the ones in the remote interface
292 // list and store the corresponding object in MethodConfig
293 ArrayList JavaDoc remoteInterfaceList =
294                     (ArrayList JavaDoc) model.getRemoteInterfaceList();
295                 if (remoteInterfaceList != null)
296                 {
297                     Object JavaDoc[] remoteInterfaceListArray = remoteInterfaceList.toArray();
298                     int i = 0;
299                     boolean found = false;
300                     String JavaDoc remoteInterfaceListName = null;
301                     Object JavaDoc selectedInterface = null;
302                     while (i < remoteInterfaceListArray.length && !found)
303                     {
304                         remoteInterfaceListName = remoteInterfaceListArray[i].toString();
305                         if (remoteInterfaceListName.equals(interfaceName))
306                         {
307                             found = true;
308                             selectedInterface = remoteInterfaceListArray[i];
309                         }
310                         i++;
311                     }
312                     model.setRemoteInterfaceType(selectedInterface);
313                     model.setState(MethodConfig.METHOD_GET_REMOTE_NAMES);
314                 }
315                 resetRemoteMethodName();
316                 resetRemoteMethodParms();
317                 // methodParmsPanel.setVisible(false);
318 actionButton.setText(
319                     JMeterUtils.getResString("jndi_method_button_reflect"));
320                 updateGui();
321             }
322         });
323         methodRemoteNameBox = new JComboBox JavaDoc();
324         methodRemoteNameBox.setEditable(false);
325         methodRemoteNameBox.setAlignmentX(Component.LEFT_ALIGNMENT);
326         methodRemoteNameBox.addActionListener(new ActionListener JavaDoc()
327         {
328             public void actionPerformed(ActionEvent JavaDoc e)
329             {
330                 log.debug("actionPerformed1 : Remote method name JComboBox changed");
331                 // change in method name so do the following
332 JComboBox JavaDoc comboBox = (JComboBox JavaDoc) e.getSource();
333                 String JavaDoc method = (String JavaDoc) methodRemoteNameBox.getSelectedItem();
334                 model.setMethodRemoteName(method);
335                 model.setState(MethodConfig.METHOD_GET_REMOTE_PARMS);
336                 resetRemoteMethodParms();
337                 // methodParmsPanel.setVisible(false);
338 actionButton.setText(
339                     JMeterUtils.getResString("jndi_method_button_reflect"));
340                 updateGui();
341             }
342         });
343         //rootHome = new DefaultMutableTreeNode("Root");
344 //treeModelHome = new DefaultTreeModel(rootHome);
345 this.setLayout(
346             new VerticalLayout(5, VerticalLayout.LEFT, VerticalLayout.TOP));
347         JPanel JavaDoc mainPanel = new JPanel JavaDoc();
348         Border JavaDoc margin = new EmptyBorder JavaDoc(10, 10, 5, 10);
349         mainPanel.setBorder(margin);
350         mainPanel.setLayout(new VerticalLayout(5, VerticalLayout.LEFT));
351         // title
352 JLabel JavaDoc panelTitleLabel =
353             new JLabel JavaDoc(JMeterUtils.getResString("jndi_method_title"));
354         Font JavaDoc curFont = panelTitleLabel.getFont();
355         int curFontSize = curFont.getSize();
356         curFontSize += 4;
357         panelTitleLabel.setFont(
358             new Font JavaDoc(curFont.getFontName(), curFont.getStyle(), curFontSize));
359         mainPanel.add(panelTitleLabel);
360         // name
361 namePanel = new NamePanel(model);
362         mainPanel.add(namePanel);
363         // method properties
364 JPanel JavaDoc jndiPanel = new JPanel JavaDoc();
365         jndiPanel.setLayout(new VerticalLayout(5, VerticalLayout.LEFT));
366         jndiPanel.setBorder(
367             BorderFactory.createTitledBorder(
368                 JMeterUtils.getResString("jndi_method_name")));
369         methodHomeNamePanel = getMethodHomeNamePanel();
370         methodHomeParmsPanel = getMethodHomeParmsPanel();
371         remoteInterfaceListPanel = getRemoteInterfaceListPanel();
372         methodRemoteNamePanel = getMethodRemoteNamePanel();
373         methodRemoteParmsPanel = getMethodRemoteParmsPanel();
374         jndiPanel.add(methodHomeNamePanel);
375         jndiPanel.add(methodHomeParmsPanel);
376         jndiPanel.add(remoteInterfaceListPanel);
377         jndiPanel.add(methodRemoteNamePanel);
378         jndiPanel.add(methodRemoteParmsPanel);
379         controlPanel = new JPanel JavaDoc();
380         actionButton =
381             new JButton JavaDoc(JMeterUtils.getResString("jndi_method_button_reflect"));
382         actionButton.addActionListener(this);
383         actionButton.setActionCommand(REFLECT);
384         controlPanel.add(actionButton);
385         jndiPanel.add(controlPanel);
386         mainPanel.add(jndiPanel);
387         this.add(mainPanel);
388         //methodHomeParmsPanel.setVisible(false);
389 log.info("End : init1");
390     }
391     /**
392      * Given a parameter type of a method, this method will find out
393      * if the parm type is a primitive. If so, it'll just add the parm type
394      * as a node into the tree model (used to store all parm types of the method).
395      * If however, the parm type is not a primitive, then the parm type will be
396      * further recursed i.e. a reflection of all the fields is obtained
397      * and each of which will be examined to determined if they are primitives.
398      * For those which are primitives, they'll be added to the tree model
399      * and those otherwise will be further recursed.
400      *
401      * @param parmType the parmType of a method which will be examined
402      * @param parentNode the node under which the parmType will be added to
403      * @param childIndex the index of the this parmType if it were to be added
404      * under the parent node
405      */
406     protected void recurseParm(
407         Class JavaDoc parmType,
408         DefaultMutableTreeNode JavaDoc parentNode,
409         int childIndex,
410         DefaultTreeModel JavaDoc treeModel)
411     {
412         log.debug("Start - recurseParm1");
413         DefaultMutableTreeNode JavaDoc node = new DefaultMutableTreeNode JavaDoc(parmType);
414         treeModel.insertNodeInto(node, parentNode, childIndex);
415         log.info("recurseParm1 - parent : " + parentNode);
416         log.info("recurseParm1 - parent : " + treeModel.getChildCount(parentNode));
417         log.info("recurseParm1 - child : " + treeModel.getChildCount(node));
418         if (parmType.isPrimitive())
419         {
420             // if parmType is primitive then no need to recurse the parm
421 }
422         else if (parmType.getName().equals(STRING_CLASS))
423         {
424             // consider String as a primitive i.e. there is not need to recurse parm
425 }
426         else if (parmType.isArray())
427         {
428             // if parmType is array then need to handle differently
429 }
430         else
431         {
432             // if parmType is NOT primitive then need to recurse the parm since
433 // it's an object.
434 // to recurse the object, use reflections to get all fields
435 Field JavaDoc[] fields = parmType.getFields();
436             for (int i = 0; i < fields.length; i++)
437             {
438                 Class JavaDoc fieldClass = fields[i].getType();
439                 log.debug("recurseParm1 : field #" + i + " - " + fieldClass);
440                 recurseParm(fieldClass, node, i, treeModel);
441             }
442         }
443         log.debug("End - recurseParm1");
444     }
445     protected JPanel JavaDoc getMethodHomeNamePanel()
446     {
447         log.info("Start : getMethodHomeNamePanel1");
448         JPanel JavaDoc panel = new JPanel JavaDoc();
449         panel.add(new JLabel JavaDoc(JMeterUtils.getResString("jndi_method_home_name")));
450         String JavaDoc methodName = model.getMethodHomeName();
451         if (methodName != null)
452         {
453             methodHomeNameBox.setSelectedItem(methodName);
454         }
455         panel.add(methodHomeNameBox);
456         log.info("End : getMethodHomeNamePanel1");
457         return panel;
458     }
459     protected JPanel JavaDoc getRemoteInterfaceListPanel()
460     {
461         log.info("Start : getRemoteInterfaceListPanel1");
462         JPanel JavaDoc panel = new JPanel JavaDoc();
463         panel.add(
464             new JLabel JavaDoc(
465                 JMeterUtils.getResString("jndi_method_remote_interface_list")));
466         Object JavaDoc remoteInterfaceType = model.getRemoteInterfaceType();
467         if (remoteInterfaceType != null)
468         {
469             remoteInterfaceBox.setSelectedItem(remoteInterfaceType.toString());
470         }
471         panel.add(remoteInterfaceBox);
472         log.info("End : getRemoteInterfaceListPanel1");
473         return panel;
474     }
475     protected JPanel JavaDoc getMethodRemoteNamePanel()
476     {
477         log.info("Start : getMethodRemoteNamePanel1");
478         JPanel JavaDoc panel = new JPanel JavaDoc();
479         panel.add(new JLabel JavaDoc(JMeterUtils.getResString("jndi_method_remote_name")));
480         String JavaDoc methodName = model.getMethodRemoteName();
481         if (methodName != null)
482         {
483             methodRemoteNameBox.setSelectedItem(methodName);
484         }
485         panel.add(methodRemoteNameBox);
486         log.info("End : getMethodRemoteNamePanel1");
487         return panel;
488     }
489     protected JPanel JavaDoc getMethodHomeParmsPanel()
490     {
491         log.info("Start : getMethodHomeParmsPanel1");
492         JPanel JavaDoc panel = new JPanel JavaDoc();
493         panel.add(new JLabel JavaDoc(JMeterUtils.getResString("jndi_method_home_parms")));
494         rootHome = new DefaultMutableTreeNode JavaDoc("Root");
495         treeModelHome = new DefaultTreeModel JavaDoc(rootHome);
496         jTreeHome = new JTree JavaDoc(treeModelHome);
497         jTreeHome.getSelectionModel().setSelectionMode(
498             TreeSelectionModel.SINGLE_TREE_SELECTION);
499         jTreeHome.addTreeSelectionListener(this);
500         jTreeHome.setPreferredSize(new Dimension JavaDoc(200, 50));
501         JPanel JavaDoc jTreePanel = new JPanel JavaDoc();
502         jTreePanel.add(jTreeHome);
503         panel.add(jTreePanel);
504         // set mouse listener to listen for double clicks
505 MouseListener JavaDoc ml = new MouseAdapter JavaDoc()
506         {
507             public void mousePressed(MouseEvent JavaDoc e)
508             {
509                 TreePath JavaDoc selPath = jTreeHome.getPathForLocation(e.getX(), e.getY());
510                 if (e.getClickCount() == 2)
511                 {
512                     log.info("Double clicked on - " + selPath.getLastPathComponent());
513                     DefaultMutableTreeNode JavaDoc node =
514                         (DefaultMutableTreeNode JavaDoc) selPath.getLastPathComponent();
515                     int childCount = node.getChildCount();
516                     // if node is a leaf and has a parent (i.e. not root)
517 // then node is a parm which needs a value so pop out
518 // dialog for user to fill in
519 if (childCount == 0 && node.getParent() != null)
520                     {
521                         log.info("Pop!!!");
522                         Object JavaDoc userObject = node.getUserObject();
523                         Class JavaDoc type = null;
524                         if (userObject instanceof Class JavaDoc)
525                         {
526                             type = (Class JavaDoc) userObject;
527                         }
528                         else if (userObject instanceof MethodConfigUserObject)
529                         {
530                             type = (Class JavaDoc) ((MethodConfigUserObject) userObject).getType();
531                         }
532                         MethodConfigDialog dialog = new MethodConfigDialog(frame, type);
533                         dialog.pack();
534                         dialog.setVisible(true);
535                         MethodConfigUserObject input = dialog.getValidatedInput();
536                         log.info("input - " + input);
537                         if (input != null)
538                         {
539                             node.setUserObject(input);
540                         }
541                     }
542                 }
543             }
544         };
545         jTreeHome.addMouseListener(ml);
546         log.info("End : getMethodHomeParmsPanel1");
547         return panel;
548     }
549     protected JPanel JavaDoc getMethodRemoteParmsPanel()
550     {
551         log.info("Start : getMethodRemoteParmsPanel1");
552         JPanel JavaDoc panel = new JPanel JavaDoc();
553         panel.add(new JLabel JavaDoc(JMeterUtils.getResString("jndi_method_remote_parms")));
554         rootRemote = new DefaultMutableTreeNode JavaDoc("Root");
555         treeModelRemote = new DefaultTreeModel JavaDoc(rootRemote);
556         jTreeRemote = new JTree JavaDoc(treeModelRemote);
557         jTreeRemote.getSelectionModel().setSelectionMode(
558             TreeSelectionModel.SINGLE_TREE_SELECTION);
559         jTreeRemote.addTreeSelectionListener(this);
560         jTreeRemote.setPreferredSize(new Dimension JavaDoc(200, 50));
561         JPanel JavaDoc jTreePanel = new JPanel JavaDoc();
562         jTreePanel.add(jTreeRemote);
563         panel.add(jTreePanel);
564         // set mouse listener to listen for double clicks
565 MouseListener JavaDoc ml = new MouseAdapter JavaDoc()
566         {
567             public void mousePressed(MouseEvent JavaDoc e)
568             {
569                 TreePath JavaDoc selPath = jTreeRemote.getPathForLocation(e.getX(), e.getY());
570                 if (e.getClickCount() == 2)
571                 {
572                     log.info("Double clicked on - " + selPath.getLastPathComponent());
573                     DefaultMutableTreeNode JavaDoc node =
574                         (DefaultMutableTreeNode JavaDoc) selPath.getLastPathComponent();
575                     int childCount = node.getChildCount();
576                     if (childCount == 0)
577                     {
578                         log.info("Pop!!!");
579                         Object JavaDoc userObject = node.getUserObject();
580                         Class JavaDoc type = null;
581                         if (userObject instanceof Class JavaDoc)
582                         {
583                             type = (Class JavaDoc) userObject;
584                         }
585                         else if (userObject instanceof MethodConfigUserObject)
586                         {
587                             type = (Class JavaDoc) ((MethodConfigUserObject) userObject).getType();
588                         }
589                         MethodConfigDialog dialog = new MethodConfigDialog(frame, type);
590                         dialog.pack();
591                         dialog.setVisible(true);
592                         MethodConfigUserObject input = dialog.getValidatedInput();
593                         log.info("input - " + input);
594                         if (input != null)
595                         {
596                             node.setUserObject(input);
597                         }
598                     }
599                 }
600             }
601         };
602         jTreeRemote.addMouseListener(ml);
603         log.info("End : getMethodHomeParmsPanel1");
604         return panel;
605     }
606     public MethodConfig getModel()
607     {
608         return model;
609     }
610     /**
611      * Caller needs to be able to get Method Parms for both the Home Method
612      * and Remote Method. Based on the state this method will call
613      * <code>getMethodParmsValues</code> witht the appropriate root. NOTE :
614      * parms for Home and Remote Methods are stored under different roots.
615      */
616     public Object JavaDoc[] getMethodParmsValues(int state)
617         throws MethodConfigUserObjectException
618     {
619         Object JavaDoc[] objects = null;
620         if (state == MethodConfig.METHOD_INVOKE_HOME)
621         {
622             objects = getMethodParmsValues(rootHome);
623         }
624         else if (state == MethodConfig.METHOD_INVOKE_REMOTE)
625         {
626             objects = getMethodParmsValues(rootRemote);
627         }
628         return objects;
629     }
630     public Object JavaDoc[] getMethodParmsValues(DefaultMutableTreeNode JavaDoc root)
631         throws MethodConfigUserObjectException
632 </