mainframe.java

著名的开源仿真软件yale

	menuBar.add(expMenu);

	setJMenuBar(menuBar);

	JMenu helpMenu = new JMenu("Help");
	helpMenu.setMnemonic(KeyEvent.VK_H);
	JMenuItem aboutItem = new JMenuItem("About",
					    new ImageIcon(Tools.getResource("icons/icon_about.gif")));
	aboutItem.setToolTipText("Display information about Yale");
	aboutItem.addActionListener(new ActionListener() {
		public void actionPerformed(ActionEvent e) {
		    try {
			new AboutBox(MainFrame.this, 
				     "YALE", 
				     "YALE - Yet Another Learning Environment\n"+
				     "Copyright (C) 2001, 2002, 2003 "+
				     "Simon Fischer, Ralf Klinkenberg, Ingo Mierswa, Katharina Morik, Oliver Ritthoff\n"+
				     "Artificial Intelligence Unit, Computer Science Department, University of Dortmund, 44221 Dortmund, Germany\n"+
				     "email: [e-mail], web: http://yale.cs.uni-dortmund.de/\n\n"+
				     "Yale comes with ABSOLUTELY NO WARRANTY; This is free software," +
				     "and you are welcome to redistribute it under certain conditions;"+
				     "see license information in the file named LICENSE.",
				     new Image[] { ImageIO.read(Tools.getResource("yale_logo.gif"))}).show();
		    } catch (IOException ioe) {
			ioe.printStackTrace();
		    }
		}
	    });
	helpMenu.add(aboutItem);
	JMenuItem contents = new JMenuItem("Contents");
	contents.setToolTipText("Browse the Yale GU Manual");
	contents.addActionListener(new ActionListener() {
		public void actionPerformed(ActionEvent e) {
		    //Browser.showDialog("file:///home/simon/yale/tutorial/Manual-HTML/Manual.html");
		    Browser.showDialog(Tools.getResource("html/manual/Manual.html"));
		}
	    });
	helpMenu.add(contents);

	menuBar.add(helpMenu);

	JMenuItem paperItem = new JMenuItem("Generate Paper");
	paperItem.addActionListener(new ActionListener() {
		public void actionPerformed(ActionEvent e) {
		    JOptionPane.showMessageDialog(MainFrame.this, 
						  "Function will be implemented in later release.", 
						  "Error", 
						  JOptionPane.WARNING_MESSAGE);
		} 
	    });
	helpMenu.add(paperItem);
	menuBar.add(helpMenu);
	
	JToolBar toolBar = new JToolBar();
	toolBar.setRollover(true);
	toolBar.removeNotify();
	toolBar.add(NEW_ACTION);
	toolBar.add(OPEN_ACTION);
	toolBar.add(SAVE_ACTION);
        toolBar.add(SAVE_AS_ACTION);
        toolBar.add(PRINT_ACTION);
	toolBar.addSeparator();
        toolBar.add(treePanel.getOperatorTree().CUT_ACTION);
        toolBar.add(treePanel.getOperatorTree().PASTE_ACTION);
	toolBar.addSeparator();
	toolBar.add(RUN_ACTION);
	toolBar.add(RESUME_ACTION);
	toolBar.add(STOP_ACTION);
	toolBar.addSeparator();
        toolBar.add(treePanel.getOperatorTree().INSERT_OPERATOR_ACTION);
	toolBar.add(VALIDATE_ACTION);
	getContentPane().add(toolBar, BorderLayout.NORTH);
	getContentPane().add(statusBar, BorderLayout.SOUTH);

	enableActions();
	pack();
	splitPaneV.setDividerLocation(3*splitPaneV.getHeight()/4);
    }

    public int getHorizontalDividerLocation() {
	return splitPaneV.getDividerLocation();
    }
    public int getVerticalDividerLocation() {
	return treePanel.getDividerLocation();
    }
    public void setDividerLocations(int h, int v) {
	splitPaneV.setDividerLocation(h);
	treePanel.setDividerLocation(v);
    }

    public OperatorPropertyTable getPropertyTable() {
	return treePanel.getPropertyTable();
    }

    public MessageViewer getMessageViewer() {
	return messageViewer;
    }

    public OperatorTree getOperatorTree() {
	return treePanel.getOperatorTree();
    }
    
    public ResultDisplay getResultDisplay() {
	return resultDisplay;
    }

    public void experimentEnded(IOContainer results) {
	if (results != null) {
	    statusBar.experimentEnded();
	    resultDisplay.setData(results, "Experiment results:");
	    editorTabs.setSelectedComponent(resultDisplay);
	    resultDisplay.showSomething();
	}
    	experimentThread = null;
	enableActions();
    }

    public void breakpointReached(Operator operator, IOContainer ioContainer) {
	List additionalButtons= new LinkedList();
	additionalButtons.add(new JButton(RESUME_ACTION));
	additionalButtons.add(new JButton(STOP_ACTION));
	resultDisplay.setData(ioContainer, 
			      "Results in application "+operator.getApplyCount()+" of "+operator.getName()+":");
	ExperimentThread.beep("breakpoint");
    }

    /** Sets a new experiment and registers the MainFrame listener. */
    public void setExperiment(Experiment experiment) {
	Yale.setExperiment(experiment);
	Yale.getExperiment().addBreakpointListener(MainFrame.this);
	setOperator(Yale.getExperiment().getRootOperator());
	Yale.getExperiment().getRootOperator().addExperimentListener(monitorPanel);
	Yale.getExperiment().getRootOperator().addExperimentListener(statusBar);
	resultDisplay.clear();
	enableActions();
	setTitle();
    }

    /** Sets the root operator for all editors. */
    public void setOperator(Operator root) {
	treePanel.experimentChanged(root);
	editor.experimentChanged(root);
	experimentPanel.experimentChanged(root);
    }

    /** Must be called when the experiment changed (such that is different
     *  from the experiment last saved to disk. */
    public void experimentChanged() {
	boolean oldValue = this.changed;
	this.changed = true;
	if (!oldValue) {
	    setTitle();
	}	
	if (Yale.getExperiment().getExperimentFile() != null)
	    this.SAVE_ACTION.setEnabled(true);	
    }

    /** Sets the window title (Yale + filename + an asterisk if experiment was modified. */
    private void setTitle() {
	File file = null;
	if (Yale.getExperiment() != null)
	    file = Yale.getExperiment().getExperimentFile();
	if (file != null) {
	    setTitle(TITLE + " ("+file.getName()+
		     (changed?"*":"")+")");	     
	} else {
	    setTitle(TITLE);
	}	
    }

    ////////////////////// File menu actions ////////////////////

    private boolean close() {
	if (changed) {
	    File file = Yale.getExperiment().getExperimentFile();
	    if (file == null) {
		file = new File("unnamed.xml");
	    }	
	    int choice = JOptionPane.showConfirmDialog(this,
						       "Save changes to '"+file+"'?", 
						       "Save changes", 
						       JOptionPane.YES_NO_CANCEL_OPTION);
	    switch (choice) {
	    case JOptionPane.YES_OPTION:
		save();
	    case JOptionPane.NO_OPTION:
		if (experimentThread != null) experimentThread.stopExperiment();
		return true;
	    default:
	    case JOptionPane.CANCEL_OPTION:
		return false;
	    }
	} else {
	    return true;
	}
    }


    protected void open() {
	if (close()) {
	    File file = SwingTools.chooseFile(MainFrame.this, null, true);
	    if (file == null) {
		return;
	    }	    
	    open(file);
	}
    }

    protected void open(File file) {
	try {
	    try {
		YaleGUI.readExperimentFile(file);		
		setExperiment(Yale.getExperiment());
	    } catch (XMLException ex) {
		ex.printStackTrace();
		SwingTools.showErrorMessage("While loading '"+file+"'", ex);
		Experiment experiment = new Experiment();
		experiment.setExperimentFile(file);
		YaleGUI.setExperiment(experiment);
		setExperiment(experiment);
		editorTabs.setSelectedComponent(editor);	    
		editor.setText(Tools.readOutput(new BufferedReader(new FileReader(file))));
	    }
	} catch (Exception ex) { // io exceptions
	    ex.printStackTrace();
	    SwingTools.showErrorMessage("While loading '"+file+"'", ex);
	    return;
	}

	SAVE_ACTION.setEnabled(false);
	YaleGUI.useExperimentFile();
	updateRecentFileList();
    }

    private void save() {
	try {
	    File file = Yale.getExperiment().getExperimentFile();
	    if (file == null) {
		file = SwingTools.chooseFile(this, new File("."), false);
		if (file == null) return;
		else Yale.getExperiment().setExperimentFile(file);
	    } 
	    Yale.getExperiment().save();	    
	    SAVE_ACTION.setEnabled(false);
	    changed = false;
	    setTitle();
	    YaleGUI.useExperimentFile();
	    updateRecentFileList(); 
  	} catch (IOException ex) {
  	    SwingTools.showErrorMessage("Cannot save experiment file!", ex);
  	}
    }

    private void exit() {
	if (changed) {
	    File file = Yale.getExperiment().getExperimentFile();
	    if (file == null) {
		file = new File("unnamed.xml");
	    }	    
	    switch (JOptionPane.showConfirmDialog(this,
						  "Save changes to '"+file+"'?", 
						  "Save changes", 
						  JOptionPane.YES_NO_CANCEL_OPTION)) {
	    case JOptionPane.YES_OPTION:
		save();
		if (changed) return;
		break;		
	    case JOptionPane.NO_OPTION:
		break;		
	    case JOptionPane.CANCEL_OPTION:
	    default:
		return;
	    }
	} else if (JOptionPane.showConfirmDialog(this, "Really exit?", "Exit Yale", JOptionPane.YES_NO_OPTION)
		   != JOptionPane.YES_OPTION) {
	    return;
	}
	dispose();
	System.exit(0);
    }

    /** Updates the list of recently used files. */
    public void updateRecentFileList() {
	recentFilesMenu.removeAll();
	List recentFiles = YaleGUI.getRecentFiles();
	Iterator i = recentFiles.iterator();
	int j = 1;
	while (i.hasNext()) {
	    final File recentFile = (File)i.next();
	    JMenuItem menuItem = new JMenuItem(j+" "+recentFile.getPath());
	    menuItem.setMnemonic('0'+j);
	    menuItem.addActionListener(new ActionListener() {
		    public void actionPerformed(ActionEvent e) {
			open(recentFile);
		    }		    
		});
	    recentFilesMenu.add(menuItem);
	    j++;
	}
    }

    public void windowOpened(WindowEvent e) { }
    public void windowClosing(WindowEvent e) { exit(); }
    public void windowClosed(WindowEvent e) { }
    public void windowIconified(WindowEvent e) { }
    public void windowDeiconified(WindowEvent e) { }
    public void windowActivated(WindowEvent e) { }
    public void windowDeactivated(WindowEvent e) { }

    /** Handles events of the editorTabs, i.e. updates all editors such that
     *  they reflect the changed experiment. */
    public void stateChanged(ChangeEvent e) {
	ExperimentEditor newEditor = (ExperimentEditor)editorTabs.getSelectedComponent();
	if (newEditor.equals(currentExperimentEditor)) {
	    return;
	}
	
	try {
	    currentExperimentEditor.validateExperiment();
	    newEditor.experimentChanged(Yale.getExperiment().getRootOperator());
	    currentExperimentEditor = newEditor;
	} catch (Exception ex) {
	    switch (JOptionPane.showConfirmDialog(this, ex.toString()+"\nCancel to ignore changes, Ok to go on editing.", 
						  "Error", JOptionPane.OK_CANCEL_OPTION, JOptionPane.ERROR_MESSAGE)) {
	    case JOptionPane.OK_OPTION:
		editorTabs.setSelectedComponent((Component)currentExperimentEditor);		 
		break;
	    default:
	    case JOptionPane.CANCEL_OPTION:
		currentExperimentEditor.experimentChanged(Yale.getExperiment().getRootOperator());
		currentExperimentEditor = newEditor;
		break;		
	    }
	}
	enableActions();
    }

    /** Enables and disables all actions according to the current state (experiment running,
     *  operator selected... */
    public void enableActions() {
	boolean[] currentStates = new boolean[ConditionalAction.NUMBER_OF_CONDITIONS];
	Operator op = treePanel.getOperatorTree().getSelectedOperator();
	if (op != null) {
	    currentStates[ConditionalAction.OPERATOR_SELECTED] = true;
	    if (op instanceof OperatorChain) currentStates[ConditionalAction.OPERATOR_CHAIN_SELECTED] = true;
	    if (op.getParent() == null) currentStates[ConditionalAction.ROOT_SELECTED] = true;
	}
	currentStates[ConditionalAction.EXPERIMENT_RUNNING] = (experimentThread != null) && (experimentThread.isAlive());
	currentStates[ConditionalAction.CLIPBOARD_FILLED] = treePanel.getOperatorTree().getClipBoard() != null;
	
	ConditionalAction.updateAll(currentStates);	
    }

}