Inheritance diagram for org.jgraph.graph.GraphLayoutCache:
Public Member Functions | |
GraphLayoutCache () | |
GraphLayoutCache (GraphModel model, CellViewFactory factory) | |
GraphLayoutCache (GraphModel model, CellViewFactory factory, boolean partial) | |
GraphLayoutCache (GraphModel model, CellViewFactory factory, CellView[] cellViews, CellView[] hiddenCellViews, boolean partial) | |
void | addGraphLayoutCacheListener (GraphLayoutCacheListener l) |
void | removeGraphLayoutCacheListener (GraphLayoutCacheListener l) |
void | cellViewsChanged (final CellView[] cellViews) |
GraphLayoutCacheListener[] | getGraphLayoutCacheListeners () |
void | setFactory (CellViewFactory factory) |
CellViewFactory | getFactory () |
void | setModel (GraphModel model) |
CellView[] | getCellViews () |
Object[] | getCells (boolean groups, boolean vertices, boolean ports, boolean edges) |
Map | createNestedMap () |
CellView[] | getHiddenCellViews () |
synchronized void | reload () |
GraphModel | getModel () |
CellView[] | getRoots () |
CellView[] | getRoots (Rectangle2D clip) |
Object[] | getVisibleCells (Object[] cells) |
PortView[] | getPorts () |
void | refresh (CellView[] views, boolean create) |
void | refresh (CellView view, boolean create) |
void | update (CellView[] views) |
void | update (CellView view) |
void | graphChanged (GraphModelEvent.GraphModelChange change) |
void | insertViews (CellView[] views) |
CellView[] | removeCells (Object[] cells) |
Object[] | getCells (CellView[] views) |
CellView | getMapping (Object cell, boolean create) |
CellView[] | getMapping (Object[] cells) |
CellView[] | getMapping (Object[] cells, boolean create) |
void | putMapping (Object cell, CellView view) |
CellView | removeMapping (Object cell) |
boolean | isVisible (Object cell) |
Set | getVisibleSet () |
void | setVisibleSet (Set visible) |
void | setVisible (Object cell, boolean visible) |
void | setVisible (Object[] cells, boolean visible) |
void | setVisible (Object[] visible, Object[] invisible) |
void | setVisible (Object[] visible, Object[] invisible, ConnectionSet cs) |
boolean | setVisibleImpl (Object[] cells, boolean visible) |
boolean | isPartial () |
void | valueForCellChanged (Object cell, Object newValue) |
void | insert (Object[] roots, Map attributes, ConnectionSet cs, ParentMap pm, UndoableEdit[] e) |
Object[] | insertClones (Object[] cells, Map clones, Map nested, ConnectionSet cs, ParentMap pm, double dx, double dy) |
void | insert (Object cell) |
void | insertEdge (Object edge, Object source, Object target) |
void | insert (Object[] cells) |
void | insert (Object[] cells, Map nested, ConnectionSet cs, ParentMap pm) |
void | insertGroup (Object group, Object[] children) |
void | remove (Object[] cells) |
void | remove (Object[] cells, boolean descendants, boolean edges) |
void | hideCells (Object[] cells, boolean descandants) |
void | showCells (Object[] cells, boolean descandants) |
Object[] | ungroup (Object[] cells) |
void | toggleCollapsedState (Object[] cells, boolean collapseOnly, boolean expandOnly) |
void | collapse (Object[] groups) |
void | expand (Object[] cells) |
void | setCollapsedState (Object[] collapse, Object[] expand) |
void | edit (Map attributes, ConnectionSet cs, ParentMap pm, UndoableEdit[] e) |
void | edit (Map attributes) |
void | edit (Object[] cells, Map attributes) |
void | editCell (Object cell, Map attributes) |
void | toBack (Object[] cells) |
void | toFront (Object[] cells) |
boolean | removeViewLocalAttribute (Object key, boolean addToModel, boolean override) |
List | getNeighbours (Object cell, Set exclude, boolean directed, boolean visibleCells) |
List | getOutgoingEdges (Object cell, Set exclude, boolean visibleCells, boolean selfLoops) |
List | getIncomingEdges (Object cell, Set exclude, boolean visibleCells, boolean selfLoops) |
CellView[] | getAllViews () |
CellView[] | getAllDescendants (CellView[] views) |
Map | getHiddenMapping () |
void | setShowsExistingConnections (boolean showsExistingConnections) |
boolean | isShowsExistingConnections () |
void | setShowsInsertedConnections (boolean showsInsertedConnections) |
boolean | isShowsInsertedConnections () |
void | setHidesExistingConnections (boolean hidesExistingConnections) |
boolean | isHidesExistingConnections () |
void | setHidesDanglingConnections (boolean hidesDanglingConnections) |
boolean | isHidesDanglingConnections () |
void | setRemembersCellViews (boolean rememberCellViews) |
boolean | isRemembersCellViews () |
void | setHiddenSet (Map hiddenSet) |
Set | getLocalAttributes () |
void | setLocalAttributes (Set localAttributes) |
boolean | isAllAttributesLocal () |
void | setAllAttributesLocal (boolean allAttributesLocal) |
boolean | isAutoSizeOnValueChange () |
void | setAutoSizeOnValueChange (boolean flag) |
boolean | isSelectsAllInsertedCells () |
void | setSelectsAllInsertedCells (boolean selectsAllInsertedCells) |
boolean | isSelectsLocalInsertedCells () |
void | setSelectsLocalInsertedCells (boolean selectsLocalInsertedCells) |
boolean | isReconnectsEdgesToVisibleParent () |
void | setReconnectsEdgesToVisibleParent (boolean reconnectsEdgesToVisibleParent) |
boolean | isShowsChangedConnections () |
void | setShowsChangedConnections (boolean showsChangedConnections) |
boolean | isMovesChildrenOnExpand () |
void | setMovesChildrenOnExpand (boolean moveChildrenOnExpand) |
double | getCollapseXScale () |
void | setCollapseXScale (double collapseXScale) |
double | getCollapseYScale () |
void | setCollapseYScale (double collapseYScale) |
boolean | isMovesParentsOnCollapse () |
void | setMovesParentsOnCollapse (boolean movesParentsOnCollapse) |
boolean | isResizesParentsOnCollapse () |
void | setResizesParentsOnCollapse (boolean resizesParentsOnCollapse) |
Static Public Member Functions | |
static Rectangle2D | getBounds (CellView[] views) |
static void | translateViews (CellView[] views, double dx, double dy) |
Protected Member Functions | |
void | fireGraphLayoutCacheChanged (Object source, GraphLayoutCacheEvent.GraphLayoutCacheChange edit) |
void | updatePorts () |
void | reloadRoots () |
Object[] | getContext (GraphModelEvent.GraphModelChange change) |
void | hideCellsForChange (GraphModelEvent.GraphModelChange change) |
boolean | hasVisibleParent (Object cell, Set invisible) |
void | showCellsForChange (GraphModelEvent.GraphModelChange change) |
Object[] | addVisibleDependencies (Object[] cells, boolean visible) |
Collection | getParentPorts (Object cell) |
Collection | getPorts (Object cell) |
void | augmentNestedMapForValueChange (Map nested, Object cell, Object newValue) |
Object | getParentPort (Object edge, boolean source) |
Object | getChildPort (Object edge, boolean source) |
UndoableEdit[] | augment (UndoableEdit[] e, UndoableEdit edit) |
GraphLayoutCacheEdit | createLocalEdit (Object[] inserted, Map nested, Object[] visible, Object[] invisible) |
boolean | isLocalAttribute (Object cell, Object key, Object value) |
boolean | isControlAttribute (Object cell, Object key, Object value) |
void | cellExpanded (Object cell) |
void | cellWillCollapse (Object cell) |
Map | handleAttributes (Map attributes) |
List | getEdges (Object cell, Set exclude, boolean visibleCells, boolean selfLoops, boolean incoming) |
Protected Attributes | |
boolean | autoSizeOnValueChange = false |
boolean | showsExistingConnections = true |
boolean | showsChangedConnections = true |
boolean | showsInvisibleEditedCells = true |
boolean | showsInsertedCells = true |
boolean | showsInsertedConnections = true |
boolean | hidesExistingConnections = true |
boolean | hidesDanglingConnections = false |
boolean | remembersCellViews = true |
boolean | selectsAllInsertedCells = true |
boolean | selectsLocalInsertedCells = true |
boolean | movesChildrenOnExpand = true |
boolean | movesParentsOnCollapse = true |
boolean | resizesParentsOnCollapse = false |
double | collapseXScale = 1.0 |
double | collapseYScale = 1.0 |
boolean | reconnectsEdgesToVisibleParent = false |
EventListenerList | listenerList = new EventListenerList() |
GraphModel | graphModel |
Map | mapping = new Hashtable() |
Map | hiddenMapping = new WeakHashMap() |
CellViewFactory | factory = null |
Set | visibleSet = new HashSet() |
List | roots = new ArrayList() |
PortView[] | ports |
boolean | partial = false |
boolean | allAttributesLocal = false |
Set | localAttributes = new HashSet() |
Private Member Functions | |
void | copyRemovedViewValue (Object key, boolean addToModel, boolean override, Collection coll) |
Classes | |
class | GraphLayoutCacheEdit |
|
Constructs a graph layout cache. |
|
Constructs a view for the specified model that uses
|
|
Constructs a view for the specified model that uses
|
|
Constructs a view for the specified model that uses
|
|
Adds a listener for the GraphLayoutCacheEvent posted after the graph layout cache changes.
|
|
|
|
|
|
Hook for subclassers to add more stuff for value changes. Currently this adds the new value to the change. |
|
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). |
|
Invoke this method after you've changed how the cells are to be represented in the graph. |
|
|
|
Collapses all groups by hiding all their descendants.
|
|
Helper method to copy removed view local attributes to model cell's
|
|
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. |
|
Returns a nested map of (cell, map) pairs that represent all attributes of all cell views in this view.
|
|
Applies the
Map attrs = new java.util.Hashtable(); GraphConstants.setBackground(attrs, Color.RED); graph.getGraphLayoutCache().edit(graph.getSelectionCells(), attrs); |
|
A shortcut method that takes a nested map and passes it to the edit method. |
|
Applies the |
|
Applies the
Map attrs = new java.util.Hashtable(); GraphConstants.setBackground(attrs, Color.RED); graph.getGraphLayoutCache().editCell(graph.getSelectionCell(), attrs); |
|
Expands all groups by showing all children. (Note: This does not show all descandants, but only the first generation of children.) |
|
|
|
Returns all views, including descendants that have a parent in |
|
Returns all views, shortcut to getAllDescendants(getRoots()) |
|
Returns the bounding box for the specified cell views. |
|
Takes an array of views and returns the array of the corresponding cells by using |
|
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 |
|
|
|
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 |
|
|
|
|
|
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 manas.event. eg. parallel edges when one is removed or added. |
|
Returns the incoming or outgoing edges for cell. Cell should be a port or a vertex.
|
|
Returns the factory that was passed to the constructor. |
|
Return an array of all GraphLayoutCacheListener that were added to this model. |
|
|
|
Returns the hiddenMapping.
|
|
Returns the incoming edges for cell. Cell should be a port or a vertex.
|
|
|
|
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 |
|
Returns the views for the specified array of cells without creating these views on the fly. |
|
Returns the view for the specified cell. If create is true and no view is found then a view is created using createView(Object). Implements org.jgraph.graph.CellMapper. |
|
Returns the current model. |
|
Returns a collection of cells that are connected to the specified cell by edges. Any cells specified in the exclude set will be ignored.
|
|
Returns the outgoing edges for cell. Cell should be a port or a vertex.
|
|
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. |
|
|
|
|
|
Returns the ports of the view. |
|
Return all root cells that intersect the given rectangle. |
|
Returns the roots of the view. |
|
Returns a an array with the visible cells in |
|
|
|
Called from BasicGraphUI.ModelHandler to update the view based on the specified GraphModelEvent. |
|
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). |
|
Checks if the port or one of its parents is visible. |
|
Hides the specified cells with all children if |
|
|
|
Variant of the insert method that allows to pass a default connection set and parent map and nested map. |
|
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); |
|
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);
|
|
Inserts the |
|
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); |
|
Inserts the specified edge into the graph model. This method does in fact nothing, it calls insert with a default connection set.
|
|
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); |
|
Adds the specified model root cells to the view. Do not add a view that is already in roots. |
|
|
|
Returns true if cells should be auto-sized when their values change
|
|
Returns true if |
|
Returns the hidesDanglingConnections.
|
|
Returns the hidesExistingConnections.
|
|
Returns true if the set of local attributes contains |
|
|
|
|
|
|
|
|
|
Returns the remembersCellViews.
|
|
|
|
|
|
|
|
|
|
Returns the showsExistingConnections.
|
|
Returns the showsInsertedConnections.
|
|
|
|
Associates the specified model cell with the specified view. Implements org.jgraph.graph.CellMapper. |
|
|
|
|
|
|
|
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. |
|
Removes cells from the model, including all children and connected edges if
|
|
Removes |
|
Removes the specified model root cells from the view by removing the mapping between the cell and its view and makes the cells invisible. |
|
Removes a listener previously added with addGraphLayoutCacheListener() .
|
|
Removes the associaten for the specified model cell and returns the view that was previously associated with the cell. Updates the portlist if necessary. |
|
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.
|
|
|
|
Determines whether cells should be auto-sized when their values change. Fires a property change manas.event if the new setting is different from the existing setting.
|
|
Collapses and/or expands the specified cell(s)
|
|
|
|
|
|
Sets the factory that creates the cell views. |
|
Sets the hiddenSet.
|
|
Sets the hidesDanglingConnections
|
|
Sets the hidesExistingConnections
|
|
|
|
Sets the current model. |
|
|
|
|
|
|
|
Sets the rememberCellViews.
|
|
|
|
|
|
|
|
|
|
Sets the showsExistingConnections
|
|
Sets the showsInsertedConnections
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Shows the specified cells with all children if |
|
|
|
Sends |
|
Brings |
|
Toggles the collapsed state of the specified cells.
|
|
Translates the specified views by the given amount.
|
|
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. |
|
|
|
|
|
Updates the cached array of ports. |
|
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 manas.event. This calls augmentNestedMapForValueChange. |
|
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. |
|
True if the cells should be auto-sized when their values change. Default is false. |
|
Specified the initial x- and y-scaling factor for initial collapsed group bounds. Default is 1.0, ie. no scaling. |
|
|
|
Factory to create the views. |
|
Reference to the graphModel |
|
|
|
Boolean indicating whether existing connections should be hidden if their source or target port is removed from the model. Default is false. |
|
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. |
|
The list of listeners that listen to the model. |
|
A set containing all attribute keys that are stored in the cell views, in other words, the view-local attributes. |
|
Maps cells to views. The hidden mapping is used to remembed cell views that are hidden, based on the remembersCellViews setting. hiddenMapping must weak keys for the cells since when cells are removed hiddenMapping is not updated. |
|
Boolean indicating whether children should be moved to the parent group's origin on expand. Default is true. |
|
Boolean indicating whether parents should be moved to the child area origin on collapse. Default is true. |
|
Only portions of the model are visible. |
|
Cached array of all ports for the view. |
|
Boolean indicating whether edges should be reconneted to visible parents on collapse/expand. Default is false.
|
|
Boolean indicating whether cellviews should be remembered once visible in this GraphLayoutCache. Default is true. |
|
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. |
|
Ordered list of roots for the view. |
|
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. |
|
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. |
|
Boolean indicating whether connections should be made visible when reconnected and their source and target port is visible. Default is true. |
|
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. |
|
Boolean indicating whether inserted should be made visible if they are inserted via insert(Object[], Map, ConnectionSet, ParentMap, UndoableEdit[]). Default is true. |
|
Boolean indicating whether inserted edges should me made visible if their sources or targets are already visible. Default is true. |
|
Boolean indicating whether edited cells should be made visible if they are changed via edit(Map, ConnectionSet, ParentMap, UndoableEdit[]). Default is true. |
|
The set of visible cells. |