TreeLayoutData

Specifies custom data for the TreeLayout.

Inheritance Hierarchy

TreeLayoutData

Examples

The following example shows how to create a new instance of TreeLayoutData and use it with an TreeLayout:

Creating an instance of TreeLayoutData

const layoutData = new TreeLayoutData()
layoutData.nodeHalos.constant = NodeHalo.create(15)
layoutData.treeRoot.item = rootNode

graph.applyLayout(new TreeLayout(), layoutData)

In many cases the complete initialization of TreeLayoutData can also be done in a single object initializer:

Using an object initializer for easy creation of TreeLayoutData

const layoutData = new TreeLayoutData({
  nodeHalos: NodeHalo.create(15),
  treeRoot: (node) => node === rootNode
})

graph.applyLayout(new TreeLayout(), layoutData)

Type Details

yfiles module: view-layout-bridge
yfiles-umd modules: view-layout-bridge
Legacy UMD name: yfiles.tree.TreeLayoutData

Constructors

TreeLayoutData

()

Creates a new instance of TreeLayoutData which helps configuring TreeLayout.

ParametersOptions Overload

options - Object
A map of options to pass to the method.

nodePlacers - ItemMapping<INode,ITreeLayoutNodePlacer>: The mapping from nodes to their ITreeLayoutNodePlacer. This option sets the nodePlacers property on the created object.
portAssignments - ItemMapping<INode,ITreeLayoutPortAssignment>: The mapping from nodes to their ITreeLayoutPortAssignment. This option sets the portAssignments property on the created object.
outEdgeComparers - ItemMapping<INode,system.Comparison<IEdge>>: The mapping from nodes to comparison functions used to sort the nodes' outgoing edges. This option sets the outEdgeComparers property on the created object.
nodeHalos - ItemMapping<INode,NodeHalo>: The mapping from nodes to their NodeHalo. This option sets the nodeHalos property on the created object.
nodeTypes - ItemMapping<INode,Object>: The mapping from nodes to an object defining the node type, which influences the ordering of child nodes such that those with same type are preferably placed next to each other. This option sets the nodeTypes property on the created object.
sourcePortConstraints - ItemMapping<IEdge,PortConstraint>: A mapping from edges to their source PortConstraint. This option sets the sourcePortConstraints property on the created object.
targetPortConstraints - ItemMapping<IEdge,PortConstraint>: A mapping from edges to their target PortConstraint. This option sets the targetPortConstraints property on the created object.
assistantNodes - ItemCollection<INode>: The collection of nodes the AssistantNodePlacer considers as assistants. This option sets the assistantNodes property on the created object.
delegatingNodePlacerPrimaryNodes - ItemCollection<INode>: The collection of nodes the DelegatingNodePlacer places with its primaryPlacer. This option sets the delegatingNodePlacerPrimaryNodes property on the created object.
leftRightNodePlacerLeftNodes - ItemCollection<INode>: The set of nodes that are placed on the left side of the bus. This option sets the leftRightNodePlacerLeftNodes property on the created object.
gridNodePlacerRowIndices - ItemMapping<INode,number>: The mapping from nodes to the index of the row the GridNodePlacer shall place the node in. This option sets the gridNodePlacerRowIndices property on the created object.
abortHandler - AbortHandler: The AbortHandler used during the layout. This option sets the abortHandler property on the created object.
treeRoot - SingleItem<INode>: The mapping for marking the node that will be used as root node of the tree. This option sets the treeRoot property on the created object.
edgeLabelPreferredPlacement - ItemMapping<ILabel,PreferredPlacementDescriptor>: The mapping that provides a PreferredPlacementDescriptor instance for edge ILabels. This option sets the edgeLabelPreferredPlacement property on the created object.
compactNodePlacerStrategyMementos - IMapper<INode,Object>: A mapper from nodes to a strategy memento object for the CompactNodePlacer. This option sets the compactNodePlacerStrategyMementos property on the created object.
criticalEdgePriorities - ItemMapping<IEdge,number>: A mapping from edges to their priority to be a 'critical' edge. This option sets the criticalEdgePriorities property on the created object.

Properties

abortHandler

: AbortHandler

Gets or sets the AbortHandler used during the layout.

Remarks

An AbortHandler can be used to gracefully stop or cancel a running layout and offers options for automatically doing so after a predetermined time.

An AbortHandler configured or set here overrides the one on LayoutExecutor.

Examples

The most common use case would be to just configure the AbortHandler here, e.g. to set timeouts for a graceful stop or canceling the running layout:

layoutData.abortHandler.stopDuration = TimeSpan.fromSeconds(10)
layoutData.abortHandler.cancelDuration = TimeSpan.fromSeconds(30)layoutData.abortHandler!.stopDuration = TimeSpan.fromSeconds(10)
layoutData.abortHandler!.cancelDuration = TimeSpan.fromSeconds(30)

If there's already an AbortHandler instance that's pre-configured or will be used in a different place to, e.g., cancel the layout when the user presses a button, you can also set one explicitly:

layoutData.abortHandler = abortHandler

assistantNodes

: ItemCollection<INode>

Gets or sets the collection of nodes the AssistantNodePlacer considers as assistants.

Remarks

This collection is only considered if nodePlacers returns an instance of AssistantNodePlacer or CompactNodePlacer for any node.

Examples

Specifying which nodes to lay out as assistant nodes can be done in various ways, depending on which option is more convenient at the moment. For example, if you already have a collection or IEnumerable<T> somewhere that contains all nodes that should be treated as assistant nodes, then the easiest option usually is to use the source property:

Using a collection for assistant nodes

layoutData.assistantNodes = graphComponent.selection.selectedNodes

In some cases only some nodes may need to be directly set as assistant nodes, but are not already in a collection, in which case the items property can be used directly to add them:

Adding individual nodes as assistant nodes

const layoutData = new TreeLayoutData()
layoutData.assistantNodes.items.add(assistantNode1)
layoutData.assistantNodes.items.add(assistantNode2)

In cases where it's directly apparent from a node whether to lay it out as an assistant node, the best option usually is to use a delegate:

Using a delegate to dynamically determine whether a node is an assistant node

layoutData.assistantNodes = (node) => node.tag.isAssistantlayoutData.assistantNodes = (node: INode): boolean => node.tag.isAssistant

Sample Graphs

compactNodePlacerStrategyMementos

: IMapper<INode,any>

Gets or sets a mapper from nodes to a strategy memento object for the CompactNodePlacer.

Remarks

This property has an effect only if CompactNodePlacer is selected as node placer for at least one subtree of the input graph. Then, given that this property is set, the node placer stores the applied placement strategy for the nodes' children and keeps it in subsequent layout runs. This is useful to maintain similar layout styles over subsequent runs. Otherwise, even for small changes in the graph structure, the results produced by CompactNodePlacer can drastically change.

The actual values stored in this mapper are opaque objects only intended for internal use by CompactNodePlacer.

Examples

The following example shows how to set this property so that CompactNodePlacer remembers previous arrangements of subtrees:

layoutData.compactNodePlacerStrategyMementos = new Mapper()

criticalEdgePriorities

: ItemMapping<IEdge,number>

Gets or sets a mapping from edges to their priority to be a 'critical' edge.

Remarks

The layout tries to align each node pair that is connected by a critical edge (integer value > 0).

Critical edges highlight different edge paths that are relevant for a user. The layout tries to align each node pair that is connected by a critical edge. Conflicts between different critical edges are always resolved in favor of the higher priority.

Examples

Critical edges are often determined by some external data source and are often part of a larger path. The following example shows how two different such paths can be made 'critical' with different priorities:

Configuring critical edges via a mapper

// Set two different critical edge paths with different priorities
for (const edge of path1) {
  layoutData.criticalEdgePriorities.mapper.set(edge, 5)
}
// Lower priority for the second path, which then may deviate from a straight line
for (const edge of path2) {
  layoutData.criticalEdgePriorities.mapper.set(edge, 2)
}

Alternatively, a delegate may be used as well, if determining edge criticality is easier when looking at the edge itself:

Configuring critical edges via a delegate

// Assume that the edge's tag holds an instance that has an 'IsCritical' property
layoutData.criticalEdgePriorities = (edge) => (edge.tag.isCritical ? 1 : 0)// Assume that the edge's tag holds an instance that has an 'IsCritical' property
layoutData.criticalEdgePriorities = (edge: IEdge): 0 | 1 =>
  edge.tag.isCritical ? 1 : 0

delegatingNodePlacerPrimaryNodes

: ItemCollection<INode>

Gets or sets the collection of nodes the DelegatingNodePlacer places with its primaryPlacer.

Remarks

This collection is only considered if nodePlacers returns any DelegatingNodePlacer .

edgeLabelPreferredPlacement

: ItemMapping<ILabel,PreferredPlacementDescriptor>

Gets or sets the mapping that provides a PreferredPlacementDescriptor instance for edge ILabels.

Examples

Depending on how much customization is needed, some ways of setting PreferredPlacementDescriptors are more convenient than others. For example, to set the same descriptor for all labels, you can just use the constant property:

Setting the same PreferredPlacementDescriptor for all labels

layoutData.edgeLabelPreferredPlacement = new PreferredPlacementDescriptor({
  // Place labels along the edge
  angleReference: LabelAngleReferences.RELATIVE_TO_EDGE_FLOW,
  angle: 0,
  // ... on either side
  sideOfEdge: LabelPlacements.LEFT_OF_EDGE | LabelPlacements.RIGHT_OF_EDGE,
  // ... with a bit of distance to the edge
  distanceToEdge: 5
})

If some labels should use custom placement or this has to be configured ahead of time, you can use the mapper instead:

Customizing the placement of certain labels individually via a mapper

// Place label1 orthogonal to the edge anywhere on it
layoutData.edgeLabelPreferredPlacement.mapper.set(
  label1,
  new PreferredPlacementDescriptor({
    placeAlongEdge: LabelPlacements.ANYWHERE,
    angleReference: LabelAngleReferences.RELATIVE_TO_EDGE_FLOW,
    angle: Math.PI / 2
  })
)
// Place label2 near the edge's source on either side of it, and make it parallel to the edge
layoutData.edgeLabelPreferredPlacement.mapper.set(
  label2,
  new PreferredPlacementDescriptor({
    placeAlongEdge: LabelPlacements.AT_SOURCE,
    sideOfEdge: LabelPlacements.RIGHT_OF_EDGE | LabelPlacements.LEFT_OF_EDGE,
    angleReference: LabelAngleReferences.RELATIVE_TO_EDGE_FLOW,
    angle: 0
  })
)

When the preferred placement can be inferred from the label itself, a delegate is usually the easiest choice:

Configuring preferred placement for all labels with a delegate

layoutData.edgeLabelPreferredPlacement = (label) => {
  const customData = label.tag
  return new PreferredPlacementDescriptor({
    angle: 0,
    angleReference: LabelAngleReferences.RELATIVE_TO_EDGE_FLOW,
    // If the tag says to place the label in the center, put it in the center parallel to the edge's path
    // All other labels can be placed anywhere, but on the side of the edge.
    placeAlongEdge: customData.placeInCenter
      ? LabelPlacements.AT_CENTER
      : LabelPlacements.ANYWHERE,
    sideOfEdge: customData.placeInCenter
      ? LabelPlacements.ON_EDGE
      : LabelPlacements.LEFT_OF_EDGE | LabelPlacements.RIGHT_OF_EDGE
  })
}layoutData.edgeLabelPreferredPlacement = (
  label: ILabel
): PreferredPlacementDescriptor => {
  const customData = label.tag
  return new PreferredPlacementDescriptor({
    angle: 0,
    angleReference: LabelAngleReferences.RELATIVE_TO_EDGE_FLOW,
    // If the tag says to place the label in the center, put it in the center parallel to the edge's path
    // All other labels can be placed anywhere, but on the side of the edge.
    placeAlongEdge: customData.placeInCenter
      ? LabelPlacements.AT_CENTER
      : LabelPlacements.ANYWHERE,
    sideOfEdge: customData.placeInCenter
      ? LabelPlacements.ON_EDGE
      : LabelPlacements.LEFT_OF_EDGE | LabelPlacements.RIGHT_OF_EDGE
  })
}

Note that the preferred placement can also be inferred from an arbitrary ILabelModelParameter:

Configuring preferred placement from a label model parameter

layoutData.edgeLabelPreferredPlacement =
  PreferredPlacementDescriptor.fromParameter(
    NinePositionsEdgeLabelModel.CENTER_CENTERED
  )

gridNodePlacerRowIndices

: ItemMapping<INode,number>

Gets or sets the mapping from nodes to the index of the row the GridNodePlacer shall place the node in.

Remarks

This collection is only considered if nodePlacers returns any GridNodePlacer .

leftRightNodePlacerLeftNodes

: ItemCollection<INode>

Gets or sets the set of nodes that are placed on the left side of the bus.

Remarks

Nodes that appear in this collection are placed left of the bus, those that do not will be placed on the right.

Examples

When customizing left/right placement for nodes it's common to have some sort of telling from the node where it should be placed. The simplest way to use this would be the delegate:

Assigning left/right placement of nodes via a delegate

layoutData.leftRightNodePlacerLeftNodes = (node) =>
  node.tag.placement === 'left'

In other cases, the mapper option allows more flexibility over its use:

Assigning left/right placement of nodes via a mapper

// Place up to three nodes to the left, and the others to the right
for (const node of graph.nodes) {
  let i = 0
  for (const n of graph.successors(node).takeWhile(() => i++ < 3)) {
    layoutData.leftRightNodePlacerLeftNodes.mapper.set(n, true)
  }
  // Placement to the right is the default, so nothing else is necessary here
}// Place up to three nodes to the left, and the others to the right
for (const node of graph.nodes) {
  let i = 0
  for (const n of graph.successors(node).takeWhile(() => i++ < 3)) {
    layoutData.leftRightNodePlacerLeftNodes.mapper!.set(n, true)
  }
  // Placement to the right is the default, so nothing else is necessary here
}

Sample Graphs

This collection is only considered if nodePlacers returns a LeftRightNodePlacer.

If this property is not used, then nodes are placed alternating left and right.

nodeHalos

: ItemMapping<INode,NodeHalo>

Gets or sets the mapping from nodes to their NodeHalo.

Remarks

NodeHalos allow to reserve space around nodes.

Examples

The easiest option is to reserve the same space around all nodes, by setting a constant NodeHalo:

Using constant space around all nodes

layoutData.nodeHalos.constant = NodeHalo.create(20)

Handling only certain nodes differently can be done easily by using the mapper property:

Using a mapper to set halos for certain nodes

// node1 only reserves space above and below
layoutData.nodeHalos.mapper.set(node1, NodeHalo.create(20, 0, 0, 10))
// node2 has space all around
layoutData.nodeHalos.mapper.set(node2, NodeHalo.create(25))
// all other nodes don't get extra space

In cases where the NodeHalo for each node can be determined by looking at the node itself it's often easier to just set a delegate instead of preparing a mapper:

Using a delegate to determine halos for all nodes

// Retrieve the space around the node from its Tag property
layoutData.nodeHalos = (node) => NodeHalo.create(parseFloat(node.tag))// Retrieve the space around the node from its Tag property
layoutData.nodeHalos = (node: INode): NodeHalo =>
  NodeHalo.create(parseFloat(node.tag))

nodePlacers

: ItemMapping<INode,ITreeLayoutNodePlacer>

Gets or sets the mapping from nodes to their ITreeLayoutNodePlacer.

Remarks

If a node is mapped to null, then the default node placer applies for that node.

Examples

Depending on the customization needed, ItemMapping<TItem,TValue> has several options that work well in different situations. To change the default only for some nodes that are known beforehand, it's often easiest to just use the mapper:

Using a mapper to change node placers for certain subtrees

// Arrange node1's children below the node and to the right
layoutData.nodePlacers.mapper.set(
  node1,
  new DefaultNodePlacer(
    ChildPlacement.VERTICAL_TO_RIGHT,
    RootAlignment.LEADING,
    10,
    10
  )
)
// Arrange node2's children as compactly as possible via CompactNodePlacer
layoutData.nodePlacers.mapper.set(node2, new CompactNodePlacer())

In case the desired configuration can readily be inferred from each node, the most convenient option usually is to use a delegate:

Using a delegate to determine a node placer for each subtree

layoutData.nodePlacers = (node) => {
  // If the node has too many children, switch to CompactNodePlacer
  const successors = graph.successors(node).toList()
  if (successors.size > 10) {
    return new CompactNodePlacer()
  }
  // Otherwise if there are assistant children, we use AssistantNodePlacer
  if (successors.some((n) => n.tag.isAssistant)) {
    return new AssistantNodePlacer()
  }
  // In all other cases use the default configured on TreeLayout
  return null
}layoutData.nodePlacers = (node: INode): ITreeLayoutNodePlacer => {
  // If the node has too many children, switch to CompactNodePlacer
  const successors = graph.successors(node).toList()
  if (successors.size > 10) {
    return new CompactNodePlacer()
  }
  // Otherwise if there are assistant children, we use AssistantNodePlacer
  if (successors.some((n: INode): boolean => n.tag.isAssistant)) {
    return new AssistantNodePlacer()
  }
  // In all other cases use the default configured on TreeLayout
  return null!
}

nodeTypes

: ItemMapping<INode,any>

Gets or sets the mapping from nodes to an object defining the node type, which influences the ordering of child nodes such that those with same type are preferably placed next to each other.

Remarks

The types of the nodes are a criterion for sorting the child nodes of a local root node such that nodes of the same type are placed consecutively, if possible. The primary criterion is still given by the defaultOutEdgeComparer. Furthermore, node placers optimizing criteria like the compactness (e.g. CompactNodePlacer) still primarily focus on these criteria, so that nodes of same type are not necessarily consecutive.

Sample Graphs

outEdgeComparers

: ItemMapping<INode,system.Comparison<IEdge>>

Gets or sets the mapping from nodes to comparison functions used to sort the nodes' outgoing edges.

portAssignments

: ItemMapping<INode,ITreeLayoutPortAssignment>

Gets or sets the mapping from nodes to their ITreeLayoutPortAssignment.

Remarks

Port assignments define where ports of incident edges are placed.

Examples

Using a mapper to change port assignments for certain nodes

// Place ports at node1 at the center of the node
layoutData.portAssignments.mapper.set(
  node1,
  new DefaultTreeLayoutPortAssignment(TreeLayoutPortAssignmentMode.NONE)
)
// Distribute ports on node2 on the bottom border of the node
layoutData.portAssignments.mapper.set(
  node2,
  new DefaultTreeLayoutPortAssignment(
    TreeLayoutPortAssignmentMode.DISTRIBUTED_SOUTH
  )
)

In case the desired configuration can readily be inferred from each node, the most convenient option usually is to use a delegate:

Using a delegate to determine the port assignment for each node

layoutData.portAssignments = (node) => {
  const customData = node.tag
  if (customData.portPlacement === 'left') {
    return new DefaultTreeLayoutPortAssignment(
      TreeLayoutPortAssignmentMode.DISTRIBUTED_WEST
    )
  }
  if (customData.portPlacement === 'right') {
    return new DefaultTreeLayoutPortAssignment(
      TreeLayoutPortAssignmentMode.DISTRIBUTED_EAST
    )
  }
  // Fall back to TreeLayout.defaultPortAssignment for other cases
  return null
}layoutData.portAssignments = (node: INode): ITreeLayoutPortAssignment => {
  const customData = node.tag
  if (customData.portPlacement === 'left') {
    return new DefaultTreeLayoutPortAssignment(
      TreeLayoutPortAssignmentMode.DISTRIBUTED_WEST
    )
  }
  if (customData.portPlacement === 'right') {
    return new DefaultTreeLayoutPortAssignment(
      TreeLayoutPortAssignmentMode.DISTRIBUTED_EAST
    )
  }
  // Fall back to TreeLayout.defaultPortAssignment for other cases
  return null!
}

sourcePortConstraints

: ItemMapping<IEdge,PortConstraint>

Gets or sets a mapping from edges to their source PortConstraint.

Remarks

Port constraints allow to define where an edge attaches to its source node and can either restrict that to one of the node's sides, or to a fixed port position.

Examples

If all edges should exit their source node on the same side, you can simply set a constant constraint for all edges:

Setting the same port constraint for all edges

// All source ports should be on the bottom side
layoutData.sourcePortConstraints.constant = PortConstraint.create(
  PortSide.SOUTH
)

To change the constraints for individual edges, it's usually easiest to use the mapper:

Using a mapper to set different port constraints for certain edges

// edge1 should leave the source node on the left side, while keeping its exact port position (strong port constraint)
layoutData.sourcePortConstraints.mapper.set(
  edge1,
  PortConstraint.create(PortSide.WEST, true)
)
// edge2 should leave the source node downwards, but the port may be placed anywhere along that node border
layoutData.sourcePortConstraints.mapper.set(
  edge2,
  PortConstraint.create(PortSide.SOUTH)
)

If a PortConstraint can readily be created from an edge, using a delegate is often easier:

Using a delegate to set a different port constraint for each edge

// Source ports will be placed on the right side and use a property in the edge's tag
// to determine whether ports will stay fixed at their position.
layoutData.sourcePortConstraints = (edge) =>
  PortConstraint.create(PortSide.EAST, edge.tag.fixPorts)// Source ports will be placed on the right side and use a property in the edge's tag
// to determine whether ports will stay fixed at their position.
layoutData.sourcePortConstraints = (edge: IEdge): PortConstraint =>
  PortConstraint.create(PortSide.EAST, edge.tag.fixPorts)

Sample Graphs

targetPortConstraints

: ItemMapping<IEdge,PortConstraint>

Gets or sets a mapping from edges to their target PortConstraint.

Remarks

Port constraints allow to define where an edge attaches to its target node and can either restrict that to one of the node's sides, or to a fixed port position.

Examples

If all edges should exit their source node on the same side, you can simply set a constant constraint for all edges:

Setting the same port constraint for all edges

// All target ports should be on the top side
layoutData.targetPortConstraints.constant = PortConstraint.create(
  PortSide.NORTH
)

To change the constraints for individual edges, it's usually easiest to use the mapper:

Using a mapper to set different port constraints for certain edges

// edge1 should enter the target node on the right side, while keeping its exact port position (strong port
// constraint)
layoutData.targetPortConstraints.mapper.set(
  edge1,
  PortConstraint.create(PortSide.EAST, true)
)
// edge2 should enter the target node from the top, but the port may be placed anywhere along that node border
layoutData.targetPortConstraints.mapper.set(
  edge2,
  PortConstraint.create(PortSide.NORTH)
)

If a PortConstraint can readily be created from an edge, using a delegate is often easier:

Using a delegate to set a different port constraint for each edge

// Target ports will be placed on the right side and use a property in the edge's tag
// to determine whether ports will stay fixed at their position.
layoutData.targetPortConstraints = (edge) =>
  PortConstraint.create(PortSide.EAST, edge.tag.fixPorts)// Target ports will be placed on the right side and use a property in the edge's tag
// to determine whether ports will stay fixed at their position.
layoutData.targetPortConstraints = (edge: IEdge): PortConstraint =>
  PortConstraint.create(PortSide.EAST, edge.tag.fixPorts)

Sample Graphs

treeRoot

: SingleItem<INode>

Gets or sets the mapping for marking the node that will be used as root node of the tree.

Examples

The simplest way to set a custom root node for the layout, if you already have an INode for that, would be to use the item to specify it as the root:

Specifying a custom root node directly

layoutData.treeRoot.item = root

In cases where it's easier to look at an INode to determine whether it should be the root node or not, it's often most convenient to use the delegate property:

Specifying a custom root node via a delegate

// This is equivalent to the declaration above
layoutData.treeRoot = (node) => node === root
// Or use a different way of choosing the root node, e.g. by taking the node whose label
// says 'Root'
layoutData.treeRoot = (node) => node.labels.get(0).text === 'Root'

Sometimes there might also be a collection that usually holds just the single node that should be the root, in which case source can be useful:

Specifying a custom root node from an IEnumerable

// Use the first selected node as the root
// This will be evaluated anew each time the layout is applied
layoutData.treeRoot = graphComponent.selection.selectedNodes

Methods

combineWith

(data: LayoutData…) : LayoutData

Combines this instance with the given layout data.

Remarks

This keeps the current instance unmodified and instead returns a new instance that dynamically combines the contents of all involved instances.

Parameters

options - Object
A map of options to pass to the method.

data - LayoutData: The LayoutData to combine this instance with.

Returns

↪LayoutData: The combined layout data.

Defined in

LayoutData

TreeLayoutData

Examples

Type Details

See Also

Constructors

TreeLayoutData

ParametersOptions Overload

Properties

abortHandler

Remarks

Examples

See Also

assistantNodes

Remarks

Examples

See Also

Sample Graphs

compactNodePlacerStrategyMementos

Remarks

Examples

See Also

criticalEdgePriorities

Remarks

Examples

See Also

delegatingNodePlacerPrimaryNodes

Remarks

See Also

edgeLabelPreferredPlacement

Examples

See Also

gridNodePlacerRowIndices

Remarks

See Also

leftRightNodePlacerLeftNodes

Remarks

Examples

See Also

Sample Graphs

nodeHalos

Remarks

Examples

See Also

nodePlacers

Remarks

Examples

See Also

nodeTypes

Remarks

See Also

Sample Graphs

outEdgeComparers

See Also

portAssignments

Remarks

Examples

See Also

sourcePortConstraints

Remarks

Examples

See Also

Sample Graphs

targetPortConstraints

Remarks

Examples

See Also

Sample Graphs

treeRoot

Examples

See Also

Methods

combineWith

Remarks

Parameters

Returns

See Also

Defined in