public Collection<GraphArc> getArcs(Object nodeUserObject) { if (nodes.containsKey(nodeUserObject)) { GraphNode node = nodes.get(nodeUserObject); return node.getArcs(); } // not sure if this is necessary or a good idea if (nodeUserObject instanceof GraphNode) { GraphNode node = (GraphNode) nodeUserObject; return node.getArcs(); } // return null or empty list? return Collections.emptyList(); }
/** * 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); } }
/** * Determines whether the given GraphNode is removable. It is removable if it does not have any * arcs or the only arcs it has are self loops. * * @param node * @return True if removable. */ private boolean isRemovable(GraphNode node) { for (GraphArc arc : node.getArcs()) { if (!arc.getDestination().equals(arc.getSource())) { return false; } } return true; }
ArrayList<GraphArc> srcToDestArcs = new ArrayList<GraphArc>(); ArrayList<GraphArc> destToSrcArcs = new ArrayList<GraphArc>(); for (GraphArc arc : src.getArcs()) { if ((src == arc.getSource()) && (dest == arc.getDestination())) { srcToDestArcs.add(arc);
@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(); } }
/** * 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); } } }
/** * 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); } } } }
/** * Hides all incoming arcs and attempts to hide any nodes and their arcs. * * @param graphNode * @param seen The list of recursively visited items, need this to avoid cycles */ private void hideAscendants(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.getSource().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 (!seen.contains(((OWLEntity) userObject).getIRI())) { hideAll(node, seen); } if (isRemovable(node)) { removeNode(userObject); } } else { userObject = arc.getDestination().getUserObject(); seen.add(((OWLEntity) userObject).getIRI()); } } }