public HashTree addSubTree(HashTree subTree) throws IllegalUserActionException 
{
        return treeModel.addSubTree(subTree, treeListener.getCurrentNode());
}

Add a subtree to the currently selected node.

 public  void clearTestPlan() 
{
        getTreeModel().clearTestPlan();
        nodesToGui.clear();
        setTestPlanFile(null);
}

Clears the test plan and associated objects. Clears the test plan file name.

 public  void clearTestPlan(TestElement element) 
{
        getTreeModel().clearTestPlan(element);
        removeNode(element);
}

Clears the test plan element and associated object

 public TestElement createTestElement(String objClass) 
{
        JMeterGUIComponent comp;
        Class c;
        try {
            c = Class.forName(objClass);
            if (TestBean.class.isAssignableFrom(c)) {
                comp = getGuiFromCache(TestBeanGUI.class, c);
            } else {
                comp = getGuiFromCache(c, null);
            }
            comp.clearGui();
            TestElement node = comp.createTestElement();
            nodesToGui.put(node, comp);
            return node;
        } catch (NoClassDefFoundError e) {
            log.error("Problem retrieving gui for " + objClass, e);
            String msg="Cannot find class: "+e.getMessage();
            JOptionPane.showMessageDialog(null,
                    msg,
                    "Missing jar? See log file." ,
                    JOptionPane.ERROR_MESSAGE);
            throw new RuntimeException(e.toString()); // Probably a missing
                                                        // jar
        } catch (ClassNotFoundException e) {
            log.error("Problem retrieving gui for " + objClass, e);
            throw new RuntimeException(e.toString()); // Programming error:
                                                        // bail out.
        } catch (InstantiationException e) {
            log.error("Problem retrieving gui for " + objClass, e);
            throw new RuntimeException(e.toString()); // Programming error:
                                                        // bail out.
        } catch (IllegalAccessException e) {
            log.error("Problem retrieving gui for " + objClass, e);
            throw new RuntimeException(e.toString()); // Programming error:
                                                        // bail out.
        }
}

Create a TestElement for a GUI or TestBean class.

This is a utility method to help actions do with one single String parameter.

 public TestElement createTestElement(Class guiClass,
    Class testClass) 
{
        try {
            JMeterGUIComponent comp = getGuiFromCache(guiClass, testClass);
            comp.clearGui();
            TestElement node = comp.createTestElement();
            nodesToGui.put(node, comp);
            return node;
        } catch (Exception e) {
            log.error("Problem retrieving gui", e);
            return null;
        }
}

Create a TestElement corresponding to the specified GUI class.

 public  void displayPopUp(MouseEvent e,
    JPopupMenu popup) 
{
        displayPopUp((Component) e.getSource(), e, popup);
}

Display the specified popup menu with the source component and location from the specified mouse event.

 public  void displayPopUp(Component invoker,
    MouseEvent e,
    JPopupMenu popup) 
{
        if (popup != null) {
            log.debug("Showing pop up for " + invoker + " at x,y = " + e.getX() + "," + e.getY());
            popup.pack();
            popup.show(invoker, e.getX(), e.getY());
            popup.setVisible(true);
            popup.requestFocus();
        }
}

Display the specified popup menu at the location specified by a mouse event with the specified source component.

 public TestElement getCurrentElement() 
{
        return getCurrentNode().getTestElement();
}

 public JMeterGUIComponent getCurrentGui() 
{
        try {
            updateCurrentNode();
            TestElement curNode = treeListener.getCurrentNode().getTestElement();
            JMeterGUIComponent comp = getGui(curNode);
            comp.clearGui();
            log.debug("Updating gui to new node");
            comp.configure(curNode);
            currentNodeUpdated = false;
            return comp;
        } catch (Exception e) {
            log.error("Problem retrieving gui", e);
            return null;
        }
}

Convenience method for grabbing the gui for the current node.

 public JMeterTreeNode getCurrentNode() 
{
        return treeListener.getCurrentNode();
}

 public HashTree getCurrentSubTree() 
{
        return treeModel.getCurrentSubTree(treeListener.getCurrentNode());
}

Get the currently selected subtree.

 public JMeterGUIComponent getGui(TestElement node) 
{
        String testClassName = node.getPropertyAsString(TestElement.TEST_CLASS);
        String guiClassName = node.getPropertyAsString(TestElement.GUI_CLASS);
        try {
            Class testClass;
            if (testClassName.equals("")) { // $NON-NLS-1$
                testClass = node.getClass();
            } else {
                testClass = Class.forName(testClassName);
            }
            Class guiClass = null;
            if (!guiClassName.equals("")) { // $NON-NLS-1$
                guiClass = Class.forName(guiClassName);
            }
            return getGui(node, guiClass, testClass);
        } catch (ClassNotFoundException e) {
            log.error("Could not get GUI for " + node, e);
            return null;
        }
}

Get a JMeterGUIComponent for the specified test element. If the GUI has already been created, that instance will be returned. Otherwise, if a GUI component of the same type has been created, and the component is not marked as an UnsharedComponent , that shared component will be returned. Otherwise, a new instance of the component will be created. The TestElement's GUI_CLASS property will be used to determine the appropriate type of GUI component to use.

 public JMeterGUIComponent getGui(TestElement node,
    Class guiClass,
    Class testClass) 
{
        try {
            JMeterGUIComponent comp = (JMeterGUIComponent) nodesToGui.get(node);
            if (comp == null) {
                comp = getGuiFromCache(guiClass, testClass);
                nodesToGui.put(node, comp);
            }
            log.debug("Gui retrieved = " + comp);
            return comp;
        } catch (Exception e) {
            log.error("Problem retrieving gui", e);
            return null;
        }
}

Get a JMeterGUIComponent for the specified test element. If the GUI has already been created, that instance will be returned. Otherwise, if a GUI component of the same type has been created, and the component is not marked as an UnsharedComponent , that shared component will be returned. Otherwise, a new instance of the component will be created.

 public static GuiPackage getInstance() 
{
        return guiPack;
}

Retrieve the singleton GuiPackage instance.

 public static GuiPackage getInstance(JMeterTreeListener listener,
    JMeterTreeModel treeModel) 
{
        if (guiPack == null) {
            guiPack = new GuiPackage();
            guiPack.setTreeListener(listener);
            guiPack.setTreeModel(treeModel);
        }
        return guiPack;
}

When GuiPackage is requested for the first time, it should be given handles to JMeter's Tree Listener and TreeModel.

 public MainFrame getMainFrame() 
{
        return mainFrame;
}

Get the main JMeter frame.

 public JMeterTreeNode getNodeOf(TestElement userObject) 
{
        return treeModel.getNodeOf(userObject);
}

Find the JMeterTreeNode for a certain TestElement object.

 public ValueReplacer getReplacer() 
{
        return new ValueReplacer((TestPlan) ((JMeterTreeNode) getTreeModel().getTestPlan().getArray()[0])
                .getTestElement());
}

Get a ValueReplacer for the test tree.

 public String getTestPlanFile() 
{
        return testPlanFile;
}

 public JMeterTreeListener getTreeListener() 
{
        return treeListener;
}

Get the listener for JMeter's test tree.

 public JMeterTreeModel getTreeModel() 
{
        return treeModel;
}

Get the model for JMeter's test tree.

 public boolean isDirty() 
{
        return dirty;
}

Retrieves the state of the 'dirty' property, a flag that indicates if there are test tree components that have been modified since they were last saved.

 public  void localeChanged(LocaleChangeEvent event) 
{
        // FIrst make sure we save the content of the current GUI (since we
        // will flush it away):
        updateCurrentNode();
        // Forget about all GUIs we've created so far: we'll need to re-created
        // them all!
        guis = new HashMap();
        nodesToGui = new HashMap();
        testBeanGUIs = new HashMap();
        // BeanInfo objects also contain locale-sensitive data -- flush them
        // away:
        Introspector.flushCaches();
        // Now put the current GUI in place. [This code was copied from the
        // EditCommand action -- we can't just trigger the action because that
        // would populate the current node with the contents of the new GUI --
        // which is empty.]
        MainFrame mf = getMainFrame(); // Fetch once
        if (mf == null) // Probably caused by unit testing on headless system
        {
            log.warn("Mainframe is null");
        } else {
            mf.setMainPanel((javax.swing.JComponent) getCurrentGui());
            mf.setEditMenu(getTreeListener().getCurrentNode().createPopupMenu());
        }
}

 public  void removeNode(TestElement node) 
{
        nodesToGui.remove(node);
}

Remove a test element from the tree. This removes the reference to any associated GUI component.

 public  void setDirty(boolean dirty) 
{
        this.dirty = dirty;
}

The dirty property is a flag that indicates whether there are parts of JMeter's test tree that the user has not saved since last modification. Various (@link Command actions) set this property when components are modified/created/saved.

 public  void setMainFrame(MainFrame newMainFrame) 
{
        mainFrame = newMainFrame;
}

Set the main JMeter frame.

 public  void setTestPlanFile(String f) 
{
        testPlanFile = f;
        getMainFrame().setExtendedFrameTitle(testPlanFile);
        // Enable file revert action if a file is used
        getMainFrame().setFileRevertEnabled(f != null);
        getMainFrame().setProjectFileLoaded(f);
        try {
            FileServer.getFileServer().setBasedir(testPlanFile);
        } catch (IOException e1) {
            log.error("Failure setting file server's base dir", e1);
        }
}

Sets the filepath of the current test plan. It's shown in the main frame title and used on saving.

 public  void setTreeListener(JMeterTreeListener newTreeListener) 
{
        treeListener = newTreeListener;
}

Set the listener for JMeter's test tree.

 public  void setTreeModel(JMeterTreeModel newTreeModel) 
{
        treeModel = newTreeModel;
}

Set the model for JMeter's test tree.

 public static  void showErrorMessage(String message,
    String title) 
{
        showMessage(message,title,JOptionPane.ERROR_MESSAGE);
}

 public static  void showInfoMessage(String message,
    String title) 
{
        showMessage(message,title,JOptionPane.INFORMATION_MESSAGE);
}

 public static  void showMessage(String message,
    String title,
    int type) 
{
        if (guiPack == null) {
            return ;
        }
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                JOptionPane.showMessageDialog(null,message,title,type);
            }
        });
}

 public static  void showWarningMessage(String message,
    String title) 
{
        showMessage(message,title,JOptionPane.WARNING_MESSAGE);
}

 public  void updateCurrentGui() 
{
        updateCurrentNode();
        currentNode = treeListener.getCurrentNode();
        TestElement element = currentNode.getTestElement();
        JMeterGUIComponent comp = getGui(element);
        comp.configure(element);
        currentNodeUpdated = false;
}

Update the GUI for the currently selected node. The GUI component is configured to reflect the settings in the current tree node.

 public  void updateCurrentNode() 
{
        try {
            if (currentNode != null && !currentNodeUpdated) {
                log.debug("Updating current node " + currentNode.getName());
                JMeterGUIComponent comp = getGui(currentNode.getTestElement());
                TestElement el = currentNode.getTestElement();
                comp.modifyTestElement(el);
            }
            // The current node is now updated
            currentNodeUpdated = true;
            currentNode = treeListener.getCurrentNode();
        } catch (Exception e) {
            log.error("Problem retrieving gui", e);
        }
}

This method should be called in order for GuiPackage to change the current node. This will save any changes made to the earlier node before choosing the new node.