public boolean containsNode(GraphNode node) { if (node != null) { return nodes.containsKey(node.getUserObject()); } return false; }
/** * Creates a GraphArc with the given parameters without actually adding the GraphNodes or * GraphArc to the model. * * @return A GraphArc object. */ protected GraphArc createArc(GraphNode srcNode, GraphNode destNode, String relType, Icon icon) { String key = srcNode.getUserObject().toString() + relType + destNode.getUserObject().toString(); return new DefaultGraphArc(key, srcNode, destNode, icon, relType); }
/** * Expands the given graphNode by showing it's neighborhood and keeping existing nodes. * * @param graphNode */ public void expandNode(GraphNode graphNode) { showNeighborhood((OWLEntity) graphNode.getUserObject(), false); }
/** * Checks if the given graphNode can be expanded, i.e. has relationships. * */ public boolean isExpandable(GraphNode graphNode) { return getNodeToArcCount((OWLEntity) graphNode.getUserObject()) > 0; }
/** * Determines if the given graphNode is expanded. * * @return True if already expanded. */ public boolean isExpanded(GraphNode graphNode) { int modelArcsSize = graphNode.getArcs().size(); int frameArcsSize = getNodeToArcCount((OWLEntity) graphNode.getUserObject()); return modelArcsSize >= frameArcsSize; } }
protected void removeNodeInternal(GraphNode node) { if (nodes.containsKey(node.getUserObject())) { // remove the arcs for this node first GraphArc[] arcs = node.getArcs().toArray(new GraphArc[node.getArcs().size()]); for (GraphArc arc : arcs) { removeArc(arc.getUserObject()); } // now remove the node from this model nodes.remove(node.getUserObject()); fireNodeRemovedEvent(node); } }
protected void addNodeInternal(GraphNode node) { if ((node != null) && !nodes.containsKey(node.getUserObject())) { // this should be the ONLY place where nodes are added to the map nodes.put(node.getUserObject(), node); if (!nodeTypes.contains(node.getType())) { nodeTypes.add(node.getType()); fireNodeTypeAddedEvent(node.getType()); } fireNodeAddedEvent(node); } }
/** * Expands the given graphNode based on a specific arcType and keeping existing nodes. * * @param graphNode */ public void expandNode(GraphNode graphNode, String arcType) { graphNode.setHighlighted(false); restrictToArcType = arcType; showNeighborhood((OWLEntity) graphNode.getUserObject(), false); restrictToArcType = ""; }
/** * Uses the arc cache to get all the unique arc types for the given node. */ private void prepareNodeSpecificActions(GraphNode node, JMenu expandBasedOnMenu) { expandBasedOnActions.clear(); expandBasedOnMenu.removeAll(); for(GraphArc arc : model.getCachedArcsForEntity((OWLEntity)node.getUserObject())) { Action action = getNodeExpansionAction(arc.getType().toString()); if(!expandBasedOnActions.contains(action)) { expandBasedOnActions.add(action); expandBasedOnMenu.add(action); } } }
private Set<GraphArc> loadUnreifiedRelations(OWLEntity entityOfInterest, boolean mustBeVisible) { unreifyRelationInstances(); Set<GraphArc> unreifiedRels = artifactToUnreifiedRels.get(entityOfInterest); if(unreifiedRels != null) { for(GraphArc arc : unreifiedRels) { if(!filterManager.isArcTypeVisible(arc.getType())) { unreifiedRels.remove(arc); } else { if(!isDisplayableNode((OWLEntity)arc.getDestination().getUserObject(), mustBeVisible)) { unreifiedRels.remove(arc); } } } } return unreifiedRels == null ? new HashSet<GraphArc>() : unreifiedRels; }
public void actionPerformed(ActionEvent e) { owlClass = (OWLEntity) graph.getFirstSelectedNode().getUserObject(); model.showNeighborhood(owlClass, true); graph.performLayout(); } });
/** * When a node gets selected in the graph, we want to update the global class selection for Protege. */ private void syncNodeSelection() { GraphNode node = ((AbstractGraph)graphController.getGraph()).getFirstSelectedNode(); if(node != null) { cancelSelectionUpdate = true; setGlobalSelection((OWLEntity)node.getUserObject()); } }
public void actionPerformed(ActionEvent e) { owlClass = (OWLEntity)graph.getFirstSelectedNode().getUserObject(); model.expandNode(graph.getFirstSelectedNode()); graph.performLayout(); } };
/** * Finds relationships between an artifact as a item in the domain, and the ranges of its * properties */ private Set<GraphArc> loadDomainRangeRels(OWLEntity entityOfInterest, boolean outgoing, boolean mustBeVisible) { Set<GraphArc> domainRangeArcs = new HashSet<GraphArc>(); getDomainRangeRelationships(); // ensures that domain range rels are created for (GraphArc relationship : domainRangeRelsBuffer) { if(!filterManager.isArcTypeVisible(relationship.getType())) continue; OWLEntity sourceObject = (OWLEntity) relationship.getSource().getUserObject(); OWLEntity destObject = (OWLEntity) relationship.getDestination().getUserObject(); if (!isDisplayableNode(sourceObject, mustBeVisible) || !isDisplayableNode(destObject, mustBeVisible)) { continue; } if ((outgoing && sourceObject.equals(entityOfInterest)) || destObject.equals(entityOfInterest)) { if(outgoing) relationship.setInverted(false); domainRangeArcs.add(relationship); } } return domainRangeArcs; }
@Override public void doAction() { boolean graphChanged = false; GraphNode nodes[] = model.getAllNodes().toArray(new GraphNode[model.getAllNodes().size()]); // goes through all nodes and hides any that have no arcs or have no visible arcs for(GraphNode node : nodes) { if(node.getArcs().size() == 0) { graphChanged = true; model.removeNode(node.getUserObject()); } else { boolean found = false; for(GraphArc arc : node.getArcs()) { if(arc.isVisible()) { found = true; } } if(!found) { graphChanged = true; model.removeNode(node.getUserObject()); } } } // re-layout the graph if it changed if(graphChanged) graph.performLayout(); } }
public void actionPerformed(ActionEvent e) { owlClass = (OWLEntity)graph.getFirstSelectedNode().getUserObject(); model.hideAscendants(graph.getFirstSelectedNode()); graph.performLayout(); } });
public void actionPerformed(ActionEvent e) { owlClass = (OWLEntity)graph.getFirstSelectedNode().getUserObject(); model.collapseNode(graph.getFirstSelectedNode()); graph.performLayout(); } };
/** * Hides all arcs recursively from the given graphNode. * * @param graphNode * @param seen Set of URIs that have already been recursed on */ private void hideAll(GraphNode graphNode, Set<IRI> seen) { GraphArc[] arcs = graphNode.getArcs().toArray(new GraphArc[graphNode.getArcs().size()]); seen.add(((OWLEntity) graphNode.getUserObject()).getIRI()); for (GraphArc arc : arcs) { Object userObject = arc.getDestination().getUserObject(); GraphNode node = getNode(userObject); if (node == null || node.equals(graphNode)) { continue; } // recursively collapse the child node, check our seen object in order to avoid cycles removeArc(arc.getUserObject()); if (!seen.contains(((OWLEntity) userObject).getIRI())) { hideAll(node, seen); } if (node != null && isRemovable(node)) { removeNode(userObject); } } }
private void showAllTooltips() { for(GraphNode node : graphController.getModel().getAllNodes()) { // make sure there isn't already a tooltip showing if(existingTooltipsMap.get((PNode)node) == null) { FrameTooltipNode toolTip = new FrameTooltipNode(graphController.getModel().getOwlModelManager(), (AbstractGraph)graphController.getGraph(), (PNode)node, (OWLEntity)node.getUserObject()); ((PNode)node).addChild(toolTip); existingTooltipsMap.put((PNode)node, toolTip); ChangeListener changeListener = new ChangeListener() { public void stateChanged(ChangeEvent e) { PNode targetNode = existingTooltipsMap.get((PNode)e.getSource()); if(targetNode != null) { FrameTooltipNode toolTip = (FrameTooltipNode)targetNode; toolTip.updateLocation((AbstractGraph)graphController.getGraph(), toolTip.getParent()); } } }; ((DefaultGraphNode)node).addChangeListener(changeListener); changeListenerMap.put(toolTip, changeListener); } } } }
/** * Collapses the given graphNode by recursively removing all outgoing relationships and nodes * that become separate components. * * @param graphNode * @param seen The list of recursively visited items, need this to avoid cycles */ private void collapseNode(GraphNode graphNode, Set<IRI> seen) { GraphArc[] arcs = graphNode.getArcs().toArray(new GraphArc[graphNode.getArcs().size()]); //createOutgoingRelationships((Frame) graphNode.getUserObject(), true); seen.add(((OWLEntity) graphNode.getUserObject()).getIRI()); for (GraphArc arc : arcs) { Object userObject = arc.getDestination().getUserObject(); GraphNode node = getNode(userObject); // recursively collapse the child node, check our seen object in order to avoid cycles if (node != null && !node.equals(graphNode)) { removeArc(arc.getUserObject()); if (isRecursableArc(seen, userObject, arc)) { collapseNode(node, seen); } if (isRemovable(node)) { removeNode(userObject); } } } }