| java.lang.Object
 org.jgraph.graph.GraphLayoutCache
| GraphLayoutCache | | public class GraphLayoutCache implements CellMapper,Serializable(Code) | | 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.
version:
1.0 1/1/02
author:
Gaudenz Alder |
| Field Summary | |
| protected boolean | allAttributesLocal
Controls if all attributes are local. | | protected boolean | autoSizeOnValueChange
True if the cells should be auto-sized when their values change. | | protected double | collapseXScalecollapseYScale
Specified the initial x- and y-scaling factor for initial collapsed group
bounds. | | protected CellViewFactory | factory
Factory to create the views. | | protected GraphModel | graphModel
| | protected transient Map | hiddenMapping
Maps cells to views. | | protected boolean | hidesDanglingConnections
Boolean indicating whether existing connections should be hidden if their
source or target port is removed from the model. | | 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. | | protected EventListenerList | listenerList
The list of listeners that listen to the model. | | protected Set | localAttributes
A set containing all attribute keys that are stored in the cell views, in
other words, the view-local attributes. | | protected Map | mapping
Maps cells to views. | | protected boolean | movesChildrenOnExpand
Boolean indicating whether children should be moved to the parent group's
origin on expand. | | protected boolean | movesParentsOnCollapse
Boolean indicating whether parents should be moved to the child area
origin on collapse. | | protected boolean | partial
Only portions of the model are visible. | | protected PortView[] | ports
Cached array of all ports for the view. | | protected boolean | reconnectsEdgesToVisibleParent
Boolean indicating whether edges should be reconneted to visible parents
on collapse/expand. | | protected boolean | remembersCellViews
Boolean indicating whether cellviews should be remembered once visible in
this GraphLayoutCache. | | protected boolean | resizesParentsOnCollapse
Boolean indicating whether parents should always be resized to the child
area on collapse. | | protected List | roots
Ordered list of roots for the view. | | protected boolean | selectsAllInsertedCells
Boolean indicating whether inserted cells should automatically be
selected. | | protected boolean | selectsLocalInsertedCells
Boolean indicating whether cells that are inserted using the local insert
method should automatically be selected. | | protected boolean | showsChangedConnections
Boolean indicating whether connections should be made visible when
reconnected and their source and target port is visible. | | 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. | | protected boolean | showsInsertedCells
Boolean indicating whether inserted should be made visible if they are
inserted via
GraphLayoutCache.insert(Object[],Map,ConnectionSet,ParentMap,UndoableEdit[]) . | | protected boolean | showsInsertedConnections
Boolean indicating whether inserted edges should me made visible if their
sources or targets are already visible. | | protected boolean | showsInvisibleEditedCells
Boolean indicating whether edited cells should be made visible if they
are changed via
GraphLayoutCache.edit(Map,ConnectionSet,ParentMap,UndoableEdit[]) . | | protected Set | visibleSet
The set of visible cells. |
| Method Summary | |
| public void | addGraphLayoutCacheListener(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 void | augmentNestedMapForValueChange(Map nested, Object cell, Object newValue)
Hook for subclassers to add more stuff for value changes. | | protected void | cellExpanded(Object cell)
Called when a child has been made visible by expanding its parent. | | public void | cellViewsChanged(CellView[] cellViews)
Invoke this method after you've changed how the cells are to be
represented in the graph. | | protected void | cellWillCollapse(Object cell)
| | public void | collapse(Object[] groups)
Collapses all groups by hiding all their descendants. | | protected GraphLayoutCacheEdit | createLocalEdit(Object[] inserted, Map nested, Object[] visible, Object[] invisible)
Creates a local edit for the specified change. | | public Map | createNestedMap()
Returns a nested map of (cell, map) pairs that represent all attributes
of all cell views in this view. | | public void | edit(Map attributes, ConnectionSet cs, ParentMap pm, UndoableEdit[] e)
Applies the propertyMap and the connection changes to the
model. | | public void | edit(Map attributes)
A shortcut method that takes a nested map and passes it to the edit
method. | | 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. | | 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. | | public void | expand(Object[] cells)
Expands all groups by showing all children. | | protected void | fireGraphLayoutCacheChanged(Object source, GraphLayoutCacheEvent.GraphLayoutCacheChange edit)
| | public CellView[] | getAllDescendants(CellView[] views)
Returns all views, including descendants that have a parent in
views, especially the PortViews. | | public CellView[] | getAllViews()
| | public static Rectangle2D | getBounds(CellView[] views)
Returns the bounding box for the specified cell views. | | public CellView[] | getCellViews()
| | 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. | | public Object[] | getCells(CellView[] views)
Takes an array of views and returns the array of the corresponding cells
by using getCell for each view. | | 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. | | public double | getCollapseXScale()
| | public double | getCollapseYScale()
| | protected Object[] | getContext(GraphModelEvent.GraphModelChange change)
Hook for subclassers to augment the context for a graphChange. | | protected List | getEdges(Object cell, Set exclude, boolean visibleCells, boolean selfLoops, boolean incoming)
Returns the incoming or outgoing edges for cell. | | public CellViewFactory | getFactory()
Returns the factory that was passed to the constructor. | | public GraphLayoutCacheListener[] | getGraphLayoutCacheListeners()
Return an array of all GraphLayoutCacheListener that were added to this
model. | | public CellView[] | getHiddenCellViews()
| | public Map | getHiddenMapping()
Returns the hiddenMapping. | | public List | getIncomingEdges(Object cell, Set exclude, boolean visibleCells, boolean selfLoops)
Returns the incoming edges for cell. | | public Set | getLocalAttributes()
| | public CellView | getMapping(Object cell, boolean create)
Returns the view for the specified cell. | | public CellView[] | getMapping(Object[] cells)
Returns the views for the specified array of cells without creating these
views on the fly. | | public CellView[] | getMapping(Object[] cells, boolean create)
Returns the views for the specified array of cells. | | public GraphModel | getModel()
Returns the current model. | | 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. | | public List | getOutgoingEdges(Object cell, Set exclude, boolean visibleCells, boolean selfLoops)
Returns the outgoing edges for cell. | | 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. | | protected Collection | getParentPorts(Object cell)
| | public boolean | getPartial()
| | public PortView[] | getPorts()
Returns the ports of the view. | | protected Collection | getPorts(Object cell)
| | public CellView[] | getRoots()
Returns the roots of the view. | | public CellView[] | getRoots(Rectangle2D clip)
Return all root cells that intersect the given rectangle. | | public Object[] | getVisibleCells(Object[] cells)
Returns a an array with the visible cells in cells. | | public Set | getVisibleSet()
| | public void | graphChanged(GraphModelEvent.GraphModelChange change)
Called from BasicGraphUI.ModelHandler to update the view based on the
specified GraphModelEvent. | | protected Map | handleAttributes(Map attributes)
Attention: Undo will not work for routing-change if ROUTING and POINTS
are stored in different locations. | | protected boolean | hasVisibleParent(Object cell, Set invisible)
Checks if the port or one of its parents is visible. | | public void | hideCells(Object[] cells, boolean descandants)
Hides the specified cells with all children if descandants
is true. | | protected void | hideCellsForChange(GraphModelEvent.GraphModelChange change)
| | 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. | | public void | insert(Object cell)
Inserts the specified vertex into the graph model. | | public void | insert(Object[] cells)
Inserts the specified cells into the graph model. | | 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. | | 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. | | public void | insertEdge(Object edge, Object source, Object target)
Inserts the specified edge into the graph model. | | public void | insertGroup(Object group, Object[] children)
Inserts the specified cell as a parent of children. | | public void | insertViews(CellView[] views)
Adds the specified model root cells to the view. | | public boolean | isAllAttributesLocal()
| | public boolean | isAutoSizeOnValueChange()
| | protected boolean | isControlAttribute(Object cell, Object key, Object value)
| | public boolean | isHidesDanglingConnections()
Returns the hidesDanglingConnections. | | public boolean | isHidesExistingConnections()
Returns the hidesExistingConnections. | | protected boolean | isLocalAttribute(Object cell, Object key, Object value)
| | public boolean | isMovesChildrenOnExpand()
| | public boolean | isMovesParentsOnCollapse()
| | public boolean | isPartial()
| | public boolean | isReconnectsEdgesToVisibleParent()
| | public boolean | isRemembersCellViews()
Returns the remembersCellViews. | | public boolean | isResizesParentsOnCollapse()
| | public boolean | isSelectsAllInsertedCells()
| | public boolean | isSelectsLocalInsertedCells()
| | public boolean | isShowsChangedConnections()
| | public boolean | isShowsExistingConnections()
Returns the showsExistingConnections. | | public boolean | isShowsInsertedConnections()
Returns the showsInsertedConnections. | | public boolean | isVisible(Object cell)
| | public void | putMapping(Object cell, CellView view)
Associates the specified model cell with the specified view. | | public void | refresh(CellView[] views, boolean create)
| | public void | refresh(CellView view, boolean create)
| | public synchronized void | reload()
Remaps all existing views using the CellViewFactory
and replaces the respective root views. | | protected void | reloadRoots()
Completely reloads all roots from the model in the order returned by
DefaultGraphModel.getAll. | | public void | remove(Object[] cells)
Removes cells from the model. | | 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. | | 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. | | public void | removeGraphLayoutCacheListener(GraphLayoutCacheListener l)
Removes a listener previously added with addGraphLayoutCacheListener()
. | | public CellView | removeMapping(Object cell)
Removes the associaten for the specified model cell and returns the view
that was previously associated with the cell. | | public boolean | removeViewLocalAttribute(Object key, boolean addToModel, boolean override)
Handles the removal of view local attributes. | | public void | setAllAttributesLocal(boolean allAttributesLocal)
| | public void | setAutoSizeOnValueChange(boolean flag)
Determines whether cells should be auto-sized when their values change. | | public void | setCollapseXScale(double collapseXScale)
| | public void | setCollapseYScale(double collapseYScale)
| | public void | setCollapsedState(Object[] collapse, Object[] expand)
| | public void | setFactory(CellViewFactory factory)
Sets the factory that creates the cell views. | | public void | setHiddenSet(Map hiddenSet)
Sets the hiddenSet. | | public void | setHidesDanglingConnections(boolean hidesDanglingConnections)
| | public void | setHidesExistingConnections(boolean hidesExistingConnections)
| | public void | setLocalAttributes(Set localAttributes)
| | public void | setModel(GraphModel model)
Sets the current model. | | public void | setMovesChildrenOnExpand(boolean moveChildrenOnExpand)
| | public void | setMovesParentsOnCollapse(boolean movesParentsOnCollapse)
| | public void | setReconnectsEdgesToVisibleParent(boolean reconnectsEdgesToVisibleParent)
| | public void | setRemembersCellViews(boolean rememberCellViews)
Sets the rememberCellViews. | | public void | setResizesParentsOnCollapse(boolean resizesParentsOnCollapse)
| | public void | setSelectsAllInsertedCells(boolean selectsAllInsertedCells)
| | public void | setSelectsLocalInsertedCells(boolean selectsLocalInsertedCells)
| | public void | setShowsChangedConnections(boolean showsChangedConnections)
| | public void | setShowsExistingConnections(boolean showsExistingConnections)
| | public void | setShowsInsertedConnections(boolean showsInsertedConnections)
| | public void | setVisible(Object cell, boolean visible)
Makes the specified cell visible or invisible depending on the flag
passed in. | | public void | setVisible(Object[] cells, boolean visible)
Makes the specified cells visible or invisible depending on the flag
passed in. | | public void | setVisible(Object[] visible, Object[] invisible)
Changes the visibility state of the cells passed in. | | public void | setVisible(Object[] visible, Object[] invisible, ConnectionSet cs)
Changes the visibility state of the cells passed in. | | public boolean | setVisibleImpl(Object[] cells, boolean visible)
The actual implementation of changing cells' visibility state. | | public void | setVisibleSet(Set visible)
| | public void | showCells(Object[] cells, boolean descandants)
Shows the specified cells with all children if descandants
is true. | | protected void | showCellsForChange(GraphModelEvent.GraphModelChange change)
| | public void | toBack(Object[] cells)
Sends cells to back. | | public void | toFront(Object[] cells)
Brings cells to front. | | public void | toggleCollapsedState(Object[] cells, boolean collapseOnly, boolean expandOnly)
Toggles the collapsed state of the specified cells. | | public static void | translateViews(CellView[] views, double dx, double dy)
Translates the specified views by the given amount. | | public Object[] | ungroup(Object[] cells)
Ungroups all groups in cells and returns the children that are not ports. | | public void | update(CellView[] views)
| | public void | update(CellView view)
| | protected void | updatePorts()
Updates the cached array of ports. | | public void | valueForCellChanged(Object cell, Object newValue)
Messaged when the user has altered the value for the item identified by
cell to newValue. |
| allAttributesLocal | | protected boolean allAttributesLocal(Code) | | 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(Code) | | True if the cells should be auto-sized when their values change. Default
is false.
|
| collapseXScalecollapseYScale | | protected double collapseXScalecollapseYScale(Code) | | Specified the initial x- and y-scaling factor for initial collapsed group
bounds. Default is 1.0, ie. no scaling.
|
| hiddenMapping | | protected transient Map hiddenMapping(Code) | | 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(Code) | | 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(Code) | | 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.
|
| localAttributes | | protected Set localAttributes(Code) | | A set containing all attribute keys that are stored in the cell views, in
other words, the view-local attributes.
|
| mapping | | protected Map mapping(Code) | | Maps cells to views.
|
| movesChildrenOnExpand | | protected boolean movesChildrenOnExpand(Code) | | Boolean indicating whether children should be moved to the parent group's
origin on expand. Default is true.
|
| movesParentsOnCollapse | | protected boolean movesParentsOnCollapse(Code) | | Boolean indicating whether parents should be moved to the child area
origin on collapse. Default is true.
|
| partial | | protected boolean partial(Code) | | Only portions of the model are visible.
|
| ports | | protected PortView[] ports(Code) | | Cached array of all ports for the view.
|
| reconnectsEdgesToVisibleParent | | protected boolean reconnectsEdgesToVisibleParent(Code) | | Boolean indicating whether edges should be reconneted to visible parents
on collapse/expand. Default is false.
|
| remembersCellViews | | protected boolean remembersCellViews(Code) | | Boolean indicating whether cellviews should be remembered once visible in
this GraphLayoutCache. Default is true.
|
| resizesParentsOnCollapse | | protected boolean resizesParentsOnCollapse(Code) | | 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(Code) | | Ordered list of roots for the view.
|
| selectsAllInsertedCells | | protected boolean selectsAllInsertedCells(Code) | | 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(Code) | | 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(Code) | | 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(Code) | | 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.
|
| showsInsertedConnections | | protected boolean showsInsertedConnections(Code) | | Boolean indicating whether inserted edges should me made visible if their
sources or targets are already visible. Default is true.
|
| visibleSet | | protected Set visibleSet(Code) | | The set of visible cells.
|
| GraphLayoutCache | | public GraphLayoutCache()(Code) | | Constructs a graph layout cache.
|
| GraphLayoutCache | | public GraphLayoutCache(GraphModel model, CellViewFactory factory)(Code) | | 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)(Code) | | 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)(Code) | | Constructs a view for the specified model that uses factory
to create its views.
Parameters:
model - the model that constitues the data source |
| addVisibleDependencies | | protected Object[] addVisibleDependencies(Object[] cells, boolean visible)(Code) | | |
| augmentNestedMapForValueChange | | protected void augmentNestedMapForValueChange(Map nested, Object cell, Object newValue)(Code) | | 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)(Code) | | 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
GraphLayoutCache.movesChildrenOnExpand ).
|
| cellViewsChanged | | public void cellViewsChanged(CellView[] cellViews)(Code) | | Invoke this method after you've changed how the cells are to be
represented in the graph.
|
| cellWillCollapse | | protected void cellWillCollapse(Object cell)(Code) | | |
| collapse | | public void collapse(Object[] groups)(Code) | | Collapses all groups by hiding all their descendants.
Parameters:
groups - |
| createLocalEdit | | protected GraphLayoutCacheEdit createLocalEdit(Object[] inserted, Map nested, Object[] visible, Object[] invisible)(Code) | | 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()(Code) | | Returns a nested map of (cell, map) pairs that represent all attributes
of all cell views in this view.
See Also: GraphLayoutCache.getCellViews |
| edit | | public void edit(Map attributes, ConnectionSet cs, ParentMap pm, UndoableEdit[] e)(Code) | | 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)(Code) | | A shortcut method that takes a nested map and passes it to the edit
method.
|
| edit | | public void edit(Object[] cells, Map attributes)(Code) | | 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)(Code) | | 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)(Code) | | Expands all groups by showing all children. (Note: This does not show all
descandants, but only the first generation of children.)
|
| getAllDescendants | | public CellView[] getAllDescendants(CellView[] views)(Code) | | 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()(Code) | | Returns all views, shortcut to getAllDescendants(getRoots())
|
| getCellViews | | public CellView[] getCellViews()(Code) | | Returns an unordered array of all visible cellviews. |
| getCells | | public Object[] getCells(boolean groups, boolean vertices, boolean ports, boolean edges)(Code) | | 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)(Code) | | Takes an array of views and returns the array of the corresponding cells
by using getCell for each view.
|
| getChildPort | | protected Object getChildPort(Object edge, boolean source)(Code) | | 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()(Code) | | Returns the collapseXScale. |
| getCollapseYScale | | public double getCollapseYScale()(Code) | | Returns the collapseYScale. |
| getContext | | protected Object[] getContext(GraphModelEvent.GraphModelChange change)(Code) | | 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)(Code) | | 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
Parameters:
exclude - The set of edges to ignore when searching
Parameters:
visibleCells - whether or not only visible cells should be processed
Parameters:
selfLoops - whether or not to include self loops in the returned list
Parameters:
incoming - true if incoming edges are to be obtained,false if outgoing edges are to be obtained Returns the list of incoming or outgoing edges forcell |
| getFactory | | public CellViewFactory getFactory()(Code) | | Returns the factory that was passed to the constructor.
|
| getGraphLayoutCacheListeners | | public GraphLayoutCacheListener[] getGraphLayoutCacheListeners()(Code) | | Return an array of all GraphLayoutCacheListener that were added to this
model.
|
| getHiddenCellViews | | public CellView[] getHiddenCellViews()(Code) | | Returns an unordered array of all hidden cellviews. |
| getHiddenMapping | | public Map getHiddenMapping()(Code) | | Returns the hiddenMapping.
Map |
| getIncomingEdges | | public List getIncomingEdges(Object cell, Set exclude, boolean visibleCells, boolean selfLoops)(Code) | | 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
Parameters:
exclude - The set of edges to ignore when searching
Parameters:
visibleCells - whether or not only visible cells should be processed
Parameters:
selfLoops - whether or not to include self loops in the returned list Returns the list of incoming edges for cell |
| getLocalAttributes | | public Set getLocalAttributes()(Code) | | Returns the localAttributes. |
| getMapping | | public CellView getMapping(Object cell, boolean create)(Code) | | 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)(Code) | | Returns the views for the specified array of cells without creating these
views on the fly.
|
| getMapping | | public CellView[] getMapping(Object[] cells, boolean create)(Code) | | 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.
|
| getNeighbours | | public List getNeighbours(Object cell, Set exclude, boolean directed, boolean visibleCells)(Code) | | 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
Parameters:
exclude - The set of cells to ignore when searching
Parameters:
directed - whether or not direction of edges should be taken into account
Parameters:
visibleCells - whether or not to only consider visible cells Returns the list of neighbours for cell |
| getOutgoingEdges | | public List getOutgoingEdges(Object cell, Set exclude, boolean visibleCells, boolean selfLoops)(Code) | | 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
Parameters:
exclude - The set of edges to ignore when searching
Parameters:
visibleCells - whether or not only visible cells should be processed
Parameters:
selfLoops - whether or not to include self loops in the returned list Returns the list of outgoing edges for cell |
| getParentPort | | protected Object getParentPort(Object edge, boolean source)(Code) | | 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.
|
| getPartial | | public boolean getPartial()(Code) | | Required for XML persistence
whether or not the cache is partial |
| getPorts | | public PortView[] getPorts()(Code) | | Returns the ports of the view.
|
| getRoots | | public CellView[] getRoots()(Code) | | Returns the roots of the view.
|
| getVisibleCells | | public Object[] getVisibleCells(Object[] cells)(Code) | | Returns a an array with the visible cells in cells.
|
| getVisibleSet | | public Set getVisibleSet()(Code) | | |
| handleAttributes | | protected Map handleAttributes(Map attributes)(Code) | | 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)(Code) | | Checks if the port or one of its parents is visible.
|
| hideCells | | public void hideCells(Object[] cells, boolean descandants)(Code) | | Hides the specified cells with all children if descandants
is true.
|
| insert | | public void insert(Object[] roots, Map attributes, ConnectionSet cs, ParentMap pm, UndoableEdit[] e)(Code) | | 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)(Code) | | 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)(Code) | | 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)(Code) | | 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)(Code) | | 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)(Code) | | 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
Parameters:
source - the source port this edge is connected to
Parameters:
target - the target port this edge is connected to |
| insertGroup | | public void insertGroup(Object group, Object[] children)(Code) | | 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)(Code) | | Adds the specified model root cells to the view. Do not add a view that
is already in roots.
|
| isAllAttributesLocal | | public boolean isAllAttributesLocal()(Code) | | Returns the askLocalAttribute. |
| isAutoSizeOnValueChange | | public boolean isAutoSizeOnValueChange()(Code) | | Returns true if cells should be auto-sized when their values change
true if cells should be auto-sized when their values change |
| isControlAttribute | | protected boolean isControlAttribute(Object cell, Object key, Object value)(Code) | | Returns true if key is a control attribute
|
| isHidesDanglingConnections | | public boolean isHidesDanglingConnections()(Code) | | Returns the hidesDanglingConnections.
boolean |
| isHidesExistingConnections | | public boolean isHidesExistingConnections()(Code) | | Returns the hidesExistingConnections.
boolean |
| isLocalAttribute | | protected boolean isLocalAttribute(Object cell, Object key, Object value)(Code) | | Returns true if the set of local attributes contains key
|
| isMovesChildrenOnExpand | | public boolean isMovesChildrenOnExpand()(Code) | | Returns the moveChildrenOnExpand. |
| isMovesParentsOnCollapse | | public boolean isMovesParentsOnCollapse()(Code) | | Returns the movesParentsOnCollapse. |
| isPartial | | public boolean isPartial()(Code) | | |
| isReconnectsEdgesToVisibleParent | | public boolean isReconnectsEdgesToVisibleParent()(Code) | | Returns the reconnectsEdgesToVisibleParent. |
| isRemembersCellViews | | public boolean isRemembersCellViews()(Code) | | Returns the remembersCellViews.
boolean |
| isResizesParentsOnCollapse | | public boolean isResizesParentsOnCollapse()(Code) | | Returns the resizesParentsOnCollapse. |
| isSelectsAllInsertedCells | | public boolean isSelectsAllInsertedCells()(Code) | | Returns the selectsAllInsertedCells. |
| isSelectsLocalInsertedCells | | public boolean isSelectsLocalInsertedCells()(Code) | | Returns the selectsLocalInsertedCells. |
| isShowsChangedConnections | | public boolean isShowsChangedConnections()(Code) | | Returns the showsChangedConnections. |
| isShowsExistingConnections | | public boolean isShowsExistingConnections()(Code) | | Returns the showsExistingConnections.
boolean |
| isShowsInsertedConnections | | public boolean isShowsInsertedConnections()(Code) | | Returns the showsInsertedConnections.
boolean |
| putMapping | | public void putMapping(Object cell, CellView view)(Code) | | Associates the specified model cell with the specified view.
|
| reload | | public synchronized void reload()(Code) | | Remaps all existing views using the CellViewFactory
and replaces the respective root views.
|
| reloadRoots | | protected void reloadRoots()(Code) | | 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)(Code) | | Removes cells from the model.
|
| remove | | public void remove(Object[] cells, boolean descendants, boolean edges)(Code) | | Removes cells from the model, including all children and connected edges
if children or edges is true, respectively.
Parameters:
cells - The cells to remove.
Parameters:
descendants - Whether to remove all descendants as well.
Parameters:
edges - Whether to remove all connected edges as well. |
| removeCells | | public CellView[] removeCells(Object[] cells)(Code) | | Removes the specified model root cells from the view by removing the
mapping between the cell and its view and makes the cells invisible.
|
| removeMapping | | public CellView removeMapping(Object cell)(Code) | | Removes the associaten 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)(Code) | | 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
Parameters:
addToModel - whether or not to move the attribute values to the graph model
Parameters:
override - whether or not to override the key's value in the model cell'sattribute map if it exists whether or not the operation completed sucessfully |
| setAllAttributesLocal | | public void setAllAttributesLocal(boolean allAttributesLocal)(Code) | |
Parameters:
allAttributesLocal - The allAttributesLocal to set. |
| setAutoSizeOnValueChange | | public void setAutoSizeOnValueChange(boolean flag)(Code) | | 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 theirvalues change |
| setCollapseXScale | | public void setCollapseXScale(double collapseXScale)(Code) | |
Parameters:
collapseXScale - The collapseXScale to set. |
| setCollapseYScale | | public void setCollapseYScale(double collapseYScale)(Code) | |
Parameters:
collapseYScale - The collapseYScale to set. |
| setCollapsedState | | public void setCollapsedState(Object[] collapse, Object[] expand)(Code) | | Collapses and/or expands the specified cell(s)
Parameters:
collapse - the cells to be collapsed
Parameters:
expand - the cells to be expanded |
| setFactory | | public void setFactory(CellViewFactory factory)(Code) | | Sets the factory that creates the cell views.
|
| setHiddenSet | | public void setHiddenSet(Map hiddenSet)(Code) | | Sets the hiddenSet.
Parameters:
hiddenSet - The hiddenSet to set |
| setHidesDanglingConnections | | public void setHidesDanglingConnections(boolean hidesDanglingConnections)(Code) | | Sets the hidesDanglingConnections
Parameters:
hidesDanglingConnections - |
| setHidesExistingConnections | | public void setHidesExistingConnections(boolean hidesExistingConnections)(Code) | | Sets the hidesExistingConnections
Parameters:
hidesExistingConnections - |
| setLocalAttributes | | public void setLocalAttributes(Set localAttributes)(Code) | |
Parameters:
localAttributes - The localAttributes to set. |
| setMovesChildrenOnExpand | | public void setMovesChildrenOnExpand(boolean moveChildrenOnExpand)(Code) | |
Parameters:
moveChildrenOnExpand - The moveChildrenOnExpand to set. |
| setMovesParentsOnCollapse | | public void setMovesParentsOnCollapse(boolean movesParentsOnCollapse)(Code) | |
Parameters:
movesParentsOnCollapse - The movesParentsOnCollapse to set. |
| setReconnectsEdgesToVisibleParent | | public void setReconnectsEdgesToVisibleParent(boolean reconnectsEdgesToVisibleParent)(Code) | |
Parameters:
reconnectsEdgesToVisibleParent - The reconnectsEdgesToVisibleParent to set. |
| setRemembersCellViews | | public void setRemembersCellViews(boolean rememberCellViews)(Code) | | Sets the rememberCellViews.
Parameters:
rememberCellViews - The rememberCellViews to set |
| setResizesParentsOnCollapse | | public void setResizesParentsOnCollapse(boolean resizesParentsOnCollapse)(Code) | |
Parameters:
resizesParentsOnCollapse - The resizesParentsOnCollapse to set. |
| setSelectsAllInsertedCells | | public void setSelectsAllInsertedCells(boolean selectsAllInsertedCells)(Code) | |
Parameters:
selectsAllInsertedCells - The selectsAllInsertedCells to set. |
| setSelectsLocalInsertedCells | | public void setSelectsLocalInsertedCells(boolean selectsLocalInsertedCells)(Code) | |
Parameters:
selectsLocalInsertedCells - The selectsLocalInsertedCells to set. |
| setShowsChangedConnections | | public void setShowsChangedConnections(boolean showsChangedConnections)(Code) | |
Parameters:
showsChangedConnections - The showsChangedConnections to set. |
| setShowsExistingConnections | | public void setShowsExistingConnections(boolean showsExistingConnections)(Code) | | Sets the showsExistingConnections
Parameters:
showsExistingConnections - |
| setShowsInsertedConnections | | public void setShowsInsertedConnections(boolean showsInsertedConnections)(Code) | | Sets the showsInsertedConnections
Parameters:
showsInsertedConnections - |
| setVisible | | public void setVisible(Object cell, boolean visible)(Code) | | Makes the specified cell visible or invisible depending on the flag
passed in. Note the cell really is a cell, not a cell view.
Parameters:
cell - the cell whose visibility is to be changed
Parameters:
visible - true if cell is to be made visible |
| setVisible | | public void setVisible(Object[] cells, boolean visible)(Code) | | Makes the specified cells visible or invisible depending on the flag
passed in. Note the cells really are cells, not cell views.
Parameters:
cells - the cells whose visibility is to be changed
Parameters:
visible - true if the cells are to be made visible |
| setVisible | | public void setVisible(Object[] visible, Object[] invisible)(Code) | | Changes the visibility state of the cells passed in. Note that the arrays
must contain cells, not cell views.
Parameters:
visible - cells to be made visible
Parameters:
invisible - cells to be made invisible |
| setVisible | | public void setVisible(Object[] visible, Object[] invisible, ConnectionSet cs)(Code) | | Changes the visibility state of the cells passed in. Note that the arrays
must contain cells, not cell views.
Parameters:
visible - cells to be made visible
Parameters:
invisible - cells to be made invisible
Parameters:
cs - a ConnectionSet describing the new state ofedge connections in the graph |
| setVisibleImpl | | public boolean setVisibleImpl(Object[] cells, boolean visible)(Code) | | 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.
Parameters:
cells -
Parameters:
visible - whether or not the ports needed updating in the calling method |
| setVisibleSet | | public void setVisibleSet(Set visible)(Code) | | |
| showCells | | public void showCells(Object[] cells, boolean descandants)(Code) | | Shows the specified cells with all children if descandants
is true.
|
| toBack | | public void toBack(Object[] cells)(Code) | | Sends cells to back. Note: This expects an array of cells!
|
| toFront | | public void toFront(Object[] cells)(Code) | | Brings cells to front. Note: This expects an array of
cells!
|
| toggleCollapsedState | | public void toggleCollapsedState(Object[] cells, boolean collapseOnly, boolean expandOnly)(Code) | | Toggles the collapsed state of the specified cells.
Parameters:
cells - The cells to toggle the collapsed state for.
Parameters:
collapseOnly - Whether cells should only be collapsed.
Parameters:
expandOnly - Whether cells should only be expanded. |
| translateViews | | public static void translateViews(CellView[] views, double dx, double dy)(Code) | | Translates the specified views by the given amount.
Parameters:
views - an array of cell view to each be translated
Parameters:
dx - the amount to translate the views in the x-axis
Parameters:
dy - the amount to translate the views in the x-axis |
| ungroup | | public Object[] ungroup(Object[] cells)(Code) | | 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.
|
| updatePorts | | protected void updatePorts()(Code) | | Updates the cached array of ports.
|
| valueForCellChanged | | public void valueForCellChanged(Object cell, Object newValue)(Code) | | 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.
|
|
|