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

Example 1 with UserCancelException

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

the class PDEExportDataPanel method createSimulationSelector.

private ExportSpecs.SimulationSelector createSimulationSelector() {
    ExportSpecs.SimulationSelector simulationSelector = new ExportSpecs.SimulationSelector() {

        private ExportSpecs.SimNameSimDataID[] multiSimNameSimDataIDs;

        // private ExportSpecs.ExportParamScanInfo exportParamScanInfo;
        private int[] selectedParamScanIndexes;

        private Simulation[] simulations;

        public SimNameSimDataID[] getSelectedSimDataInfo() {
            // }
            if (multiSimNameSimDataIDs == null) {
                return new ExportSpecs.SimNameSimDataID[] { currentSimNameSimDataID };
            }
            return multiSimNameSimDataIDs;
        }

        public void selectSimulations() {
            getNumAvailableSimulations();
            String[][] rowData = new String[simulations.length][5];
            for (int i = 0; i < rowData.length; i++) {
                rowData[i][0] = simulations[i].getName();
                rowData[i][1] = simulations[i].getMeshSpecification().getSamplingSize().toString();
                rowData[i][2] = simulations[i].getSolverTaskDescription().getExpectedNumTimePoints() + "";
                rowData[i][3] = simulations[i].getSolverTaskDescription().getTimeBounds().getEndingTime() + "";
                rowData[i][4] = simulations[i].getSolverTaskDescription().getOutputTimeSpec().getShortDescription();
            }
            try {
                int[] choices = DialogUtils.showComponentOKCancelTableList(PDEExportDataPanel.this, "Choose Sims to export together", new String[] { "Simulation", "Mesh x,y,z", "NumTimePoints", "EndTime", "Output Descr." }, rowData, ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
                if (choices != null) {
                    multiSimNameSimDataIDs = new ExportSpecs.SimNameSimDataID[choices.length];
                    for (int i = 0; i < choices.length; i++) {
                        multiSimNameSimDataIDs[i] = new ExportSpecs.SimNameSimDataID(simulations[choices[i]].getName(), simulations[choices[i]].getSimulationInfo().getAuthoritativeVCSimulationIdentifier(), SimResultsViewer.getParamScanInfo(simulations[choices[i]], (currentSimNameSimDataID == null ? 0 : currentSimNameSimDataID.getDefaultJobIndex())));
                    }
                }
            } catch (UserCancelException uce) {
            // ignore
            }
        }

        public void selectParamScanInfo() {
            String[][] rowData = new String[currentSimNameSimDataID.getExportParamScanInfo().getParamScanJobIndexes().length][currentSimNameSimDataID.getExportParamScanInfo().getParamScanConstantNames().length];
            for (int i = 0; i < rowData.length; i++) {
                for (int j = 0; j < rowData[i].length; j++) {
                    rowData[i][j] = currentSimNameSimDataID.getExportParamScanInfo().getParamScanConstantValues()[i][j];
                }
            }
            try {
                int[] choices = DialogUtils.showComponentOKCancelTableList(PDEExportDataPanel.this, "Choose ParameterScans to export together", currentSimNameSimDataID.getExportParamScanInfo().getParamScanConstantNames(), rowData, ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
                if (choices != null && choices.length > 0) {
                    selectedParamScanIndexes = new int[choices.length];
                    // String[][] selectedParamScanValues = new String[choices.length][currentSimNameSimDataID.getExportParamScanInfo().getParamScanConstantNames().length];
                    for (int i = 0; i < choices.length; i++) {
                        selectedParamScanIndexes[i] = choices[i];
                    // for (int j = 0; j < currentSimNameSimDataID.getExportParamScanInfo().getParamScanConstantNames().length; j++) {
                    // selectedParamScanValues[i][j] = currentSimNameSimDataID.getExportParamScanInfo().getParamScanConstantValues()[choices[i]][j];
                    // }
                    }
                // exportParamScanInfo =
                // new ExportSpecs.ExportParamScanInfo(selectedParamScanIndexes, selectedParamScanIndexes[0], currentSimNameSimDataID.getExportParamScanInfo().getParamScanConstantNames(), selectedParamScanValues);
                } else {
                    selectedParamScanIndexes = null;
                }
            } catch (UserCancelException uce) {
            // ignore
            }
        }

        public int[] getselectedParamScanIndexes() {
            return selectedParamScanIndexes;
        }

        public int getNumAvailableParamScans() {
            if (currentSimNameSimDataID == null || currentSimNameSimDataID.getExportParamScanInfo() == null) {
                return 0;
            }
            return currentSimNameSimDataID.getExportParamScanInfo().getParamScanJobIndexes().length;
        }

        public int getNumAvailableSimulations() {
            if (simulations == null) {
                VCDocument thisDocument = (getDataViewerManager() instanceof DocumentWindowManager ? ((DocumentWindowManager) getDataViewerManager()).getVCDocument() : null);
                if (thisDocument instanceof BioModel) {
                    String thisSimContextName = dataInfoProvider.getSimulationModelInfo().getContextName();
                    SimulationContext[] simContexts = ((BioModel) thisDocument).getSimulationContexts();
                    SimulationContext thisSimulationContext = null;
                    for (int i = 0; i < simContexts.length; i++) {
                        if (thisSimContextName.equals(thisDocument.getName() + "::" + simContexts[i].getName())) {
                            thisSimulationContext = simContexts[i];
                            break;
                        }
                    }
                    simulations = thisSimulationContext.getSimulations();
                } else if (thisDocument instanceof MathModel) {
                    simulations = ((MathModel) thisDocument).getSimulations();
                } else {
                    simulations = new Simulation[0];
                }
            }
            return simulations.length;
        }
    };
    return simulationSelector;
}

Example 2 with UserCancelException

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

the class ReferenceDataPanel method updateReferenceDataFromFile.

/**
 * Comment
 */
private void updateReferenceDataFromFile() {
    try {
        VCFileChooser fileChooser = new VCFileChooser();
        fileChooser.setFileSelectionMode(javax.swing.JFileChooser.FILES_ONLY);
        fileChooser.setMultiSelectionEnabled(false);
        fileChooser.addChoosableFileFilter(FileFilters.FILE_FILTER_CSV);
        // Set the default file filter...
        fileChooser.setFileFilter(FileFilters.FILE_FILTER_CSV);
        // remove all selector
        fileChooser.removeChoosableFileFilter(fileChooser.getAcceptAllFileFilter());
        File defaultPath = null;
        if (getUserPreferences() != null) {
            defaultPath = getUserPreferences().getCurrentDialogPath();
            if (defaultPath != null) {
                fileChooser.setCurrentDirectory(defaultPath);
            }
        }
        fileChooser.setDialogTitle("Import Data File");
        if (fileChooser.showOpenDialog(this) != javax.swing.JFileChooser.APPROVE_OPTION) {
            // user didn't choose save
            throw UserCancelException.CANCEL_FILE_SELECTION;
        } else {
            File selectedFile = fileChooser.getSelectedFile();
            if (selectedFile == null) {
                // no file selected (no name given)
                throw UserCancelException.CANCEL_FILE_SELECTION;
            } else {
                if (getUserPreferences() != null) {
                    File newPath = selectedFile.getParentFile();
                    if (!newPath.equals(defaultPath)) {
                        getUserPreferences().setCurrentDialogPath(newPath);
                    }
                }
                CSV csv = new CSV();
                RowColumnResultSet rowColumnResultSet = csv.importFrom(new java.io.FileReader(selectedFile));
                double[] weights = new double[rowColumnResultSet.getDataColumnCount()];
                java.util.Arrays.fill(weights, 1.0);
                ReferenceData referenceData = new SimpleReferenceData(rowColumnResultSet, weights);
                updateReferenceData(referenceData);
            }
        }
    } catch (UserCancelException e) {
    // ignore
    } catch (Exception e) {
        e.printStackTrace();
        if (e instanceof ParseException) {
            showHelp((ParseException) e);
        } else {
            DialogUtils.showErrorDialog(this, e.getMessage(), e);
        }
    }
}

Example 3 with UserCancelException

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

the class ClientRequestManager method openAfterChecking.

private void openAfterChecking(VCDocumentInfo documentInfo, final TopLevelWindowManager requester, final boolean inNewWindow) {
    final String DOCUMENT_INFO = "documentInfo";
    final String SEDML_TASK = "SedMLTask";
    final String SEDML_MODEL = "SedMLModel";
    final String BNG_UNIT_SYSTEM = "bngUnitSystem";
    /* asynchronous and not blocking any window */
    bOpening = true;
    Hashtable<String, Object> hashTable = new Hashtable<String, Object>();
    // may want to insert corrected VCDocumentInfo later if our import debugger corrects it (BNGL Debugger).
    hashTable.put(DOCUMENT_INFO, documentInfo);
    // start a thread that gets it and updates the GUI by creating a new document desktop
    String taskName = null;
    if (documentInfo instanceof ExternalDocInfo) {
        taskName = "Importing document";
        ExternalDocInfo externalDocInfo = (ExternalDocInfo) documentInfo;
        File file = externalDocInfo.getFile();
        if (file != null && !file.getName().isEmpty() && file.getName().endsWith("bngl")) {
            BngUnitSystem bngUnitSystem = new BngUnitSystem(BngUnitOrigin.DEFAULT);
            String fileText;
            String originalFileText;
            try {
                fileText = BeanUtils.readBytesFromFile(file, null);
                originalFileText = new String(fileText);
            } catch (IOException e1) {
                e1.printStackTrace();
                DialogUtils.showErrorDialog(requester.getComponent(), "<html>Error reading file " + file.getPath() + "</html>");
                return;
            }
            Reader reader = externalDocInfo.getReader();
            boolean bException = true;
            while (bException) {
                try {
                    BioModel bioModel = createDefaultBioModelDocument(bngUnitSystem);
                    boolean bStochastic = true;
                    boolean bRuleBased = true;
                    SimulationContext ruleBasedSimContext = bioModel.addNewSimulationContext("temp NFSim app", SimulationContext.Application.RULE_BASED_STOCHASTIC);
                    List<SimulationContext> appList = new ArrayList<SimulationContext>();
                    appList.add(ruleBasedSimContext);
                    RbmModelContainer rbmModelContainer = bioModel.getModel().getRbmModelContainer();
                    RbmUtils.reactionRuleLabelIndex = 0;
                    RbmUtils.reactionRuleNames.clear();
                    ASTModel astModel = RbmUtils.importBnglFile(reader);
                    // for now, hasUnitSystem() always returns false
                    if (astModel.hasUnitSystem()) {
                        bngUnitSystem = astModel.getUnitSystem();
                    }
                    if (astModel.hasCompartments()) {
                        Structure struct = bioModel.getModel().getStructure(0);
                        if (struct != null) {
                            bioModel.getModel().removeStructure(struct);
                        }
                    }
                    BnglObjectConstructionVisitor constructionVisitor = null;
                    if (!astModel.hasMolecularDefinitions()) {
                        System.out.println("Molecular Definition Block missing.");
                        constructionVisitor = new BnglObjectConstructionVisitor(bioModel.getModel(), appList, bngUnitSystem, false);
                    } else {
                        constructionVisitor = new BnglObjectConstructionVisitor(bioModel.getModel(), appList, bngUnitSystem, true);
                    }
                    astModel.jjtAccept(constructionVisitor, rbmModelContainer);
                    bException = false;
                } catch (final Exception e) {
                    e.printStackTrace(System.out);
                    BNGLDebuggerPanel panel = new BNGLDebuggerPanel(fileText, e);
                    int oKCancel = DialogUtils.showComponentOKCancelDialog(requester.getComponent(), panel, "Bngl Debugger: " + file.getName());
                    if (oKCancel == JOptionPane.CANCEL_OPTION || oKCancel == JOptionPane.DEFAULT_OPTION) {
                        throw new UserCancelException("Canceling Import");
                    }
                    // inserting <potentially> corrected DocumentInfo
                    fileText = panel.getText();
                    externalDocInfo = new ExternalDocInfo(panel.getText());
                    reader = externalDocInfo.getReader();
                    hashTable.put(DOCUMENT_INFO, externalDocInfo);
                }
            }
            if (!originalFileText.equals(fileText)) {
                // file has been modified
                String message = "Importing <b>" + file.getName() + "</b> into vCell. <br>Overwrite the file on the disk?<br>";
                message = "<html>" + message + "</html>";
                Object[] options = { "Overwrite and Import", "Import Only", "Cancel" };
                int returnCode = JOptionPane.showOptionDialog(requester.getComponent(), message, "Bngl Debugger", JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.QUESTION_MESSAGE, null, options, options[2]);
                if (returnCode == JOptionPane.YES_OPTION) {
                    try {
                        FileWriter fw = new FileWriter(file);
                        fw.write(fileText);
                        fw.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                } else if (returnCode == JOptionPane.CANCEL_OPTION || returnCode == JOptionPane.CLOSED_OPTION) {
                    return;
                }
            }
            if (!(bngUnitSystem.getOrigin() == BngUnitOrigin.PARSER)) {
                BNGLUnitsPanel panel = new BNGLUnitsPanel(bngUnitSystem);
                int oKCancel = DialogUtils.showComponentOKCancelDialog(requester.getComponent(), panel, " Bngl Units Selector", null, false);
                if (oKCancel == JOptionPane.CANCEL_OPTION || oKCancel == JOptionPane.DEFAULT_OPTION) {
                    // TODO: or do nothing and continue with default values?
                    return;
                } else {
                    bngUnitSystem = panel.getUnits();
                }
            }
            hashTable.put(BNG_UNIT_SYSTEM, bngUnitSystem);
        } else if (file != null && !file.getName().isEmpty() && file.getName().toLowerCase().endsWith(".sedml")) {
            try {
                XMLSource xmlSource = externalDocInfo.createXMLSource();
                File sedmlFile = xmlSource.getXmlFile();
                SedML sedml = Libsedml.readDocument(sedmlFile).getSedMLModel();
                if (sedml == null || sedml.getModels().isEmpty()) {
                    return;
                }
                AbstractTask chosenTask = SEDMLChooserPanel.chooseTask(sedml, requester.getComponent(), file.getName());
                hashTable.put(SEDML_MODEL, sedml);
                hashTable.put(SEDML_TASK, chosenTask);
            } catch (Exception e) {
                e.printStackTrace();
                throw new RuntimeException("failed to read document: " + e.getMessage(), e);
            }
        } else if (file != null && !file.getName().isEmpty() && (file.getName().toLowerCase().endsWith(".sedx") || file.getName().toLowerCase().endsWith(".omex"))) {
            try {
                ArchiveComponents ac = null;
                ac = Libsedml.readSEDMLArchive(new FileInputStream(file));
                SEDMLDocument doc = ac.getSedmlDocument();
                SedML sedml = doc.getSedMLModel();
                if (sedml == null) {
                    throw new RuntimeException("Failed importing " + file.getName());
                }
                if (sedml.getModels().isEmpty()) {
                    throw new RuntimeException("Unable to find any model in " + file.getName());
                }
                AbstractTask chosenTask = SEDMLChooserPanel.chooseTask(sedml, requester.getComponent(), file.getName());
                hashTable.put(SEDML_MODEL, sedml);
                hashTable.put(SEDML_TASK, chosenTask);
            } catch (Exception e) {
                e.printStackTrace();
                throw new RuntimeException("failed to read archive: " + e.getMessage(), e);
            }
        }
    } else {
        taskName = "Loading document '" + documentInfo.getVersion().getName() + "' from database";
    }
    AsynchClientTask task0 = new AsynchClientTask(taskName, AsynchClientTask.TASKTYPE_SWING_BLOCKING) {

        public void run(Hashtable<String, Object> hashTable) throws Exception {
            if (!inNewWindow) {
                // request was to replace the document in an existing window
                getMdiManager().blockWindow(requester.getManagerID());
            }
        }
    };
    AsynchClientTask task1 = new AsynchClientTask(taskName, AsynchClientTask.TASKTYPE_NONSWING_BLOCKING) {

        @Override
        public void run(Hashtable<String, Object> hashTable) throws Exception {
            VCDocument doc = null;
            VCDocumentInfo documentInfo = (VCDocumentInfo) hashTable.get(DOCUMENT_INFO);
            if (documentInfo instanceof BioModelInfo) {
                BioModelInfo bmi = (BioModelInfo) documentInfo;
                doc = getDocumentManager().getBioModel(bmi);
            } else if (documentInfo instanceof MathModelInfo) {
                MathModelInfo mmi = (MathModelInfo) documentInfo;
                doc = getDocumentManager().getMathModel(mmi);
            } else if (documentInfo instanceof GeometryInfo) {
                GeometryInfo gmi = (GeometryInfo) documentInfo;
                doc = getDocumentManager().getGeometry(gmi);
            } else if (documentInfo instanceof ExternalDocInfo) {
                ExternalDocInfo externalDocInfo = (ExternalDocInfo) documentInfo;
                File file = externalDocInfo.getFile();
                if (file != null && !file.getName().isEmpty() && (file.getName().toLowerCase().endsWith(".sedx") || file.getName().toLowerCase().endsWith(".omex"))) {
                    TranslationLogger transLogger = new TranslationLogger(requester);
                    doc = XmlHelper.sedmlToBioModel(transLogger, externalDocInfo, (SedML) hashTable.get(SEDML_MODEL), (AbstractTask) hashTable.get(SEDML_TASK));
                } else if (!externalDocInfo.isXML()) {
                    if (hashTable.containsKey(BNG_UNIT_SYSTEM)) {
                        // not XML, look for BNGL etc.
                        // we use the BngUnitSystem already created during the 1st pass
                        BngUnitSystem bngUnitSystem = (BngUnitSystem) hashTable.get(BNG_UNIT_SYSTEM);
                        BioModel bioModel = createDefaultBioModelDocument(bngUnitSystem);
                        SimulationContext ruleBasedSimContext = bioModel.addNewSimulationContext("NFSim app", SimulationContext.Application.RULE_BASED_STOCHASTIC);
                        SimulationContext odeSimContext = bioModel.addNewSimulationContext("BioNetGen app", SimulationContext.Application.NETWORK_DETERMINISTIC);
                        List<SimulationContext> appList = new ArrayList<SimulationContext>();
                        appList.add(ruleBasedSimContext);
                        appList.add(odeSimContext);
                        // set convention for initial conditions in generated application for seed species (concentration or count)
                        ruleBasedSimContext.setUsingConcentration(bngUnitSystem.isConcentration());
                        odeSimContext.setUsingConcentration(bngUnitSystem.isConcentration());
                        RbmModelContainer rbmModelContainer = bioModel.getModel().getRbmModelContainer();
                        RbmUtils.reactionRuleLabelIndex = 0;
                        RbmUtils.reactionRuleNames.clear();
                        Reader reader = externalDocInfo.getReader();
                        ASTModel astModel = RbmUtils.importBnglFile(reader);
                        if (bioModel.getModel() != null && bioModel.getModel().getVcMetaData() != null) {
                            VCMetaData vcMetaData = bioModel.getModel().getVcMetaData();
                            vcMetaData.setFreeTextAnnotation(bioModel, astModel.getProlog());
                        }
                        if (astModel.hasCompartments()) {
                            Structure struct = bioModel.getModel().getStructure(0);
                            if (struct != null) {
                                bioModel.getModel().removeStructure(struct);
                            }
                        }
                        BnglObjectConstructionVisitor constructionVisitor = null;
                        if (!astModel.hasMolecularDefinitions()) {
                            System.out.println("Molecular Definition Block missing. Extracting it from Species, Reactions, Obserbables.");
                            constructionVisitor = new BnglObjectConstructionVisitor(bioModel.getModel(), appList, bngUnitSystem, false);
                        } else {
                            constructionVisitor = new BnglObjectConstructionVisitor(bioModel.getModel(), appList, bngUnitSystem, true);
                        }
                        // we'll convert the kinetic parameters to BngUnitSystem inside the visit(ASTKineticsParameter...)
                        astModel.jjtAccept(constructionVisitor, rbmModelContainer);
                        // set the volume in the newly created application to BngUnitSystem.bnglModelVolume
                        // TODO: set the right values if we import compartments from the bngl file!
                        // if(!bngUnitSystem.isConcentration()) {
                        Expression sizeExpression = new Expression(bngUnitSystem.getVolume());
                        ruleBasedSimContext.getGeometryContext().getStructureMapping(0).getSizeParameter().setExpression(sizeExpression);
                        odeSimContext.getGeometryContext().getStructureMapping(0).getSizeParameter().setExpression(sizeExpression);
                        // }
                        // we remove the NFSim application if any seed species is clamped because NFSim doesn't know what to do with it
                        boolean bClamped = false;
                        for (SpeciesContextSpec scs : ruleBasedSimContext.getReactionContext().getSpeciesContextSpecs()) {
                            if (scs.isConstant()) {
                                bClamped = true;
                                break;
                            }
                        }
                        if (bClamped) {
                            bioModel.removeSimulationContext(ruleBasedSimContext);
                        }
                        // // TODO: DON'T delete this code
                        // // the code below is needed if we also want to create simulations, example for 1 rule based simulation
                        // // it is rule-based so it wont have to flatten, should be fast.
                        // MathMappingCallback callback = new MathMappingCallbackTaskAdapter(getClientTaskStatusSupport());
                        // NetworkGenerationRequirements networkGenerationRequirements = null; // network generation should not be executed.
                        // ruleBasedSimContext.refreshMathDescription(callback,networkGenerationRequirements);
                        // Simulation sim = ruleBasedSimContext.addNewSimulation(SimulationOwner.DEFAULT_SIM_NAME_PREFIX,callback,networkGenerationRequirements);
                        doc = bioModel;
                    }
                } else {
                    // is XML
                    try (TranslationLogger transLogger = new TranslationLogger(requester)) {
                        XMLSource xmlSource = externalDocInfo.createXMLSource();
                        org.jdom.Element rootElement = xmlSource.getXmlDoc().getRootElement();
                        String xmlType = rootElement.getName();
                        String modelXmlType = null;
                        if (xmlType.equals(XMLTags.VcmlRootNodeTag)) {
                            // For now, assuming that <vcml> element has only one child (biomodel, mathmodel or geometry).
                            // Will deal with multiple children of <vcml> Element when we get to model composition.
                            @SuppressWarnings("unchecked") List<Element> childElementList = rootElement.getChildren();
                            // assuming first child is the biomodel, mathmodel or geometry.
                            Element modelElement = childElementList.get(0);
                            modelXmlType = modelElement.getName();
                        }
                        if (xmlType.equals(XMLTags.BioModelTag) || (xmlType.equals(XMLTags.VcmlRootNodeTag) && modelXmlType.equals(XMLTags.BioModelTag))) {
                            doc = XmlHelper.XMLToBioModel(xmlSource);
                        } else if (xmlType.equals(XMLTags.MathModelTag) || (xmlType.equals(XMLTags.VcmlRootNodeTag) && modelXmlType.equals(XMLTags.MathModelTag))) {
                            doc = XmlHelper.XMLToMathModel(xmlSource);
                        } else if (xmlType.equals(XMLTags.GeometryTag) || (xmlType.equals(XMLTags.VcmlRootNodeTag) && modelXmlType.equals(XMLTags.GeometryTag))) {
                            doc = XmlHelper.XMLToGeometry(xmlSource);
                        } else if (xmlType.equals(XMLTags.SbmlRootNodeTag)) {
                            Namespace namespace = rootElement.getNamespace(XMLTags.SBML_SPATIAL_NS_PREFIX);
                            boolean bIsSpatial = (namespace == null) ? false : true;
                            doc = XmlHelper.importSBML(transLogger, xmlSource, bIsSpatial);
                        } else if (xmlType.equals(XMLTags.CellmlRootNodeTag)) {
                            if (requester instanceof BioModelWindowManager) {
                                doc = XmlHelper.importBioCellML(transLogger, xmlSource);
                            } else {
                                doc = XmlHelper.importMathCellML(transLogger, xmlSource);
                            }
                        } else if (xmlType.equals(MicroscopyXMLTags.FRAPStudyTag)) {
                            doc = VFrapXmlHelper.VFRAPToBioModel(hashTable, xmlSource, getDocumentManager(), requester);
                        } else if (xmlType.equals(XMLTags.SedMLTypeTag)) {
                            doc = XmlHelper.sedmlToBioModel(transLogger, externalDocInfo, (SedML) hashTable.get(SEDML_MODEL), (AbstractTask) hashTable.get(SEDML_TASK));
                        } else {
                            // unknown XML format
                            throw new RuntimeException("unsupported XML format, first element tag is <" + rootElement.getName() + ">");
                        }
                        if (externalDocInfo.getDefaultName() != null) {
                            doc.setName(externalDocInfo.getDefaultName());
                        }
                    }
                }
                if (doc == null) {
                    File f = externalDocInfo.getFile();
                    if (f != null) {
                        throw new RuntimeException("Unable to determine type of file " + f.getCanonicalPath());
                    }
                    throw new ProgrammingException();
                }
            }
            // create biopax objects using annotation
            if (doc instanceof BioModel) {
                BioModel bioModel = (BioModel) doc;
                try {
                    bioModel.getVCMetaData().createBioPaxObjects(bioModel);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            requester.prepareDocumentToLoad(doc, inNewWindow);
            hashTable.put("doc", doc);
        }
    };
    AsynchClientTask task2 = new AsynchClientTask("Showing document", AsynchClientTask.TASKTYPE_SWING_BLOCKING, false, false) {

        @Override
        public void run(Hashtable<String, Object> hashTable) throws Exception {
            try {
                Throwable exc = (Throwable) hashTable.get(ClientTaskDispatcher.TASK_ABORTED_BY_ERROR);
                if (exc == null) {
                    VCDocument doc = (VCDocument) hashTable.get("doc");
                    DocumentWindowManager windowManager = null;
                    if (inNewWindow) {
                        windowManager = createDocumentWindowManager(doc);
                        // request was to create a new top-level window with this doc
                        getMdiManager().createNewDocumentWindow(windowManager);
                    // if (windowManager instanceof BioModelWindowManager) {
                    // ((BioModelWindowManager)windowManager).preloadApps();
                    // }
                    } else {
                        // request was to replace the document in an existing window
                        windowManager = (DocumentWindowManager) requester;
                        getMdiManager().setCanonicalTitle(requester.getManagerID());
                        windowManager.resetDocument(doc);
                    }
                    hashTable.put(WIN_MGR_KEY, windowManager);
                }
            } finally {
                if (!inNewWindow) {
                    getMdiManager().unBlockWindow(requester.getManagerID());
                }
                bOpening = false;
            }
        }
    };
    AsynchClientTask task3 = new AsynchClientTask("Special Layout", AsynchClientTask.TASKTYPE_SWING_BLOCKING, false, false) {

        @Override
        public void run(Hashtable<String, Object> hashTable) throws Exception {
            // TODO Auto-generated method stub
            if (documentInfo instanceof ExternalDocInfo) {
                ExternalDocInfo externalDocInfo = (ExternalDocInfo) documentInfo;
                if (externalDocInfo.isBioModelsNet()) {
                    DocumentWindowManager windowManager = (DocumentWindowManager) hashTable.get(WIN_MGR_KEY);
                    if (windowManager instanceof BioModelWindowManager) {
                        ((BioModelWindowManager) windowManager).specialLayout();
                    }
                }
            }
        }
    };
    AsynchClientTask task4 = new AsynchClientTaskFunction(ClientRequestManager::setWindowFocus, "Set window focus", AsynchClientTask.TASKTYPE_SWING_BLOCKING, false, false);
    ClientTaskDispatcher.dispatch(requester.getComponent(), hashTable, new AsynchClientTask[] { task0, task1, task2, task3, task4 }, false);
}

Example 4 with UserCancelException

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

the class ClientRequestManager method runSimulations.

public void runSimulations(final ClientSimManager clientSimManager, final Simulation[] simulations) {
    DocumentWindowManager documentWindowManager = clientSimManager.getDocumentWindowManager();
    /*	run some quick checks to see if we need to do a SaveAs */
    boolean needSaveAs = false;
    if (documentWindowManager.getVCDocument().getVersion() == null) {
        // never saved
        needSaveAs = true;
    } else if (!documentWindowManager.getVCDocument().getVersion().getOwner().compareEqual(getDocumentManager().getUser())) {
        // not the owner
        // keep the user informed this time
        String choice = PopupGenerator.showWarningDialog(documentWindowManager, getUserPreferences(), UserMessage.warn_SaveNotOwner, null);
        if (choice.equals(UserMessage.OPTION_SAVE_AS_NEW)) {
            needSaveAs = true;
        } else {
            // user canceled, just show existing document
            getMdiManager().showWindow(documentWindowManager.getManagerID());
            throw new UserCancelException("user canceled");
        }
    }
    // Before running the simulation, check if all the sizes of structures are set
    if (simulations != null && simulations.length > 0) {
        VCDocument vcd = documentWindowManager.getVCDocument();
        if (vcd instanceof BioModel) {
            String stochChkMsg = null;
            // we want to check when there is stochastic application if the rate laws set in model can be automatically transformed.
            for (int i = 0; i < simulations.length; i++) {
                if (simulations[i].getMathDescription().isNonSpatialStoch() || simulations[i].getMathDescription().isSpatialStoch() || simulations[i].getMathDescription().isSpatialHybrid()) {
                    if (stochChkMsg == null) {
                        stochChkMsg = ((BioModel) vcd).getModel().isValidForStochApp();
                    }
                    if (!(stochChkMsg.equals(""))) {
                        DialogUtils.showErrorDialog(documentWindowManager.getComponent(), "Problem in simulation: " + simulations[i].getName() + ".\n" + stochChkMsg);
                        throw new RuntimeException("Problem in simulation: " + simulations[i].getName() + "\n" + stochChkMsg);
                    }
                }
            }
        }
    }
    // 
    for (int i = 0; simulations != null && i < simulations.length; i++) {
        if (simulations[i].getSimulationVersion() != null && simulations[i].getSimulationVersion().getParentSimulationReference() != null) {
            simulations[i].clearVersion();
        }
    }
    /* now start the dirty work */
    /* block document window */
    JFrame currentDocumentWindow = getMdiManager().blockWindow(documentWindowManager.getManagerID());
    /* prepare hashtable for tasks */
    Hashtable<String, Object> hash = new Hashtable<String, Object>();
    hash.put("mdiManager", getMdiManager());
    hash.put(DocumentManager.IDENT, getDocumentManager());
    hash.put(CommonTask.DOCUMENT_WINDOW_MANAGER.name, documentWindowManager);
    hash.put("currentDocumentWindow", currentDocumentWindow);
    hash.put("clientSimManager", clientSimManager);
    hash.put("simulations", simulations);
    hash.put("jobManager", getClientServerManager().getJobManager());
    hash.put("requestManager", this);
    /* create tasks */
    AsynchClientTask[] tasks = null;
    if (needSaveAs) {
        // check document consistency first
        AsynchClientTask documentValid = new DocumentValidTask();
        AsynchClientTask setMathDescription = new SetMathDescription();
        // get a new name
        AsynchClientTask newName = new NewName();
        // save it
        AsynchClientTask saveDocument = new SaveDocument();
        // clean up
        AsynchClientTask finishSave = new FinishSave();
        // run the simulations
        AsynchClientTask runSims = new RunSims();
        // assemble array
        tasks = new AsynchClientTask[] { documentValid, setMathDescription, newName, saveDocument, finishSave, runSims };
    } else {
        // check document consistency first
        AsynchClientTask documentValid = new DocumentValidTask();
        AsynchClientTask setMathDescription = new SetMathDescription();
        // check if unchanged document
        AsynchClientTask checkUnchanged = new CheckUnchanged(true);
        // save it
        AsynchClientTask saveDocument = new SaveDocument();
        // check for lost results
        AsynchClientTask checkBeforeDelete = new CheckBeforeDelete();
        // delete old document
        AsynchClientTask deleteOldDocument = new DeleteOldDocument();
        // clean up
        AsynchClientTask finishSave = new FinishSave();
        // run the simulations
        AsynchClientTask runSims = new RunSims();
        // assemble array
        tasks = new AsynchClientTask[] { documentValid, setMathDescription, checkUnchanged, saveDocument, checkBeforeDelete, deleteOldDocument, finishSave, runSims };
    }
    /* run the tasks */
    ClientTaskDispatcher.dispatch(currentDocumentWindow, hash, tasks, true);
}

Example 5 with UserCancelException

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

the class DatabaseWindowManager method compareAnotherModel.

/**
 * Comment
 */
public void compareAnotherModel() {
    // 
    if (getPanelSelection() == null) {
        PopupGenerator.showErrorDialog(this, "Error Comparing documents : First document not selected");
        return;
    }
    VCDocumentInfo thisDocumentInfo = getPanelSelection();
    // Choose the other documentInfo. Bring up the appropriate dbTreePanel depending on the type of thisDocumentInfo
    VCDocumentInfo otherDocumentInfo = null;
    try {
        otherDocumentInfo = selectDocument(thisDocumentInfo.getVCDocumentType(), this);
    } catch (Exception e) {
        if (!(e instanceof UserCancelException)) {
            e.printStackTrace();
            DialogUtils.showErrorDialog(this.getComponent(), "Error Comparing documents: " + e.getMessage());
        }
        return;
    }
    if (otherDocumentInfo == null) {
        // PopupGenerator.showErrorDialog(this, "Error Comparing documents : Second document is null ");
        return;
    }
    // Check if both document types are of the same kind. If not, throw an error.
    if (((thisDocumentInfo instanceof BioModelInfo) && !(otherDocumentInfo instanceof BioModelInfo)) || ((thisDocumentInfo instanceof MathModelInfo) && !(otherDocumentInfo instanceof MathModelInfo)) || ((thisDocumentInfo instanceof GeometryInfo) && !(otherDocumentInfo instanceof GeometryInfo))) {
        PopupGenerator.showErrorDialog(this, "Error Comparing documents : The two documents are not of the same type!");
        return;
    }
    // Now that we have both the document versions to be compared, do the comparison and display the result
    compareWithOther(otherDocumentInfo, thisDocumentInfo);
}