org.jgraph.graph

Class GraphLayoutCache

public class GraphLayoutCache extends Object implements CellMapper, Serializable

An object that defines the view of a graphmodel. This object maps between model cells and views and provides a set of methods to change these views. The view may also contain its own set of attributes and is therefore an extension of an Observable, which may be observed by the GraphUI. It uses the model to send its changes to the command history.
Nested Class Summary
classGraphLayoutCache.GraphLayoutCacheEdit
An implementation of GraphLayoutCacheChange.
Field Summary
protected booleanallAttributesLocal
Controls if all attributes are local.
protected booleanautoSizeOnValueChange
True if the cells should be auto-sized when their values change.
protected doublecollapseXScale
Specified the initial x- and y-scaling factor for initial collapsed group bounds.
protected doublecollapseYScale
Specified the initial x- and y-scaling factor for initial collapsed group bounds.
protected CellViewFactoryfactory
Factory to create the views.
protected GraphModelgraphModel
Reference to the graphModel
protected MaphiddenMapping
Maps cells to views.
protected booleanhidesDanglingConnections
Boolean indicating whether existing connections should be hidden if their source or target port is removed from the model.
protected booleanhidesExistingConnections
Boolean indicating whether existing connections should be hidden if their source or target and no parent of the ports is visible, either by hiding the cell or by changing the source or target of the edge to a hidden cell.
protected EventListenerListlistenerList
The list of listeners that listen to the GraphLayoutCache.
protected SetlocalAttributes
A set containing all attribute keys that are stored in the cell views, in other words, the view-local attributes.
protected Mapmapping
Maps cells to views.
protected booleanmovesChildrenOnExpand
Boolean indicating whether children should be moved to the parent group's origin on expand.
protected booleanmovesParentsOnCollapse
Boolean indicating whether parents should be moved to the child area origin on collapse.
protected booleanpartial
Only portions of the model are visible.
protected PortView[]ports
Cached array of all ports for the view.
protected booleanreconnectsEdgesToVisibleParent
Boolean indicating whether edges should be reconneted to visible parents on collapse/expand.
protected booleanremembersCellViews
Boolean indicating whether cellviews should be remembered once visible in this GraphLayoutCache.
protected booleanresizesParentsOnCollapse
Boolean indicating whether parents should always be resized to the child area on collapse.
protected Listroots
Ordered list of roots for the view.
protected booleanselectsAllInsertedCells
Boolean indicating whether inserted cells should automatically be selected.
protected booleanselectsLocalInsertedCells
Boolean indicating whether cells that are inserted using the local insert method should automatically be selected.
protected booleanshowsChangedConnections
Boolean indicating whether connections should be made visible when reconnected and their source and target port is visible.
protected booleanshowsExistingConnections
Boolean indicating whether existing connections should me made visible if their sources or targets are made visible, given the opposite end of the edge is already visible or made visible, too.
protected booleanshowsInsertedCells
Boolean indicating whether inserted should be made visible if they are inserted via (Object[], Map, ConnectionSet, ParentMap, UndoableEdit[]).
protected booleanshowsInsertedConnections
Boolean indicating whether inserted edges should me made visible if their sources or targets are already visible.
protected booleanshowsInvisibleEditedCells
Boolean indicating whether edited cells should be made visible if they are changed via (Map, ConnectionSet, ParentMap, UndoableEdit[]).
protected SetvisibleSet
The set of visible cells.
Constructor Summary
GraphLayoutCache()
Constructs a graph layout cache.
GraphLayoutCache(GraphModel model, CellViewFactory factory)
Constructs a view for the specified model that uses factory to create its views.
GraphLayoutCache(GraphModel model, CellViewFactory factory, boolean partial)
Constructs a view for the specified model that uses factory to create its views.
GraphLayoutCache(GraphModel model, CellViewFactory factory, CellView[] cellViews, CellView[] hiddenCellViews, boolean partial)
Constructs a view for the specified model that uses factory to create its views.
Method Summary
voidaddGraphLayoutCacheListener(GraphLayoutCacheListener l)
Adds a listener for the GraphLayoutCacheEvent posted after the graph layout cache changes.
protected Object[]addVisibleDependencies(Object[] cells, boolean visible)
protected UndoableEdit[]augment(UndoableEdit[] e, UndoableEdit edit)
protected voidaugmentNestedMapForValueChange(Map nested, Object cell, Object newValue)
Hook for subclassers to add more stuff for value changes.
protected voidcellExpanded(Object cell)
Called when a child has been made visible by expanding its parent.
voidcellViewsChanged(CellView[] cellViews)
Invoke this method after you've changed how the cells are to be represented in the graph.
protected voidcellWillCollapse(Object cell)
voidcollapse(Object[] groups)
Collapses all groups by hiding all their descendants.
protected GraphLayoutCache.GraphLayoutCacheEditcreateLocalEdit(Object[] inserted, Map nested, Object[] visible, Object[] invisible)
Creates a local edit for the specified change.
MapcreateNestedMap()
Returns a nested map of (cell, map) pairs that represent all attributes of all cell views in this view.
voidedit(Map attributes, ConnectionSet cs, ParentMap pm, UndoableEdit[] e)
Applies the propertyMap and the connection changes to the model.
voidedit(Map attributes)
A shortcut method that takes a nested map and passes it to the edit method.
voidedit(Object[] cells, Map attributes)
Applies the attributes to all cells by creating a map that contains the attributes for each cell and passing it to edit on this layout cache.
voideditCell(Object cell, Map attributes)
Applies the attributes to a single cell by creating a map that contains the attributes for this cell and passing it to edit on this layout cache.
voidexpand(Object[] cells)
Expands all groups by showing all children.
protected voidfireGraphLayoutCacheChanged(Object source, GraphLayoutCacheEvent.GraphLayoutCacheChange edit)
CellView[]getAllDescendants(CellView[] views)
Returns all views, including descendants that have a parent in views, especially the PortViews.
CellView[]getAllViews()
Returns all views, shortcut to getAllDescendants(getRoots())
static Rectangle2DgetBounds(CellView[] views)
Returns the bounding box for the specified cell views.
Object[]getCells(boolean groups, boolean vertices, boolean ports, boolean edges)
A helper method to return various arrays of cells that are visible in this cache.
Object[]getCells(CellView[] views)
Takes an array of views and returns the array of the corresponding cells by using getCell for each view.
CellView[]getCellViews()
protected ObjectgetChildPort(Object edge, boolean source)
Hook for subclassers to return the port to be used for edges that have been connected to the group.
doublegetCollapseXScale()
doublegetCollapseYScale()
protected Object[]getContext(GraphModelEvent.GraphModelChange change)
Hook for subclassers to augment the context for a graphChange.
protected ListgetEdges(Object cell, Set exclude, boolean visibleCells, boolean selfLoops, boolean incoming)
Returns the incoming or outgoing edges for cell.
CellViewFactorygetFactory()
Returns the factory that was passed to the constructor.
GraphLayoutCacheListener[]getGraphLayoutCacheListeners()
Return an array of all GraphLayoutCacheListener that were added to this model.
CellView[]getHiddenCellViews()
MapgetHiddenMapping()
Returns the hiddenMapping.
ListgetIncomingEdges(Object cell, Set exclude, boolean visibleCells, boolean selfLoops)
Returns the incoming edges for cell.
SetgetLocalAttributes()
CellViewgetMapping(Object cell, boolean create)
Returns the view for the specified cell.
CellView[]getMapping(Object[] cells)
Returns the views for the specified array of cells without creating these views on the fly.
CellView[]getMapping(Object[] cells, boolean create)
Returns the views for the specified array of cells.
GraphModelgetModel()
Returns the current model.
ListgetNeighbours(Object cell, Set exclude, boolean directed, boolean visibleCells)
Returns a collection of cells that are connected to the specified cell by edges.
ListgetOutgoingEdges(Object cell, Set exclude, boolean visibleCells, boolean selfLoops)
Returns the outgoing edges for cell.
protected ObjectgetParentPort(Object edge, boolean source)
Hook for subclassers to return the first or last visible port to replace the current source or target port of the edge.
protected CollectiongetParentPorts(Object cell)
booleangetPartial()
Required for XML persistence
PortView[]getPorts()
Returns the ports of the view.
protected CollectiongetPorts(Object cell)
CellView[]getRoots()
Returns the roots of the view.
CellView[]getRoots(Rectangle2D clip)
Return all root cells that intersect the given rectangle.
Object[]getVisibleCells(Object[] cells)
Returns a an array with the visible cells in cells.
SetgetVisibleSet()
Returns the set of visible sets in this view.
voidgraphChanged(GraphModelEvent.GraphModelChange change)
Called from BasicGraphUI.ModelHandler to update the view based on the specified GraphModelEvent.
protected MaphandleAttributes(Map attributes)
Attention: Undo will not work for routing-change if ROUTING and POINTS are stored in different locations.
protected booleanhasVisibleParent(Object cell, Set invisible)
Checks if the port or one of its parents is visible.
voidhideCells(Object[] cells, boolean descandants)
Hides the specified cells with all children if descandants is true.
protected voidhideCellsForChange(GraphModelEvent.GraphModelChange change)
voidinsert(Object[] roots, Map attributes, ConnectionSet cs, ParentMap pm, UndoableEdit[] e)
Inserts the cells and connections into the model, and absorbs the local attributes.
voidinsert(Object cell)
Inserts the specified vertex into the graph model.
voidinsert(Object[] cells)
Inserts the specified cells into the graph model.
voidinsert(Object[] cells, Map nested, ConnectionSet cs, ParentMap pm)
Variant of the insert method that allows to pass a default connection set and parent map and nested map.
Object[]insertClones(Object[] cells, Map clones, Map nested, ConnectionSet cs, ParentMap pm, double dx, double dy)
Inserts the cloned cells from the clone map and clones the passed-in arguments according to the clone map before insertion and returns the clones in order of the cells.
voidinsertEdge(Object edge, Object source, Object target)
Inserts the specified edge into the graph model.
voidinsertGroup(Object group, Object[] children)
Inserts the specified cell as a parent of children.
voidinsertViews(CellView[] views)
Adds the specified model root cells to the view.
booleanisAllAttributesLocal()
booleanisAutoSizeOnValueChange()
Returns true if cells should be auto-sized when their values change
protected booleanisControlAttribute(Object cell, Object key, Object value)
Returns true if key is a control attribute
booleanisHidesDanglingConnections()
Returns the hidesDanglingConnections.
booleanisHidesExistingConnections()
Returns the hidesExistingConnections.
protected booleanisLocalAttribute(Object cell, Object key, Object value)
Returns true if the set of local attributes contains key
booleanisMovesChildrenOnExpand()
booleanisMovesParentsOnCollapse()
booleanisPartial()
booleanisReconnectsEdgesToVisibleParent()
booleanisRemembersCellViews()
Returns the remembersCellViews.
booleanisResizesParentsOnCollapse()
booleanisSelectsAllInsertedCells()
booleanisSelectsLocalInsertedCells()
booleanisShowsChangedConnections()
booleanisShowsExistingConnections()
Returns the showsExistingConnections.
booleanisShowsInsertedConnections()
Returns the showsInsertedConnections.
booleanisShowsInvisibleEditedCells()
booleanisVisible(Object cell)
Whether or not the specified cell is visible.
voidputMapping(Object cell, CellView view)
Associates the specified model cell with the specified view.
voidrefresh(CellView[] views, boolean create)
voidrefresh(CellView view, boolean create)
voidreload()
Remaps all existing views using the CellViewFactory and replaces the respective root views.
protected voidreloadRoots()
Completely reloads all roots from the model in the order returned by DefaultGraphModel.getAll.
voidremove(Object[] cells)
Removes cells from the model.
voidremove(Object[] cells, boolean descendants, boolean edges)
Removes cells from the model, including all children and connected edges if children or edges is true, respectively.
CellView[]removeCells(Object[] cells)
Removes the specified model root cells from the view by removing the mapping between the cell and its view and makes the cells invisible.
voidremoveGraphLayoutCacheListener(GraphLayoutCacheListener l)
Removes a listener previously added with addGraphLayoutCacheListener() .
CellViewremoveMapping(Object cell)
Removes the association for the specified model cell and returns the view that was previously associated with the cell.
booleanremoveViewLocalAttribute(Object key, boolean addToModel, boolean override)
Handles the removal of view local attributes.
voidsetAllAttributesLocal(boolean allAttributesLocal)
voidsetAutoSizeOnValueChange(boolean flag)
Determines whether cells should be auto-sized when their values change.
voidsetCollapsedState(Object[] collapse, Object[] expand)
Collapses and/or expands the specified cell(s) NOTE: Your GraphLayoutCache must be partial (set partial to true in the constructor) in order to use the visibility functionality of expand/collapse, setVisible, etc.
voidsetCollapseXScale(double collapseXScale)
voidsetCollapseYScale(double collapseYScale)
voidsetFactory(CellViewFactory factory)
Sets the factory that creates the cell views.
voidsetHiddenSet(Map hiddenSet)
Sets the hiddenSet.
voidsetHidesDanglingConnections(boolean hidesDanglingConnections)
Sets the hidesDanglingConnections
voidsetHidesExistingConnections(boolean hidesExistingConnections)
Sets the hidesExistingConnections
voidsetLocalAttributes(Set localAttributes)
voidsetModel(GraphModel model)
Sets the current model.
voidsetMovesChildrenOnExpand(boolean moveChildrenOnExpand)
voidsetMovesParentsOnCollapse(boolean movesParentsOnCollapse)
voidsetReconnectsEdgesToVisibleParent(boolean reconnectsEdgesToVisibleParent)
voidsetRemembersCellViews(boolean rememberCellViews)
Sets the rememberCellViews.
voidsetResizesParentsOnCollapse(boolean resizesParentsOnCollapse)
voidsetSelectsAllInsertedCells(boolean selectsAllInsertedCells)
voidsetSelectsLocalInsertedCells(boolean selectsLocalInsertedCells)
voidsetShowsChangedConnections(boolean showsChangedConnections)
voidsetShowsExistingConnections(boolean showsExistingConnections)
Sets the showsExistingConnections
voidsetShowsInsertedConnections(boolean showsInsertedConnections)
Sets the showsInsertedConnections
voidsetShowsInvisibleEditedCells(boolean showsInvisibleEditedCells)
voidsetVisible(Object cell, boolean visible)
Makes the specified cell visible or invisible depending on the flag passed in.
voidsetVisible(Object[] cells, boolean visible)
Makes the specified cells visible or invisible depending on the flag passed in.
voidsetVisible(Object[] visible, Object[] invisible)
Changes the visibility state of the cells passed in.
voidsetVisible(Object[] visible, Object[] invisible, ConnectionSet cs)
Changes the visibility state of the cells passed in.
voidsetVisible(Object[] visible, Object[] invisible, Map attributes, ConnectionSet cs)
Changes the visibility state of the cells passed in.
booleansetVisibleImpl(Object[] cells, boolean visible)
The actual implementation of changing cells' visibility state.
voidsetVisibleSet(Set visible)
Applies the specified set of cells as being those visible
voidshowCells(Object[] cells, boolean descandants)
Shows the specified cells with all children if descandants is true.
protected voidshowCellsForChange(GraphModelEvent.GraphModelChange change)
voidtoBack(Object[] cells)
Sends cells to back.
voidtoFront(Object[] cells)
Brings cells to front.
voidtoggleCollapsedState(Object[] cells, boolean collapseOnly, boolean expandOnly)
Toggles the collapsed state of the specified cells.
static voidtranslateViews(CellView[] views, double dx, double dy)
Translates the specified views by the given amount.
Object[]ungroup(Object[] cells)
Ungroups all groups in cells and returns the children that are not ports.
voidupdate()
Sets the current model.
voidupdate(CellView[] views)
voidupdate(CellView view)
protected voidupdatePorts()
Updates the cached array of ports.
voidvalueForCellChanged(Object cell, Object newValue)
Messaged when the user has altered the value for the item identified by cell to newValue.

Field Detail

allAttributesLocal

protected boolean allAttributesLocal
Controls if all attributes are local. If this is false then the createLocalEdit will check the localAttributes set to see if a specific attribute is local, otherwise it will assume that all attributes are local. This allows to make all attributes local without actually knowing them. Default is false.

autoSizeOnValueChange

protected boolean autoSizeOnValueChange
True if the cells should be auto-sized when their values change. Default is false.

collapseXScale

protected double collapseXScale
Specified the initial x- and y-scaling factor for initial collapsed group bounds. Default is 1.0, ie. no scaling.

collapseYScale

protected double collapseYScale
Specified the initial x- and y-scaling factor for initial collapsed group bounds. Default is 1.0, ie. no scaling.

factory

protected CellViewFactory factory
Factory to create the views.

graphModel

protected GraphModel graphModel
Reference to the graphModel

hiddenMapping

protected transient Map hiddenMapping
Maps cells to views. The hidden mapping is used to remembed cell views that are hidden, based on the remembersCellViews setting. hiddenMapping must use weak keys for the cells since when cells are removed hiddenMapping is not updated.

hidesDanglingConnections

protected boolean hidesDanglingConnections
Boolean indicating whether existing connections should be hidden if their source or target port is removed from the model. Default is false.

hidesExistingConnections

protected boolean hidesExistingConnections
Boolean indicating whether existing connections should be hidden if their source or target and no parent of the ports is visible, either by hiding the cell or by changing the source or target of the edge to a hidden cell. Default is true.

listenerList

protected EventListenerList listenerList
The list of listeners that listen to the GraphLayoutCache.

localAttributes

protected Set localAttributes
A set containing all attribute keys that are stored in the cell views, in other words, the view-local attributes.

mapping

protected Map mapping
Maps cells to views.

movesChildrenOnExpand

protected boolean movesChildrenOnExpand
Boolean indicating whether children should be moved to the parent group's origin on expand. Default is true.

movesParentsOnCollapse

protected boolean movesParentsOnCollapse
Boolean indicating whether parents should be moved to the child area origin on collapse. Default is true.

partial

protected boolean partial
Only portions of the model are visible.

ports

protected PortView[] ports
Cached array of all ports for the view.

reconnectsEdgesToVisibleParent

protected boolean reconnectsEdgesToVisibleParent

Deprecated: edges are moved to parent view and back automatically

Boolean indicating whether edges should be reconneted to visible parents on collapse/expand. Default is false.

remembersCellViews

protected boolean remembersCellViews
Boolean indicating whether cellviews should be remembered once visible in this GraphLayoutCache. Default is true.

resizesParentsOnCollapse

protected boolean resizesParentsOnCollapse
Boolean indicating whether parents should always be resized to the child area on collapse. If false the size is only initially updated if it has not yet been assigned. Default is false.

roots

protected List roots
Ordered list of roots for the view.

selectsAllInsertedCells

protected boolean selectsAllInsertedCells
Boolean indicating whether inserted cells should automatically be selected. Default is true. This is ignored if the cache is partial. Note: Despite the name of this field the implementation is located in the BasicGraphUI.GraphModelHandler.graphChanged method.

selectsLocalInsertedCells

protected boolean selectsLocalInsertedCells
Boolean indicating whether cells that are inserted using the local insert method should automatically be selected. Default is true. This is ignored if the cache is not partial and selectsAllInsertedCells is true, in which case the cells will be selected through another mechanism. Note: Despite the name of this field the implementation is located in the BasicGraphUI.GraphLayoutCacheObserver.changed method.

showsChangedConnections

protected boolean showsChangedConnections
Boolean indicating whether connections should be made visible when reconnected and their source and target port is visible. Default is true.

showsExistingConnections

protected boolean showsExistingConnections
Boolean indicating whether existing connections should me made visible if their sources or targets are made visible, given the opposite end of the edge is already visible or made visible, too. Default is true.

showsInsertedCells

protected boolean showsInsertedCells
Boolean indicating whether inserted should be made visible if they are inserted via (Object[], Map, ConnectionSet, ParentMap, UndoableEdit[]). Default is true.

showsInsertedConnections

protected boolean showsInsertedConnections
Boolean indicating whether inserted edges should me made visible if their sources or targets are already visible. Default is true.

showsInvisibleEditedCells

protected boolean showsInvisibleEditedCells
Boolean indicating whether edited cells should be made visible if they are changed via (Map, ConnectionSet, ParentMap, UndoableEdit[]). Default is false.

visibleSet

protected Set visibleSet
The set of visible cells.

Constructor Detail

GraphLayoutCache

public GraphLayoutCache()
Constructs a graph layout cache.

GraphLayoutCache

public GraphLayoutCache(GraphModel model, CellViewFactory factory)
Constructs a view for the specified model that uses factory to create its views.

Parameters: model the model that constitues the data source

GraphLayoutCache

public GraphLayoutCache(GraphModel model, CellViewFactory factory, boolean partial)
Constructs a view for the specified model that uses factory to create its views.

Parameters: model the model that constitues the data source

GraphLayoutCache

public GraphLayoutCache(GraphModel model, CellViewFactory factory, CellView[] cellViews, CellView[] hiddenCellViews, boolean partial)
Constructs a view for the specified model that uses factory to create its views.

Parameters: model the model that constitues the data source

Method Detail

addGraphLayoutCacheListener

public void addGraphLayoutCacheListener(GraphLayoutCacheListener l)
Adds a listener for the GraphLayoutCacheEvent posted after the graph layout cache changes.

Parameters: l the listener to add

See Also: GraphLayoutCache

addVisibleDependencies

protected Object[] addVisibleDependencies(Object[] cells, boolean visible)

augment

protected UndoableEdit[] augment(UndoableEdit[] e, UndoableEdit edit)

augmentNestedMapForValueChange

protected void augmentNestedMapForValueChange(Map nested, Object cell, Object newValue)
Hook for subclassers to add more stuff for value changes. Currently this adds the new value to the change.

cellExpanded

protected void cellExpanded(Object cell)
Called when a child has been made visible by expanding its parent. This implementation translates the child so that it reflects the offset of the parent group since the child was last visible (see movesChildrenOnExpand).

cellViewsChanged

public void cellViewsChanged(CellView[] cellViews)
Invoke this method after you've changed how the cells are to be represented in the graph.

cellWillCollapse

protected void cellWillCollapse(Object cell)

collapse

public void collapse(Object[] groups)
Collapses all groups by hiding all their descendants. NOTE: Your GraphLayoutCache must be partial (set partial to true in the constructor) in order to use the visibility functionality of expand/collapse, setVisible, etc.

Parameters: groups

createLocalEdit

protected GraphLayoutCache.GraphLayoutCacheEdit createLocalEdit(Object[] inserted, Map nested, Object[] visible, Object[] invisible)
Creates a local edit for the specified change. A local operation contains all visibility changes, as well as all changes to attributes that are local, and all control attributes.
Note: You must use cells as keys for the nested map, not cell views.

createNestedMap

public Map createNestedMap()
Returns a nested map of (cell, map) pairs that represent all attributes of all cell views in this view.

See Also: GraphLayoutCache

edit

public void edit(Map attributes, ConnectionSet cs, ParentMap pm, UndoableEdit[] e)
Applies the propertyMap and the connection changes to the model. The initial edits that triggered the call are considered to be part of this transaction. Notifies the model- and undo listeners of the change. Note: The passed in attributes may contain PortViews.

edit

public void edit(Map attributes)
A shortcut method that takes a nested map and passes it to the edit method.

edit

public void edit(Object[] cells, Map attributes)
Applies the attributes to all cells by creating a map that contains the attributes for each cell and passing it to edit on this layout cache. Example:
 Map attrs = new java.util.Hashtable();
 GraphConstants.setBackground(attrs, Color.RED);
 graph.getGraphLayoutCache().edit(graph.getSelectionCells(), attrs);
 

editCell

public void editCell(Object cell, Map attributes)
Applies the attributes to a single cell by creating a map that contains the attributes for this cell and passing it to edit on this layout cache. Example:
 Map attrs = new java.util.Hashtable();
 GraphConstants.setBackground(attrs, Color.RED);
 graph.getGraphLayoutCache().editCell(graph.getSelectionCell(), attrs);
 

expand

public void expand(Object[] cells)
Expands all groups by showing all children. (Note: This does not show all descandants, but only the first generation of children.) NOTE: Your GraphLayoutCache must be partial (set partial to true in the constructor) in order to use the visibility functionality of expand/collapse, setVisible, etc.

fireGraphLayoutCacheChanged

protected void fireGraphLayoutCacheChanged(Object source, GraphLayoutCacheEvent.GraphLayoutCacheChange edit)

getAllDescendants

public CellView[] getAllDescendants(CellView[] views)
Returns all views, including descendants that have a parent in views, especially the PortViews. Note: Iterative Implementation using model.getChild and getMapping on this cell mapper.

getAllViews

public CellView[] getAllViews()
Returns all views, shortcut to getAllDescendants(getRoots())

getBounds

public static Rectangle2D getBounds(CellView[] views)
Returns the bounding box for the specified cell views.

getCells

public Object[] getCells(boolean groups, boolean vertices, boolean ports, boolean edges)
A helper method to return various arrays of cells that are visible in this cache. For example, to get all selected vertices in a graph, do graph.getSelectionCells(graph.getGraphLayoutCache().getCells(false, true, false, false));

getCells

public Object[] getCells(CellView[] views)
Takes an array of views and returns the array of the corresponding cells by using getCell for each view.

getCellViews

public CellView[] getCellViews()

Returns: Returns an unordered array of all visible cellviews.

getChildPort

protected Object getChildPort(Object edge, boolean source)
Hook for subclassers to return the port to be used for edges that have been connected to the group. This is called from expand. This returns the first port of the first or last vertex depending on source.

getCollapseXScale

public double getCollapseXScale()

Returns: Returns the collapseXScale.

getCollapseYScale

public double getCollapseYScale()

Returns: Returns the collapseYScale.

getContext

protected Object[] getContext(GraphModelEvent.GraphModelChange change)
Hook for subclassers to augment the context for a graphChange. This means you can add additional cells that should be refreshed on a special change event. eg. parallel edges when one is removed or added.

getEdges

protected List getEdges(Object cell, Set exclude, boolean visibleCells, boolean selfLoops, boolean incoming)
Returns the incoming or outgoing edges for cell. Cell should be a port or a vertex.

Parameters: cell The cell from which the 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 incoming true if incoming edges are to be obtained, false if outgoing edges are to be obtained

Returns: Returns the list of incoming or outgoing edges for cell

getFactory

public CellViewFactory getFactory()
Returns the factory that was passed to the constructor.

getGraphLayoutCacheListeners

public GraphLayoutCacheListener[] getGraphLayoutCacheListeners()
Return an array of all GraphLayoutCacheListener that were added to this model.

getHiddenCellViews

public CellView[] getHiddenCellViews()

Returns: Returns an unordered array of all hidden cellviews.

getHiddenMapping

public Map getHiddenMapping()
Returns the hiddenMapping.

Returns: Map

getIncomingEdges

public List getIncomingEdges(Object cell, 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

getLocalAttributes

public Set getLocalAttributes()

Returns: Returns the localAttributes.

getMapping

public CellView getMapping(Object cell, boolean create)
Returns the view for the specified cell. If create is true and no view is found then a view is created using createView(Object).

getMapping

public CellView[] getMapping(Object[] cells)
Returns the views for the specified array of cells without creating these views on the fly.

getMapping

public CellView[] getMapping(Object[] cells, boolean create)
Returns the views for the specified array of cells. Returned array may contain null pointers if the respective cell is not mapped in this view and create is false.

getModel

public GraphModel getModel()
Returns the current model.

getNeighbours

public List getNeighbours(Object cell, Set exclude, boolean directed, boolean visibleCells)
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 directed whether or not direction of edges should be taken into account visibleCells whether or not to only consider visible cells

Returns: Returns the list of neighbours for cell

getOutgoingEdges

public List getOutgoingEdges(Object cell, 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

getParentPort

protected Object getParentPort(Object edge, boolean source)
Hook for subclassers to return the first or last visible port to replace the current source or target port of the edge. This is called when groups are collapsed for the edges that cross the group, ie. go from a child cell to a cell which is outside the group. This implementation returns the first port of the parent group if source is true, otherwise it returns the last port of the parent group.

getParentPorts

protected Collection getParentPorts(Object cell)

getPartial

public boolean getPartial()
Required for XML persistence

Returns: whether or not the cache is partial

getPorts

public PortView[] getPorts()
Returns the ports of the view.

getPorts

protected Collection getPorts(Object cell)

getRoots

public CellView[] getRoots()
Returns the roots of the view.

getRoots

public CellView[] getRoots(Rectangle2D clip)
Return all root cells that intersect the given rectangle.

getVisibleCells

public Object[] getVisibleCells(Object[] cells)
Returns a an array with the visible cells in cells.

getVisibleSet

public Set getVisibleSet()
Returns the set of visible sets in this view.

Returns: the set of visible sets in this view.

graphChanged

public void graphChanged(GraphModelEvent.GraphModelChange change)
Called from BasicGraphUI.ModelHandler to update the view based on the specified GraphModelEvent.

handleAttributes

protected Map handleAttributes(Map attributes)
Attention: Undo will not work for routing-change if ROUTING and POINTS are stored in different locations. This happens if the model holds the routing attribute and the routing changes from unrouted to routed. In this case the points in the view are already routed according to the new scheme when written to the command history (-> no undo).

hasVisibleParent

protected boolean hasVisibleParent(Object cell, Set invisible)
Checks if the port or one of its parents is visible.

hideCells

public void hideCells(Object[] cells, boolean descandants)
Hides the specified cells with all children if descandants is true. NOTE: Your GraphLayoutCache must be partial (set partial to true in the constructor) in order to use the visibility functionality of expand/collapse, setVisible, etc.

hideCellsForChange

protected void hideCellsForChange(GraphModelEvent.GraphModelChange change)

insert

public void insert(Object[] roots, Map attributes, ConnectionSet cs, ParentMap pm, UndoableEdit[] e)
Inserts the cells and connections into the model, and absorbs the local attributes. This implementation sets the inserted cells visible and selects the new roots depending on graph.selectNewCells.

insert

public void insert(Object cell)
Inserts the specified vertex into the graph model. This method does in fact nothing, it calls insert edge with the vertex and the source and target port set to null. This example shows how to add a vertex with a port and a black border:
 DefaultGraphCell vertex = new DefaultGraphCell("Hello, world!");
 Map attrs = vertex.getAttributes();
 GraphConstants.setOpaque(attrs, false);
 GraphConstants.setBorderColor(attrs, Color.black);
 DefaultPort port = new DefaultPort();
 vertex.add(port);
 port.setParent(vertex);
 graph.getGraphLayoutCache().insert(vertex);
 

Parameters: cell inserts the specified cell in the cache

insert

public void insert(Object[] cells)
Inserts the specified cells into the graph model. This method is a general implementation of cell insertion. If the source and target port are null, then no connection set is created. The method uses the attributes from the specified edge and the egdge's children to construct the insert call. This example shows how to insert an edge with a special arrow between two known vertices:
 Object source = graph.getDefaultPortForCell(sourceVertex).getCell();
 Object target = graph.getDefaultPortForCell(targetVertex).getCell();
 DefaultEdge edge = new DefaultEdge("Hello, world!");
 edge.setSource(source);
 edge.setTarget(target);
 Map attrs = edge.getAttributes();
 GraphConstants.setLineEnd(attrs, GraphConstants.ARROW_TECHNICAL);
 graph.getGraphLayoutCache().insert(edge);
 

insert

public void insert(Object[] cells, Map nested, ConnectionSet cs, ParentMap pm)
Variant of the insert method that allows to pass a default connection set and parent map and nested map.

insertClones

public Object[] insertClones(Object[] cells, Map clones, Map nested, ConnectionSet cs, ParentMap pm, double dx, double dy)
Inserts the cloned cells from the clone map and clones the passed-in arguments according to the clone map before insertion and returns the clones in order of the cells. This example shows how to clone the current selection and get a reference to the clones:
 Object[] cells = graph.getDescendants(graph.order(graph.getSelectionCells()));
 ConnectionSet cs = ConnectionSet.create(graphModel, cells, false);
 ParentMap pm = ParentMap.create(graphModel, cells, false, true);
 cells = graphLayoutCache.insertClones(cells, graph.cloneCells(cells),
 		attributes, cs, pm, 0, 0);
 

insertEdge

public void insertEdge(Object edge, Object source, Object target)
Inserts the specified edge into the graph model. This method does in fact nothing, it calls insert with a default connection set.

Parameters: edge the edge to be inserted source the source port this edge is connected to target the target port this edge is connected to

insertGroup

public void insertGroup(Object group, Object[] children)
Inserts the specified cell as a parent of children. Note: All cells that are not yet in the model will be inserted. This example shows how to group the current selection and pass the group default bounds in case it is later collapsed:
 DefaultGraphCell group = new DefaultGraphCell("Hello, world!");
 Object[] cells = DefaultGraphModel.order(graph.getModel(), graph
 		.getSelectionCells());
 Rectangle2D bounds = graph.getCellBounds(cells);
 if (bounds != null) {
 	bounds = new Rectangle2D.Double(bounds.getX() + bounds.getWidth() / 4,
 			bounds.getY() + bounds.getHeight() / 4, bounds.getWidth() / 2,
 			bounds.getHeight() / 2);
 	GraphConstants.setBounds(group.getAttributes(), bounds);
 }
 graph.getGraphLayoutCache().insertGroup(group, cells);
 

insertViews

public void insertViews(CellView[] views)
Adds the specified model root cells to the view. Do not add a view that is already in roots.

isAllAttributesLocal

public boolean isAllAttributesLocal()

Returns: Returns the askLocalAttribute.

isAutoSizeOnValueChange

public boolean isAutoSizeOnValueChange()
Returns true if cells should be auto-sized when their values change

Returns: true if cells should be auto-sized when their values change

isControlAttribute

protected boolean isControlAttribute(Object cell, Object key, Object value)
Returns true if key is a control attribute

isHidesDanglingConnections

public boolean isHidesDanglingConnections()
Returns the hidesDanglingConnections.

Returns: boolean

isHidesExistingConnections

public boolean isHidesExistingConnections()
Returns the hidesExistingConnections.

Returns: boolean

isLocalAttribute

protected boolean isLocalAttribute(Object cell, Object key, Object value)
Returns true if the set of local attributes contains key

isMovesChildrenOnExpand

public boolean isMovesChildrenOnExpand()

Returns: Returns the moveChildrenOnExpand.

isMovesParentsOnCollapse

public boolean isMovesParentsOnCollapse()

Returns: Returns the movesParentsOnCollapse.

isPartial

public boolean isPartial()

isReconnectsEdgesToVisibleParent

public boolean isReconnectsEdgesToVisibleParent()

Deprecated: edges are moved to parent view and back automatically

Returns: Returns the reconnectsEdgesToVisibleParent.

isRemembersCellViews

public boolean isRemembersCellViews()
Returns the remembersCellViews.

Returns: boolean

isResizesParentsOnCollapse

public boolean isResizesParentsOnCollapse()

Returns: Returns the resizesParentsOnCollapse.

isSelectsAllInsertedCells

public boolean isSelectsAllInsertedCells()

Returns: Returns the selectsAllInsertedCells.

isSelectsLocalInsertedCells

public boolean isSelectsLocalInsertedCells()

Returns: Returns the selectsLocalInsertedCells.

isShowsChangedConnections

public boolean isShowsChangedConnections()

Returns: Returns the showsChangedConnections.

isShowsExistingConnections

public boolean isShowsExistingConnections()
Returns the showsExistingConnections.

Returns: boolean

isShowsInsertedConnections

public boolean isShowsInsertedConnections()
Returns the showsInsertedConnections.

Returns: boolean

isShowsInvisibleEditedCells

public boolean isShowsInvisibleEditedCells()

isVisible

public boolean isVisible(Object cell)
Whether or not the specified cell is visible. NOTE: Your GraphLayoutCache must be partial (set partial to true in the constructor) in order to use the visibility functionality of expand/collapse, setVisible, etc. null is always visible

Parameters: cell the whose visibility to determine

Returns: whether or not the cell is visible

putMapping

public void putMapping(Object cell, CellView view)
Associates the specified model cell with the specified view.

refresh

public void refresh(CellView[] views, boolean create)

refresh

public void refresh(CellView view, boolean create)

reload

public void reload()
Remaps all existing views using the CellViewFactory and replaces the respective root views.

reloadRoots

protected void reloadRoots()
Completely reloads all roots from the model in the order returned by DefaultGraphModel.getAll. This uses the current visibleSet and mapping to fetch the cell views for the cells.

remove

public void remove(Object[] cells)
Removes cells from the model.

remove

public void remove(Object[] cells, boolean descendants, boolean edges)
Removes cells from the model, including all children and connected edges if children or edges is true, respectively.

Parameters: cells The cells to remove. descendants Whether to remove all descendants as well. edges Whether to remove all connected edges as well.

removeCells

public CellView[] removeCells(Object[] cells)
Removes the specified model root cells from the view by removing the mapping between the cell and its view and makes the cells invisible.

removeGraphLayoutCacheListener

public void removeGraphLayoutCacheListener(GraphLayoutCacheListener l)
Removes a listener previously added with addGraphLayoutCacheListener() .

Parameters: l the listener to remove

See Also: GraphLayoutCache

removeMapping

public CellView removeMapping(Object cell)
Removes the association for the specified model cell and returns the view that was previously associated with the cell. Updates the portlist if necessary.

removeViewLocalAttribute

public boolean removeViewLocalAttribute(Object key, boolean addToModel, boolean override)
Handles the removal of view local attributes. Since these attributes are only being stored in the view, the option is provided to copy the values for that key into the model. Without this, those values are lost.

Parameters: key the key of the view local attribute addToModel whether or not to move the attribute values to the graph model override whether or not to override the key's value in the model cell's attribute map if it exists

Returns: whether or not the operation completed sucessfully

setAllAttributesLocal

public void setAllAttributesLocal(boolean allAttributesLocal)

Parameters: allAttributesLocal The allAttributesLocal to set.

setAutoSizeOnValueChange

public void setAutoSizeOnValueChange(boolean flag)
Determines whether cells should be auto-sized when their values change. Fires a property change event if the new setting is different from the existing setting.

Parameters: flag a boolean value, true if cells should be auto-sized when their values change

setCollapsedState

public void setCollapsedState(Object[] collapse, Object[] expand)
Collapses and/or expands the specified cell(s) NOTE: Your GraphLayoutCache must be partial (set partial to true in the constructor) in order to use the visibility functionality of expand/collapse, setVisible, etc.

Parameters: collapse the cells to be collapsed expand the cells to be expanded

setCollapseXScale

public void setCollapseXScale(double collapseXScale)

Parameters: collapseXScale The collapseXScale to set.

setCollapseYScale

public void setCollapseYScale(double collapseYScale)

Parameters: collapseYScale The collapseYScale to set.

setFactory

public void setFactory(CellViewFactory factory)
Sets the factory that creates the cell views.

setHiddenSet

public void setHiddenSet(Map hiddenSet)
Sets the hiddenSet. NOTE: Your GraphLayoutCache must be partial (set partial to true in the constructor) in order to use the visibility functionality of expand/collapse, setVisible, etc.

Parameters: hiddenSet The hiddenSet to set

setHidesDanglingConnections

public void setHidesDanglingConnections(boolean hidesDanglingConnections)
Sets the hidesDanglingConnections

Parameters: hidesDanglingConnections

setHidesExistingConnections

public void setHidesExistingConnections(boolean hidesExistingConnections)
Sets the hidesExistingConnections

Parameters: hidesExistingConnections

setLocalAttributes

public void setLocalAttributes(Set localAttributes)

Parameters: localAttributes The localAttributes to set.

setModel

public void setModel(GraphModel model)
Sets the current model.

setMovesChildrenOnExpand

public void setMovesChildrenOnExpand(boolean moveChildrenOnExpand)

Parameters: moveChildrenOnExpand The moveChildrenOnExpand to set.

setMovesParentsOnCollapse

public void setMovesParentsOnCollapse(boolean movesParentsOnCollapse)

Parameters: movesParentsOnCollapse The movesParentsOnCollapse to set.

setReconnectsEdgesToVisibleParent

public void setReconnectsEdgesToVisibleParent(boolean reconnectsEdgesToVisibleParent)

Deprecated: edges are moved to parent view and back automatically

Parameters: reconnectsEdgesToVisibleParent The reconnectsEdgesToVisibleParent to set.

setRemembersCellViews

public void setRemembersCellViews(boolean rememberCellViews)
Sets the rememberCellViews.

Parameters: rememberCellViews The rememberCellViews to set

setResizesParentsOnCollapse

public void setResizesParentsOnCollapse(boolean resizesParentsOnCollapse)

Parameters: resizesParentsOnCollapse The resizesParentsOnCollapse to set.

setSelectsAllInsertedCells

public void setSelectsAllInsertedCells(boolean selectsAllInsertedCells)

Parameters: selectsAllInsertedCells The selectsAllInsertedCells to set.

setSelectsLocalInsertedCells

public void setSelectsLocalInsertedCells(boolean selectsLocalInsertedCells)

Parameters: selectsLocalInsertedCells The selectsLocalInsertedCells to set.

setShowsChangedConnections

public void setShowsChangedConnections(boolean showsChangedConnections)

Parameters: showsChangedConnections The showsChangedConnections to set.

setShowsExistingConnections

public void setShowsExistingConnections(boolean showsExistingConnections)
Sets the showsExistingConnections

Parameters: showsExistingConnections

setShowsInsertedConnections

public void setShowsInsertedConnections(boolean showsInsertedConnections)
Sets the showsInsertedConnections

Parameters: showsInsertedConnections

setShowsInvisibleEditedCells

public void setShowsInvisibleEditedCells(boolean showsInvisibleEditedCells)

setVisible

public void setVisible(Object cell, boolean visible)
Makes the specified cell visible or invisible depending on the flag passed in. Note the cell really is a cell, not a cell view. NOTE: Your GraphLayoutCache must be partial (set partial to true in the constructor) in order to use the visibility functionality of expand/collapse, setVisible, etc.

Parameters: cell the cell whose visibility is to be changed visible true if cell is to be made visible

setVisible

public void setVisible(Object[] cells, boolean visible)
Makes the specified cells visible or invisible depending on the flag passed in. Note the cells really are cells, not cell views. NOTE: Your GraphLayoutCache must be partial (set partial to true in the constructor) in order to use the visibility functionality of expand/collapse, setVisible, etc.

Parameters: cells the cells whose visibility is to be changed visible true if the cells are to be made visible

setVisible

public void setVisible(Object[] visible, Object[] invisible)
Changes the visibility state of the cells passed in. Note that the arrays must contain cells, not cell views. NOTE: Your GraphLayoutCache must be partial (set partial to true in the constructor) in order to use the visibility functionality of expand/collapse, setVisible, etc.

Parameters: visible cells to be made visible invisible cells to be made invisible

setVisible

public void setVisible(Object[] visible, Object[] invisible, ConnectionSet cs)
Changes the visibility state of the cells passed in. Note that the arrays must contain cells, not cell views. NOTE: Your GraphLayoutCache must be partial (set partial to true in the constructor) in order to use the visibility functionality of expand/collapse, setVisible, etc.

Parameters: visible cells to be made visible invisible cells to be made invisible cs a ConnectionSet describing the new state of edge connections in the graph

setVisible

public void setVisible(Object[] visible, Object[] invisible, Map attributes, ConnectionSet cs)
Changes the visibility state of the cells passed in. Note that the arrays must contain cells, not cell views. NOTE: Your GraphLayoutCache must be partial (set partial to true in the constructor) in order to use the visibility functionality of expand/collapse, setVisible, etc.

Parameters: visible cells to be made visible invisible cells to be made invisible attributes a nested attribute map of cells/attribute maps cs a ConnectionSet describing the new state of edge connections in the graph

setVisibleImpl

public boolean setVisibleImpl(Object[] cells, boolean visible)
The actual implementation of changing cells' visibility state. This method does not deal with creating the undo or updating the GraphLayoutCache correctly. The setVisible methods in this class are intended to be the main public way to change visiblilty. However, if you do not require the undo to be formed, this method is much quicker, just note that you must call updatePorts if this method returns true. NOTE: Your GraphLayoutCache must be partial (set partial to true in the constructor) in order to use the visibility functionality of expand/collapse, setVisible, etc.

Parameters: cells visible

Returns: whether or not the ports needed updating in the calling method

setVisibleSet

public void setVisibleSet(Set visible)
Applies the specified set of cells as being those visible

Parameters: visible the set of visible cells

showCells

public void showCells(Object[] cells, boolean descandants)
Shows the specified cells with all children if descandants is true. NOTE: Your GraphLayoutCache must be partial (set partial to true in the constructor) in order to use the visibility functionality of expand/collapse, setVisible, etc.

showCellsForChange

protected void showCellsForChange(GraphModelEvent.GraphModelChange change)

toBack

public void toBack(Object[] cells)
Sends cells to back. Note: This expects an array of cells!

toFront

public void toFront(Object[] cells)
Brings cells to front. Note: This expects an array of cells!

toggleCollapsedState

public void toggleCollapsedState(Object[] cells, boolean collapseOnly, boolean expandOnly)
Toggles the collapsed state of the specified cells. NOTE: Your GraphLayoutCache must be partial (set partial to true in the constructor) in order to use the visibility functionality of expand/collapse, setVisible, etc.

Parameters: cells The cells to toggle the collapsed state for. collapseOnly Whether cells should only be collapsed. expandOnly Whether cells should only be expanded.

translateViews

public static void translateViews(CellView[] views, double dx, double dy)
Translates the specified views by the given amount.

Parameters: views an array of cell view to each be translated dx the amount to translate the views in the x-axis dy the amount to translate the views in the x-axis

ungroup

public Object[] ungroup(Object[] cells)
Ungroups all groups in cells and returns the children that are not ports. Note: This replaces the parents with their group cells in the group structure.

update

public void update()
Sets the current model.

update

public void update(CellView[] views)

update

public void update(CellView view)

updatePorts

protected void updatePorts()
Updates the cached array of ports.

valueForCellChanged

public void valueForCellChanged(Object cell, Object newValue)
Messaged when the user has altered the value for the item identified by cell to newValue. If newValue signifies a truly new value the model should post a graphCellsChanged event. This calls augmentNestedMapForValueChange.
Copyright (C) 2001-2009 JGraph Ltd. All rights reserved.