Examples with MathModelInfo org.vcell.util.document.MathModelInfo used on opensource projects

Example 71 with MathModelInfo

use of org.vcell.util.document.MathModelInfo in project vcell by virtualcell.

the class MathModelDbTreeModel method createBaseTree.

/**
 * Insert the method's description here.
 * Creation date: (11/28/00 1:06:51 PM)
 * @return cbit.vcell.desktop.BioModelNode
 * @param docManager cbit.vcell.clientdb.DocumentManager
 */
protected void createBaseTree() throws DataAccessException {
    rootNode.removeAllChildren();
    rootNode.add(myModelsNode);
    rootNode.add(sharedModelsNode);
    // rootNode.add(tutorialModelsNode);
    // rootNode.add(educationModelsNode);
    rootNode.add(allPublicModelsNode);
    allPublicModelsNode.add(publishedModelsNode);
    allPublicModelsNode.add(curatedModelsNode);
    allPublicModelsNode.add(otherModelsNode);
    rootNode.setUserObject("Math Models");
    sharedModelsNode.setUserObject(SHARED_MATH_MODELS);
    MathModelInfo[] mathModelInfos = getDocumentManager().getMathModelInfos();
    User loginUser = getDocumentManager().getUser();
    TreeMap<String, BioModelNode> treeMap = null;
    try {
        treeMap = VCDocumentDbTreeModel.initOwners(mathModelInfos, loginUser, this, this.getClass().getMethod("createOwnerSubTree", new Class[] { User.class, MathModelInfo[].class }));
    } catch (Exception e) {
        e.printStackTrace();
        treeMap = new TreeMap<String, BioModelNode>();
        treeMap.put(loginUser.getName(), new BioModelNode("Error:" + e.getMessage()));
    }
    initFinalTree(this, treeMap, loginUser);
}

Example 72 with MathModelInfo

use of org.vcell.util.document.MathModelInfo in project vcell by virtualcell.

the class MathModelDbTreeModel method createBaseTree2.

protected void createBaseTree2() throws DataAccessException {
    VCDocumentDbTreeModel.initBaseTree(rootNode, new BioModelNode[] { myModelsNode, sharedModelsNode, otherModelsNode, /*educationModelsNode,*/
    publishedModelsNode }, "Math Models", sharedModelsNode, SHARED_MATH_MODELS);
    MathModelInfo[] mathModelInfos = getDocumentManager().getMathModelInfos();
    User loginUser = getDocumentManager().getUser();
    TreeMap<String, BioModelNode> treeMap = null;
    try {
        treeMap = VCDocumentDbTreeModel.initOwners(mathModelInfos, loginUser, this, this.getClass().getMethod("createOwnerSubTree", new Class[] { User.class, MathModelInfo[].class }));
    } catch (Exception e) {
        e.printStackTrace();
        treeMap = new TreeMap<String, BioModelNode>();
        treeMap.put(loginUser.getName(), new BioModelNode("Error:" + e.getMessage()));
    }
    initFinalTree(this, treeMap, loginUser);
}

Example 73 with MathModelInfo

use of org.vcell.util.document.MathModelInfo in project vcell by virtualcell.

the class PublicationInfoNodeTreeModel method createVersionSubTree.

private BioModelNode createVersionSubTree(BioModelNode publicationsInfoNode) throws DataAccessException {
    BioModelNode versionNode = new BioModelNode("Root", true);
    Object uo = publicationsInfoNode.getUserObject();
    if (!(uo instanceof PublicationInfo)) {
        String title = "PublicationInfo missing";
        publicationNode = new BioModelNode(title, false);
        versionNode.add(publicationNode);
        return versionNode;
    }
    publicationNode = null;
    modelsNode = null;
    PublicationInfo pi = (PublicationInfo) uo;
    publicationNode = new BioModelNode("Publication", true);
    publicationNode.setRenderHint("type", "PublicationsInfo");
    BioModelNode piTitleNode = new BioModelNode(pi, true);
    piTitleNode.setRenderHint("type", "PublicationInfoTitle");
    publicationNode.add(piTitleNode);
    BioModelNode piAuthorsNode = new BioModelNode(pi, false);
    piAuthorsNode.setRenderHint("type", "PublicationInfoAuthors");
    piTitleNode.add(piAuthorsNode);
    BioModelNode piCitationNode = new BioModelNode(pi, false);
    piCitationNode.setRenderHint("type", "PublicationInfoCitation");
    piTitleNode.add(piCitationNode);
    BioModelNode piDoiNode = new BioModelNode(pi, false);
    piDoiNode.setRenderHint("type", "PublicationInfoDoi");
    piTitleNode.add(piDoiNode);
    if (pi.getUrl() != null && !pi.getUrl().isEmpty()) {
        if (pi.getUrl().contains("pubmed") || pi.getUrl().contains("PubMed")) {
            BioModelNode piUrlNode = new BioModelNode(pi, false);
            piUrlNode.setRenderHint("type", "PublicationInfoUrl");
            piTitleNode.add(piUrlNode);
        }
    }
    versionNode.add(publicationNode);
    String name = publicationsInfoNode.getChildCount() > 1 ? "Models" : "Model";
    modelsNode = new BioModelNode(name, true);
    modelsNode.setRenderHint("type", "ModelsList");
    for (int i = 0; i < publicationsInfoNode.getChildCount(); i++) {
        TreeNode child = publicationsInfoNode.getChildAt(i);
        if (!(child instanceof BioModelNode)) {
            versionNode.add(modelsNode);
            return versionNode;
        }
        BioModelNode modelNode = (BioModelNode) child;
        uo = modelNode.getUserObject();
        if (!(uo instanceof VCDocumentInfoNode)) {
            versionNode.add(modelsNode);
            return versionNode;
        }
        VCDocumentInfoNode din = (VCDocumentInfoNode) uo;
        Version version = din.getVCDocumentInfo().getVersion();
        BioModelNode mNameNode = new BioModelNode(version.getName(), true);
        mNameNode.setRenderHint("type", "ModelName");
        VCDocumentInfo di = din.getVCDocumentInfo();
        if (di instanceof BioModelInfo) {
            mNameNode.setRenderHint("category", "BioModel");
        } else if (di instanceof MathModelInfo) {
            mNameNode.setRenderHint("category", "MathModel");
        } else if (di instanceof GeometryInfo) {
            mNameNode.setRenderHint("category", "Geometry");
        }
        modelsNode.add(mNameNode);
        BioModelNode mOwnerNode = new BioModelNode(version.getOwner(), true);
        mOwnerNode.setRenderHint("type", "ModelOwner");
        mNameNode.add(mOwnerNode);
        BioModelNode mDateNode = new BioModelNode(version.getDate(), true);
        mDateNode.setRenderHint("type", "ModelDate");
        mNameNode.add(mDateNode);
    }
    versionNode.add(modelsNode);
    return versionNode;
}

Example 74 with MathModelInfo

use of org.vcell.util.document.MathModelInfo in project vcell by virtualcell.

the class VCellBasicCellRenderer method getTreeCellRendererComponent.

/**
 * Insert the method's description here.
 * Creation date: (7/27/2000 6:41:57 PM)
 * @return java.awt.Component
 */
public java.awt.Component getTreeCellRendererComponent(JTree tree, Object value, boolean sel, boolean expanded, boolean leaf, int row, boolean hasFocus) {
    JLabel component = (JLabel) super.getTreeCellRendererComponent(tree, value, sel, expanded, leaf, row, hasFocus);
    // 
    if (!leaf && expanded) {
        setIcon(fieldFolderOpenIcon);
    } else if (!leaf && !expanded) {
        setIcon(fieldFolderClosedIcon);
    }
    try {
        if (value instanceof BioModelNode) {
            BioModelNode node = (BioModelNode) value;
            boolean bLoaded = false;
            // 
            // Check if node is a SolverResultSetInfo
            // 
            Object userObject = node.getUserObject();
            if (userObject instanceof SimulationInfo) {
                // 
                // Check if node is a SimulationInfo
                // 
                setComponentProperties(component, (SimulationInfo) userObject);
                int maxErrorLevel = getMaxErrorLevel(node);
                if (maxErrorLevel == BioModelNode.ERROR_POSSIBLE) {
                    setIcon(fieldSimulationWarningIcon);
                    component.setToolTipText("Simulation contains possibly invalid results");
                } else if (maxErrorLevel == BioModelNode.ERROR_CONFIRMED) {
                    setIcon(fieldSimulationErrorIcon);
                    component.setToolTipText("Simulation contains invalid results");
                }
            } else if (userObject instanceof String && node.getChildCount() == 0) {
                component.setToolTipText(null);
                component.setText((String) userObject);
            } else if (userObject instanceof BioModelInfo) {
                // 
                // Check if node is a BioModelInfo
                // 
                setComponentProperties(component, (BioModelInfo) userObject);
                bLoaded = isLoaded((BioModelInfo) userObject);
                int maxErrorLevel = getMaxErrorLevel(node);
                if (maxErrorLevel == BioModelNode.ERROR_POSSIBLE) {
                    setIcon(fieldBioModelWarningIcon);
                    component.setToolTipText("BioModel version: Has possibly invalid simulation results");
                } else if (maxErrorLevel == BioModelNode.ERROR_CONFIRMED) {
                    setIcon(fieldBioModelErrorIcon);
                    component.setToolTipText("BioModel version: Has invalid simulation results");
                }
            } else if (userObject instanceof String && node.getChildCount() > 0 && ((BioModelNode) node.getChildAt(0)).getUserObject() instanceof BioModelInfo) {
                // 
                // Check if node is a BioModelName (String), with children (at least one version of biomodel), and if the child is a
                // BioModelInfo node
                // 
                String label = (String) userObject;
                component.setToolTipText("BioModel");
                component.setText(label);
                // 
                // check if child is loaded
                // 
                int maxErrorLevel = BioModelNode.ERROR_NONE;
                for (int i = 0; i < node.getChildCount(); i++) {
                    maxErrorLevel = Math.max(maxErrorLevel, getMaxErrorLevel((BioModelNode) node.getChildAt(i)));
                }
                if (maxErrorLevel == BioModelNode.ERROR_POSSIBLE) {
                    if (!leaf && expanded) {
                        setIcon(fieldFolderOpenWarningIcon);
                    } else if (!leaf && !expanded) {
                        setIcon(fieldFolderClosedWarningIcon);
                    }
                    component.setToolTipText("BioModel: one or more versions may have invalid simulation results");
                } else if (maxErrorLevel == BioModelNode.ERROR_CONFIRMED) {
                    if (!leaf && expanded) {
                        setIcon(fieldFolderOpenErrorIcon);
                    } else if (!leaf && !expanded) {
                        setIcon(fieldFolderClosedErrorIcon);
                    }
                    component.setToolTipText("BioModel: one or more versions have invalid simulation results");
                }
                // 
                for (int i = 0; i < node.getChildCount(); i++) {
                    BioModelInfo bioModelInfo = (BioModelInfo) ((BioModelNode) node.getChildAt(i)).getUserObject();
                    if (isLoaded(bioModelInfo)) {
                        bLoaded = true;
                    }
                }
            } else if (userObject instanceof User && node.getChildCount() > 0 && (((BioModelNode) node.getChildAt(0)).getUserObject() instanceof String) && ((BioModelNode) (node.getChildAt(0).getChildAt(0))).getUserObject() instanceof BioModelInfo) {
                // 
                // Check if node is a User, with at least one child which is a string (BioModel name)
                // and if the child's child is a BioModelInfo node
                // 
                String label = ((User) userObject).getName();
                component.setToolTipText("User Name");
                component.setText(label);
                if (isLoaded((User) userObject)) {
                    bLoaded = true;
                }
            } else if (userObject instanceof MathModelInfo) {
                // 
                // Check if node is a MathModelInfo node
                // 
                setComponentProperties(component, (MathModelInfo) userObject);
                bLoaded = isLoaded((MathModelInfo) userObject);
            } else if (userObject instanceof String && node.getChildCount() > 0 && ((BioModelNode) node.getChildAt(0)).getUserObject() instanceof MathModelInfo) {
                // 
                // Check if node is a MathModel name (String), with children (at least one version of mathmodel), and
                // if the child is a MathModelInfo node
                // 
                String label = (String) userObject;
                component.setToolTipText("Mathematical Model");
                component.setText(label);
                // 
                for (int i = 0; i < node.getChildCount(); i++) {
                    MathModelInfo mathModelInfo = (MathModelInfo) ((BioModelNode) node.getChildAt(i)).getUserObject();
                    if (isLoaded(mathModelInfo)) {
                        bLoaded = true;
                    }
                }
            } else if (userObject instanceof User && node.getChildCount() > 0 && (((BioModelNode) node.getChildAt(0)).getUserObject() instanceof String) && ((BioModelNode) (node.getChildAt(0).getChildAt(0))).getUserObject() instanceof MathModelInfo) {
                // 
                // Check if node is a User, with at least one child which is a string (Mathmodel name)
                // and if the child's child is a MathModelInfo node
                // 
                String label = ((User) userObject).getName();
                component.setToolTipText("User Name");
                component.setText(label);
                if (isLoaded((User) userObject)) {
                    bLoaded = true;
                }
            } else if (userObject instanceof cbit.vcell.geometry.GeometryInfo) {
                // 
                // Check if node is a GeometryInfo
                // 
                setComponentProperties(component, (GeometryInfo) userObject);
                bLoaded = isLoaded((GeometryInfo) userObject);
            } else if (userObject instanceof String && node.getChildCount() > 0 && ((BioModelNode) node.getChildAt(0)).getUserObject() instanceof GeometryInfo) {
                // 
                // Check if node is a Geometry name (String), with children (at least one version of Geometry), and
                // if the child is a GeometryInfo node
                // 
                String label = (String) userObject;
                component.setToolTipText("Geometry");
                component.setText(label);
                // 
                for (int i = 0; i < node.getChildCount(); i++) {
                    GeometryInfo geometryInfo = (GeometryInfo) ((BioModelNode) node.getChildAt(i)).getUserObject();
                    if (isLoaded(geometryInfo)) {
                        bLoaded = true;
                    }
                }
            } else if (userObject instanceof User && node.getChildCount() > 0 && (((BioModelNode) node.getChildAt(0)).getUserObject() instanceof String) && ((BioModelNode) (node.getChildAt(0).getChildAt(0))).getUserObject() instanceof GeometryInfo) {
                // 
                // Check if node is a User, with at least one child which is a string (Geometry name)
                // and if the child's child is a GeometryInfo node
                // 
                String label = ((User) userObject).getName();
                component.setToolTipText("User Name");
                component.setText(label);
                if (isLoaded((User) userObject)) {
                    bLoaded = true;
                }
            } else if (userObject instanceof String && node.getChildCount() > 0) {
                component.setToolTipText(null);
                component.setText((String) userObject);
            // }else if (node.getUserObject() instanceof MathInfo) {
            // setComponentProperties(component,(MathInfo)node.getUserObject());
            } else if (userObject instanceof VCImageInfo) {
                setComponentProperties(component, (VCImageInfo) userObject);
            } else if (userObject instanceof Extent) {
                setComponentProperties(component, (Extent) userObject);
            } else if (userObject instanceof Annotation) {
                setComponentProperties(component, (Annotation) userObject);
            } else if (userObject instanceof MathModel) {
                setComponentProperties(component, (MathModel) userObject);
            } else if (userObject instanceof BioModel) {
                setComponentProperties(component, (BioModel) userObject);
            } else if (userObject instanceof SimulationContext) {
                setComponentProperties(component, (SimulationContext) userObject);
                bLoaded = isLoaded((SimulationContext) userObject);
            } else if (userObject instanceof Simulation) {
                setComponentProperties(component, (Simulation) userObject);
            } else if (userObject instanceof MathDescription) {
                setComponentProperties(component, (MathDescription) userObject);
            } else if (userObject instanceof Geometry) {
                setComponentProperties(component, (Geometry) userObject);
            } else if (userObject instanceof User) {
                setComponentProperties(component, (User) userObject);
            } else {
                setComponentProperties(component, userObject);
            }
            if (selectedFont == null && component.getFont() != null) {
                selectedFont = component.getFont().deriveFont(Font.BOLD);
            }
            if (unselectedFont == null && component.getFont() != null) {
                unselectedFont = component.getFont().deriveFont(Font.PLAIN);
            }
            if (bLoaded) {
                component.setFont(selectedFont);
            } else {
                component.setFont(unselectedFont);
            }
        }
    } catch (Throwable e) {
        e.printStackTrace(System.out);
    }
    // 
    return component;
}