/** * Set the graph being viewed. If there is a graph already and it contains data, delete the * figures of that graph's nodes and edges (but don't modify the graph itself). */ public void setGraphModel(GraphModel model) { Iterator i; // FIXME we shouldn't have to cast this. // FigureLayer layer = getGraphPane().getForegroundLayer(); if (_model != null) { // Clear existing figures Object root = _model.getRoot(); if (_model.getNodeCount(root) != 0) { for (i = _model.nodes(root); i.hasNext(); ) { clearNode(i.next()); } for (i = GraphUtilities.totallyContainedEdges(root, _model); i.hasNext(); ) { clearEdge(i.next()); } } _model.removeGraphListener(_localListener); } // Set the graph _model = model; if (_model != null) { _model.addGraphListener(_localListener); Object root = _model.getRoot(); GraphEvent evt = new GraphEvent(new Object(), GraphEvent.STRUCTURE_CHANGED, root); _localListener.structureChanged(evt); } }
/** @see HorizontalPlacement#buildRankSeparators(RankList) */ void buildRankSeparators(RankList ranks) { CompoundDirectedGraph g = (CompoundDirectedGraph) graph; Rank rank; for (int row = 0; row < g.ranks.size(); row++) { rank = g.ranks.getRank(row); Node n = null, prev = null; for (int j = 0; j < rank.size(); j++) { n = rank.getNode(j); if (prev == null) { Node left = addSeparatorsLeft(n, null); if (left != null) { Edge e = new Edge(graphLeft, getPrime(left), 0, 0); prime.edges.add(e); e.delta = graph.getPadding(n).left + graph.getMargin().left; } } else { Subgraph s = GraphUtilities.getCommonAncestor(prev, n); Node left = addSeparatorsRight(prev, s); Node right = addSeparatorsLeft(n, s); createEdge(left, right); } prev = n; } if (n != null) addSeparatorsRight(n, null); } }
private void checkValidEndParallel(JSONObject graph) { List<JSONObject> endParallels = GraphUtilities.findOperatorByKind(BVirtualMarker.END_PARALLEL, graph); for (JSONObject endParallel : endParallels) { List<JSONObject> endParallelParents = null; // Setting up loop JSONObject endParallelParent = endParallel; do { endParallelParents = GraphUtilities.getUpstream(endParallelParent, graph); if (endParallelParents.size() != 1) { throw new IllegalStateException( "Cannot union multiple streams before invoking endParallel()"); } endParallelParent = endParallelParents.get(0); } while (((String) endParallelParent.get("kind")).startsWith("$")); List<JSONObject> endParallelParentChildren = GraphUtilities.getDownstream(endParallelParent, graph); if (endParallelParentChildren.size() != 1) { throw new IllegalStateException("Cannot fanout a stream before invoking endParallel()"); } } }
/** * Checks if the path is already contained in the map * * @param map * @param path * @return */ private static boolean containsPath( Set<GraphPath<IModelEntity, Relationship>> map, GraphPath<IModelEntity, Relationship> path) { logger.debug("IN"); Iterator<GraphPath<IModelEntity, Relationship>> iter = map.iterator(); while (iter.hasNext()) { GraphPath<IModelEntity, Relationship> graphPath = iter.next(); if (GraphUtilities.arePathsEquals(graphPath, path)) { logger.debug("Adding the path in the map" + path.toString()); return true; } } logger.debug("OUT"); return false; }
/** * Render the current graph again by recreating the figures for all nodes and edges, but do not * alter the connectivity in the graph. This should be called when changes to renderers are made. */ public void rerender() { // FIXME: it would be nice to be able to do this without all // stupid business with the selection model. List selectedEdges = new LinkedList(); List selectedNodes = new LinkedList(); // Remove any old objects that no longer exist in the model Do // the edges first, then the nodes, since we cannot blow away // selection on an edge before getting rid of the endpoints of // the edge. Iterator figures = (new HashSet(_map.values())).iterator(); while (figures.hasNext()) { Figure figure = (Figure) figures.next(); Object object = figure.getUserObject(); if (_model.isEdge(object)) { if (!GraphUtilities.isPartiallyContainedEdge(object, _model.getRoot(), _model)) { if (_selectionModel.containsSelection(figure)) { _selectionModel.removeSelection(figure); } clearEdge(object); // Previously, the figure was being left in _map, // which results in an accumulation over time // of figures that should not be rendered. // EAL 4/29/04. _map.remove(object); } } } figures = (new HashSet(_map.values())).iterator(); while (figures.hasNext()) { Figure figure = (Figure) figures.next(); Object object = figure.getUserObject(); if (_model.isNode(object)) { if (!GraphUtilities.isContainedNode(object, _model.getRoot(), _model)) { if (_selectionModel.containsSelection(figure)) { _selectionModel.removeSelection(figure); } clearNode(object); // Previously, the figure was being left in _map, // which results in an accumulation over time // of figures that should not be rendered. // EAL 4/29/04. _map.remove(object); } } } // Save the selected edges. Iterator edges = GraphUtilities.totallyContainedEdges(_model.getRoot(), _model); while (edges.hasNext()) { Object edge = edges.next(); Figure oldFigure = getFigure(edge); boolean selected = _selectionModel.containsSelection(oldFigure); if (selected) { selectedEdges.add(edge); } } // Save the selected nodes. Iterator nodes = (GraphUtilities.nodeSet(_model.getRoot(), _model)).iterator(); while (nodes.hasNext()) { Object node = nodes.next(); Figure oldFigure = getFigure(node); boolean selected = _selectionModel.containsSelection(oldFigure); if (selected) { selectedNodes.add(node); } } // Clear all the selections (note that there may be selected objects // which no longer exist!) _selectionModel.clearSelection(); // Draw the nodes to be rendered before the edges. nodes = _model.nodesBeforeEdges(_model.getRoot()); while (nodes.hasNext()) { Object node = nodes.next(); drawNode(node); } // Draw the edges that are connected to any of the above nodes. edges = GraphUtilities.partiallyContainedEdges(_model.getRoot(), _model); while (edges.hasNext()) { Object edge = edges.next(); drawEdge(edge); if (selectedEdges.contains(edge)) { _selectionModel.addSelection(getFigure(edge)); } } // Draw the nodes to be rendered after the edges. nodes = _model.nodesAfterEdges(_model.getRoot()); while (nodes.hasNext()) { Object node = nodes.next(); drawNode(node); } // Restore the selected nodes. nodes = (GraphUtilities.nodeSet(_model.getRoot(), _model)).iterator(); while (nodes.hasNext()) { Object node = nodes.next(); if (selectedNodes.contains(node)) { _selectionModel.addSelection(getFigure(node)); } } }