JGraph
v5.13.0.4


com.jgraph.layout
Class JGraphFacade

java.lang.Object
  extended by com.jgraph.layout.JGraphFacade
Direct Known Subclasses:
JGraphModelFacade

public class JGraphFacade
extends java.lang.Object

An abstract description of a graph that can be used by a layout algorithm. This abstracts visibility, grouping, directed edges, any root cells, translation and scaling functions. It also stores the actual graph to be acted upon by the layout and provides utility method to determine the characteristics of the contained cells. After the layout has been applied this class stores the result of that layout as a nested attribute map.


Nested Class Summary
static 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  java.util.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  java.util.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  java.util.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  java.util.List roots
          The root vertex to be used by tree layouts.
protected  java.util.Set verticesFilter
          If instaniated, this set defines which vertices are to be processed in any layouts.
 
Constructor Summary
JGraphFacade(GraphLayoutCache cache)
          Creates a JGraphFacade specifying the graph passed in as the input graph.
JGraphFacade(GraphLayoutCache cache, java.lang.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, GraphLayoutCache cache, java.lang.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, java.lang.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(JGraph graph)
          Constructs a JGraphGraphFacade specifying the graph passed in as the input graph
JGraphFacade(JGraph graph, java.lang.Object[] roots)
          Constructs a JGraphGraphFacade specifying the graph passed in as the input graph
JGraphFacade(JGraph graph, java.lang.Object[] roots, boolean ignoresHiddenCells, boolean ignoresCellsInGroups, boolean ignoresUnconnectedCells, boolean directed)
          Constructs a JGraphGraphFacade
JGraphFacade(JGraph graph, java.lang.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.
 
Method Summary
 void bfs(java.lang.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(java.util.Collection vertices)
          Arrange the specified vertices into a circular shape, with a regular distance between each vertex
 java.util.Map createNestedMap(boolean ignoreGrid, boolean flushOrigin)
          Compatibility method to invoke createNestedMap(boolean, Point2D) with an origin or null depending on flushOrigin.
 java.util.Map createNestedMap(boolean ignoreGrid, java.awt.geom.Point2D origin)
          Creates and returns nested attribute map specifying what changes the layout made to the input graph.
 java.util.Map createNestedMap(java.util.Map nestedMap)
          Deprecated. as of version 1.1
protected  void determineLayoutHierarchies()
          Divides the graph into groups of sibling vertices, vertices that share the same parent.
 void dfs(java.lang.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.
 void dfs(java.lang.Object parent, java.lang.Object root, java.lang.Object previousSibling, JGraphFacade.CellVisitor visitor, java.util.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(java.lang.Object parent, java.lang.Object root, java.lang.Object previousSibling, JGraphFacade.CellVisitor visitor, java.util.Set seen, java.util.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(java.lang.Object edge)
          Disables per-edge on the specified edge
 void findTreeRoots()
          Utility method to update the array of tree roots in a graph.
protected  java.util.List getAll()
          Returns all cells including all descendants.
 java.util.Hashtable getAttributes()
          Returns the nested map that specifies what changes the layout has made to the input graph.
 java.util.Map getAttributes(java.lang.Object cell)
          Returns the local attributes for the specified cell.
 java.awt.geom.Rectangle2D getBounds(java.util.List vertices)
          Returns the minimal rectangular bounds that enclose the specified vertices
 java.awt.geom.Rectangle2D getBounds(java.lang.Object cell)
          Returns the current bounds for the specified cell.
 double[][] getBounds(java.lang.Object[] cells)
          Same as getLocations, but with width and height added at index 3 and 4 respectively.
 java.awt.geom.Rectangle2D getCellBounds()
          Returns the minimal rectangular bounds that enclose all the elements in the bounds map.
protected  java.util.Collection getCells(java.util.Collection cells, boolean edges, boolean ordered)
          Returns a collection of cells in the current graph.
 java.lang.Object getCellView(java.lang.Object cell)
          Obtains the cell view corresponding the cell passed in
 double getCircleRadiusFactor()
           
 java.util.List getComponents()
          Calculates a list of non-connected graph components for the current graph.
 JGraphUnionFind getConnectionComponents(java.lang.Object[] v, java.lang.Object[] e)
          Returns a union find structure representing the connection components of G=(E,V).
 double getDistance(java.lang.Object v1, java.lang.Object v2, int maxHops)
          Returns the length of the shortest path connecting v1 and v2 wrt distanceFunction.
 java.util.Collection getEdges()
          Returns all edges in the graph.
 java.lang.Object[] getEdges(java.lang.Object cell)
          Returns the connected edges for a cell.
 java.lang.Object[] getEdges(java.lang.Object cell, boolean incoming)
          Returns the incoming or outgoing edges for cell.
 java.lang.Object[] getEdgesBetween(java.lang.Object cell1, java.lang.Object cell2, boolean directed)
          Returns the edges between two specified ports or two specified vertices.
 java.awt.geom.Rectangle2D getGraphBounds()
          Returns the minimal rectangular bounds that enclose all the elements in the bounds map.
 java.awt.geom.Point2D getGraphOrigin()
          Returns the origin of the graph (ie the top left corner of the root cells) for the original geometry.
 java.util.List getGroupHierarchies()
           
 java.util.List getIncomingEdges(java.lang.Object cell, java.util.Set exclude, boolean visibleCells, boolean selfLoops)
          Returns the incoming edges for cell.
 double getLength(java.lang.Object edge)
          Returns the length of the specified edge wrt distanceFunction.
 java.awt.geom.Point2D getLocation(java.lang.Object cell)
          Returns the current location of the specified cell
 double[][] getLocations(java.lang.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.
 java.awt.Dimension getMaxSize(java.util.Collection vertices)
          Obtains the maximum width or height dimension of any of the vertices in the specified collection
 java.lang.Object[] getMinimumSpanningTree(java.lang.Object[] v, JGraphCostFunction cf)
          Returns the minimum spanning tree (MST) for the graph defined by G=(E,V).
 java.util.List getNeighbours(java.lang.Object cell, boolean ordered)
          A shortcut method that calls getNeighbours with no cells to exclude.
 java.util.List getNeighbours(java.lang.Object cell, java.util.Set exclude, boolean ordered)
          Returns a collection of cells that are connected to the specified cell by edges.
 java.util.Comparator getOrder()
           
 java.util.List getOutgoingEdges(java.lang.Object cell, java.util.Set exclude, boolean visibleCells, boolean selfLoops)
          Returns the outgoing edges for cell.
 java.lang.Object[] getPath(java.lang.Object v1, java.lang.Object v2, int steps, JGraphCostFunction cf)
          Returns the shortest path connecting v1 and v2 wrt cf with traverses no more than steps edges.
 java.util.List getPoints(java.lang.Object edge)
          Returns the points of the specified edge.
 java.lang.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.
 java.util.List getRoots()
          Returns the list of root vertices.
 java.awt.geom.Dimension2D getSize(java.lang.Object cell)
          Return the size of the specified cell
 java.lang.Object getSource(java.lang.Object edge)
          Returns the vertex that is connected to the source end of the specified edge
 java.lang.Object getSourcePort(java.lang.Object edge)
          Returns the port that is connected to the source end of the specified edge
 java.lang.Object getTarget(java.lang.Object edge)
          Returns the vertex that is connected to the target end of the specified edge
 java.lang.Object getTargetPort(java.lang.Object edge)
          Returns the port that is connected to the target end of the specified edge
 java.util.Collection getUnconnectedVertices(boolean ordered)
          Returns all unconnected vertices in the graph.
 java.util.Collection getVertices()
          Returns all vertices in the graph.
 java.util.Collection getVertices(java.util.Collection cells, boolean ordered)
          Returns a collection of vertices found in the specified collection.
 java.util.Set getVerticesFilter()
           
 boolean isDirected()
           
 boolean isEdge(java.lang.Object cell)
          Returns whether or not the specified cell is an edge and should be taken into account by the layout
 boolean isEdgePromotion()
           
 boolean IsIgnoresCellsInGroups()
           
 boolean isIgnoresHiddenCells()
           
 boolean isIgnoresUnconnectedCells()
           
 boolean isMoveable(java.lang.Object cell)
          Returns true if the cell is moveable.
 boolean isOrdered()
           
 boolean isRoot(java.lang.Object cell)
          Returns true if cell is a root.
 boolean isVertex(java.lang.Object cell)
          Returns whether or not the specified cell is a vertex and should be taken into account by the layout
 double norm(java.awt.geom.Point2D p)
          Calculates the euklidische Norm for the point p.
protected  void populateGroupHierarchies(java.lang.Object vertex)
          Creates a set of sibling vertices and adds them to the group hierarchy collection.
 void randomize(java.util.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(java.util.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 scale(java.awt.geom.Rectangle2D frame)
          Scales the graph bounds defined in bounds to fit into the specified frame
 void setAttributes(java.util.Hashtable attributes)
          Sets the map that stores all attributes that comprise the changes made by the layout to the input graph
 void setAttributes(java.lang.Object cell, java.util.Map map)
          Sets the local attributes for the specified cell.
 void setBounds(java.util.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(java.lang.Object[] cells, double[][] locations)
          Same as setLocations, but with width and height added at index 3 and 4 respectively.
 void setBounds(java.lang.Object cell, java.awt.geom.Rectangle2D rect)
          Sets the current bounds for the specified cell.
 void setCircleRadiusFactor(double circleRadiusFactor)
           
 void setDirected(boolean directed)
           
 void setEdgePromotion(boolean edgePromotion)
           
 void setGroupHierarchies(java.util.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(java.lang.Object cell, double x, double y)
          Sets the current location of the specified cell.
 void setLocation(java.lang.Object cell, double x, double y, boolean moveGroups)
          Sets the current location of the specified cell.
 void setLocations(java.lang.Object[] cells, double[][] locations)
          Sets the locations of the specified cells according to the arrays specified in locations.
 void setLoggerLevel(java.util.logging.Level level)
          Sets the logging level of this class
 void setOrder(java.util.Comparator order)
           
 void setOrdered(boolean ordered)
           
 void setPoints(java.lang.Object edge, java.util.List points)
          Sets the points of the specified edge
 void setRoots(java.util.List roots)
           
 void setSize(java.lang.Object cell, double width, double height)
          Sets the current size of the specified cell.
 void setVerticesFilter(java.util.Set verticesFilter)
           
 void tilt(java.util.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(java.lang.Object cell, double dx, double dy)
          Moved the specified cell by the specified x and y co-ordinate amounts
 void translateCells(java.util.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,
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

ignoresHiddenCells

protected boolean ignoresHiddenCells
Stores whether or not the layout is to act on only visible cells i.e. true means only act on visible cells, false act on cells regardless of their visibility. Default is true.


ignoresUnconnectedCells

protected boolean ignoresUnconnectedCells
Stores whether or not the layout is to act on only cells that have at least one connection. true means only act on connected cells, false act on cells regardless of their connections. Default is true.


ignoresCellsInGroups

protected boolean ignoresCellsInGroups
Stores whether or not the layout is to only act on root cells in the model. true means only act on root cells, false means act upon roots and their children. Default is false.


directed

protected boolean directed
Stores whether or not the graph is to be treated as a directed graph. true means follow edges in target to source direction,y false means treat edges as directionless


edgePromotion

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


ordered

protected boolean ordered
Whether or not cells should be returned in the same order as found in the model. Set to true to obtain deterministic results for things such as the order of cells with a particular level of a tree layout. Note that setting this variable to true can cause quadratic performance, therefore it defaults to false.


graph

protected transient JGraph graph
The JGraph to have the layout applied to it. There is no accessor to the graph for the layouts. If you need access to the graph, try to factor out the methods into a custom facade, and pass an instance of that facade to your layout's run method.


graphLayoutCache

protected transient GraphLayoutCache graphLayoutCache
The layout cache to have the layout applied to it. There is no accessor to the graph for the layouts. If you need access to the graph, try to factor out the methods into a custom facade, and pass an instance of that facade to your layout's run method.


model

protected transient GraphModel model
The model to have the layout applied to it. There is no accessor to the graph for the layouts. If you need access to the graph, try to factor out the methods into a custom facade, and pass an instance of that facade to your layout's run method.


attributes

protected transient java.util.Hashtable attributes
The map of attribute changes made be the layout. Maps from cells to maps.


order

protected transient java.util.Comparator order
The default comparator to be used where ordering is required in layouts


distanceCostFunction

protected transient JGraphCostFunction distanceCostFunction
The default cost function used for shortest path search.


algebra

protected transient JGraphAlgebra algebra
The default graph algebra used for basic algorithms and functions.


roots

protected transient java.util.List roots
The root vertex to be used by tree layouts.


verticesFilter

protected transient java.util.Set verticesFilter
If instaniated, this set defines which vertices are to be processed in any layouts. Set to null to apply no filtered set


groupHierarchies

protected transient java.util.List groupHierarchies
A collection of groups of sibling vertices


circleRadiusFactor

protected double circleRadiusFactor
The factor by which to multiple the radius of the circle layout

Constructor Detail

JGraphFacade

public JGraphFacade(JGraph graph)
Constructs a JGraphGraphFacade specifying the graph passed in as the input graph

Parameters:
graph - the JGraph to be laid out

JGraphFacade

public JGraphFacade(JGraph graph,
                    java.lang.Object[] roots)
Constructs a JGraphGraphFacade specifying the graph passed in as the input graph

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.

JGraphFacade

public JGraphFacade(JGraph graph,
                    java.lang.Object[] roots,
                    boolean ignoresHiddenCells,
                    boolean ignoresCellsInGroups,
                    boolean ignoresUnconnectedCells,
                    boolean directed)
Constructs a JGraphGraphFacade

See Also:
JGraphFacade(JGraph, Object[], boolean, boolean, boolean, boolean, JGraphCostFunction, JGraphAlgebra)

JGraphFacade

public JGraphFacade(JGraph graph,
                    java.lang.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. Also configures properties of layout, whether or not edge direction is to be taken into account, whether or not invisible cells are to be considered and whether or not only root cells are to be considered or roots and all their children. A root is only used if the isVertex method returns true.

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:
isVertex(java.lang.Object), ignoresHiddenCells, ignoresCellsInGroups, ignoresUnconnectedCells, directed

JGraphFacade

public JGraphFacade(GraphLayoutCache cache)
Creates a JGraphFacade specifying the graph passed in as the input graph.

Parameters:
cache - The GraphLayoutCache to be used as input to the layout

JGraphFacade

public JGraphFacade(GraphLayoutCache cache,
                    java.lang.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. Also configures properties of layout, whether or not edge direction is to be taken into account, whether or not invisible cells are to be considered and whether or not only root cells are to be considered or roots and all their children. A root is only used if the isVertex method returns true.

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:
isVertex(java.lang.Object), ignoresHiddenCells, ignoresCellsInGroups, ignoresUnconnectedCells, directed

JGraphFacade

public JGraphFacade(GraphModel model,
                    java.lang.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. Also configures properties of layout, whether or not edge direction is to be taken into account, whether or not invisible cells are to be considered and whether or not only root cells are to be considered or roots and all their children. A root is only used if the isVertex method returns true.

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:
isVertex(java.lang.Object), ignoresHiddenCells, ignoresCellsInGroups, ignoresUnconnectedCells, directed

JGraphFacade

public JGraphFacade(GraphModel model,
                    GraphLayoutCache cache,
                    java.lang.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. Also configures properties of layout, whether or not edge direction is to be taken into account, whether or not invisible cells are to be considered and whether or not only root cells are to be considered or roots and all their children. A root is only used if the isVertex method returns true.

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:
isVertex(java.lang.Object), ignoresHiddenCells, ignoresCellsInGroups, ignoresUnconnectedCells, directed
Method Detail

run

public void run(JGraphLayout layout,
                boolean processByGroups)
The main method to execute layouts

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

resetControlPoints

public void resetControlPoints()
Resets the control points of all moveable edges in the graph.


resetControlPoints

public void resetControlPoints(boolean setRouting,
                               Edge.Routing routing)
Resets the control points of all moveable edges in the graph. Also set the routing on the edges to the specified value if the parameter flag indicates to do so

Parameters:
whether - or not to set a new routing style on each edge
the - routing style to set on each edge if setRouting is true

isVertex

public boolean isVertex(java.lang.Object cell)
Returns whether or not the specified cell is a vertex and should be taken into account by the layout

Parameters:
cell - the cell that is to be classified as a vertex or not
Returns:
Returns true if cell is a vertex

isEdge

public boolean isEdge(java.lang.Object cell)
Returns whether or not the specified cell is an edge and should be taken into account by the layout

Parameters:
cell - the cell that is to be classified as an edge or not
Returns:
Returns true if the cell is an edge

getNeighbours

public java.util.List getNeighbours(java.lang.Object cell,
                                    boolean ordered)
A shortcut method that calls getNeighbours with no cells to exclude.

See Also:
getNeighbours(Object, Set, boolean)

getNeighbours

public java.util.List getNeighbours(java.lang.Object cell,
                                    java.util.Set exclude,
                                    boolean ordered)
Returns a collection of cells that are connected to the specified cell by edges. Any cells specified in the exclude set will be ignored.

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

getLength

public double getLength(java.lang.Object edge)
Returns the length of the specified edge wrt distanceFunction.

Parameters:
edge - the edge whos length is returned
Returns:
Returns the length of edge
See Also:
distanceCostFunction, getPath(Object, Object, int, JGraphCostFunction)

getDistance

public double getDistance(java.lang.Object v1,
                          java.lang.Object v2,
                          int maxHops)
Returns the length of the shortest path connecting 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, getPath(Object, Object, int, JGraphCostFunction)

getPath

public java.lang.Object[] getPath(java.lang.Object v1,
                                  java.lang.Object v2,
                                  int steps,
                                  JGraphCostFunction cf)
Returns the shortest path connecting 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.getShortestPath(GraphModel, Object, Object, JGraphCostFunction, int, boolean)

getConnectionComponents

public JGraphUnionFind getConnectionComponents(java.lang.Object[] v,
                                               java.lang.Object[] e)
Returns a union find structure representing the connection components of G=(E,V). The union find may be used as follows to determine whether two cells are connected:

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:
JGraphAlgebra.getConnectionComponents(GraphModel, Object[], Object[])

getMinimumSpanningTree

public java.lang.Object[] getMinimumSpanningTree(java.lang.Object[] v,
                                                 JGraphCostFunction cf)
Returns the minimum spanning tree (MST) for the graph defined by G=(E,V). The MST is defined as the set of all vertices with minimal lengths that forms no cycles in G.

Parameters:
v - the vertices of the graph
Returns:
Returns the MST as an array of edges
See Also:
JGraphAlgebra.getMinimumSpanningTree(GraphModel, Object[], JGraphCostFunction, boolean)

getVertices

public java.util.Collection getVertices()
Returns all vertices in the graph.
Note: This returns a linked list, for frequent read operations you should turn this into an array, or at least an array list.

Returns:
Returns all cells that the layout should take into account
See Also:
isVertex(Object)

getUnconnectedVertices

public java.util.Collection getUnconnectedVertices(boolean ordered)
Returns all unconnected vertices in the graph.

Returns:
Returns all the unconnected cells that the layout should take into account

getEdges

public java.util.Collection getEdges()
Returns all edges in the graph.
Note: This returns a linked list, for frequent read operations you should turn this into an array, or at least an array list.

Returns:
Returns all edges that the layout should take into account
See Also:
isEdge(Object)

getEdges

public java.lang.Object[] getEdges(java.lang.Object cell)
Returns the connected edges for a cell. Cell should be a port or a vertex.

Parameters:
cell - the cell whose edges are to be obtained
Returns:
Returns the array of all connected edges

getEdges

public java.lang.Object[] getEdges(java.lang.Object cell,
                                   boolean incoming)
Returns the incoming or outgoing edges for cell. Cell should be a port or a vertex.

Parameters:
cell - the graph cell whose edges are to be obtained
incoming - whether or not to obtain incoming edges only

getSource

public java.lang.Object getSource(java.lang.Object edge)
Returns the vertex that is connected to the source end of the specified edge

Parameters:
edge - the reference edge
Returns:
any vertex connected as the source the specified edge

getTarget

public java.lang.Object getTarget(java.lang.Object edge)
Returns the vertex that is connected to the target end of the specified edge

Parameters:
edge - the reference edge
Returns:
any vertex connected as the target the specified edge

getSourcePort

public java.lang.Object getSourcePort(java.lang.Object edge)
Returns the port that is connected to the source end of the specified edge

Parameters:
edge - the reference edge
Returns:
any vertex connected as the source the specified edge

getTargetPort

public java.lang.Object getTargetPort(java.lang.Object edge)
Returns the port that is connected to the target end of the specified edge

Parameters:
edge - the reference edge
Returns:
any vertex connected as the target the specified edge

getAll

protected java.util.List getAll()
Returns all cells including all descendants.


getCells

protected java.util.Collection getCells(java.util.Collection cells,
                                        boolean edges,
                                        boolean ordered)
Returns a collection of cells in the current graph. Roots are flattened and returned also. It can be specified whether or not to return edges in the graph using the appropriate parameter. If the ordered flag is set to true the result will be ordered by the current comparator set for this facade.
Note: This returns a set, for frequent read operations you should turn this into an array, or at least an array list.

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

getCellView

public java.lang.Object getCellView(java.lang.Object cell)
Obtains the cell view corresponding the cell passed in

Parameters:
cell - the cell whose view is to be obtained
Returns:
the cell view, if any, assoicated with this cell

getVertices

public java.util.Collection getVertices(java.util.Collection cells,
                                        boolean ordered)
Returns a collection of vertices found in the specified collection.

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(Object)

getOutgoingEdges

public java.util.List getOutgoingEdges(java.lang.Object cell,
                                       java.util.Set exclude,
                                       boolean visibleCells,
                                       boolean selfLoops)
Returns the outgoing edges for cell. Cell should be a port or a vertex.

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

getIncomingEdges

public java.util.List getIncomingEdges(java.lang.Object cell,
                                       java.util.Set exclude,
                                       boolean visibleCells,
                                       boolean selfLoops)
Returns the incoming edges for cell. Cell should be a port or a vertex.

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

createNestedMap

public java.util.Map createNestedMap(java.util.Map nestedMap)
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 change

Returns:
a nested Map of the changes the layout made upon the input graph
See Also:
createNestedMap(boolean, boolean), GraphConstants.merge(Map, Map)

createNestedMap

public java.util.Map createNestedMap(boolean ignoreGrid,
                                     boolean flushOrigin)
Compatibility method to invoke createNestedMap(boolean, Point2D) with an origin or null depending on 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

createNestedMap

public java.util.Map createNestedMap(boolean ignoreGrid,
                                     java.awt.geom.Point2D origin)
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 change

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

getComponents

public java.util.List getComponents()
Calculates a list of non-connected graph components for the current graph.

Returns:
a collection of seperate graph components

norm

public double norm(java.awt.geom.Point2D p)
Calculates the euklidische Norm for the point p.

Parameters:
p - the point to calculate the norm for
Returns:
the euklidische Norm for the point p

getAttributes

public java.util.Hashtable getAttributes()
Returns the nested map that specifies what changes the layout has made to the input graph.

Returns:
The map that stores all attributes.

setAttributes

public void setAttributes(java.util.Hashtable attributes)
Sets the map that stores all attributes that comprise the changes made by the layout to the input graph

Parameters:
attributes - the new map of cell, map pairs

getAttributes

public java.util.Map getAttributes(java.lang.Object cell)
Returns the local attributes for the specified cell.


isMoveable

public boolean isMoveable(java.lang.Object cell)
Returns true if the cell is moveable. If this returns false then the cells bounds cannot be changed via the facade. The default implementation checks the moveable attribute. Subclassers can override this eg. to check if a cell is not selected in the graph.


setAttributes

public void setAttributes(java.lang.Object cell,
                          java.util.Map map)
Sets the local attributes for the specified cell.

Parameters:
cell - the cell to set the attributes for
map - the new attributes for the cell

getBounds

public java.awt.geom.Rectangle2D getBounds(java.util.List vertices)
Returns the minimal rectangular bounds that enclose the specified vertices

Parameters:
vertices - the vertices whose collective bounds are to be determined
Returns:
the collective bounds of the input vertices

getGraphBounds

public java.awt.geom.Rectangle2D getGraphBounds()
Returns the minimal rectangular bounds that enclose all the elements in the 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

getGraphOrigin

public java.awt.geom.Point2D getGraphOrigin()
Returns the origin of the graph (ie the top left corner of the root cells) for the original geometry.

Returns:
The origin of the graph.

getCellBounds

public java.awt.geom.Rectangle2D getCellBounds()
Returns the minimal rectangular bounds that enclose all the elements in the 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

translateCells

public void translateCells(java.util.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,

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

scale

public void scale(java.awt.geom.Rectangle2D frame)
Scales the graph bounds defined in bounds to fit into the specified frame

Parameters:
frame - the frame the bounds map colective bounds is to be scaled to

scale

public void scale(java.util.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

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

randomize

public void randomize(java.util.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. The maximum amounts can be specified seperately for the x and y axes.

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

tilt

public void tilt(java.util.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. The maximum amounts can be specified seperately for the x and y axes.

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

circle

public void circle(java.util.Collection vertices)
Arrange the specified vertices into a circular shape, with a regular distance between each vertex

Parameters:
vertices - the collection of vertices to be arranged

getBounds

public java.awt.geom.Rectangle2D getBounds(java.lang.Object cell)
Returns the current bounds for the specified cell.

Parameters:
cell - the cell whose bounds are to be determined
Returns:
the bounds of the specified cell

setBounds

public void setBounds(java.util.Map nestedMap)
Reads the bounds from the nested map for each cell and invokes setBounds for that cell with a clone of the bounds.

Parameters:
nestedMap - A map of (cell, map) pairs
See Also:
GraphConstants.getBounds(Map)

setBounds

public void setBounds(java.lang.Object cell,
                      java.awt.geom.Rectangle2D rect)
Sets the current bounds for the specified cell.

Parameters:
cell - the cell whose bounds are to be set
rect - the new bounds of the specified cell

getLocations

public double[][] getLocations(java.lang.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.

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

getBounds

public double[][] getBounds(java.lang.Object[] cells)
Same as getLocations, but with width and height added at index 3 and 4 respectively.

Parameters:
cells - The cells to return the bounds for
Returns:
Returns the bounds of the cells as an array of arrays
See Also:
getLocations(Object[])

getLocation

public java.awt.geom.Point2D getLocation(java.lang.Object cell)
Returns the current location of the specified cell

Parameters:
cell - the cell whose location is to be determined
Returns:
Returns the current location of the specified cell

setLocations

public void setLocations(java.lang.Object[] cells,
                         double[][] locations)
Sets the locations of the specified cells according to the arrays specified in 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:
getLocations(Object[])

setBounds

public void setBounds(java.lang.Object[] cells,
                      double[][] locations)
Same as setLocations, but with width and height added at index 3 and 4 respectively.

Parameters:
cells - The cells to change the bounds for
locations - The new bounds as an array of arrays
See Also:
getLocations(Object[])

setLocation

public void setLocation(java.lang.Object cell,
                        double x,
                        double y)
Sets the current location of the specified cell. This checks if the cell is moveable.

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(Object)

setLocation

public void setLocation(java.lang.Object cell,
                        double x,
                        double y,
                        boolean moveGroups)
Sets the current location of the specified cell. This checks if the cell is moveable.

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(Object)

translate

public void translate(java.lang.Object cell,
                      double dx,
                      double dy)
Moved the specified cell by the specified x and y co-ordinate amounts

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

getMaxSize

public java.awt.Dimension getMaxSize(java.util.Collection vertices)
Obtains the maximum width or height dimension of any of the vertices in the specified collection

Parameters:
vertices - collection of vertices to be analysed
Returns:
the maximum width or height of any of the vertices

setSize

public void setSize(java.lang.Object cell,
                    double width,
                    double height)
Sets the current size of the specified cell.

Parameters:
cell - the cell whose size is to be set
width - the new width of the cell
height - the new height of the cell

getSize

public java.awt.geom.Dimension2D getSize(java.lang.Object cell)
Return the size of the specified cell

Parameters:
cell - the cell whose size is to be returned
Returns:
Returns the current size of the specified cell.

getPoints

public java.util.List getPoints(java.lang.Object edge)
Returns the points of the specified edge. The list may contain PortView instances. Do a typecheck when iterating through the elements of this list, and use PortView.getLocation to get the position of the port.

Parameters:
edge - the cell whose points are returned
Returns:
Returns the points of the specified edge

setPoints

public void setPoints(java.lang.Object edge,
                      java.util.List points)
Sets the points of the specified edge

Parameters:
edge - the edge whose points are to be set
points - the new list of points for the edge

disableRouting

public void disableRouting(java.lang.Object edge)
Disables per-edge on the specified edge

Parameters:
edge - the edge to have per-edge routing disabled

getEdgesBetween

public java.lang.Object[] getEdgesBetween(java.lang.Object cell1,
                                          java.lang.Object cell2,
                                          boolean directed)
Returns the edges between two specified ports or two specified vertices. If directed is true then 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

determineLayoutHierarchies

protected void determineLayoutHierarchies()
Divides the graph into groups of sibling vertices, vertices that share the same parent. This is mostly used for layouting of cell relative to their group context.


populateGroupHierarchies

protected void populateGroupHierarchies(java.lang.Object vertex)
Creates a set of sibling vertices and adds them to the group hierarchy collection. The list of hierarchies will naturally form in an order

Parameters:
vertex - The parent vertex to the returned vertices

getRootCount

public int getRootCount()
Returns the number of root vertices to be used by tree layouts for tree traversal.

Returns:
the number of root vertices to be used by tree layouts

getRootAt

public java.lang.Object getRootAt(int index)
Returns the root at index to be used by tree layouts for tree traversal.

Returns:
the root vertex to be used by tree layouts
See Also:
dfs(Object, JGraphFacade.CellVisitor)

isRoot

public boolean isRoot(java.lang.Object cell)
Returns true if cell is a root.

Parameters:
cell - the cell to test
Returns:
Returns true if cell is a root

getRoots

public java.util.List getRoots()
Returns the list of root vertices.

Returns:
Returns the roots

setRoots

public void setRoots(java.util.List roots)
Parameters:
roots - The roots to set.

isDirected

public boolean isDirected()
Returns:
Returns the directed.

setDirected

public void setDirected(boolean directed)
Parameters:
directed - The directed to set.

getOrder

public java.util.Comparator getOrder()
Returns:
Returns the order.

setOrder

public void setOrder(java.util.Comparator order)
Parameters:
order - The order to set.

IsIgnoresCellsInGroups

public boolean IsIgnoresCellsInGroups()
Returns:
Returns the ignoresCellsInGroups.

setIgnoresCellsInGroups

public void setIgnoresCellsInGroups(boolean ignoresCellsInGroups)
Parameters:
ignoresCellsInGroups - Sets ignoresCellsInGroups.

isIgnoresHiddenCells

public boolean isIgnoresHiddenCells()
Returns:
Returns the ignoresHiddenCells.

setIgnoresHiddenCells

public void setIgnoresHiddenCells(boolean ignoresHiddenCells)
The GraphLayoutCache instance on the JGraphFacade object must be set correctly in order to change this flag. If the graphLayoutCache is null, this flag will be forced to false

Parameters:
ignoresHiddenCells - The ignoresHiddenCells to set.

isIgnoresUnconnectedCells

public boolean isIgnoresUnconnectedCells()
Returns:
Returns the ignoresUnconnectedCells.

setIgnoresUnconnectedCells

public void setIgnoresUnconnectedCells(boolean ignoresUnconnectedCells)
Parameters:
ignoresUnconnectedCells - The ignoresUnconnectedCells to set.

isEdgePromotion

public boolean isEdgePromotion()
Returns:
Returns the edgePromotion.

setEdgePromotion

public void setEdgePromotion(boolean edgePromotion)
Parameters:
edgePromotion - The edgePromotion to set.

getVerticesFilter

public java.util.Set getVerticesFilter()
Returns:
Returns the verticesFilter.

setVerticesFilter

public void setVerticesFilter(java.util.Set verticesFilter)
Parameters:
verticesFilter - The verticesFilter to set.

getGroupHierarchies

public java.util.List getGroupHierarchies()
Returns:
the groupHierarchies

setGroupHierarchies

public void setGroupHierarchies(java.util.List groupHierarchies)
Parameters:
groupHierarchies - the groupHierarchies to set

getCircleRadiusFactor

public double getCircleRadiusFactor()
Returns:
the circleRadiusFactor

setCircleRadiusFactor

public void setCircleRadiusFactor(double circleRadiusFactor)
Parameters:
circleRadiusFactor - the minCircleRadius to set

dfs

public void dfs(java.lang.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.

Parameters:
root - the node to start the search from
visitor - the visitor that defines the operations to be performed upon the graph model

dfs

public void dfs(java.lang.Object parent,
                java.lang.Object root,
                java.lang.Object previousSibling,
                JGraphFacade.CellVisitor visitor,
                java.util.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

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

dfs

public void dfs(java.lang.Object parent,
                java.lang.Object root,
                java.lang.Object previousSibling,
                JGraphFacade.CellVisitor visitor,
                java.util.Set seen,
                java.util.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

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

bfs

public void bfs(java.lang.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.

Parameters:
visitor - the visitor that defines the operations to be performed upon the graph model

findTreeRoots

public void findTreeRoots()
Utility method to update the array of tree roots in a graph. This sets all cells that have no incoming and one or more outgoing edges, or the cell with the largest difference between outgoing and incoming edges if no root cells exist.


isOrdered

public boolean isOrdered()
Returns:
Returns the ordered.

setOrdered

public void setOrdered(boolean ordered)
Parameters:
ordered - The ordered to set.

setLoggerLevel

public void setLoggerLevel(java.util.logging.Level level)
Sets the logging level of this class

Parameters:
level - the logging level to set

JGraph
v5.13.0.4


Copyright (C) 2001-2009 JGraph Ltd. All rights reserved.