Examples with UserCancelException org.vcell.util.UserCancelException used on opensource projects

Example 16 with UserCancelException

use of org.vcell.util.UserCancelException in project vcell by virtualcell.

the class BioModelEditorModelPanel method deleteButtonPressed.

private void deleteButtonPressed() {
    try {
        ArrayList<Object> deleteList = new ArrayList<Object>();
        int selectedIndex = tabbedPane.getSelectedIndex();
        if (selectedIndex == ModelPanelTabID.reaction_diagram.ordinal()) {
            deleteList.addAll(Arrays.asList(reactionCartoonEditorPanel.getReactionCartoon().getSelectedObjects()));
        // } else if (selectedIndex == ModelPanelTabID.structure_diagram.ordinal()) {
        // deleteList.addAll(Arrays.asList(cartoonEditorPanel.getStructureCartoon().getSelectedObjects()));
        } else {
            computeCurrentSelectedTable();
            int[] rows = currentSelectedTable.getSelectedRows();
            if (rows == null || rows.length == 0) {
                return;
            }
            if (currentSelectedTable == speciesTable) {
                for (int r : rows) {
                    if (r < speciesTableModel.getRowCount()) {
                        SpeciesContext speciesContext = speciesTableModel.getValueAt(r);
                        if (speciesContext != null) {
                            deleteList.add(speciesContext);
                        }
                    }
                }
            } else if (currentSelectedTable == molecularTypeTable) {
                // TODO: delete stuff
                for (int r : rows) {
                    if (r < molecularTypeTableModel.getRowCount()) {
                        MolecularType mt = molecularTypeTableModel.getValueAt(r);
                        if (mt != null) {
                            deleteList.add(mt);
                        }
                    }
                }
            } else if (currentSelectedTable == observablesTable) {
                for (int r : rows) {
                    if (r < observableTableModel.getRowCount()) {
                        RbmObservable o = observableTableModel.getValueAt(r);
                        if (o != null) {
                            deleteList.add(o);
                        }
                    }
                }
            } else if (currentSelectedTable == structuresTable) {
                for (int r : rows) {
                    if (r < structureTableModel.getRowCount()) {
                        Structure rowValue = structureTableModel.getValueAt(r);
                        if (rowValue instanceof Feature || rowValue instanceof Membrane) {
                            deleteList.add(rowValue);
                        }
                    }
                }
            } else if (currentSelectedTable == reactionsTable) {
                for (int r : rows) {
                    if (r < reactionTableModel.getRowCount()) {
                        ModelProcess reaction = reactionTableModel.getValueAt(r);
                        if (reaction != null) {
                            deleteList.add(reaction);
                        }
                    }
                }
            }
        }
        if (deleteList.size() == 0) {
            return;
        }
        StringBuilder deleteListText = new StringBuilder();
        for (Object object : deleteList) {
            if (object instanceof SpeciesContext) {
                deleteListText.append("Species\t'" + ((SpeciesContext) object).getName() + "'\n");
            } else if (object instanceof MolecularType) {
                deleteListText.append(((MolecularType) object).getDisplayType() + "\t'" + ((MolecularType) object).getDisplayName() + "'\n");
            } else if (object instanceof RbmObservable) {
                deleteListText.append("Observable\t'" + ((RbmObservable) object).getName() + "'\n");
            } else if (object instanceof ReactionStep) {
                deleteListText.append("Reaction\t'" + ((ReactionStep) object).getName() + "'\n");
            } else if (object instanceof ReactionRule) {
                deleteListText.append("Reaction rule\t'" + ((ReactionRule) object).getName() + "'\n");
            } else if (object instanceof Structure) {
                deleteListText.append("Structure\t'" + ((Structure) object).getName() + "'\n");
            }
        }
        // TODO: once we display reaction rules in the carton editor panel we'll have to change the way we delete reaction rules
        if (deleteList.get(0) instanceof SpeciesContext || deleteList.get(0) instanceof ReactionStep) {
            try {
                ArrayList<SpeciesContext> speciesContextArrList = new ArrayList<SpeciesContext>();
                ArrayList<ReactionStep> reactionStepArrList = new ArrayList<ReactionStep>();
                for (Object obj : deleteList) {
                    if (obj instanceof SpeciesContext) {
                        speciesContextArrList.add((SpeciesContext) obj);
                    } else if (obj instanceof ReactionStep) {
                        reactionStepArrList.add((ReactionStep) obj);
                    } else {
                        throw new Exception("Unexpected delete object " + obj.getClass().getName());
                    }
                }
                ReactionCartoonTool.deleteReactionsAndSpecies(reactionCartoonEditorPanel, reactionStepArrList.toArray(new ReactionStep[0]), speciesContextArrList.toArray(new SpeciesContext[0]));
            } catch (UserCancelException uce) {
                return;
            }
            return;
        } else {
            String confirm = DialogUtils.showOKCancelWarningDialog(this, "Deleting", "You are going to delete the following:\n\n" + deleteListText + "\n Continue?");
            if (confirm.equals(UserMessage.OPTION_CANCEL)) {
                return;
            }
            for (Object object : deleteList) {
                if (object instanceof ReactionRule) {
                    ReactionRule rr = (ReactionRule) object;
                    bioModel.getModel().getRbmModelContainer().removeReactionRule(rr);
                } else if (object instanceof MolecularType) {
                    Map<String, Pair<Displayable, SpeciesPattern>> usedHere = new LinkedHashMap<String, Pair<Displayable, SpeciesPattern>>();
                    MolecularType mt = (MolecularType) object;
                    if (!bioModel.getModel().getRbmModelContainer().isDeleteAllowed(mt, usedHere)) {
                        String errMsg = mt.getDisplayType() + " <b>'" + mt + "'</b> cannot be deleted because it's already being used by:<br>";
                        final int MaxListSize = 7;
                        int count = 0;
                        for (String key : usedHere.keySet()) {
                            System.out.println(key);
                            if (count >= MaxListSize) {
                                errMsg += "<br> ... and more.";
                                break;
                            }
                            Pair<Displayable, SpeciesPattern> o = usedHere.get(key);
                            Displayable e = o.one;
                            SpeciesPattern sp = o.two;
                            errMsg += "<br> - " + e.getDisplayType().toLowerCase() + " <b>" + e.getDisplayName() + "</b>";
                            errMsg += ", " + sp.getDisplayType().toLowerCase() + " " + " <b>" + sp.getDisplayName() + "</b>";
                            count++;
                        }
                        errMsg = "<html>" + errMsg + "</html>";
                        throw new RuntimeException(errMsg);
                    }
                    bioModel.getModel().getRbmModelContainer().removeMolecularType(mt);
                } else if (object instanceof RbmObservable) {
                    RbmObservable o = (RbmObservable) object;
                    bioModel.getModel().getRbmModelContainer().removeObservable(o);
                } else {
                    bioModel.getModel().removeObject(object);
                }
            }
        }
    } catch (Exception ex) {
        ex.printStackTrace();
        DialogUtils.showErrorDialog(this, ex.getMessage());
    }
}

Example 17 with UserCancelException

use of org.vcell.util.UserCancelException in project vcell by virtualcell.

the class ServerManageConsole method getQueryResultTable.

/**
 * Return the QueryResultTable property value.
 * @return cbit.vcell.messaging.admin.sorttable.JSortTable
 */
/* WARNING: THIS METHOD WILL BE REGENERATED. */
private JSortTable getQueryResultTable() {
    if (ivjQueryResultTable == null) {
        try {
            ivjQueryResultTable = new JSortTable();
            ivjQueryResultTable.setName("QueryResultTable");
            ivjQueryResultTable.setModel(new JobTableModel());
            ivjQueryResultTable.disableUneditableForeground();
            final JPopupMenu popup = new JPopupMenu();
            JMenuItem viewMongoMenuItem = new JMenuItem("View Mongo Log Info...");
            popup.add(viewMongoMenuItem);
            viewMongoMenuItem.addActionListener(new ActionListener() {

                public void actionPerformed(ActionEvent e) {
                    try {
                        Number simID = (Number) ivjQueryResultTable.getModel().getValueAt(ivjQueryResultTable.getSelectedRow(), JobTableModel.columnIndex_SimID);
                        String userid = (String) ivjQueryResultTable.getModel().getValueAt(ivjQueryResultTable.getSelectedRow(), JobTableModel.columnIndex_UserID);
                        System.out.println("----- user=" + userid + " simID=" + simID);
                        String mongoDbHost = PropertyLoader.getRequiredProperty(PropertyLoader.mongodbHostInternal);
                        // default 27017
                        int mongoDbPort = Integer.parseInt(PropertyLoader.getRequiredProperty(PropertyLoader.mongodbPortInternal));
                        Mongo m = new Mongo(mongoDbHost, mongoDbPort);
                        String mongoDbDatabaseName = PropertyLoader.getRequiredProperty(PropertyLoader.mongodbDatabase);
                        DB db = m.getDB(mongoDbDatabaseName);
                        String mongoDbLoggingCollectionName = PropertyLoader.getRequiredProperty(PropertyLoader.mongodbLoggingCollection);
                        DBCollection dbCollection = db.getCollection(mongoDbLoggingCollectionName);
                        BasicDBObject query = new BasicDBObject();
                        query.put(VCMongoMessage.MongoMessage_simId, simID.intValue() + "");
                        DBCursor cur = dbCollection.find(query);
                        TreeMap<String, Integer> mapKeyToColumnIndex = new TreeMap<String, Integer>();
                        Vector<DBObject> dbObjV = new Vector<DBObject>();
                        while (cur.hasNext()) {
                            DBObject dbObject = cur.next();
                            dbObjV.add(dbObject);
                            Set<String> keys = dbObject.keySet();
                            Iterator<String> iter = keys.iterator();
                            while (iter.hasNext()) {
                                String key = iter.next();
                                Integer columnIndex = mapKeyToColumnIndex.get(key);
                                if (columnIndex == null) {
                                    columnIndex = mapKeyToColumnIndex.size();
                                    mapKeyToColumnIndex.put(key, columnIndex);
                                }
                            }
                        }
                        int msgTimeColumnIndex = -1;
                        if (mapKeyToColumnIndex.size() > 0) {
                            String[] columnNames = new String[mapKeyToColumnIndex.size()];
                            Iterator<String> keyIter = mapKeyToColumnIndex.keySet().iterator();
                            while (keyIter.hasNext()) {
                                String key = keyIter.next();
                                int columnIndex = mapKeyToColumnIndex.get(key);
                                columnNames[columnIndex] = key;
                                if (key.equals(VCMongoMessage.MongoMessage_msgTime)) {
                                    msgTimeColumnIndex = columnIndex;
                                }
                            }
                            // //Ask which columns to view
                            // Object[][] colrowdata = new Object[columnNames.length][1];
                            // for (int i = 0; i < colrowdata.length; i++) {
                            // colrowdata[i][0] = columnNames[i];
                            // }
                            // int[] showcolArr =
                            // DialogUtils.showComponentOKCancelTableList(ServerManageConsole.this, "Select Columns to View...", new String[] {"Column Names"}, colrowdata, ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
                            Object[][] rowData = new Object[dbObjV.size()][columnNames.length];
                            for (int i = 0; i < rowData.length; i++) {
                                DBObject dbObj = dbObjV.get(i);
                                Set<String> keys = dbObj.keySet();
                                Iterator<String> iter = keys.iterator();
                                while (iter.hasNext()) {
                                    String key = iter.next();
                                    rowData[i][mapKeyToColumnIndex.get(key)] = dbObj.get(key);
                                }
                            }
                            // sort by msgtime
                            final int msgTimeColumnIndexFinal = msgTimeColumnIndex;
                            if (msgTimeColumnIndex != -1) {
                                Arrays.sort(rowData, new Comparator<Object[]>() {

                                    public int compare(Object[] o1, Object[] o2) {
                                        Long o1Long = (Long) o1[msgTimeColumnIndexFinal];
                                        Long o2Long = (Long) o2[msgTimeColumnIndexFinal];
                                        int result = (int) (o2Long - o1Long);
                                        return result;
                                    }
                                });
                            }
                            DialogUtils.showComponentOptionsTableList(ServerManageConsole.this, "Mongo Log Info (" + rowData.length + ") " + userid + " " + simID, columnNames, rowData, ListSelectionModel.SINGLE_SELECTION, null, null, null, null, false);
                        } else {
                            DialogUtils.showWarningDialog(ServerManageConsole.this, "No Mongo Log Info found for simID=" + simID.intValue());
                        }
                    } catch (UserCancelException uce) {
                    // ignore
                    } catch (Exception e1) {
                        e1.printStackTrace();
                    }
                }
            });
            ivjQueryResultTable.addMouseListener(new MouseAdapter() {

                public void mouseReleased(MouseEvent e) {
                    if (e.isPopupTrigger()) {
                        JTable source = (JTable) e.getSource();
                        int row = source.rowAtPoint(e.getPoint());
                        int column = source.columnAtPoint(e.getPoint());
                        if (!source.isRowSelected(row))
                            source.changeSelection(row, column, false, false);
                        popup.show(e.getComponent(), e.getX(), e.getY());
                    }
                }
            });
        // user code begin {1}
        // user code end
        } catch (java.lang.Throwable ivjExc) {
            // user code begin {2}
            // user code end
            handleException(ivjExc);
        }
    }
    return ivjQueryResultTable;
}

Example 18 with UserCancelException

use of org.vcell.util.UserCancelException in project vcell by virtualcell.

the class VCellClient method login.

public static void login(final RequestManager requestManager, final ClientServerInfo clientServerInfo, final DocumentWindowManager currWindowManager) {
    final LoginManager loginManager = new LoginManager();
    LoginDelegate loginDelegate = new LoginDelegate() {

        public void login(final String userid, final UserLoginInfo.DigestedPassword digestedPassword) {
            AsynchClientTask task1 = new AsynchClientTask("connect to server", AsynchClientTask.TASKTYPE_NONSWING_BLOCKING) {

                @Override
                public void run(Hashtable<String, Object> hashTable) throws Exception {
                    ClientServerInfo newClientServerInfo = createClientServerInfo(clientServerInfo, userid, digestedPassword);
                    requestManager.connectToServer(currWindowManager, newClientServerInfo);
                }
            };
            AsynchClientTask task2 = new AsynchClientTask("logging in", AsynchClientTask.TASKTYPE_SWING_BLOCKING) {

                @Override
                public void run(Hashtable<String, Object> hashTable) throws Exception {
                    ConnectionStatus connectionStatus = requestManager.getConnectionStatus();
                    loginManager.close();
                    if (connectionStatus.getStatus() != ConnectionStatus.CONNECTED) {
                        VCellClient.login(requestManager, clientServerInfo, currWindowManager);
                    } else {
                        ErrorUtils.setLoginInfo(clientServerInfo.getUserLoginInfo());
                    }
                }
            };
            ClientTaskDispatcher.dispatch(currWindowManager.getComponent(), new Hashtable<String, Object>(), new AsynchClientTask[] { task1, task2 });
        }

        public void registerRequest() {
            loginManager.close();
            try {
                UserRegistrationManager.registrationOperationGUI(requestManager, currWindowManager, clientServerInfo, LoginManager.USERACTION_REGISTER, null);
            } catch (UserCancelException e) {
            // do nothing
            } catch (Exception e) {
                e.printStackTrace();
                PopupGenerator.showErrorDialog(currWindowManager, "New user Registration error:\n" + e.getMessage());
            }
        }

        public void lostPasswordRequest(String userid) {
            try {
                ClientServerInfo newClientServerInfo = createClientServerInfo(clientServerInfo, userid, null);
                UserRegistrationManager.registrationOperationGUI(requestManager, currWindowManager, newClientServerInfo, LoginManager.USERACTION_LOSTPASSWORD, null);
            } catch (UserCancelException e) {
            // do nothing
            } catch (Exception e) {
                e.printStackTrace();
                PopupGenerator.showErrorDialog(currWindowManager, "New user Registration error:\n" + e.getMessage());
            }
        }

        public void userCancel() {
            loginManager.close();
            PopupGenerator.showInfoDialog(currWindowManager, "Note:  The Login dialog can be accessed any time under the 'Server' main menu as 'Change User...'");
        }
    };
    loginManager.showLoginDialog(currWindowManager.getComponent(), currWindowManager, loginDelegate);
}

Example 19 with UserCancelException

use of org.vcell.util.UserCancelException in project vcell by virtualcell.

the class TestingFrameworkWindowPanel method testingFrameworkPanel_actionPerformed.

/**
 * Comment
 */
private void testingFrameworkPanel_actionPerformed(final ActionEvent e) {
    if (tfRefreshTreeTask == null) {
        tfRefreshTreeTask = new TFRefresh(getTestingFrameworkWindowManager());
    }
    Hashtable<String, Object> hash = new Hashtable<String, Object>();
    Vector<AsynchClientTask> tasksV = new Vector<AsynchClientTask>();
    try {
        final TreePath[] selectedTreePaths = gettestingFrameworkPanel().getSelectedTreePaths();
        if (selectedTreePaths != null && selectedTreePaths.length > 1) {
            Object refObj = ((BioModelNode) selectedTreePaths[0].getLastPathComponent()).getUserObject();
            for (int i = 1; i < selectedTreePaths.length; i++) {
                Object currentObj = ((BioModelNode) selectedTreePaths[i].getLastPathComponent()).getUserObject();
                if ((refObj == null && currentObj == null) || ((refObj != null && currentObj != null) && (refObj.getClass().equals(currentObj.getClass()))) || (refObj instanceof TestCaseNew && currentObj instanceof TestCaseNew)) {
                    continue;
                } else {
                    throw new IllegalArgumentException("Multiple selections must all be of same type");
                }
            }
        }
        final Object selectedObj = gettestingFrameworkPanel().getTreeSelection();
        if (e.getActionCommand().equals(TestingFrameworkPanel.DELETE_XML_LOAD_TEST)) {
            int result = DialogUtils.showComponentOKCancelDialog(this, new JLabel("Delete " + selectedTreePaths.length + " Load Tests?"), "Confirm Load Test Delete");
            if (result != JOptionPane.OK_OPTION) {
                return;
            }
            AsynchClientTask deleteLoadTestTask = new AsynchClientTask("Deleting Load Test...", AsynchClientTask.TASKTYPE_NONSWING_BLOCKING) {

                @Override
                public void run(Hashtable<String, Object> hashTable) throws Exception {
                    LoadTestInfoOP deleteLoadTestInfoOP = new LoadTestInfoOP(LoadTestOpFlag.delete, null, null);
                    LoadTestSoftwareVersionTimeStamp[] deleteTheseversTimestamps = new LoadTestSoftwareVersionTimeStamp[selectedTreePaths.length];
                    for (int i = 0; i < selectedTreePaths.length; i++) {
                        deleteTheseversTimestamps[i] = ((LoadTestTreeInfo) ((BioModelNode) selectedTreePaths[i].getLastPathComponent()).getUserObject()).loadTestSoftwareVersionTimeStamp;
                    }
                    deleteLoadTestInfoOP.setDeleteInfo(deleteTheseversTimestamps);
                    getTestingFrameworkWindowManager().getRequestManager().getDocumentManager().doTestSuiteOP(deleteLoadTestInfoOP);
                    final ActionEvent refreshAction = new ActionEvent(this, 0, TestingFrameworkPanel.REFRESH_XML_LOAD_TEST);
                    new Thread(new Runnable() {

                        public void run() {
                            testingFrameworkPanel_actionPerformed(refreshAction);
                        }
                    }).start();
                }
            };
            tasksV.add(deleteLoadTestTask);
        } else if (e.getActionCommand().equals(TestingFrameworkPanel.RUN_XML_LOAD_TEST_All) || e.getActionCommand().equals(TestingFrameworkPanel.RUN_XML_LOAD_TEST_MODELS) || e.getActionCommand().equals(TestingFrameworkPanel.RUN_XML_LOAD_TEST_USERS)) {
            final Date[] beginDate = new Date[1];
            final Date[] endDate = new Date[1];
            final TreeSet<String> uniqueUserIDTreeSet = new TreeSet<String>();
            final Vector<KeyValue> bioAndMathModelKeyValueV = new Vector<KeyValue>();
            String typeMsg = "All";
            if (!e.getActionCommand().equals(TestingFrameworkPanel.RUN_XML_LOAD_TEST_All)) {
                if (selectedTreePaths != null && selectedTreePaths.length > 0) {
                    Object refObj = ((BioModelNode) selectedTreePaths[0].getLastPathComponent()).getUserObject();
                    if (refObj instanceof TestingFrmwkTreeModel.LoadTestTreeInfo) {
                        for (int i = 0; i < selectedTreePaths.length; i++) {
                            refObj = ((BioModelNode) selectedTreePaths[i].getLastPathComponent()).getUserObject();
                            uniqueUserIDTreeSet.add(((TestingFrmwkTreeModel.LoadTestTreeInfo) refObj).userid);
                            if (!e.getActionCommand().equals(TestingFrameworkPanel.RUN_XML_LOAD_TEST_USERS)) {
                                bioAndMathModelKeyValueV.add(((TestingFrmwkTreeModel.LoadTestTreeInfo) refObj).bioOrMathModelKey);
                            }
                        }
                    }
                }
            } else {
                // TreeSet<VCDocumentInfo> dateRangeDocInfoTreeSet =
                // new TreeSet<VCDocumentInfo>(new Comparator<VCDocumentInfo>() {
                // public int compare(VCDocumentInfo o1, VCDocumentInfo o2) {
                // return o1.getVersion().getDate().compareTo(o2.getVersion().getDate());
                // }
                // });
                // BioModelInfo[] allBioModelInfos = getDocumentManager().getBioModelInfos();
                // dateRangeDocInfoTreeSet.addAll(Arrays.asList(allBioModelInfos));
                // MathModelInfo[] allMathModelInfos = getDocumentManager().getMathModelInfos();
                // dateRangeDocInfoTreeSet.addAll(Arrays.asList(allMathModelInfos));
                SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
                // Date firstDate = simpleDateFormat.parse(simpleDateFormat.format(dateRangeDocInfoTreeSet.first().getVersion().getDate()));
                // Date lastDate = simpleDateFormat.parse(simpleDateFormat.format(dateRangeDocInfoTreeSet.last().getVersion().getDate()));
                Date firstDate = simpleDateFormat.parse("2000-01-01");
                Date lastDate = simpleDateFormat.parse(simpleDateFormat.format(Calendar.getInstance().getTime()));
                String allDateRangeString = simpleDateFormat.format(firstDate) + "," + simpleDateFormat.format(lastDate);
                while (beginDate[0] == null || endDate[0] == null) {
                    try {
                        String dateRangeString = DialogUtils.showInputDialog0(this, "Enter Date Range (begin,end) to include (e.g. '" + allDateRangeString + "')", allDateRangeString);
                        beginDate[0] = simpleDateFormat.parse(dateRangeString.substring(0, dateRangeString.indexOf(",")));
                        endDate[0] = simpleDateFormat.parse(dateRangeString.substring(dateRangeString.indexOf(",") + 1));
                    // if(beginDate.compareTo(firstDate) != 0 ||
                    // endDate.compareTo(lastDate) != 0){
                    // Iterator<VCDocumentInfo> vcDocIter = dateRangeDocInfoTreeSet.iterator();
                    // while(vcDocIter.hasNext()){
                    // VCDocumentInfo vcDocInfo = vcDocIter.next();
                    // Date docDate = simpleDateFormat.parse(simpleDateFormat.format(vcDocInfo.getVersion().getDate()));
                    // if(docDate.compareTo(beginDate) < 0 ||
                    // docDate.compareTo(endDate) > 0){
                    // continue;
                    // }
                    // uniqueUserIDTreeSet.add(vcDocInfo.getVersion().getOwner().getName());
                    // bioAndMathModelKeyValueV.add(vcDocInfo.getVersion().getVersionKey());
                    // }
                    // }
                    } catch (UtilCancelException uce) {
                        return;
                    } catch (Exception e2) {
                        DialogUtils.showErrorDialog(this, e2.getMessage());
                    }
                }
                if (beginDate[0].compareTo(firstDate) == 0 && endDate[0].compareTo(lastDate) == 0) {
                    beginDate[0] = null;
                    endDate[0] = null;
                } else {
                    typeMsg = "between " + simpleDateFormat.format(beginDate[0]) + "," + simpleDateFormat.format(endDate[0]);
                }
            }
            if (e.getActionCommand().equals(TestingFrameworkPanel.RUN_XML_LOAD_TEST_MODELS)) {
                typeMsg = "Models (" + bioAndMathModelKeyValueV.size() + ")";
            } else if (e.getActionCommand().equals(TestingFrameworkPanel.RUN_XML_LOAD_TEST_USERS)) {
                typeMsg = "Users (" + uniqueUserIDTreeSet.size() + ")";
            }
            int result = DialogUtils.showComponentOKCancelDialog(TestingFrameworkWindowPanel.this, new JLabel("Run " + typeMsg + " Load Tests?"), "Confirm Load Test Run");
            if (result != JOptionPane.OK_OPTION) {
                return;
            }
            result = DialogUtils.showComponentOKCancelDialog(this, enterDBAndSoftwareVersPanel, "Enter Software Version running load test");
            if (result != JOptionPane.OK_OPTION) {
                return;
            }
            AsynchClientTask runXMLLoadTestTask = new AsynchClientTask("Running XML Load Test...", AsynchClientTask.TASKTYPE_NONSWING_BLOCKING) {

                @Override
                public void run(Hashtable<String, Object> hashTable) throws Exception {
                    String[] uniqueUserIDArr = null;
                    KeyValue[] bioAndMathModelKeyValueArr = null;
                    if (beginDate[0] != null && endDate[0] != null) {
                        LoadTestInfoOpResults loadTestInfoOpResults = getTestingFrameworkWindowManager().getLoadTestInfoBetweenDates(beginDate[0], endDate[0]);
                        uniqueUserIDArr = loadTestInfoOpResults.getUniqueUserIDsBetweenDates();
                        bioAndMathModelKeyValueArr = loadTestInfoOpResults.getKeyValuesBetweenDates();
                    } else {
                        uniqueUserIDArr = (uniqueUserIDTreeSet.size() == 0 ? null : uniqueUserIDTreeSet.toArray(new String[0]));
                        bioAndMathModelKeyValueArr = (bioAndMathModelKeyValueV.size() == 0 ? null : bioAndMathModelKeyValueV.toArray(new KeyValue[0]));
                    }
                    throw new RuntimeException(TestingFrameworkWindowPanel.class.getSimpleName() + ".runXMLLoadTestTask(): Run Load Test disabled, directly dependend on MathVerifier.runLoadTest(), should move to standalone admin tool.");
                // MathVerifier mathVerifier = MathVerifier.createMathVerifier(
                // enterDBAndSoftwareVersPanel.getDBHost(),
                // enterDBAndSoftwareVersPanel.getDBName(),
                // enterDBAndSoftwareVersPanel.getDBSchema(),
                // enterDBAndSoftwareVersPanel.getDBPassword());
                // mathVerifier.runLoadTest(
                // uniqueUserIDArr,
                // bioAndMathModelKeyValueArr,
                // enterDBAndSoftwareVersPanel.getSoftwareVersion(),
                // (enterDBAndSoftwareVersPanel.getSoftwareVersion().length()==0?false:true),
                // (enterDBAndSoftwareVersPanel.getSoftwareVersion().length()==0?Compare.DEFAULT_COMPARE_LOGGER:null));
                }
            };
            tasksV.add(runXMLLoadTestTask);
        } else if (e.getActionCommand().equals(TestingFrameworkPanel.REFRESH_XML_LOAD_TEST)) /*||
				e.getActionCommand().equals(TestingFrameworkPanel.REFRESH_INCLUDE_SLOW_XML_LOAD_TEST)*/
        {
            final String LOADTESTDETAILS_KEY = "LOADTESTDETAILS_KEY";
            AsynchClientTask getFailedLoadTest = new AsynchClientTask("Getting FailedLoadTests...", AsynchClientTask.TASKTYPE_NONSWING_BLOCKING) {

                @Override
                public void run(Hashtable<String, Object> hashTable) throws Exception {
                    /*						Integer slowLoadThreshold = null;
						if(e.getActionCommand().equals(TestingFrameworkPanel.REFRESH_INCLUDE_SLOW_XML_LOAD_TEST)){
							String result = DialogUtils.showInputDialog0(TestingFrameworkWindowPanel.this, "Enter load time threshold (millseconds)","10000");
							slowLoadThreshold = new Integer(result);
						}
*/
                    if (gettestingFrameworkPanel().getSlowLoadThreshold() != null && gettestingFrameworkPanel().getLoadTestSQLCondition() != null) {
                        throw new IllegalArgumentException("SlowLoadThreshold and 'SQL Condition' cannot both be non-null at the same time.");
                    }
                    hashTable.put(LOADTESTDETAILS_KEY, getTestingFrameworkWindowManager().getLoadTestDetails(gettestingFrameworkPanel().getSlowLoadThreshold(), gettestingFrameworkPanel().getLoadTestSQLCondition()));
                }
            };
            AsynchClientTask refreshFailedLoadTest = new AsynchClientTask("Refreshing FailedLoadTests...", AsynchClientTask.TASKTYPE_SWING_BLOCKING) {

                @Override
                public void run(Hashtable<String, Object> hashTable) throws Exception {
                    getTestingFrameworkWindowManager().refreshLoadTest((LoadTestInfoOpResults) hashTable.get(LOADTESTDETAILS_KEY));
                }
            };
            tasksV.add(getFailedLoadTest);
            tasksV.add(refreshFailedLoadTest);
        } else if (e.getActionCommand().equals(TestingFrameworkPanel.QUERY_TCRITVAR_CROSSREF)) {
            if (selectedObj instanceof TestingFrmwkTreeModel.TestCriteriaVarUserObj && selectedTreePaths.length == 1) {
                final TestingFrmwkTreeModel.TestCriteriaVarUserObj tcritVaruserObj = (TestingFrmwkTreeModel.TestCriteriaVarUserObj) selectedObj;
                final TestSuiteInfoNew tsInfoNew = gettestingFrameworkPanel().getTestSuiteInfoOfTreePath(selectedTreePaths[0]);
                AsynchClientTask queryTCritCrossRef = new AsynchClientTask("Query TCrit Var Cross Ref", AsynchClientTask.TASKTYPE_NONSWING_BLOCKING) {

                    public void run(Hashtable<String, Object> hashTable) throws Exception {
                        getTestingFrameworkWindowManager().queryTCritCrossRef(tsInfoNew, tcritVaruserObj.getTestCriteria(), tcritVaruserObj.getVariableComparisonSummary().getName());
                    }
                };
                tasksV.add(queryTCritCrossRef);
            } else {
                throw new Exception("Selected Object is not a TestCriteria Variable! Failed to Query Var Cross Ref.");
            }
        } else if (e.getActionCommand().equals(TestingFrameworkPanel.QUERY_TCRIT_CROSSREF)) {
            if (selectedObj instanceof TestCriteriaNew) {
                final TestCriteriaNew tcritNew = (TestCriteriaNew) selectedObj;
                final TestSuiteInfoNew tsInfoNew = gettestingFrameworkPanel().getTestSuiteInfoOfSelectedTestCriteria();
                AsynchClientTask queryTCritCrossRef = new AsynchClientTask("Query TCrit Cross Ref", AsynchClientTask.TASKTYPE_NONSWING_BLOCKING) {

                    public void run(Hashtable<String, Object> hashTable) throws Exception {
                        getTestingFrameworkWindowManager().queryTCritCrossRef(tsInfoNew, tcritNew, null);
                    }
                };
                tasksV.add(queryTCritCrossRef);
            } else {
                throw new Exception("Selected Object is not a TestCriteria! Failed to Query Cross Ref.");
            }
        } else if (e.getActionCommand().equals(TestingFrameworkPanel.LOCK_TESTSUITE)) {
            if (selectedObj instanceof TestSuiteInfoNew) {
                final TestSuiteInfoNew tsInfoNew = (TestSuiteInfoNew) selectedObj;
                AsynchClientTask lockTestSuiteTask = new AsynchClientTask("Lock TestSuite", AsynchClientTask.TASKTYPE_NONSWING_BLOCKING) {

                    public void run(Hashtable<String, Object> hashTable) throws Exception {
                        getTestingFrameworkWindowManager().lockTestSuite(tsInfoNew);
                    }
                };
                tasksV.add(lockTestSuiteTask);
                tfRefreshTreeTask = new TFRefresh(getTestingFrameworkWindowManager(), tsInfoNew);
                tasksV.add(tfRefreshTreeTask);
            } else {
                throw new Exception("Selected Object is not a TestSuite! Failed to Lock TestSuite.");
            }
        } else if (e.getActionCommand().equals(TestingFrameworkPanel.EDIT_ANNOT_TESTSUITE)) {
            if (selectedObj instanceof TestSuiteInfoNew) {
                final TestSuiteInfoNew tsInfoNew = (TestSuiteInfoNew) selectedObj;
                String newAnnotation;
                // initialize fields
                String oldAnnotation = tsInfoNew.getTSAnnotation();
                // show the editor
                newAnnotation = org.vcell.util.gui.DialogUtils.showAnnotationDialog(this, oldAnnotation);
                final String finalAnnotation = newAnnotation;
                AsynchClientTask editTestSuiteAnnotation = new AsynchClientTask("Edit TestSuite Annotation", AsynchClientTask.TASKTYPE_NONSWING_BLOCKING) {

                    public void run(Hashtable<String, Object> hashTable) throws Exception {
                        getTestingFrameworkWindowManager().updateTestSuiteAnnotation(tsInfoNew, finalAnnotation);
                    }
                };
                tasksV.add(editTestSuiteAnnotation);
                tfRefreshTreeTask = new TFRefresh(getTestingFrameworkWindowManager(), tsInfoNew);
                tasksV.add(tfRefreshTreeTask);
            } else {
                throw new Exception("Selected Object is not a TestSuite! Failed to Edit TestSuite Annotation.");
            }
        } else if (e.getActionCommand().equals(TestingFrameworkPanel.EDIT_ANNOT_TESTCASE)) {
            if (selectedObj instanceof TestCaseNew) {
                final TestCaseNew tcNew = (TestCaseNew) selectedObj;
                String newAnnotation;
                // initialize fields
                String oldAnnotation = tcNew.getAnnotation();
                // show the editor
                newAnnotation = org.vcell.util.gui.DialogUtils.showAnnotationDialog(this, oldAnnotation);
                final String finalAnnotation = newAnnotation;
                AsynchClientTask editTestCaseAnnotation = new AsynchClientTask("Edit TestCase Annotation", AsynchClientTask.TASKTYPE_NONSWING_BLOCKING) {

                    public void run(Hashtable<String, Object> hashTable) throws Exception {
                        getTestingFrameworkWindowManager().updateTestCaseAnnotation(tcNew, finalAnnotation);
                    }
                };
                tasksV.add(editTestCaseAnnotation);
                TestSuiteInfoNew tsInfo = gettestingFrameworkPanel().getTestSuiteInfoOfSelectedTestCase();
                tfRefreshTreeTask = new TFRefresh(getTestingFrameworkWindowManager(), tsInfo);
                tasksV.add(tfRefreshTreeTask);
            } else {
                throw new Exception("Selected Object is not a TestCase! Failed to Edit TestCase Annotation.");
            }
        } else if (e.getActionCommand().equals(TestingFrameworkPanel.TOGGLE_STEADYSTATE)) {
            if (selectedObj instanceof TestCaseNew) {
                final TestCaseNew testCase = (TestCaseNew) selectedObj;
                String okString = "Ok";
                String confirm = PopupGenerator.showWarningDialog(this, "Toggle TestCase '" + testCase.getVersion().getName() + "'\nfrom " + testCase.getType() + " to " + (testCase.getType().equals(TestCaseNew.EXACT) ? TestCaseNew.EXACT_STEADY : TestCaseNew.EXACT), new String[] { okString, "Cancel" }, okString);
                if (confirm.equals(okString)) {
                    AsynchClientTask toggleSteadyState = new AsynchClientTask("Toggle Steady State", AsynchClientTask.TASKTYPE_NONSWING_BLOCKING) {

                        public void run(Hashtable<String, Object> hashTable) throws Exception {
                            getTestingFrameworkWindowManager().toggleTestCaseSteadyState(new TestCaseNew[] { testCase });
                        }
                    };
                    tasksV.add(toggleSteadyState);
                    TestSuiteInfoNew tsInfo = gettestingFrameworkPanel().getTestSuiteInfoOfSelectedTestCase();
                    tfRefreshTreeTask = new TFRefresh(getTestingFrameworkWindowManager(), tsInfo);
                    tasksV.add(tfRefreshTreeTask);
                } else {
                    throw UserCancelException.CANCEL_GENERIC;
                }
            } else {
                throw new Exception("Selected Object is not a TestCase! Cannot Toggle SteadyState");
            }
        } else if (e.getActionCommand().equals(TestingFrameworkPanel.ADD_TESTSUITE)) {
            TestingFrameworkWindowManager.NewTestSuiteUserInformation newTestSuiteUserInfo = getTestingFrameworkWindowManager().getNewTestSuiteInfoFromUser(null, null);
            tasksV.add(new TFAddTestSuite(getTestingFrameworkWindowManager(), newTestSuiteUserInfo.testSuiteInfoNew));
            tfRefreshTreeTask = new TFRefresh(getTestingFrameworkWindowManager(), newTestSuiteUserInfo.testSuiteInfoNew);
            tasksV.add(tfRefreshTreeTask);
        } else if (e.getActionCommand().equals(TestingFrameworkPanel.REFRESH_TESTSUITE)) {
            TestSuiteInfoNew tsin = null;
            if (selectedObj instanceof TestSuiteInfoNew) {
                tsin = (TestSuiteInfoNew) selectedObj;
            } else if (selectedObj instanceof TestCaseNew) {
                tsin = gettestingFrameworkPanel().getTestSuiteInfoOfSelectedTestCase();
            } else if (selectedObj instanceof TestCriteriaNew) {
                tsin = gettestingFrameworkPanel().getTestSuiteInfoOfSelectedTestCriteria();
            }
            if (tsin == null) {
                throw new IllegalArgumentException("Refresh error: Unexpected tree selection type=" + selectedObj.getClass().getName());
            }
            tfRefreshTreeTask = new TFRefresh(getTestingFrameworkWindowManager(), tsin);
            tasksV.add(new TFUpdateRunningStatus(getTestingFrameworkWindowManager(), tsin));
            tasksV.add(tfRefreshTreeTask);
        // getTestingFrameworkWindowManager().updateSimRunningStatus();
        } else if (e.getActionCommand().equals(TestingFrameworkPanel.ADD_TESTCASE)) {
            if (selectedObj instanceof TestSuiteInfoNew) {
                TestSuiteInfoNew tsInfo = (TestSuiteInfoNew) selectedObj;
                TestCaseNew[] tcnArr = getTestingFrameworkWindowManager().getNewTestCaseArr();
                tasksV.add(new cbit.vcell.client.task.TFAddTestCases(getTestingFrameworkWindowManager(), tsInfo, tcnArr));
                tfRefreshTreeTask = new TFRefresh(getTestingFrameworkWindowManager(), tsInfo);
                tasksV.add(tfRefreshTreeTask);
            } else {
                throw new Exception("Selected Object is not a test suite! Cannot add a test case");
            }
        } else if (e.getActionCommand().equals("Run All")) {
            if (selectedTreePaths == null || selectedTreePaths.length != 1) {
                throw new IllegalArgumentException("Command '" + e.getActionCommand() + "' Single Selection Only!");
            }
            if (selectedObj instanceof TestSuiteInfoNew) {
                TestSuiteInfoNew tsInfo = (TestSuiteInfoNew) selectedObj;
                String okString = "Ok";
                String confirm = PopupGenerator.showWarningDialog(this, "Run All Sims for TestSuite '" + tsInfo.getTSID() + "'?", new String[] { okString, "Cancel" }, okString);
                if (confirm.equals(okString)) {
                    tasksV.add(new TFRunSims(getTestingFrameworkWindowManager(), tsInfo));
                    tfRefreshTreeTask = new TFRefresh(getTestingFrameworkWindowManager(), tsInfo);
                    tasksV.add(tfRefreshTreeTask);
                }
            } else {
                throw new Exception("Selected Object is not a test suite!");
            }
        } else if (e.getActionCommand().equals("Run Simulations")) {
            if (selectedTreePaths == null || selectedTreePaths.length != 1) {
                throw new IllegalArgumentException("Command '" + e.getActionCommand() + "' Single Selection Only!");
            }
            if (selectedObj instanceof TestCaseNew) {
                TestCaseNew testCase = (TestCaseNew) selectedObj;
                String okString = "Ok";
                String confirm = PopupGenerator.showWarningDialog(this, "Run All Sims for TestCase '" + testCase.getVersion().getName() + "'?", new String[] { okString, "Cancel" }, okString);
                if (confirm.equals(okString)) {
                    tasksV.add(new TFRunSims(getTestingFrameworkWindowManager(), testCase));
                    TestSuiteInfoNew tsInfo = gettestingFrameworkPanel().getTestSuiteInfoOfSelectedTestCase();
                    tfRefreshTreeTask = new TFRefresh(getTestingFrameworkWindowManager(), tsInfo);
                    tasksV.add(tfRefreshTreeTask);
                }
            } else {
                throw new Exception("Selected Object is not a TestCase! Cannot run simulations");
            }
        } else if (e.getActionCommand().equals("Run")) {
            if (selectedTreePaths != null && selectedTreePaths.length > 0 && selectedTreePaths[0].getLastPathComponent() instanceof BioModelNode && ((BioModelNode) selectedTreePaths[0].getLastPathComponent()).getUserObject() instanceof TestCriteriaNew) {
                for (int i = 0; i < selectedTreePaths.length; i += 1) {
                    TestCriteriaNew tCriteria = (TestCriteriaNew) ((BioModelNode) selectedTreePaths[i].getLastPathComponent()).getUserObject();
                    tasksV.add(new TFRunSims(getTestingFrameworkWindowManager(), tCriteria));
                }
                TestSuiteInfoNew tsInfo = gettestingFrameworkPanel().getTestSuiteInfoOfSelectedTestCriteria();
                tfRefreshTreeTask = new TFRefresh(getTestingFrameworkWindowManager(), tsInfo);
                tasksV.add(tfRefreshTreeTask);
            } else {
                throw new Exception("Selected Object is not a TestCriteria!");
            }
        } else if (e.getActionCommand().equals("View Results")) {
            if (selectedObj instanceof cbit.vcell.numericstest.TestCriteriaNew) {
                TestCriteriaNew tCriteria = (TestCriteriaNew) selectedObj;
                getTestingFrameworkWindowManager().viewResults(tCriteria);
            } else {
                PopupGenerator.showErrorDialog(TestingFrameworkWindowPanel.this, "Selected Object is not a TestCriteria!");
            }
        } else if (e.getActionCommand().equals(TestingFrameworkPanel.COMPARERREGR_INTERNALREF_TESTCRITERIA) || e.getActionCommand().equals(TestingFrameworkPanel.COMPARERREGR_USERDEFREF_TESTCRITERIA)) {
            if (selectedObj instanceof cbit.vcell.numericstest.TestCriteriaNew) {
                TestCriteriaNew tCriteria = (TestCriteriaNew) selectedObj;
                SimulationStatus simStatus = getTestingFrameworkWindowManager().getRequestManager().getServerSimulationStatus(tCriteria.getSimInfo());
                if (simStatus.isRunning()) {
                    PopupGenerator.showErrorDialog(TestingFrameworkWindowPanel.this, "Selected simulation is still running!");
                    return;
                }
                SimulationInfo simulationInfo = tCriteria.getRegressionSimInfo();
                if (e.getActionCommand().equals(TestingFrameworkPanel.COMPARERREGR_USERDEFREF_TESTCRITERIA)) {
                    try {
                        simulationInfo = getUserSelectedSimulationInfo().getSimInfo();
                    } catch (UserCancelException e2) {
                        return;
                    }
                }
                if (simulationInfo == null) {
                    PopupGenerator.showErrorDialog(TestingFrameworkWindowPanel.this, "Either the selected simulation does not belong to a REGRESSION test or the regression simInfo is not set!");
                    return;
                }
                getTestingFrameworkWindowManager().compare(tCriteria, simulationInfo);
            } else {
                PopupGenerator.showErrorDialog(TestingFrameworkWindowPanel.this, "Selected Object is not a TestCriteria!");
            }
        } else if (e.getActionCommand().equals(TestingFrameworkPanel.DUPLICATE_TESTSUITE)) {
            if (selectedObj instanceof TestSuiteInfoNew) {
                TestSuiteInfoNew tsInfoOriginal = (TestSuiteInfoNew) selectedObj;
                TestingFrameworkWindowManager.NewTestSuiteUserInformation newTestSuiteUserInfo = getTestingFrameworkWindowManager().getNewTestSuiteInfoFromUser(tsInfoOriginal.getTSAnnotation(), tsInfoOriginal.getTSID());
                tasksV.add(new TFDuplicateTestSuite(getTestingFrameworkWindowManager(), tsInfoOriginal, newTestSuiteUserInfo.testSuiteInfoNew, newTestSuiteUserInfo.regrRefFlag));
                tfRefreshTreeTask = new TFRefresh(getTestingFrameworkWindowManager(), newTestSuiteUserInfo.testSuiteInfoNew);
                tasksV.add(tfRefreshTreeTask);
            // getTestingFrameworkWindowManager().duplicateTestSuite(tsInfo);
            } else {
                throw new Exception("Selected Object is not a test suite! Cannot duplicate");
            }
        } else if (e.getActionCommand().equals(TestingFrameworkPanel.REMOVE_TESTCASE)) {
            if (selectedObj instanceof TestCaseNew) {
                String[][] rowData = new String[selectedTreePaths.length][3];
                TestSuiteInfoNew tsInfo = gettestingFrameworkPanel().getTestSuiteInfoOfSelectedTestCase();
                for (int i = 0; i < selectedTreePaths.length; i += 1) {
                    TestCaseNew tCase = (TestCaseNew) ((BioModelNode) selectedTreePaths[i].getLastPathComponent()).getUserObject();
                    rowData[i][0] = tsInfo.getTSID();
                    tasksV.add(new TFRemove(getTestingFrameworkWindowManager(), tCase));
                    if (tCase instanceof TestCaseNewBioModel) {
                        rowData[i][1] = "BM " + tCase.getVersion().getName();
                        rowData[i][2] = ((TestCaseNewBioModel) tCase).getSimContextName();
                    } else {
                        rowData[i][1] = "MM " + tCase.getVersion().getName();
                        rowData[i][2] = "N/A";
                    }
                }
                DialogUtils.showComponentOKCancelTableList(this, "Confirm Remove TestCase(s)", new String[] { "Test Suite", "Test Case", "App" }, rowData, null);
                tfRefreshTreeTask = new TFRefresh(getTestingFrameworkWindowManager(), tsInfo);
                tasksV.add(tfRefreshTreeTask);
            } else {
                throw new Exception("Selected Object is not a TestCase, cannot remove selection!");
            }
        } else if (e.getActionCommand().equals(TestingFrameworkPanel.REMOVE_TESTSUITE)) {
            if (selectedObj instanceof TestSuiteInfoNew) {
                TestSuiteInfoNew tsInfo = (TestSuiteInfoNew) selectedObj;
                String confirm = PopupGenerator.showWarningDialog(this, UserMessage.warn_deleteDocument.getMessage(tsInfo.getTSID()), UserMessage.warn_deleteDocument.getOptions(), UserMessage.warn_deleteDocument.getDefaultSelection());
                if (confirm.equals(UserMessage.OPTION_DELETE)) {
                    tasksV.add(new TFRemove(getTestingFrameworkWindowManager(), tsInfo));
                    tfRefreshTreeTask = new TFRefresh(getTestingFrameworkWindowManager(), tsInfo);
                    tasksV.add(tfRefreshTreeTask);
                } else {
                    throw UserCancelException.CANCEL_GENERIC;
                }
            // getTestingFrameworkWindowManager().removeTestSuite(tsInfo);
            } else {
                throw new Exception("Selected Object is not a test suite! Cannot add a test case");
            }
        } else if (e.getActionCommand().equals("Generate TestSuite Report")) {
            final TreePath[] selectedTreePathsLocal = selectedTreePaths;
            new Thread(new Runnable() {

                public void run() {
                    try {
                        for (int i = 0; selectedTreePathsLocal != null && i < selectedTreePathsLocal.length; i += 1) {
                            Object selTreeNode = ((BioModelNode) selectedTreePathsLocal[i].getLastPathComponent()).getUserObject();
                            if (selTreeNode instanceof TestSuiteInfoNew) {
                                Vector<AsynchClientTask> tasksVLocal = new java.util.Vector<AsynchClientTask>();
                                TestSuiteInfoNew tsInfo = (TestSuiteInfoNew) selTreeNode;
                                tasksVLocal.add(new cbit.vcell.client.task.TFUpdateRunningStatus(getTestingFrameworkWindowManager(), tsInfo));
                                tasksVLocal.add(new TFGenerateReport(getTestingFrameworkWindowManager(), tsInfo));
                                final String END_NOTIFIER = "END NOTIFIER";
                                tasksVLocal.add(new AsynchClientTask(END_NOTIFIER, AsynchClientTask.TASKTYPE_NONSWING_BLOCKING, false, false) {

                                    public void run(Hashtable<String, Object> hashTable) throws Exception {
                                        hashTable.put(END_NOTIFIER, END_NOTIFIER);
                                    }
                                });
                                tfRefreshTreeTask = new TFRefresh(getTestingFrameworkWindowManager(), tsInfo);
                                tasksVLocal.add(tfRefreshTreeTask);
                                AsynchClientTask[] tasksArr = new AsynchClientTask[tasksVLocal.size()];
                                tasksVLocal.copyInto(tasksArr);
                                Hashtable<String, Object> hashLocal = new Hashtable<String, Object>();
                                ClientTaskDispatcher.dispatch(TestingFrameworkWindowPanel.this, hashLocal, tasksArr, true);
                                // Wait for each report to complete before going on to next because report methods are not thread safe?
                                while (!hashLocal.contains(END_NOTIFIER)) {
                                    Thread.sleep(100);
                                }
                            } else {
                                throw new Exception("Error GenerateTestSuiteReport\nSelected Object is not a TestSuite");
                            }
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                        PopupGenerator.showErrorDialog(TestingFrameworkWindowPanel.this, "Error GenerateTestSuiteReport\n" + e.getMessage(), e);
                        return;
                    }
                }
            }).start();
            return;
        } else if (e.getActionCommand().equals("Generate TestCase Report")) {
            Vector<TestSuiteInfoNew> tsinV = new Vector<TestSuiteInfoNew>();
            for (int i = 0; selectedTreePaths != null && i < selectedTreePaths.length; i += 1) {
                Object selTreeNode = ((BioModelNode) selectedTreePaths[i].getLastPathComponent()).getUserObject();
                if (selTreeNode instanceof TestCaseNew) {
                    TestSuiteInfoNew tsInfo = gettestingFrameworkPanel().getTestSuiteInfoOfTreePath(selectedTreePaths[i]);
                    if (!tsinV.contains(tsInfo)) {
                        tsinV.add(tsInfo);
                        tasksV.add(new cbit.vcell.client.task.TFUpdateRunningStatus(getTestingFrameworkWindowManager(), tsInfo));
                    }
                    tasksV.add(new TFGenerateReport(getTestingFrameworkWindowManager(), (TestCaseNew) selTreeNode));
                } else {
                    throw new Exception("Selected Object is not a TestCase");
                }
            }
            tfRefreshTreeTask = new TFRefresh(getTestingFrameworkWindowManager(), (tsinV.size() == 1 ? tsinV.elementAt(0) : null));
            tasksV.add(tfRefreshTreeTask);
        } else if (e.getActionCommand().equals(TestingFrameworkPanel.GENTCRITREPORT_INTERNALREF_TESTCRITERIA) || e.getActionCommand().equals(TestingFrameworkPanel.GENTCRITREPORT_USERDEFREF_TESTCRITERIA)) {
            TFGenerateReport.VCDocumentAndSimInfo userDefinedRegrRef = null;
            if (e.getActionCommand().equals(TestingFrameworkPanel.GENTCRITREPORT_USERDEFREF_TESTCRITERIA)) {
                try {
                    userDefinedRegrRef = getUserSelectedSimulationInfo();
                } catch (UserCancelException e2) {
                    return;
                }
            }
            Vector<TestSuiteInfoNew> tsinV = new Vector<TestSuiteInfoNew>();
            for (int i = 0; selectedTreePaths != null && i < selectedTreePaths.length; i += 1) {
                Object selTreeNode = ((BioModelNode) selectedTreePaths[i].getLastPathComponent()).getUserObject();
                if (selTreeNode instanceof TestCriteriaNew) {
                    TestSuiteInfoNew tsInfo = gettestingFrameworkPanel().getTestSuiteInfoOfTreePath(selectedTreePaths[i]);
                    if (!tsinV.contains(tsInfo)) {
                        tsinV.add(tsInfo);
                        tasksV.add(new cbit.vcell.client.task.TFUpdateRunningStatus(getTestingFrameworkWindowManager(), tsInfo));
                    }
                    tasksV.add(new TFGenerateReport(getTestingFrameworkWindowManager(), (TestCaseNew) ((BioModelNode) selectedTreePaths[i].getParentPath().getLastPathComponent()).getUserObject(), (TestCriteriaNew) selTreeNode, userDefinedRegrRef));
                } else {
                    throw new Exception("Selected Object is not a TestCriteria");
                }
            }
            tfRefreshTreeTask = new TFRefresh(getTestingFrameworkWindowManager(), (tsinV.size() == 1 ? tsinV.elementAt(0) : null));
            tasksV.add(tfRefreshTreeTask);
        } else if (e.getActionCommand().equals(TestingFrameworkPanel.REMOVE_DIFF_TESTCRITERIA)) {
            final int OLDER = 0;
            final int NEWER = 1;
            final TestSuiteInfoNew[] testSuiteInfoHolder = new TestSuiteInfoNew[2];
            if (selectedTreePaths.length == 2 && ((BioModelNode) selectedTreePaths[0].getLastPathComponent()).getUserObject() instanceof TestSuiteInfoNew && ((BioModelNode) selectedTreePaths[1].getLastPathComponent()).getUserObject() instanceof TestSuiteInfoNew) {
                // do outside task because its quick
                TestSuiteInfoNew testSuiteInfoOlder = (TestSuiteInfoNew) ((BioModelNode) selectedTreePaths[0].getLastPathComponent()).getUserObject();
                TestSuiteInfoNew testSuiteInfoNewer = (TestSuiteInfoNew) ((BioModelNode) selectedTreePaths[1].getLastPathComponent()).getUserObject();
                if (testSuiteInfoOlder.getTSDate().compareTo(testSuiteInfoNewer.getTSDate()) > 0) {
                    TestSuiteInfoNew temp = testSuiteInfoOlder;
                    testSuiteInfoOlder = testSuiteInfoNewer;
                    testSuiteInfoNewer = temp;
                }
                testSuiteInfoHolder[OLDER] = testSuiteInfoOlder;
                testSuiteInfoHolder[NEWER] = testSuiteInfoNewer;
                AsynchClientTask showDiffTask = new AsynchClientTask("Show Differential TestCriteria...", AsynchClientTask.TASKTYPE_NONSWING_BLOCKING) {

                    public void run(Hashtable<String, Object> hashTable) throws Exception {
                        ArrayList<TestSuiteNew> bothTestSuites = new ArrayList<TestSuiteNew>();
                        if (getClientTaskStatusSupport() != null) {
                            getClientTaskStatusSupport().setProgress(25);
                            getClientTaskStatusSupport().setMessage("Getting TestSuiteInfo '" + testSuiteInfoHolder[OLDER].getTSID() + "'");
                        }
                        bothTestSuites.add(getDocumentManager().getTestSuite(testSuiteInfoHolder[OLDER].getTSKey()));
                        if (getClientTaskStatusSupport() != null) {
                            getClientTaskStatusSupport().setProgress(50);
                            getClientTaskStatusSupport().setMessage("Getting TestSuiteInfo '" + testSuiteInfoHolder[NEWER].getTSID() + "'");
                        }
                        bothTestSuites.add(getDocumentManager().getTestSuite(testSuiteInfoHolder[NEWER].getTSKey()));
                        HashMap<String, TestCriteriaNew> olderTestCritHashMap = new HashMap<String, TestCriteriaNew>();
                        ArrayList<String> olderTestCaseBaseNames = new ArrayList<String>();
                        TreeMap<String, TestCriteriaNew> newDiffTestCriteria = new TreeMap<String, TestCriteriaNew>();
                        int excludedCount = 0;
                        for (TestSuiteNew currentTestSuite : bothTestSuites) {
                            BigDecimal currentTestSuiteKey = currentTestSuite.getTSInfoNew().getTSKey();
                            for (TestCaseNew tcn : currentTestSuite.getTestCases()) {
                                String prefixInfo = "TS='" + currentTestSuite.getTSInfoNew().getTSID() + "' Type='" + tcn.getType() + "' ";
                                String baseName = (tcn instanceof TestCaseNewBioModel ? "BioModel='" + ((TestCaseNewBioModel) tcn).getBioModelInfo().getVersion().getName() + "' App='" + ((TestCaseNewBioModel) tcn).getSimContextName() + "'" : "MathModel='" + ((TestCaseNewMathModel) tcn).getMathModelInfo().getVersion().getName()) + "'";
                                if (currentTestSuite.getTSInfoNew().getTSKey().equals(testSuiteInfoHolder[OLDER].getTSKey())) {
                                    if (!olderTestCaseBaseNames.contains(baseName)) {
                                        olderTestCaseBaseNames.add(baseName);
                                    } else {
                                        throw new Exception("Old testcase names duplicated.");
                                    }
                                }
                                for (TestCriteriaNew tcrit : tcn.getTestCriterias()) {
                                    String name = baseName + " Sim='" + tcrit.getSimInfo().getName() + "'";
                                    if (olderTestCritHashMap.containsKey(name)) {
                                        if (currentTestSuiteKey.equals(testSuiteInfoHolder[OLDER].getTSKey())) {
                                            throw new Exception("---Problem--- Older names not unique");
                                        }
                                        continue;
                                    } else if (currentTestSuiteKey.equals(testSuiteInfoHolder[NEWER].getTSKey())) {
                                        if (!olderTestCaseBaseNames.contains(baseName)) {
                                            // this happens when new TestSuite has added TestCase after duplication
                                            excludedCount += 1;
                                        } else if (newDiffTestCriteria.put(prefixInfo + name, tcrit) != null) {
                                            throw new Exception("---Problem--- Newer added names not unique");
                                        }
                                        continue;
                                    }
                                    olderTestCritHashMap.put(name, tcrit);
                                }
                            }
                        }
                        if (newDiffTestCriteria.size() > 0) {
                            if (getClientTaskStatusSupport() != null) {
                                getClientTaskStatusSupport().setMessage("Showing Differential list...");
                            }
                            String[][] rowData = new String[newDiffTestCriteria.size()][1];
                            String[] addedNamesArr = newDiffTestCriteria.keySet().toArray(new String[0]);
                            for (int i = 0; i < addedNamesArr.length; i++) {
                                rowData[i][0] = addedNamesArr[i];
                            }
                            final String DELETE = "Delete";
                            TableListResult result = DialogUtils.showComponentOptionsTableList(gettestingFrameworkPanel(), "Remove TestCriteria in TS='" + testSuiteInfoHolder[NEWER].getTSID() + "' that were not in TS='" + testSuiteInfoHolder[OLDER].getTSID() + "' (count=" + rowData.length + " of " + olderTestCritHashMap.size() + ", excluded=" + excludedCount + ")", new String[] { "Diff TestCriteria" }, rowData, ListSelectionModel.MULTIPLE_INTERVAL_SELECTION, null, new String[] { DELETE, "Cancel" }, DELETE, null);
                            if (result != null && result.selectedOption != null && result.selectedOption.equals(DELETE) && result.selectedTableRows != null && result.selectedTableRows.length > 0) {
                                TestCriteriaNew[] allNewDiffTeestCritArr = newDiffTestCriteria.values().toArray(new TestCriteriaNew[0]);
                                TestCriteriaNew[] selTestCritsArr = new TestCriteriaNew[result.selectedTableRows.length];
                                for (int i = 0; i < result.selectedTableRows.length; i++) {
                                    selTestCritsArr[i] = allNewDiffTeestCritArr[result.selectedTableRows[i]];
                                // System.out.println("Selected= "+rowData[result.selectedTableRows[i]][0]+"  --  SimName="+selTestCritsArrHolder[0][i].getSimInfo().getVersion().getName());
                                }
                                hashTable.put(TFRemoveTestCriteria.REMOVE_THESE_TESTCRITERIAS, selTestCritsArr);
                            } else {
                                throw UserCancelException.CANCEL_GENERIC;
                            }
                        } else {
                            throw new Exception("No differential TestCriteria found");
                        }
                    }
                };
                AsynchClientTask shouldRefreshTask = new // Prevent annoying refresh if cancel
                AsynchClientTask(// Prevent annoying refresh if cancel
                "", // Prevent annoying refresh if cancel
                AsynchClientTask.TASKTYPE_SWING_NONBLOCKING) {

                    public void run(Hashtable<String, Object> hashTable) throws Exception {
                        new TFRefresh(getTestingFrameworkWindowManager(), testSuiteInfoHolder[NEWER]).run(hashTable);
                    }
                };
                tasksV.add(showDiffTask);
                tasksV.add(new TFRemoveTestCriteria(getTestingFrameworkWindowManager()));
                tasksV.add(shouldRefreshTask);
            // tasksV.add(new TFRefresh(getTestingFrameworkWindowManager(),testSuiteInfoHolder[NEWER]));
            }
        } else if (e.getActionCommand().equals(TestingFrameworkPanel.REMOVE_TESTCRITERIA)) {
            if (selectedObj instanceof TestCriteriaNew) {
                ArrayList<TestCriteriaNew> selTestCritsArr = new ArrayList<TestCriteriaNew>();
                for (int i = 0; selectedTreePaths != null && i < selectedTreePaths.length; i += 1) {
                    Object selTreeNode = ((BioModelNode) selectedTreePaths[i].getLastPathComponent()).getUserObject();
                    if (selTreeNode instanceof TestCriteriaNew) {
                        selTestCritsArr.add(((TestCriteriaNew) selTreeNode));
                    }
                }
                final String DELETE = "Delete";
                String response = DialogUtils.showWarningDialog(gettestingFrameworkPanel(), "Delete " + selTestCritsArr.size() + " TestCriterias?", new String[] { DELETE, "Cancel" }, DELETE);
                if (response != null && response.equals(DELETE)) {
                    tasksV.add(new TFRemoveTestCriteria(getTestingFrameworkWindowManager(), selTestCritsArr.toArray(new TestCriteriaNew[0])));
                    TestSuiteInfoNew tsInfo = gettestingFrameworkPanel().getTestSuiteInfoOfSelectedTestCriteria();
                    tasksV.add(new TFRefresh(getTestingFrameworkWindowManager(), tsInfo));
                } else {
                    throw UserCancelException.CANCEL_GENERIC;
                }
            } else {
                throw new Exception("Selected Object is not a TestCriteria! Cannot remove test criteria.");
            }
        } else if (e.getActionCommand().equals(TestingFrameworkPanel.EDIT_TESTCRITERIA)) {
            if (selectedObj instanceof TestCriteriaNew) {
                TestCriteriaNew tCriteria = (TestCriteriaNew) selectedObj;
                TestCaseNew testCase = gettestingFrameworkPanel().getTestCaseOfSelectedCriteria();
                TestCriteriaNew tcritNew = getTestingFrameworkWindowManager().getNewTestCriteriaFromUser(testCase.getType(), tCriteria);
                tasksV.add(new TFUpdateTestCriteria(getTestingFrameworkWindowManager(), tCriteria, tcritNew));
                TestSuiteInfoNew tsInfo = gettestingFrameworkPanel().getTestSuiteInfoOfSelectedTestCriteria();
                tfRefreshTreeTask = new TFRefresh(getTestingFrameworkWindowManager(), tsInfo);
                tasksV.add(tfRefreshTreeTask);
            } else {
                throw new Exception("Selected Object is not a TestCriteria! Cannot edit test criteria.");
            }
        } else if (e.getActionCommand().equals(TestingFrameworkPanel.COPY_TCRIT_SIMID)) {
            if (selectedObj instanceof TestCriteriaNew) {
                TestCriteriaNew tCriteria = (TestCriteriaNew) selectedObj;
                KeyValue testCritSimID = tCriteria.getSimInfo().getVersion().getVersionKey();
                VCellTransferable.sendToClipboard(testCritSimID.toString());
                return;
            } else {
                throw new Exception("Selected Object is not a TestCriteria! Copy simid failed.");
            }
        } else if (e.getActionCommand().equals(TestingFrameworkPanel.LOAD_MODEL)) {
            final String LOAD_THIS_MODEL = "LOAD_THIS_MODEL";
            AsynchClientTask modelInfoTask = new AsynchClientTask("Finding Model Info...", AsynchClientTask.TASKTYPE_NONSWING_BLOCKING) {

                @Override
                public void run(Hashtable<String, Object> hashTable) throws Exception {
                    VCDocumentInfo vcDocumentInfo = null;
                    if (selectedObj instanceof TestCaseNew) {
                        TestCaseNew testCase = (TestCaseNew) selectedObj;
                        if (testCase instanceof TestCaseNewMathModel) {
                            vcDocumentInfo = ((TestCaseNewMathModel) testCase).getMathModelInfo();
                        } else if (testCase instanceof TestCaseNewBioModel) {
                            vcDocumentInfo = ((TestCaseNewBioModel) testCase).getBioModelInfo();
                        } else {
                            throw new IllegalArgumentException("Unexpected TestCase type=" + testCase.getClass().getName());
                        }
                        hashTable.put(LOAD_THIS_MODEL, vcDocumentInfo);
                    } else if (selectedObj instanceof LoadTestTreeInfo) {
                        throw new Exception("Not yet implemented for LoadTest.");
                    // LoadTestTreeInfo loadTestTreeInfo = (LoadTestTreeInfo)selectedObj;
                    // if(loadTestTreeInfo.modelType.equals(LoadTestInfoOpResults.MODELTYPE_BIO)){
                    // vcDocumentInfo = getDocumentManager().getBioModelInfo(loadTestTreeInfo.bioOrMathModelKey);
                    // }else if(loadTestTreeInfo.modelType.equals(LoadTestInfoOpResults.MODELTYPE_MATH)){
                    // vcDocumentInfo = getDocumentManager().getMathModelInfo(loadTestTreeInfo.bioOrMathModelKey);
                    // }else{
                    // throw new IllegalArgumentException("Unexpected LoadTestTreeInfo type="+loadTestTreeInfo.modelType);
                    // }
                    // hashTable.put(LOAD_THIS_MODEL, vcDocumentInfo);
                    }
                }
            };
            AsynchClientTask openModelTask = new AsynchClientTask("Opening model...", AsynchClientTask.TASKTYPE_SWING_BLOCKING) {

                @Override
                public void run(Hashtable<String, Object> hashTable) throws Exception {
                    if (selectedObj instanceof TestCaseNew) {
                        getTestingFrameworkWindowManager().loadModel((VCDocumentInfo) hashTable.get(LOAD_THIS_MODEL));
                    } else if (selectedObj instanceof LoadTestTreeInfo) {
                        throw new Exception("Not yet implemented for LoadTest.");
                    } else {
                        throw new Exception("Load Model expecting TestCaseNew or LoadTestTreeInfo but got " + selectedObj.getClass().getName());
                    }
                }
            };
            tasksV.add(modelInfoTask);
            tasksV.add(openModelTask);
        }
        // tasksV.add(tfRefreshTreeTask);
        AsynchClientTask[] tasksArr = new AsynchClientTask[tasksV.size()];
        tasksV.copyInto(tasksArr);
        ClientTaskDispatcher.dispatch(this, hash, tasksArr, true);
    } catch (Throwable exc) {
        if (!(exc instanceof UserCancelException) && !(exc instanceof UtilCancelException)) {
            exc.printStackTrace(System.out);
            PopupGenerator.showErrorDialog(TestingFrameworkWindowPanel.this, exc.getMessage(), exc);
        }
    }
}

Example 20 with UserCancelException

use of org.vcell.util.UserCancelException in project vcell by virtualcell.

the class ReactionCartoonTool method menuAction.

@Override
protected void menuAction(Shape shape, String menuAction) {
    if (shape == null) {
        return;
    }
    if (menuAction.equals(CartoonToolMiscActions.Properties.MENU_ACTION)) {
        if (shape instanceof FluxReactionShape) {
        // showFluxReactionPropertiesDialog((FluxReactionShape) shape);
        } else if (shape instanceof SimpleReactionShape) {
        // showSimpleReactionPropertiesDialog((SimpleReactionShape) shape);
        } else if (shape instanceof ReactantShape) {
        // Point locationOnScreen = shape.getSpaceManager().getAbsLoc();
        // Point graphPaneLocation = getGraphPane().getLocationOnScreen();
        // locationOnScreen.translate(graphPaneLocation.x,
        // graphPaneLocation.y);
        // showReactantPropertiesDialog((ReactantShape) shape,
        // locationOnScreen);
        } else if (shape instanceof ProductShape) {
        // Point locationOnScreen = shape.getSpaceManager().getAbsLoc();
        // Point graphPaneLocation = getGraphPane().getLocationOnScreen();
        // locationOnScreen.translate(graphPaneLocation.x,
        // graphPaneLocation.y);
        // showProductPropertiesDialog((ProductShape) shape,
        // locationOnScreen);
        } else if (shape instanceof SpeciesContextShape) {
        // showEditSpeciesDialog(getGraphPane(), getReactionCartoon()
        // .getModel(), ((SpeciesContextShape) shape)
        // .getSpeciesContext());
        } else if (shape instanceof ReactionContainerShape) {
        // ReactionContainerShape rcs = (ReactionContainerShape) shape;
        // if (rcs.getStructure() instanceof Feature) {
        // //
        // // showFeaturePropertyDialog is invoked in two modes:
        // //
        // // 1) parent!=null and child==null
        // // upon ok, it adds a new feature to the supplied parent.
        // //
        // // 2) parent==null and child!=null
        // // upon ok, edits the feature name
        // //
        // showFeaturePropertiesDialog(getGraphPane(),
        // (getReactionCartoon().getModel() == null ? null
        // : getReactionCartoon().getModel()), null,
        // (Feature) rcs.getStructure());
        // } else if (rcs.getStructure() instanceof Membrane) {
        // showMembranePropertiesDialog(getGraphPane(), (Membrane) rcs
        // .getStructure());
        // }
        }
    } else if (menuAction.equals(CartoonToolMiscActions.AddSpecies.MENU_ACTION)) {
        if (shape instanceof ReactionContainerShape) {
            getGraphModel().deselectShape(shape);
            // showCreateSpeciesContextDialog(getGraphPane(),
            // getReactionCartoon().getModel(),
            // ((ReactionContainerShape) shape).getStructure(), null);
            SpeciesContext speciesContext = getReactionCartoon().getModel().createSpeciesContext(((ReactionContainerShape) shape).getStructure());
            getGraphModel().select(speciesContext);
        }
    } else if (menuAction.equals(CartoonToolEditActions.Copy.MENU_ACTION)) {
        if (shape instanceof SpeciesContextShape || shape instanceof ReactionStepShape || // rule participants whose rule is not selected won't
        shape instanceof RuleParticipantSignatureDiagramShape || // be copied since standalone they are meaningless
        shape instanceof ReactionRuleDiagramShape) {
            SpeciesContext[] spArray = getSelectedSpeciesContextArray();
            ReactionStep[] rsArray = getSelectedReactionStepArray();
            ReactionRule[] rrArray = getSelectedReactionRuleArray();
            MolecularType[] mtArray = getSelectedMolecularTypeArray(rrArray, rsArray, spArray);
            Structure[] structArray = getSelectedStructuresArray(rrArray, rsArray, spArray, mtArray);
            Structure fromStruct = null;
            ReactionContainerShape rcs = null;
            Shape parentShape = shape.getParent();
            if (parentShape instanceof ReactionContainerShape) {
                rcs = (ReactionContainerShape) parentShape;
                fromStruct = rcs.getStructure();
            }
            ReactionSpeciesCopy reactionSpeciesCopy = new ReactionSpeciesCopy(spArray, rsArray, rrArray, mtArray, fromStruct, structArray);
            VCellTransferable.sendToClipboard(reactionSpeciesCopy);
        }
    } else if (/*menuAction.equals(CartoonToolEditActions.Paste.MENU_ACTION)
				|| */
    menuAction.equals(CartoonToolEditActions.PasteNew.MENU_ACTION)) {
        if (shape instanceof ReactionContainerShape) {
            pasteReactionsAndSpecies(((ReactionContainerShape) shape).getStructure());
        }
    } else if (menuAction.equals(CartoonToolEditActions.Delete.MENU_ACTION)) {
        try {
            if (getGraphModel().getSelectedShape() instanceof ReactionContainerShape && menuAction.equals(CartoonToolEditActions.Delete.MENU_ACTION)) {
                getModel().removeStructure(((ReactionContainerShape) getGraphModel().getSelectedShape()).getStructure());
                return;
            }
            if (getSelectedReactionStepArray() != null || getSelectedSpeciesContextArray() != null) {
                deleteReactionsAndSpecies(getGraphPane(), getSelectedReactionStepArray(), getSelectedSpeciesContextArray());
            }
            if (getSelectedReactionParticipantArray() != null && menuAction.equals(CartoonToolEditActions.Delete.MENU_ACTION)) {
                ReactionParticipant[] reactionParticipantArr = getSelectedReactionParticipantArray();
                String response = DialogUtils.showWarningDialog(getGraphPane(), "Delete " + reactionParticipantArr.length + " Reaction Stoichiometries", new String[] { RXSPECIES_DELETE, RXSPECIES_CANCEL }, RXSPECIES_CANCEL);
                if (response != null && response.equals(RXSPECIES_DELETE)) {
                    for (int i = 0; i < reactionParticipantArr.length; i++) {
                        ReactionStep reactionStep = reactionParticipantArr[i].getReactionStep();
                        reactionStep.removeReactionParticipant(reactionParticipantArr[i]);
                    }
                }
            }
        } catch (UserCancelException uce) {
            return;
        } catch (PropertyVetoException e) {
            DialogUtils.showErrorDialog(getGraphPane(), e.getMessage());
        } catch (Exception e) {
            DialogUtils.showErrorDialog(getGraphPane(), e.getMessage(), e);
        }
    } else if (menuAction.equals(CartoonToolMiscActions.SearchReactions.MENU_ACTION)) {
        try {
            if (shape instanceof ReactionContainerShape) {
                showReactionBrowserDialog(((ReactionContainerShape) shape).getStructure(), null);
            }
        } catch (Exception e) {
            DialogUtils.showErrorDialog(getGraphPane(), e.getMessage(), e);
        }
    } else if (menuAction.equals(CartoonToolSaveAsImageActions.MenuAction.MENU_ACTION)) {
        try {
            String resType = null;
            if (shape instanceof ReactionContainerShape) {
                showSaveReactionImageDialog();
            }
        } catch (Exception e) {
            e.printStackTrace();
            DialogUtils.showErrorDialog(getGraphPane(), e.getMessage(), e);
        }
    } else if (menuAction.equals(CartoonToolMiscActions.Annotate.MENU_ACTION)) {
        if (shape instanceof ReactionStepShape) {
            // MIRIAMHelper.showMIRIAMAnnotationDialog(((SimpleReactionShape)shape).getReactionStep());
            // System.out.println("Menu action annotate activated...");
            ReactionStep rs = ((ReactionStepShape) shape).getReactionStep();
            VCMetaData vcMetaData = rs.getModel().getVcMetaData();
            try {
                String newAnnotation = DialogUtils.showAnnotationDialog(getGraphPane(), vcMetaData.getFreeTextAnnotation(rs));
                vcMetaData.setFreeTextAnnotation(rs, newAnnotation);
            } catch (UtilCancelException e) {
            // Do Nothing
            } catch (Throwable exc) {
                exc.printStackTrace(System.out);
                DialogUtils.showErrorDialog(getGraphPane(), "Failed to edit annotation!\n" + exc.getMessage(), exc);
            }
        }
    } else {
    // default action is to ignore
    }
}