com.jgraph.layout
public class JGraphFacade extends Object
Nested Class Summary | |
---|---|
interface | JGraphFacade.CellVisitor
Defines the interface that visitors use to perform operations upon the
graph information during depth first search (dfs) or other tree-traversal
strategies implemented by subclassers. |
class | JGraphFacade.DefaultComparator
A default comparator for ordering cell views. |
Field Summary | |
---|---|
protected JGraphAlgebra | algebra
The default graph algebra used for basic algorithms and functions. |
protected Hashtable | attributes
The map of attribute changes made be the layout. |
protected double | circleRadiusFactor
The factor by which to multiple the radius of the circle layout |
protected boolean | directed
Stores whether or not the graph is to be treated as a directed graph.
|
protected JGraphCostFunction | distanceCostFunction
The default cost function used for shortest path search. |
protected boolean | edgePromotion
Whether or not edges connected to collapsed children are promoted to
their first visible parent within the facade, not the actual model |
protected JGraph | graph
The JGraph to have the layout applied to it. |
protected GraphLayoutCache | graphLayoutCache
The layout cache to have the layout applied to it. |
protected List | groupHierarchies
A collection of groups of sibling vertices |
protected boolean | ignoresCellsInGroups
Stores whether or not the layout is to only act on root cells in the
model. |
protected boolean | ignoresHiddenCells
Stores whether or not the layout is to act on only visible cells i.e.
|
protected boolean | ignoresUnconnectedCells
Stores whether or not the layout is to act on only cells that have at
least one connection. |
protected GraphModel | model
The model to have the layout applied to it. |
protected Comparator | order
The default comparator to be used where ordering is required in layouts |
protected boolean | ordered
Whether or not cells should be returned in the same order as found
in the model. |
protected List | roots
The root vertex to be used by tree layouts. |
protected Set | verticesFilter
If instaniated, this set defines which vertices are to be processed in
any layouts. |
Constructor Summary | |
---|---|
JGraphFacade(JGraph graph)
Constructs a JGraphGraphFacade specifying the graph passed in as the
input graph
| |
JGraphFacade(JGraph graph, Object[] roots)
Constructs a JGraphGraphFacade specifying the graph passed in as the
input graph
| |
JGraphFacade(JGraph graph, Object[] roots, boolean ignoresHiddenCells, boolean ignoresCellsInGroups, boolean ignoresUnconnectedCells, boolean directed)
Constructs a JGraphGraphFacade
| |
JGraphFacade(JGraph graph, Object[] roots, boolean ignoresHiddenCells, boolean ignoresCellsInGroups, boolean ignoresUnconnectedCells, boolean directed, JGraphCostFunction distanceCostFunction, JGraphAlgebra algebra)
Creates a JGraphGraphFacade specifying the graph passed in as the input
graph. | |
JGraphFacade(GraphLayoutCache cache)
Creates a JGraphFacade specifying the graph passed in as the input
graph.
| |
JGraphFacade(GraphLayoutCache cache, Object[] roots, boolean ignoresHiddenCells, boolean ignoresCellsInGroups, boolean ignoresUnconnectedCells, boolean directed, JGraphCostFunction distanceCostFunction, JGraphAlgebra algebra)
Creates a JGraphFacade specifying the graph passed in as the input
graph. | |
JGraphFacade(GraphModel model, Object[] roots, boolean ignoresHiddenCells, boolean ignoresCellsInGroups, boolean ignoresUnconnectedCells, boolean directed, JGraphCostFunction distanceCostFunction, JGraphAlgebra algebra)
Creates a JGraphGenericFacade specifying the graph passed in as the input
graph. | |
JGraphFacade(GraphModel model, GraphLayoutCache cache, Object[] roots, boolean ignoresHiddenCells, boolean ignoresCellsInGroups, boolean ignoresUnconnectedCells, boolean directed, JGraphCostFunction distanceCostFunction, JGraphAlgebra algebra)
Creates a JGraphGenericFacade specifying the graph passed in as the input
graph. |
Method Summary | |
---|---|
void | bfs(Object root, JGraphFacade.CellVisitor visitor)
Performs a breath-first search of the input graph from the specified root
cell using the specified visitor to extract the tree information.
|
void | circle(Collection vertices)
Arrange the specified vertices into a circular shape, with a regular
distance between each vertex
|
Map | createNestedMap(Map nestedMap)
Creates and returns nested attribute map specifying what changes the
layout made to the input graph. |
Map | createNestedMap(boolean ignoreGrid, boolean flushOrigin)
Compatibility method to invoke JGraphFacade
with an origin or null depending on flushOrigin .
|
Map | createNestedMap(boolean ignoreGrid, Point2D origin)
Creates and returns nested attribute map specifying what changes the
layout made to the input graph. |
protected void | determineLayoutHierarchies()
Divides the graph into groups of sibling vertices, vertices that
share the same parent. |
void | dfs(Object root, JGraphFacade.CellVisitor visitor)
Performs a depth-first search of the input graph from the specified root
cell using the specified visitor to extract the tree information.
isVertex must return true on the passed-in root cell in order to
continue.
|
void | dfs(Object parent, Object root, Object previousSibling, JGraphFacade.CellVisitor visitor, Set seen, int layer, int sibling)
Performs a depth-first search of the input graph from the specified root
cell using the specified visitor to extract the tree information
|
void | dfs(Object parent, Object root, Object previousSibling, JGraphFacade.CellVisitor visitor, Set seen, Set ancestors, int layer, int sibling)
Performs a depth-first search of the input graph from the specified root
cell using the specified visitor to extract the tree information
|
void | disableRouting(Object edge)
Disables per-edge on the specified edge
|
void | findTreeRoots()
Utility method to update the array of tree roots in a graph. |
protected List | getAll()
Returns all cells including all descendants. |
Hashtable | getAttributes()
Returns the nested map that specifies what changes the layout has made to
the input graph.
|
Map | getAttributes(Object cell)
Returns the local attributes for the specified cell. |
Rectangle2D | getBounds(List vertices)
Returns the minimal rectangular bounds that enclose the specified
vertices
|
Rectangle2D | getBounds(Object cell)
Returns the current bounds for the specified cell.
|
double[][] | getBounds(Object[] cells)
Same as getLocations, but with width and height added at index 3 and 4
respectively.
|
Rectangle2D | getCellBounds()
Returns the minimal rectangular bounds that enclose all the elements in
the bounds map. |
protected Collection | getCells(Collection cells, boolean edges, boolean ordered)
Returns a collection of cells in the current graph. |
Object | getCellView(Object cell)
Obtains the cell view corresponding the cell passed in |
double | getCircleRadiusFactor() |
List | getComponents()
Calculates a list of non-connected graph components for the current
graph. |
JGraphUnionFind | getConnectionComponents(Object[] v, Object[] e)
Returns a union find structure representing the connection components of
G=(E,V). |
double | getDistance(Object v1, Object v2, int maxHops)
Returns the length of the shortest path connecting v1 and
v2 wrt distanceFunction . |
Collection | getEdges()
Returns all edges in the graph. |
Object[] | getEdges(Object cell)
Returns the connected edges for a cell. |
Object[] | getEdges(Object cell, boolean incoming)
Returns the incoming or outgoing edges for cell. |
Object[] | getEdgesBetween(Object cell1, Object cell2, boolean directed)
Returns the edges between two specified ports or two specified vertices.
|
Rectangle2D | getGraphBounds()
Returns the minimal rectangular bounds that enclose all the elements in
the bounds map. |
Point2D | getGraphOrigin()
Returns the origin of the graph (ie the top left corner of the root
cells) for the original geometry.
|
List | getGroupHierarchies() |
List | getIncomingEdges(Object cell, Set exclude, boolean visibleCells, boolean selfLoops)
Returns the incoming edges for cell. |
double | getLength(Object edge)
Returns the length of the specified edge wrt
distanceFunction .
|
Point2D | getLocation(Object cell)
Returns the current location of the specified cell
|
double[][] | getLocations(Object[] cells)
Returns an array of arrays (index 0 is x-coordinate, index 1 is
y-coordinate in the second array) that fast layouts can operate upon.
|
Dimension | getMaxSize(Collection vertices)
Obtains the maximum width or height dimension of any of the vertices in
the specified collection
|
Object[] | getMinimumSpanningTree(Object[] v, JGraphCostFunction cf)
Returns the minimum spanning tree (MST) for the graph defined by G=(E,V).
|
List | getNeighbours(Object cell, boolean ordered)
A shortcut method that calls getNeighbours with no cells to exclude.
|
List | getNeighbours(Object cell, Set exclude, boolean ordered)
Returns a collection of cells that are connected to the specified cell by
edges. |
Comparator | getOrder() |
List | getOutgoingEdges(Object cell, Set exclude, boolean visibleCells, boolean selfLoops)
Returns the outgoing edges for cell. |
Object[] | getPath(Object v1, Object v2, int steps, JGraphCostFunction cf)
Returns the shortest path connecting v1 and
v2 wrt cf with traverses no more than
steps edges. |
List | getPoints(Object edge)
Returns the points of the specified edge. |
Object | getRootAt(int index)
Returns the root at index to be used by tree layouts for
tree traversal.
|
int | getRootCount()
Returns the number of root vertices to be used by tree layouts for tree
traversal.
|
List | getRoots()
Returns the list of root vertices.
|
Dimension2D | getSize(Object cell)
Return the size of the specified cell
|
Object | getSource(Object edge)
Returns the vertex that is connected to the source end of the specified
edge
|
Object | getSourcePort(Object edge)
Returns the port that is connected to the source end of the specified
edge
|
Object | getTarget(Object edge)
Returns the vertex that is connected to the target end of the specified
edge
|
Object | getTargetPort(Object edge)
Returns the port that is connected to the target end of the specified
edge
|
Collection | getUnconnectedVertices(boolean ordered)
Returns all unconnected vertices in the graph. |
Collection | getVertices()
Returns all vertices in the graph. |
Collection | getVertices(Collection cells, boolean ordered)
Returns a collection of vertices found in the specified collection.
|
Set | getVerticesFilter() |
boolean | isDirected() |
boolean | isEdge(Object cell)
Returns whether or not the specified cell is an edge and should be taken
into account by the layout
|
boolean | isEdgePromotion() |
boolean | isIgnoresHiddenCells() |
boolean | isIgnoresUnconnectedCells() |
boolean | isMoveable(Object cell)
Returns true if the cell is moveable. |
boolean | isOrdered() |
boolean | isRoot(Object cell)
Returns true if cell is a root.
|
boolean | isVertex(Object cell)
Returns whether or not the specified cell is a vertex and should be taken
into account by the layout
|
boolean | IsIgnoresCellsInGroups() |
double | norm(Point2D p)
Calculates the euklidische Norm for the point p.
|
protected void | populateGroupHierarchies(Object vertex)
Creates a set of sibling vertices and adds them to the group
hierarchy collection. |
void | randomize(Collection vertices, int maxx, int maxy)
Moves the specified vertices to random locations in the x and y axes
directions between zero and a specified maximum. |
void | resetControlPoints()
Resets the control points of all moveable edges in the graph. |
void | resetControlPoints(boolean setRouting, Edge.Routing routing)
Resets the control points of all moveable edges in the graph.
|
void | run(JGraphLayout layout, boolean processByGroups)
The main method to execute layouts
|
void | scale(Rectangle2D frame)
Scales the graph bounds defined in bounds to fit into the
specified frame
|
void | scale(Collection vertices, double scalex, double scaley, double dx, double dy)
Scales the bounds of the specified cells adding dx and
dy to the respective location axes of the cell, then by
scaling them by scalex and scaley
|
void | setAttributes(Hashtable attributes)
Sets the map that stores all attributes that comprise the changes made by
the layout to the input graph
|
void | setAttributes(Object cell, Map map)
Sets the local attributes for the specified cell.
|
void | setBounds(Map nestedMap)
Reads the bounds from the nested map for each cell and invokes setBounds
for that cell with a clone of the bounds.
|
void | setBounds(Object cell, Rectangle2D rect)
Sets the current bounds for the specified cell.
|
void | setBounds(Object[] cells, double[][] locations)
Same as setLocations, but with width and height added at index 3 and 4
respectively.
|
void | setCircleRadiusFactor(double circleRadiusFactor) |
void | setDirected(boolean directed) |
void | setEdgePromotion(boolean edgePromotion) |
void | setGroupHierarchies(List groupHierarchies) |
void | setIgnoresCellsInGroups(boolean ignoresCellsInGroups) |
void | setIgnoresHiddenCells(boolean ignoresHiddenCells)
The GraphLayoutCache instance on the JGraphFacade object must be
set correctly in order to change this flag. |
void | setIgnoresUnconnectedCells(boolean ignoresUnconnectedCells) |
void | setLocation(Object cell, double x, double y)
Sets the current location of the specified cell. |
void | setLocation(Object cell, double x, double y, boolean moveGroups)
Sets the current location of the specified cell. |
void | setLocations(Object[] cells, double[][] locations)
Sets the locations of the specified cells according to the arrays
specified in locations . |
void | setLoggerLevel(Level level)
Sets the logging level of this class |
void | setOrder(Comparator order) |
void | setOrdered(boolean ordered) |
void | setPoints(Object edge, List points)
Sets the points of the specified edge
|
void | setRoots(List roots) |
void | setSize(Object cell, double width, double height)
Sets the current size of the specified cell.
|
void | setVerticesFilter(Set verticesFilter) |
void | tilt(Collection vertices, int maxx, int maxy)
Simulates a 'nudge' to the graph, moving the specified vertices a random
distance in the x and y axes directions between zero and a specified
maximum. |
void | translate(Object cell, double dx, double dy)
Moved the specified cell by the specified x and y co-ordinate amounts
|
void | translateCells(Collection cells, double dx, double dy)
Translates the bounds of the specified cells adding dx and
dy to the respective location axes of the cell,
|
true
means follow edges in target to source direction,y
false
means treat edges as directionlesstrue
means only act on root cells,
false
means act upon roots and their children. Default is
false
.true
means only act on visible cells, false
act on cells regardless of their visibility. Default is true
.true
means only act on connected
cells, false
act on cells regardless of their connections.
Default is true
.Parameters: graph the JGraph to be laid out
Parameters: graph the JGraph to be laid out roots the root vertices to be used by tree and hierarchical layouts - NOTE, any roots will be subject to the facade filters at the time of construction.
See Also: (JGraph, Object[], boolean, boolean, boolean, boolean,
JGraphCostFunction, JGraphAlgebra)
Parameters: graph The graph used as input to the layout roots the root vertices to be used by tree and hierarchical layouts - NOTE, any roots will be subject to the facade filters at the time of construction. ignoresHiddenCells ignoresCellsInGroups ignoresUnconnectedCells directed distanceCostFunction the cost function that defines the distance metrics algebra the algebra used for basic algorithms and functions
See Also: JGraphFacade ignoresHiddenCells ignoresCellsInGroups ignoresUnconnectedCells directed
Parameters: cache The GraphLayoutCache to be used as input to the layout
Parameters: cache The GraphLayoutCache to be used as input to the layout roots the root vertices to be used by tree and hierarchical layouts - NOTE, any roots will be subject to the facade filters at the time of construction. ignoresHiddenCells ignoresCellsInGroups ignoresUnconnectedCells directed distanceCostFunction the cost function that defines the distance metrics algebra the algebra used for basic algorithms and functions
See Also: JGraphFacade ignoresHiddenCells ignoresCellsInGroups ignoresUnconnectedCells directed
Parameters: model The GraphModel to be used as input to the layout roots the root vertices to be used by tree and hierarchical layouts - NOTE, any roots will be subject to the facade filters at the time of construction. ignoresHiddenCells ignoresCellsInGroups ignoresUnconnectedCells directed distanceCostFunction the cost function that defines the distance metrics algebra the algebra used for basic algorithms and functions
See Also: JGraphFacade ignoresHiddenCells ignoresCellsInGroups ignoresUnconnectedCells directed
Parameters: model The GraphModel to be used as input to the layout cache The GraphLayoutCache to be used as input to the layout roots the root vertices to be used by tree and hierarchical layouts - NOTE, any roots will be subject to the facade filters at the time of construction. ignoresHiddenCells ignoresCellsInGroups ignoresUnconnectedCells directed distanceCostFunction the cost function that defines the distance metrics algebra the algebra used for basic algorithms and functions
See Also: JGraphFacade ignoresHiddenCells ignoresCellsInGroups ignoresUnconnectedCells directed
Parameters: visitor the visitor that defines the operations to be performed upon the graph model
Parameters: vertices the collection of vertices to be arranged
Deprecated: as of version 1.1
Creates and returns nested attribute map specifying what changes the layout made to the input graph. After a layout is run this method should be queried to see what positional changes were made. This method applied snapping to the graph if enabled and only fills the map with the bounds values since these are the only values layout changeReturns: a nested Map
of the changes the layout made upon
the input graph
See Also: JGraphFacade GraphConstants
flushOrigin
.
Parameters: ignoreGrid whether or not the map returned is snapped to the current grid flushOrigin whether or not the bounds of the graph should be moved to (0,0)
Returns: a nested Map
of the changes the layout made upon
the input graph
Parameters: ignoreGrid whether or not the map returned is snapped to the current grid origin the new origin to which the graph bounds will be flushed to
Returns: a nested Map
of the changes the layout made upon
the input graph
Parameters: root the node to start the search from visitor the visitor that defines the operations to be performed upon the graph model
Parameters: parent the parent of the current cell root the node to start the search from previousSibling the last neighbour of the current cell found visitor the visitor that defines the operations to be performed upon the graph model seen the set of cells that have already been seen layer the current layer of the tree sibling the number of siblings to the current cell
Parameters: parent the parent of the current cell root the node to start the search from previousSibling the last neighbour of the current cell found visitor the visitor that defines the operations to be performed upon the graph model seen the set of cells that have already been seen layer the current layer of the tree sibling the number of siblings to the current cell
Parameters: edge the edge to have per-edge routing disabled
Returns: The map that stores all attributes.
Parameters: vertices the vertices whose collective bounds are to be determined
Returns: the collective bounds of the input vertices
Parameters: cell the cell whose bounds are to be determined
Returns: the bounds of the specified cell
Parameters: cells The cells to return the bounds for
Returns: Returns the bounds of the cells as an array of arrays
See Also: (Object[])
bounds
map. After a layout has completed this method
will return the collective bounds of the new laid out graph.
Returns: the collective bounds of the elements in bounds
ordered
flag is set to true
the result will be ordered by the
current comparator set for this facade. Parameters: cells
the cells to be filtered and return the correct cell types edges
whether or not to return the edges of the graph ordered
whether or not to order the returned value in the order of the
current order
comparator. Be very careful
using the default comparator on the default graph model,
getIndexOfRoot
has linear performance and so
sorting the entire model roots will have quadratic
performance.
Returns: collection of cells in the graph
Parameters: cell the cell whose view is to be obtained
Returns: the cell view, if any, assoicated with this cell
Returns: the circleRadiusFactor
Returns: a collection of seperate graph components
Object[] v = facade.getVertices();
Object[] e = facade.getEdges();
JGraphUnionFind uf = facade.getConnectionComponents(v, e);
boolean connected = uf.differ(vertex1, vertex2);
Parameters: v the vertices of the graph e the edges of the graph
Returns: Returns the connection components in G=(E,V)
See Also: (GraphModel, Object[],
Object[])
v1
and
v2
wrt distanceFunction
. The path has no
more than maxHops
elements.
Parameters: v1 the source vertex v2 the target vertex maxHops the maximum number of edges the path may have
Returns: Returns the length of the shortest path between v1 and v2
See Also: distanceCostFunction JGraphFacade
Returns: Returns all edges that the layout should take into account
See Also: isEdge
Parameters: cell the cell whose edges are to be obtained
Returns: Returns the array of all connected edges
Parameters: cell the graph cell whose edges are to be obtained incoming whether or not to obtain incoming edges only
cell1
must be the source of the
returned edges.
Parameters: cell1
the first of the pair of cells to find edges between cell2
the second of the pair of cells to find edges between directed
whether or not only edges going from cell1
to
cell2
should be returned and not edges in the
other direction
bounds
map. After a layout has completed this method
will return the collective bounds of the new laid out graph.
Note this method may return null and should be checked before using.
Returns: the collective bounds of the elements in bounds
Returns: The origin of the graph.
Returns: the groupHierarchies
Parameters: cell The cell from which the incoming edges will be determined exclude The set of edges to ignore when searching visibleCells whether or not only visible cells should be processed selfLoops whether or not to include self loops in the returned list
Returns: Returns the list of incoming edges for cell
distanceFunction
.
Parameters: edge the edge whos length is returned
Returns: Returns the length of edge
See Also: distanceCostFunction JGraphFacade
Parameters: cell the cell whose location is to be determined
Returns: Returns the current location of the specified cell
This method is normally used at the beginning of a layout to setup fast internal datastructures. The layout then changes the array in-place and when finished, writes the result back using the setLocations(Object[] cells, double[][] locations) method:
public void run(JGraphFacade facade) { 1. vertices = facade.getVertices().toArray(); 2. locations = facade.getLocations(vertices); 3. perform layout on local arrays 4. return result: facade.setLocations(vertices, locations); }
Parameters: cells The cells to return the locations for
Returns: Returns the locations of the cells as an array of arrays
Parameters: vertices collection of vertices to be analysed
Returns: the maximum width or height of any of the vertices
Parameters: v the vertices of the graph
Returns: Returns the MST as an array of edges
See Also: (GraphModel, Object[],
JGraphCostFunction, boolean)
See Also: JGraphFacade
Parameters: cell
The cell from which the neighbours will be determined exclude
The set of cells to ignore when searching ordered
whether or not to order the returned value in the order of the
current order
comparator. Be very careful
using the default comparator on the default graph model,
getIndexOfRoot
has linear performance and so
sorting the entire model roots will have quadratic
performance.
Returns: Returns the set of neighbours for cell
Returns: Returns the order.
Parameters: cell The cell from which the outgoing edges will be determined exclude The set of edges to ignore when searching visibleCells whether or not only visible cells should be processed selfLoops whether or not to include self loops in the returned list
Returns: Returns the list of outgoing edges for cell
v1
and
v2
wrt cf
with traverses no more than
steps
edges. The cost function defines the metric that is
used as the edges length.
Parameters: v1 the source vertex v2 the target vertex steps the maximum number of edges in the path cf the cost function that defines the edge lengths
Returns: Returns shortest array of edges connecting v1 and v2
See Also: JGraphAlgebra
Parameters: edge the cell whose points are returned
Returns: Returns the points of the specified edge
index
to be used by tree layouts for
tree traversal.
Returns: the root vertex to be used by tree layouts
See Also: JGraphFacade
Returns: the number of root vertices to be used by tree layouts
Returns: Returns the roots
Parameters: cell the cell whose size is to be returned
Returns: Returns the current size of the specified cell.
Parameters: edge the reference edge
Returns: any vertex connected as the source the specified edge
Parameters: edge the reference edge
Returns: any vertex connected as the source the specified edge
Parameters: edge the reference edge
Returns: any vertex connected as the target the specified edge
Parameters: edge the reference edge
Returns: any vertex connected as the target the specified edge
Returns: Returns all the unconnected cells that the layout should take into account
Returns: Returns all cells that the layout should take into account
See Also: isVertex
Parameters: cells
the set of potential vertices ordered
whether or not to order the returned value in the order of the
current order
comparator. Be very careful
using the default comparator on the default graph model,
getIndexOfRoot
has linear performance and so
sorting the entire model roots will have quadratic
performance.
Returns: Returns the collection of vertices on the collection
See Also: isVertex
Returns: Returns the verticesFilter.
Returns: Returns the directed.
Parameters: cell the cell that is to be classified as an edge or not
Returns: Returns true if the cell is an edge
Returns: Returns the edgePromotion.
Returns: Returns the ignoresHiddenCells.
Returns: Returns the ignoresUnconnectedCells.
moveable
attribute. Subclassers can override
this eg. to check if a cell is not selected in the graph.Returns: Returns the ordered.
cell
is a root.
Parameters: cell the cell to test
Returns: Returns true if cell
is a root
Parameters: cell the cell that is to be classified as a vertex or not
Returns: Returns true if cell
is a vertex
Returns: Returns the ignoresCellsInGroups.
Parameters: p the point to calculate the norm for
Returns: the euklidische Norm for the point p
Parameters: vertex The parent vertex to the returned vertices
Parameters: vertices the collection of vertices to be moved maxx the maximum translation that may occur in the x-axis maxy the maximum translation that may occur in the y-axis
Parameters: layout the layout to be executed processByGroups Whether or not to process cell only at the level of their own group When true, children are only processed with siblings and their parent only with its siblings and so on
bounds
to fit into the
specified frame
Parameters: frame
the frame the bounds
map colective bounds is to
be scaled to
dx
and
dy
to the respective location axes of the cell, then by
scaling them by scalex
and scaley
Parameters: vertices the collection of vertices to be scaled scalex the amount by which the x-axis positions of the vertices will be scaled scaley the amount by which the y-axis positions of the vertices will be scaled dx the amount to be added to be x-axis positions of the vertices before scaling is applied dy the amount to be added to be y-axis positions of the vertices before scaling is applied
Parameters: attributes the new map of cell, map pairs
Parameters: cell the cell to set the attributes for map the new attributes for the cell
Parameters: nestedMap A map of (cell, map) pairs
See Also: getBounds
Parameters: cell the cell whose bounds are to be set rect the new bounds of the specified cell
Parameters: cells The cells to change the bounds for locations The new bounds as an array of arrays
See Also: (Object[])
Parameters: circleRadiusFactor the minCircleRadius to set
Parameters: directed The directed to set.
Parameters: edgePromotion The edgePromotion to set.
Parameters: groupHierarchies the groupHierarchies to set
Parameters: ignoresCellsInGroups Sets ignoresCellsInGroups.
Parameters: ignoresHiddenCells The ignoresHiddenCells to set.
Parameters: ignoresUnconnectedCells The ignoresUnconnectedCells to set.
Parameters: cell the cell whose location is to be set x the new x-axs location of the cell y the new y-axs location of the cell
See Also: isMoveable
Parameters: cell the cell whose location is to be set x the new x-axs location of the cell y the new y-axs location of the cell moveGroups whether or not to move group cells
See Also: isMoveable
locations
. The cells and locations array
must contain the same number of elements.
Parameters: cells The cells to change the locations for locations The new locations as an array of arrays
See Also: (Object[])
Parameters: level the logging level to set
Parameters: order The order to set.
Parameters: ordered The ordered to set.
Parameters: edge the edge whose points are to be set points the new list of points for the edge
Parameters: roots The roots to set.
Parameters: cell the cell whose size is to be set width the new width of the cell height the new height of the cell
Parameters: verticesFilter The verticesFilter to set.
Parameters: vertices the collection of vertices to be moved maxx the maximum translation that may occur in the x-axis maxy the maximum translation that may occur in the y-axis
Parameters: cell the cell to be moved dx the amount by which the cell will be translated in the x-axis dy the amount by which the cell will be translated in the y-axis
dx
and
dy
to the respective location axes of the cell,
Parameters: dx the amount to be added to be x-axis positions of the vertices before scaling is applied dy the amount to be added to be y-axis positions of the vertices before scaling is applied