operatortree.java

著名的开源仿真软件yale

/*
 *  YALE - Yet Another Learning Environment
 *  Copyright (C) 2002, 2003
 *      Simon Fischer, Ralf Klinkenberg, Ingo Mierswa, 
 *          Katharina Morik, Oliver Ritthoff
 *      Artificial Intelligence Unit
 *      Computer Science Department
 *      University of Dortmund
 *      44221 Dortmund,  Germany
 *  email: [e-mail]
 *  web:   http://yale.cs.uni-dortmund.de/
 *
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as 
 *  published by the Free Software Foundation; either version 2 of the
 *  License, or (at your option) any later version. 
 *
 *  This program is distributed in the hope that it will be useful, but
 *  WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 *  General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
 *  USA.
 */
package edu.udo.cs.yale.gui;

import edu.udo.cs.yale.Yale;
import edu.udo.cs.yale.operator.Operator;
import edu.udo.cs.yale.operator.OperatorChain;
import edu.udo.cs.yale.tools.Tools;

import java.io.File;
import javax.swing.JTree;
import javax.swing.ImageIcon;
import javax.swing.tree.TreeNode;
import javax.swing.tree.TreeCellRenderer;
import javax.swing.tree.TreePath;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.event.TreeSelectionListener;
import javax.swing.AbstractAction;
import javax.swing.JCheckBoxMenuItem;
import javax.swing.JMenuItem;
import java.awt.event.KeyEvent;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.Dimension;
import javax.swing.Action;
import javax.swing.JPopupMenu;
import javax.swing.JOptionPane;
import javax.swing.JMenu;
import javax.swing.KeyStroke; 
import javax.swing.ToolTipManager; 

/** Displays the experiment as a JTree. 
 *  @see edu.udo.cs.yale.gui.OperatorTreeModel */
public class OperatorTree extends JTree implements TreeSelectionListener, MouseListener {
    
    private MainFrame mainFrame;

    private OperatorTreeModel treeModel;
    private Operator clipBoard = null;

    private class CutAction extends ConditionalAction {
	private CutAction() { 
	    super("Cut",
		  new ImageIcon(Tools.getResource("icons/icon_cut.gif"))); 
   	    putValue(SHORT_DESCRIPTION, "Cut selected operator");
	    putValue(MNEMONIC_KEY, new Integer(KeyEvent.VK_C));
	    putValue(ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_X, java.awt.event.InputEvent.CTRL_MASK));
	    setCondition(OPERATOR_SELECTED, MANDATORY);
	    setCondition(ROOT_SELECTED, DISALLOWED);
	}
	public void actionPerformed(ActionEvent e) { 
	    Operator selectedOperator = getSelectedOperator();
	    if (selectedOperator != null) {
		clipBoard = selectedOperator;
		delete();
	    }
	}
    }
    
    private class PasteAction extends ConditionalAction {
	private PasteAction() { 
	    super("Paste",
		  new ImageIcon(Tools.getResource("icons/icon_paste.gif"))); 
   	    putValue(SHORT_DESCRIPTION, "Paste operator");
	    putValue(MNEMONIC_KEY, new Integer(KeyEvent.VK_P));
	    putValue(ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_V, java.awt.event.InputEvent.CTRL_MASK));
	    setCondition(CLIPBOARD_FILLED, MANDATORY);
	    setCondition(OPERATOR_CHAIN_SELECTED, MANDATORY);
	}
	public void actionPerformed(ActionEvent e) { 
	    if (clipBoard != null)
		insert(clipBoard);
	}
    }

    private class InsertOperatorAction extends ConditionalAction {

	private InsertOperatorAction() { 
	    super("Insert operator...",
		  new ImageIcon(Tools.getResource("icons/icon_insert_operator.gif"))); 
   	    putValue(SHORT_DESCRIPTION, "Insert new operator");
	    putValue(MNEMONIC_KEY, new Integer(KeyEvent.VK_I));
	    putValue(ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_I, java.awt.event.InputEvent.CTRL_MASK));
	    setCondition(OPERATOR_CHAIN_SELECTED, MANDATORY);
	}
	public void actionPerformed(ActionEvent e) { 
	    Operator newOperator = NewOperatorDialog.newOperator(mainFrame);
	    if (newOperator != null)
		insert(newOperator);
	}
    }

    private class DeleteOperatorAction extends ConditionalAction {
	private DeleteOperatorAction() { 
	    super("Delete operator",
		  new ImageIcon(Tools.getResource("icons/icon_delete_operator.gif"))); 
   	    putValue(SHORT_DESCRIPTION, "Delete selected operator");
	    putValue(MNEMONIC_KEY, new Integer(KeyEvent.VK_D));
	    putValue(ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_D, java.awt.event.InputEvent.CTRL_MASK));
	    setCondition(OPERATOR_SELECTED, MANDATORY);
	    setCondition(ROOT_SELECTED, DISALLOWED);
	}
	public void actionPerformed(ActionEvent e) { 
	    delete();
	}
    }

    private class RenameOperatorAction extends ConditionalAction {
	private RenameOperatorAction() { 
	    super("Rename operator"); 
   	    putValue(SHORT_DESCRIPTION, "Rename selected operator");
	    putValue(MNEMONIC_KEY, new Integer(KeyEvent.VK_R));
	    putValue(ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_F2, 0));
	    setCondition(OPERATOR_SELECTED, MANDATORY);
	}
	public void actionPerformed(ActionEvent e) { 
	    TreePath path = getSelectionPath();
	    if (path != null) {
		startEditingAtPath(path);
	    }
	}
    }

    private class InfoOperatorAction extends ConditionalAction {
	private InfoOperatorAction() { 
	    super("Operator Info",
		  new ImageIcon(Tools.getResource("icons/icon_info.gif"))); 
   	    putValue(SHORT_DESCRIPTION, "Shows information about selected operator");
	    putValue(MNEMONIC_KEY, new Integer(KeyEvent.VK_I));
	    putValue(ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_F1, 0));
	    setCondition(OPERATOR_SELECTED, MANDATORY);
	}
	public void actionPerformed(ActionEvent e) { 
	    Operator selectedOperator = getSelectedOperator();
	    if (selectedOperator != null) {
		new OperatorInfoScreen(mainFrame, selectedOperator).show();
	    }
	}
    }

    private static final String[] BREAKPOINT_POS_NAME = {"before","after"};
    private class ToggleBreakpointItem extends JCheckBoxMenuItem implements ActionListener {
	private int position;
	private ToggleBreakpointItem(int position) { 
	    super("Breakpoint "+BREAKPOINT_POS_NAME[position]);
	    this.position = position;
	    addActionListener(this);
   	    setToolTipText("Toggle breakpoint " + BREAKPOINT_POS_NAME[position] + " selected operator");
	    setMnemonic(position == 0 ? KeyEvent.VK_B : KeyEvent.VK_A);
	}
	public void actionPerformed(ActionEvent e) { 
	    Operator selectedOperator = getSelectedOperator();
	    if (selectedOperator != null) {
		selectedOperator.setBreakpoint(position, getState());
		refresh();
	    }
	}
    }


    public final Action CUT_ACTION             = new CutAction();
    public final Action PASTE_ACTION           = new PasteAction();
    public final Action INSERT_OPERATOR_ACTION = new InsertOperatorAction();
    public final Action DELETE_OPERATOR_ACTION = new DeleteOperatorAction();
    public final Action RENAME_OPERATOR_ACTION = new RenameOperatorAction();
    public final Action INFO_OPERATOR_ACTION   = new InfoOperatorAction();
    public final ToggleBreakpointItem TOGGLE_BREAKPOINT[] = { new ToggleBreakpointItem(0),
							      new ToggleBreakpointItem(1) };

    public OperatorTree(MainFrame mainFrame) {
	super();
	setCellRenderer(new OperatorTreeCellRenderer());
	setCellEditor(new OperatorTreeCellEditor(this));
	this.mainFrame = mainFrame;
	setEditable(true);
	setShowsRootHandles(true);
	addTreeSelectionListener(this);	
	addMouseListener(this);
	ToolTipManager.sharedInstance().registerComponent(this);
    }

    public void setOperator(Operator root) {
	this.treeModel = new OperatorTreeModel(root);
	setModel(treeModel);
	this.mainFrame = mainFrame;
	setRootVisible(true);
	for (int i = 0; i < getRowCount(); i++)
	    expandRow(i);
    }

    public Operator getSelectedOperator() {
	TreePath path = getSelectionPath();
	if (path == null) return null; 
	else return (Operator)path.getLastPathComponent();
    }

    public void refresh() {
	refresh(new TreePath(treeModel.getRoot()));
    }

    private void refresh(TreePath path) {
	treeModel.fireOperatorChanged(this, path);
	Object object = path.getLastPathComponent();
	int numberOfChildren = treeModel.getChildCount(object);
	for (int i = 0; i < numberOfChildren; i++) {
	    Object child = treeModel.getChild(object, i);
	    refresh(path.pathByAddingChild(child));
	}
    }

    public void moveDown() {
	Operator selectedOperator = getSelectedOperator();
	if (selectedOperator == null) return;
	OperatorChain parent = selectedOperator.getParent();
	if (parent == null) return;
	int oldPos = parent.getIndexOfOperator(selectedOperator);
	if (oldPos < parent.getNumberOfOperators()-1) {
	    selectedOperator.remove();
	    parent.addOperator(selectedOperator, oldPos+1);
	    TreePath path = getSelectionPath().getParentPath();
	    treeModel.fireStructureChanged(this, path);
	    setSelectionPath(path.pathByAddingChild(selectedOperator));
	    mainFrame.experimentChanged();
	}
    }

    public void moveUp() {
	Operator selectedOperator = getSelectedOperator();
	if (selectedOperator == null) return;
	OperatorChain parent = selectedOperator.getParent();
	if (parent == null) return;
	int oldPos = parent.getIndexOfOperator(selectedOperator);
	if (oldPos > 0) {
	    selectedOperator.remove();
	    parent.addOperator(selectedOperator, oldPos-1);
	    TreePath path = getSelectionPath().getParentPath();
	    treeModel.fireStructureChanged(this, path);
	    setSelectionPath(path.pathByAddingChild(selectedOperator));
	    mainFrame.experimentChanged();
	}
    }

    private void delete() {
	Operator selectedOperator = getSelectedOperator();
	if (selectedOperator == null) return;
	int index = selectedOperator.getParent().getIndexOfOperator(selectedOperator);
	selectedOperator.remove();
	treeModel.fireOperatorRemoved(this, getSelectionPath().getParentPath(), index, selectedOperator);
	mainFrame.experimentChanged();
	mainFrame.enableActions();
    }

    public void insert(Operator newOperator) {
	Operator selectedOperator = getSelectedOperator();
	if (selectedOperator == null) return;
	if (selectedOperator instanceof OperatorChain) {
	    int index = ((OperatorChain)selectedOperator).addOperator(newOperator);
	    treeModel.fireOperatorInserted(this, getSelectionPath(), index, newOperator);
	    scrollPathToVisible(getSelectionPath().pathByAddingChild(newOperator));
	    mainFrame.experimentChanged();
	}
    }

    public void valueChanged(TreeSelectionEvent e) {
	Operator selectedOperator = getSelectedOperator();
	mainFrame.getPropertyTable().setOperator(selectedOperator);
	if (selectedOperator == null) return;
	mainFrame.enableActions();
	for (int i = 0; i < TOGGLE_BREAKPOINT.length; i++)
	    TOGGLE_BREAKPOINT[i].setState(selectedOperator.hasBreakpoint(i));	     
    }

    public void mouseEntered(MouseEvent e) {}
    public void mouseExited(MouseEvent e) {}
    public void mouseReleased(MouseEvent e) {}
    public void mouseClicked(MouseEvent e) {}


    public void mousePressed(MouseEvent e) {
	setSelectionPath(getClosestPathForLocation(e.getX(), e.getY()));
	if (e.getModifiers() == MouseEvent.BUTTON3_MASK) {
	    createPopupMenu().show(this,e.getX(), e.getY());
	}
    }

    public JMenu createOperatorMenu() {
	JMenu menu = new JMenu("Operator");
	menu.setMnemonic(KeyEvent.VK_O);
	menu.add(CUT_ACTION);
	menu.add(PASTE_ACTION);
	menu.addSeparator();
	menu.add(INSERT_OPERATOR_ACTION);
	menu.add(DELETE_OPERATOR_ACTION);
	menu.add(RENAME_OPERATOR_ACTION);
	menu.addSeparator();
	menu.add(INFO_OPERATOR_ACTION);
	return menu;
    }

    public JPopupMenu createPopupMenu() {
	Operator op = getSelectedOperator();

	JPopupMenu menu = new JPopupMenu();
	menu.add(CUT_ACTION);
	menu.add(PASTE_ACTION);
	menu.addSeparator();
	if ((op != null) && (op instanceof OperatorChain))
	    menu.add(OperatorMenu.OPERATOR_MENU);
	menu.add(INSERT_OPERATOR_ACTION);
	menu.add(DELETE_OPERATOR_ACTION);
	menu.add(RENAME_OPERATOR_ACTION);
	menu.addSeparator();
	menu.add(INFO_OPERATOR_ACTION);
	menu.addSeparator();
	for (int i = 0; i < TOGGLE_BREAKPOINT.length; i++)
	    menu.add(TOGGLE_BREAKPOINT[i]);
	return menu;
    }

    public Operator getClipBoard() { return clipBoard; }
}