/** * Returns the port that is connected to the target end of the specified * edge * * @param edge * the reference edge * @return any vertex connected as the target the specified edge */ public Object getTargetPort(Object edge) { Object cell = null; cell = model.getTarget(edge); return cell; }
/** * Returns the target vertex of the edge by calling getParent on getTarget * on the specified model. */ public static Object getTargetVertex(GraphModel model, Object edge) { if (model != null) return model.getParent(model.getTarget(edge)); return null; }
/** * @param model * @param edge * @return root target node of edge */ public static Object getTargetNode(GraphModel model, Object edge) { return getRoot(model, model.getTarget(edge)); }
/** * Returns the incoming or outgoing edges for cell. Cell should be a port or * a vertex. */ public static Object[] getEdges(GraphModel model, Object cell, boolean incoming) { Set edges = DefaultGraphModel.getEdges(model, new Object[] { cell }); // Base initial capacity on size of set, it can't be any larger ArrayList result = new ArrayList(edges.size()); Iterator it = edges.iterator(); while (it.hasNext()) { Object edge = it.next(); // TODO: Handle edge groups Object port = (incoming) ? model.getTarget(edge) : model .getSource(edge); Object parent = model.getParent(port); if (port == cell || parent == cell) result.add(edge); } return result.toArray(); }
/** * @param model * @param node * @return all the edges entering the given <code>node</code> */ public static Set getIncomingEdges(GraphModel model, Object node) { Set result = new HashSet(); Set edges = DefaultGraphModel.getEdges(model, new Object[] { node }); Iterator it = edges.iterator(); while (it.hasNext()) { Object edge = it.next(); if (!DefaultGraphModel.isGroup(model, edge)) { Object target = model.getTarget(edge); if (target == node || isParentOf(model, node, target)) result.add(edge); } } return result; }
.getTarget(edges[i])) { edgeList.add(edges[i]);
.getTarget(edges[i])) { edgeList.add(edges[i]);
private static DefaultGraphCell[] getEdgeExtremes(DefaultEdge edge, GraphModel m) { DefaultEdge de = edge; DefaultGraphCell target = (DefaultGraphCell) ( (DefaultPort) m.getTarget(de)). getParent(); DefaultGraphCell source = (DefaultGraphCell) ( (DefaultPort) m.getSource(de)). getParent(); return new DefaultGraphCell[]{target,source}; }
private static DefaultGraphCell[] getEdgeExtremes(DefaultEdge edge, GraphModel m) { DefaultEdge de = edge; DefaultGraphCell target = (DefaultGraphCell) ( (DefaultPort) m.getTarget(de)). getParent(); DefaultGraphCell source = (DefaultGraphCell) ( (DefaultPort) m.getSource(de)). getParent(); return new DefaultGraphCell[]{target,source}; }
.getTarget(edges[i])) { edgeList.add(edges[i]);
/** * Returns the edges between two specified ports or two specified vertices. * If directed is true then <code>cell1</code> must be the source of the * returned edges. This method never returns null. If there are no edges * between the specified cells, then an array of length 0 is returned. */ public static Object[] getEdgesBetween(GraphModel model, Object cell1, Object cell2, boolean directed) { boolean isPort1 = model.isPort(cell1); boolean isPort2 = model.isPort(cell2); ArrayList result = new ArrayList(); Set edges = DefaultGraphModel.getEdges(model, new Object[] { cell1 }); Iterator it = edges.iterator(); while (it.hasNext()) { Object edge = it.next(); // TODO: Handle edge groups Object source = (isPort1) ? model.getSource(edge) : getSourceVertex(model, edge); Object target = (isPort2) ? model.getTarget(edge) : getTargetVertex(model, edge); if ((source == cell1 && target == cell2) || (!directed && source == cell2 && target == cell1)) result.add(edge); } return result.toArray(); }
/** * @return Returns the opposite port or vertex in <code>edge</code>. */ public static Object getOpposite(GraphModel model, Object edge, Object cell) { boolean isPort = model.isPort(cell); Object source = (isPort) ? model.getSource(edge) : getSourceVertex( model, edge); if (cell == source) return (isPort) ? model.getTarget(edge) : getTargetVertex(model, edge); else return source; }
/** * Returns a connection set that represents the connection or disconnection * of <code>cells</code> in <code>model</code> based on * <code>disconnect</code>. */ public static ConnectionSet create(GraphModel m, Object[] cells, boolean disconnect) { ConnectionSet cs = new ConnectionSet(); for (int i = 0; i < cells.length; i++) { Object cell = cells[i]; // Edge if (m.isEdge(cell)) { if (disconnect) cs.disconnect(cell); else cs.connect(cell, m.getSource(cell), m.getTarget(cell)); } // Port Iterator it = m.edges(cell); while (it.hasNext()) { // Edge At Port Object edge = it.next(); if (m.getSource(edge) == cell) connect(cs, edge, cell, true, disconnect); else if (m.getTarget(edge) == cell) connect(cs, edge, cell, false, disconnect); } } return cs; }
.getTarget().getCell(); Object newSource = graphModel.getSource(changed[i]); Object newTarget = graphModel.getTarget(changed[i]); boolean hideExisting = (hidesExistingConnections && ((newSource != null && !hasVisibleParent( newSource, null)) || (newTarget != null && !hasVisibleParent(
protected void showCellsForChange(GraphModelEvent.GraphModelChange change) { Object[] inserted = change.getInserted(); if (inserted != null && showsInsertedConnections) { for (int i = 0; i < inserted.length; i++) { if (!isVisible(inserted[i])) { Object source = graphModel.getSource(inserted[i]); Object target = graphModel.getTarget(inserted[i]); if ((source != null || target != null) && (isVisible(source) && isVisible(target))) setVisibleImpl(new Object[] { inserted[i] }, true); } } } if (change.getConnectionSet() != null) { Set changedSet = change.getConnectionSet().getChangedEdges(); if (changedSet != null && showsChangedConnections) { Object[] changed = changedSet.toArray(); for (int i = 0; i < changed.length; i++) { if (!isVisible(changed[i])) { Object source = graphModel.getSource(changed[i]); Object target = graphModel.getTarget(changed[i]); if ((source != null || target != null) && (isVisible(source) && isVisible(target)) && !isVisible(changed[i])) setVisibleImpl(new Object[] { changed[i] }, true); } } } } }
cs.connect(cells[i], sourcePort, true); Object targetPort = getModel().getTarget(cells[i]); if (targetPort != null) cs.connect(cells[i], targetPort, false);
private static boolean detectEdgeIntersections(Rectangle rect1, JGraph graph, boolean intersectsline, Object port) { Iterator edges = graph.getModel().edges(port); while (edges.hasNext()){ Object edge=edges.next(); Object targetport = graph.getModel().getTarget(edge); Object sourceport = graph.getModel().getSource(edge); AttributeMap attargetport = graph.getModel().getAttributes(graph.getModel().getParent(targetport)); AttributeMap atsourceport = graph.getModel().getAttributes(graph.getModel().getParent(sourceport)); Rectangle b1 = GraphConstants.getBounds(attargetport).getBounds(); Rectangle b2 = GraphConstants.getBounds(atsourceport).getBounds(); Float line = new Line2D.Float(new Point((int)b1.getCenterX(),(int)b1.getCenterY()),new Point((int)b2.getCenterX(),(int)b2.getCenterY())); intersectsline=intersectsline||line.intersects(rect1); if (!(graph.getModel().getParent(targetport) instanceof NAryEdge) && !ListenerContainer.isContainer((DefaultGraphCell) graph.getModel().getParent(targetport), graph)){ intersectsline=intersectsline || b1.intersects(rect1); // System.err.println("overlapping1 with "+targetport+","+graph.getModel().getParent(targetport)+" "+rect1+":"+b1); } else if (!(graph.getModel().getParent(sourceport) instanceof NAryEdge) && !ListenerContainer.isContainer((DefaultGraphCell) graph.getModel().getParent(sourceport), graph)){ intersectsline=intersectsline || b2.intersects(rect1); // System.err.println("overlapping2 with "+sourceport+","+graph.getModel().getParent(sourceport)+" "+rect1+":"+b2); } } return intersectsline; }
if (model.getSource(cell) == null || model.getTarget(cell) == null) { return false;
protected ConnectionSet createConnectionSet(EdgeView view, boolean verbose) { Object edge = view.getCell(); GraphModel model = graph.getModel(); ConnectionSet cs = new ConnectionSet(); Object sourcePort = null, targetPort = null; if (view.getSource() != null) sourcePort = view.getSource().getCell(); else if (view.getSourceParentView() != null) sourcePort = model.getSource(edge); if (view.getTarget() != null) targetPort = view.getTarget().getCell(); else if (view.getTargetParentView() != null) targetPort = model.getTarget(edge); if (view.getTarget() != null) targetPort = view.getTarget().getCell(); if (verbose || (sourcePort != model.getSource(edge) && source)) cs.connect(edge, sourcePort, true); if (verbose || (targetPort != model.getTarget(edge) && target)) cs.connect(edge, targetPort, false); return cs; }
/** * Overrides the parent method to udpate the cached points, source and * target port. If the source or target is removed, a point is inserted into * the array of points. */ public void refresh(GraphLayoutCache cache, CellMapper mapper, boolean createDependentViews) { // Makes sure the manual control points are passed to // the router instead of the cached control points after // changes to the edge (normally manual point changes). initialiseDefaultPoints(); super.refresh(cache, mapper, createDependentViews); // Re-sync source- and targetportviews GraphModel model = cache.getModel(); Object modelSource = model.getSource(cell); Object modelTarget = model.getTarget(cell); setSource(mapper.getMapping(modelSource, createDependentViews)); setTarget(mapper.getMapping(modelTarget, createDependentViews)); if (modelSource != null && getSource() == null) sourceParentView = getVisibleParent(model, mapper, modelSource); else sourceParentView = null; if (modelTarget != null && getTarget() == null) targetParentView = getVisibleParent(model, mapper, modelTarget); else targetParentView = null; }