guipackage.java

测试工具

	/**
	 * Get an instance of the specified JMeterGUIComponent class. If an instance
	 * of the GUI class has previously been created and it is not marked as an
	 * {@link UnsharedComponent}, that shared instance will be returned.
	 * Otherwise, a new instance of the component will be created, and shared
	 * components will be cached for future retrieval.
	 * 
	 * @param guiClass
	 *            the fully qualified class name of the GUI component. This
	 *            class must implement JMeterGUIComponent.
	 * @param testClass
	 *            the fully qualified class name of the test elements edited by
	 *            this GUI component. This class must implement TestElement.
	 * @return an instance of the specified class
	 * 
	 * @throws InstantiationException
	 *             if an instance of the object cannot be created
	 * @throws IllegalAccessException
	 *             if access rights do not allow the default constructor to be
	 *             called
	 * @throws ClassNotFoundException
	 *             if the specified GUI class cannot be found
	 */
	private JMeterGUIComponent getGuiFromCache(Class guiClass, Class testClass) throws InstantiationException,
			IllegalAccessException {
		JMeterGUIComponent comp;
		if (guiClass == TestBeanGUI.class) {
			comp = (TestBeanGUI) testBeanGUIs.get(testClass);
			if (comp == null) {
				comp = new TestBeanGUI(testClass);
				testBeanGUIs.put(testClass, comp);
			}
		} else {
			comp = (JMeterGUIComponent) guis.get(guiClass);
			if (comp == null) {
				comp = (JMeterGUIComponent) guiClass.newInstance();
				if (!(comp instanceof UnsharedComponent)) {
					guis.put(guiClass, comp);
				}
			}
		}
		return comp;
	}

	/**
	 * Update the GUI for the currently selected node. The GUI component is
	 * configured to reflect the settings in the current tree node.
	 * 
	 */
	public void updateCurrentGui() {
		updateCurrentNode();
		currentNode = treeListener.getCurrentNode();
		TestElement element = currentNode.getTestElement();
		JMeterGUIComponent comp = getGui(element);
		comp.configure(element);
		currentNodeUpdated = false;
	}

	/**
	 * 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.
	 */
	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);
		}
	}

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

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

	/**
	 * 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.
	 * 
	 * @param dirty
	 *            the new value of the dirty flag
	 */
	public void setDirty(boolean dirty) {
		this.dirty = 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.
	 * 
	 * @return true if some tree components have been modified since they were
	 *         last saved, false otherwise
	 */
	public boolean isDirty() {
		return dirty;
	}

	/**
	 * Add a subtree to the currently selected node.
	 * 
	 * @param subTree
	 *            the subtree to add.
	 * 
	 * @return the resulting subtree starting with the currently selected node
	 * 
	 * @throws IllegalUserActionException
	 *             if a subtree cannot be added to the currently selected node
	 */
	public HashTree addSubTree(HashTree subTree) throws IllegalUserActionException {
		return treeModel.addSubTree(subTree, treeListener.getCurrentNode());
	}

	/**
	 * Get the currently selected subtree.
	 * 
	 * @return the subtree of the currently selected node
	 */
	public HashTree getCurrentSubTree() {
		return treeModel.getCurrentSubTree(treeListener.getCurrentNode());
	}

	/**
	 * Get the model for JMeter's test tree.
	 * 
	 * @return the JMeter tree model
	 */
	public JMeterTreeModel getTreeModel() {
		return treeModel;
	}

	/**
	 * Set the model for JMeter's test tree.
	 * 
	 * @param newTreeModel
	 *            the new JMeter tree model
	 */
	public void setTreeModel(JMeterTreeModel newTreeModel) {
		treeModel = newTreeModel;
	}

	/**
	 * Get a ValueReplacer for the test tree.
	 * 
	 * @return a ValueReplacer configured for the test tree
	 */
	public ValueReplacer getReplacer() {
		return new ValueReplacer((TestPlan) ((JMeterTreeNode) getTreeModel().getTestPlan().getArray()[0])
				.getTestElement());
	}

	/**
	 * Set the main JMeter frame.
	 * 
	 * @param newMainFrame
	 *            the new JMeter main frame
	 */
	public void setMainFrame(MainFrame newMainFrame) {
		mainFrame = newMainFrame;
	}

	/**
	 * Get the main JMeter frame.
	 * 
	 * @return the main JMeter frame
	 */
	public MainFrame getMainFrame() {
		return mainFrame;
	}

	/**
	 * Set the listener for JMeter's test tree.
	 * 
	 * @param newTreeListener
	 *            the new JMeter test tree listener
	 */
	public void setTreeListener(JMeterTreeListener newTreeListener) {
		treeListener = newTreeListener;
	}

	/**
	 * Get the listener for JMeter's test tree.
	 * 
	 * @return the JMeter test tree listener
	 */
	public JMeterTreeListener getTreeListener() {
		return treeListener;
	}

	/**
	 * Display the specified popup menu with the source component and location
	 * from the specified mouse event.
	 * 
	 * @param e
	 *            the mouse event causing this popup to be displayed
	 * @param popup
	 *            the popup menu to display
	 */
	public void displayPopUp(MouseEvent e, JPopupMenu popup) {
		displayPopUp((Component) e.getSource(), e, popup);
	}

	/**
	 * Display the specified popup menu at the location specified by a mouse
	 * event with the specified source component.
	 * 
	 * @param invoker
	 *            the source component
	 * @param e
	 *            the mouse event causing this popup to be displayed
	 * @param popup
	 *            the popup menu to display
	 */
	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();
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.apache.jmeter.util.LocaleChangeListener#localeChanged(org.apache.jmeter.util.LocaleChangeEvent)
	 */
	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());
		}
	}

	private String testPlanFile;

	/**
	 * Sets the filepath of the current test plan. It's shown in the main frame
	 * title and used on saving.
	 * 
	 * @param f
	 */
	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);
		}
	}

	public String getTestPlanFile() {
		return testPlanFile;
	}


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

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

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

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