/// <summary> /// Returns all opposite vertices wrt terminal for the given edges, only$ /// returning sources and/or targets as specified. The result is returned as /// an array of mxCells. /// </summary> /// <param name="model">Model that contains the graph.</param> /// <param name="edges">Array of edges to be examined.</param> /// <param name="terminal">Cell that specifies the known end of the edges.</param> /// <param name="sources">Boolean that specifies if source terminals should /// be contained in the result. Default is true.</param> /// <param name="targets">Boolean that specifies if target terminals should /// be contained in the result. Default is true.</param> /// <returns>Returns the array of opposite terminals for the given edges.</returns> public static Object[] GetOpposites(mxIGraphModel model, Object[] edges, Object terminal, bool sources, bool targets) { List <Object> terminals = new List <Object>(); if (edges != null) { for (int i = 0; i < edges.Length; i++) { Object source = model.GetTerminal(edges[i], true); Object target = model.GetTerminal(edges[i], false); // Checks if the terminal is the source of // the edge and if the target should be // stored in the result if (source == terminal && target != null && target != terminal && targets) { terminals.Add(target); } // Checks if the terminal is the taget of // the edge and if the source should be // stored in the result else if (target == terminal && source != null && source != terminal && sources) { terminals.Add(source); } } } return(terminals.ToArray()); }
/// <summary> /// Returns the nearest ancestor terminal that is visible. The edge appears /// to be connected to this terminal on the display. /// </summary> /// <param name="edge">Cell whose visible terminal should be returned.</param> /// <param name="source">Boolean that specifies if the source or target terminal /// should be returned.</param> /// <returns>Returns the visible source or target terminal.</returns> public Object GetVisibleTerminal(Object edge, bool source) { mxIGraphModel model = graph.Model; Object result = model.GetTerminal(edge, source); Object best = result; while (result != null) { if (!graph.IsCellVisible(best) || graph.IsCellCollapsed(result)) { best = result; } result = model.GetParent(result); } // Checks if the result is not a layer if (model.GetParent(best) == model.Root) { best = null; } return(best); }
/// <summary> /// Returns all edges between the given source and target mxCells. If the /// optional boolean directed argument is false, then a matching edge is /// returned regardless of its direction. /// </summary> /// <param name="model">The graph model that contains the graph.</param> /// <param name="source">mxCell that defines the source terminal of the edge to be /// returned.</param> /// <param name="target">mxCell that defines the target terminal of the edge to be /// returned.</param> /// <param name="directed">Optional boolean that specifies if the direction of the /// edge should be taken into account. Default is true.</param> /// <returns></returns> public static Object[] GetEdgesBetween(mxIGraphModel model, Object source, Object target, bool directed) { int tmp1 = model.GetEdgeCount(source); int tmp2 = model.GetEdgeCount(target); // Assumes the source has less connected edges Object terminal = source; int edgeCount = tmp1; // Uses the smaller array of connected edges // for searching the edge if (tmp2 < tmp1) { edgeCount = tmp2; terminal = target; } List <Object> result = new List <Object>(); // Checks if the edge is connected to the correct // cell and returns the first match for (int i = 0; i < edgeCount; i++) { Object edge = model.GetEdgeAt(terminal, i); Object src = model.GetTerminal(edge, true); Object trg = model.GetTerminal(edge, false); bool isSource = src == source; if (isSource && trg == target || (!directed && model.GetTerminal(edge, !isSource) == target)) { result.Add(edge); } } return(result.ToArray()); }
/// <summary> /// Returns all distinct edges connected to this cell. If at least one of /// incoming or outgoing is true, then loops are ignored, otherwise if both /// are false, then all edges connected to the given cell are returned /// including loops. /// </summary> /// <param name="model">Model that contains the connection information</param> /// <param name="cell">Cell whose connections should be returned</param> /// <param name="incoming">Specifies if incoming edges should be returned</param> /// <param name="outgoing">Specifies if outgoing edges should be returned</param> /// <param name="includeLoops">Specifies if loops should be returned</param> /// <returns>Returns the array of connected edges for the given cell</returns> public static Object[] GetEdges(mxIGraphModel model, Object cell, bool incoming, bool outgoing, bool includeLoops) { int edgeCount = model.GetEdgeCount(cell); List <Object> result = new List <Object>(edgeCount); for (int i = 0; i < edgeCount; i++) { Object edge = model.GetEdgeAt(cell, i); Object source = model.GetTerminal(edge, true); Object target = model.GetTerminal(edge, false); if ((includeLoops && source == target) || ((source != target) && ((incoming && target == cell) || (outgoing && source == cell)))) { result.Add(edge); } } return(result.ToArray()); }
/// <summary> /// Returns the number of incoming or outgoing edges, ignoring the given /// edge. /// </summary> /// <param name="model">Graph model that contains the connection data.</param> /// <param name="cell">Cell whose edges should be counted.</param> /// <param name="outgoing">Boolean that specifies if the number of outgoing or /// incoming edges should be returned.</param> /// <param name="ignoredEdge">Object that represents an edge to be ignored.</param> /// <returns>Returns the number of incoming or outgoing edges.</returns> public static int GetDirectedEdgeCount(mxIGraphModel model, Object cell, bool outgoing, Object ignoredEdge) { int count = 0; int edgeCount = model.GetEdgeCount(cell); for (int i = 0; i < edgeCount; i++) { Object edge = model.GetEdgeAt(cell, i); if (edge != ignoredEdge && model.GetTerminal(edge, outgoing) == cell) { count++; } } return(count); }
/// <summary> /// Returns all opposite vertices wrt terminal for the given edges, only$ /// returning sources and/or targets as specified. The result is returned as /// an array of mxCells. /// </summary> /// <param name="model">Model that contains the graph.</param> /// <param name="edges">Array of edges to be examined.</param> /// <param name="terminal">Cell that specifies the known end of the edges.</param> /// <param name="sources">Boolean that specifies if source terminals should /// be contained in the result. Default is true.</param> /// <param name="targets">Boolean that specifies if target terminals should /// be contained in the result. Default is true.</param> /// <returns>Returns the array of opposite terminals for the given edges.</returns> public static Object[] GetOpposites(mxIGraphModel model, Object[] edges, Object terminal, bool sources, bool targets) { List<Object> terminals = new List<Object>(); if (edges != null) { for (int i = 0; i < edges.Length; i++) { Object source = model.GetTerminal(edges[i], true); Object target = model.GetTerminal(edges[i], false); // Checks if the terminal is the source of // the edge and if the target should be // stored in the result if (source == terminal && target != null && target != terminal && targets) { terminals.Add(target); } // Checks if the terminal is the taget of // the edge and if the source should be // stored in the result else if (target == terminal && source != null && source != terminal && sources) { terminals.Add(source); } } } return terminals.ToArray(); }
/// <summary> /// Returns all edges between the given source and target mxCells. If the /// optional boolean directed argument is false, then a matching edge is /// returned regardless of its direction. /// </summary> /// <param name="model">The graph model that contains the graph.</param> /// <param name="source">mxCell that defines the source terminal of the edge to be /// returned.</param> /// <param name="target">mxCell that defines the target terminal of the edge to be /// returned.</param> /// <param name="directed">Optional boolean that specifies if the direction of the /// edge should be taken into account. Default is true.</param> /// <returns></returns> public static Object[] GetEdgesBetween(mxIGraphModel model, Object source, Object target, bool directed) { int tmp1 = model.GetEdgeCount(source); int tmp2 = model.GetEdgeCount(target); // Assumes the source has less connected edges Object terminal = source; int edgeCount = tmp1; // Uses the smaller array of connected edges // for searching the edge if (tmp2 < tmp1) { edgeCount = tmp2; terminal = target; } List<Object> result = new List<Object>(); // Checks if the edge is connected to the correct // cell and returns the first match for (int i = 0; i < edgeCount; i++) { Object edge = model.GetEdgeAt(terminal, i); Object src = model.GetTerminal(edge, true); Object trg = model.GetTerminal(edge, false); bool isSource = src == source; if (isSource && trg == target || (!directed && model.GetTerminal(edge, !isSource) == target)) { result.Add(edge); } } return result.ToArray(); }
/// <summary> /// Returns all distinct edges connected to this cell. If at least one of /// incoming or outgoing is true, then loops are ignored, otherwise if both /// are false, then all edges connected to the given cell are returned /// including loops. /// </summary> /// <param name="model">Model that contains the connection information</param> /// <param name="cell">Cell whose connections should be returned</param> /// <param name="incoming">Specifies if incoming edges should be returned</param> /// <param name="outgoing">Specifies if outgoing edges should be returned</param> /// <param name="includeLoops">Specifies if loops should be returned</param> /// <returns>Returns the array of connected edges for the given cell</returns> public static Object[] GetEdges(mxIGraphModel model, Object cell, bool incoming, bool outgoing, bool includeLoops) { int edgeCount = model.GetEdgeCount(cell); List<Object> result = new List<Object>(edgeCount); for (int i = 0; i < edgeCount; i++) { Object edge = model.GetEdgeAt(cell, i); Object source = model.GetTerminal(edge, true); Object target = model.GetTerminal(edge, false); if ((includeLoops && source == target) || ((source != target) && ((incoming && target == cell) || (outgoing && source == cell)))) { result.Add(edge); } } return result.ToArray(); }
/// <summary> /// Returns the number of incoming or outgoing edges, ignoring the given /// edge. /// </summary> /// <param name="model">Graph model that contains the connection data.</param> /// <param name="cell">Cell whose edges should be counted.</param> /// <param name="outgoing">Boolean that specifies if the number of outgoing or /// incoming edges should be returned.</param> /// <param name="ignoredEdge">Object that represents an edge to be ignored.</param> /// <returns>Returns the number of incoming or outgoing edges.</returns> public static int GetDirectedEdgeCount(mxIGraphModel model, Object cell, bool outgoing, Object ignoredEdge) { int count = 0; int edgeCount = model.GetEdgeCount(cell); for (int i = 0; i < edgeCount; i++) { Object edge = model.GetEdgeAt(cell, i); if (edge != ignoredEdge && model.GetTerminal(edge, outgoing) == cell) { count++; } } return count; }