Determines the general layout mode.

When the layout is calculated incrementally, a data provider that holds so-called hint objects for each graph element that should be processed using incremental semantics is looked up. The data provider is expected to be registered with the graph using key INCREMENTAL_HINTS_DPKEY.

Sets the default NodeLayoutDescriptor instance that is used for all nodes that have no individual layout descriptor associated. Some of the layout and drawing options that can be set for a node by means of this descriptor are listed in the section called “Related Classes”.

To specify individual descriptors for nodes, a data provider holding such supplemental layout data can be bound to the graph. The data provider is expected to be registered with the graph using key NODE_LAYOUT_DESCRIPTOR_DPKEY. Note that in the absence of an individual descriptor the default NodeLayoutDescriptor instance will be used.

Sets the default EdgeLayoutDescriptor instance that is used for all edges that have no individual layout descriptor associated. Some of the layout and drawing options that can be set for an edge by means of this descriptor are listed in the section called “Related Classes”.

To specify individual descriptors for edges, a data provider holding such supplemental layout data can be bound to the graph. The data provider is expected to be registered with the graph using key EDGE_LAYOUT_DESCRIPTOR_DPKEY. Note that in the absence of an individual descriptor the default EdgeLayoutDescriptor instance will be used.

Determines the minimal distance between adjacent layers.

Determines the minimal distance between two adjacent nodes that reside in the same layer.

Determines the distance between two adjacent edge segments in one layer.

Determines the minimal distance between an edge and an adjacent node in one layer.

IncrementalHierarchicLayouter supports different layer assignment policies for graphs with grouped nodes. The layering for both incremental as well as "normal" layout can be determined in either of two ways:

Figure 5.34, “Flat vs. recursive layer assignment” compares the layer assignment policies. When layer assignment is done "flat," the group nodes of a graph and their adjacent edges are ignored. In particular, this means that the layering of grouped nodes can be influenced by nodes outside of the group node. In constrast, when using recursive layer assignment, grouped nodes are processed without interference from nodes outside of their group node.

Figure 5.34. Flat vs. recursive layer assignment

"Flat" layer assignment policy where group nodes and their adjacent edges are ignored.	Recursive layer assignment policy.	Recursive layer assignment policy with compaction enabled.

Recursive processing of the grouped nodes is the default behavior. Example 5.21, “Setting up "flat" layer assignment” shows how to set up "flat" layer assignment with IncrementalHierarchicLayouter.

// Set up IHL for hierarchically organized graphs.
IncrementalHierarchicLayouter ihl = new IncrementalHierarchicLayouter();
ihl.setRecursiveGroupLayeringEnabled(false);

Recursive layer assignment optionally uses a compaction step where empty layers next to group nodes are filled with nodes from layers below these group nodes. When compaction is disabled, an alignment policy is used to specify where "ordinary" nodes that are in a layer with group nodes are placed relative to these group nodes. API Excerpt 5.9, “Setter methods for recursive layering options” lists the methods for configuring these options.

// Layer compaction.
void setGroupCompactionEnabled(boolean groupCompactionEnabled)

// Group node-relative alignment policy.
void setGroupAlignmentPolicy(byte groupAlignmentPolicy)

IncrementalHierarchicLayouter's support for hierarchically organized graphs currently does not support the following features for edge ends that directly connect to group nodes: port constraints, port candidates, and edge/port grouping (bus-style edge routing). Also, swimlane layout in conjunction with hierarchically organized graphs is not supported yet.

Please see also the section called “Layout of Hierarchically Organized Graphs” below.

Integrated labeling can be enabled or disabled using the methods from API Excerpt 5.10, “Method to enable/disable integrated labeling”.

// Getter and setter for integrated labeling. 
boolean isIntegratedEdgeLabelingEnabled()

void setIntegratedEdgeLabelingEnabled(boolean enabled)

IncrementalHierarchicLayouter provides support for so-called "swimlane" layout. This type of layout uses the notion of adjacent lanes into which nodes are placed. The lanes are oriented with the general layout direction, i.e., perpendicular to the layers of the hierarchical layout, and each of the nodes of the graph is specifically assigned to a single lane.

Figure 5.35, “Swimlanes” shows the result of a swimlane layout calculated by IncrementalHierarchicLayouter where the layout direction is from top to bottom. The lanes of the swimlane layout are indicated by vertical lines. Nodes are placed into a lane according to the label text.

Figure 5.35. Swimlanes

Assigning the nodes of a graph to specific swimlanes is achieved with the help of class SwimLaneDescriptor. Each node is associated with an object of this type by means of a node map, which is then registered as a data provider with the graph using the SWIMLANE_DESCRIPTOR_DPKEY look-up key. The SwimLaneDescriptor object is given a java.lang.Comparable object at creation time that is used to determine the order of the swimlanes. This general setup for swimlane layout using IncrementalHierarchicLayouter is outlined in Example 5.22, “Setting up swimlane layout”.

public NodeMap setupSwimlaneInformation(Graph graph) {
  NodeMap swimLaneMap = graph.createNodeMap();
  graph.addDataProvider(
    IncrementalHierarchicLayouter.SWIMLANE_DESCRIPTOR_DPKEY, swimLaneMap);
  
  for (NodeCursor nc = graph.nodes(); nc.ok(); nc.next()) {
    SwimLaneDescriptor sld = 
      new SwimLaneDescriptor(graph.getLabelText(nc.node()));
    
    // More swimlane-specific configuration here...
    
    swimLaneMap.set(nc.node(), sld);
  }
  return swimLaneMap;
}

Swimlane layout is demonstrated in the tutorial demo applications SwimLaneLayoutWithoutAView.java and SimpleSwimLaneLayouterDemo.java.

Class IncrementalHierarchicLayouter will return the layer index for every node, when the graph has a data provider registered with it that can be looked up using the key LAYER_VALUE_HOLDER_DPKEY. The data provider is expected to hold IntValueHolder objects, which are retrieved and filled with the layer indices after layout calculation. Class IntValueHolderAdapter can be used as a convenient means to appropriately wrap a NodeMap for that task.