C

Classes

AlignmentStage
AlignmentStage places the nodes of the given layout on automatically determined horizontal and/or vertical lines.
AlignmentStageData
Specifies custom data for the AlignmentStage.
BasicPortData
Specifies custom data for constraining the port placement.
BendSubstitutionStage
BendSubstitutionStage replaces edge bends with proxy nodes for the coreLayout.
BorderLine
This class can be used to easily model an orthogonal borderline or sky-line.
BorderLineSegment
Represents a segment of a BorderLine in a graph or geometric representation.
ChildOrderData
Provides different ways to define an ordering for the successors of nodes.
ComponentLayout
Represents a layout algorithm that arranges the connected components of a graph, allowing for the use of different layout styles and customization for component and edge arrangement.
ComponentLayoutData
Specifies custom data for the ComponentLayout.
CompositeLayoutData
Combines several LayoutData<TNode, TEdge, TNodeLabel, TEdgeLabel> instances.
ContextModificationStage
Temporarily modifies the LayoutGraphContext for the following layout algorithms.
CurveFittingStage
CurveFittingStage fits a piecewise cubic Bezier curve to given arbitrary edge paths.
DataKey
This is the base class of all look-up keys that are used to register IMapper<K, V> with a LayoutGraph.
EdgeBundleDescriptor
An EdgeBundleDescriptor defines the bundling settings of an edge.
EdgeBundling
An EdgeBundling instance defines if and how the edges of a graph should be bundled by an ILayoutAlgorithm, given that the algorithm supports edge bundling.
EdgeDataKey
This class is used as a look-up key for registering IMapper<K, V> for LayoutEdges with a LayoutGraph.
EdgeLabelDataKey
This class is used as a look-up key for registering IMapper<K, V> for LayoutEdgeLabels with a LayoutGraph.
EdgeLabelPreferredPlacement
An EdgeLabelPreferredPlacement describes the preferred placement of edge labels for automatic edge labeling algorithms.
EdgePathPoint
Represents a point on the path of an LayoutEdge, which can either correspond to a bend on the edge or to one of the two ports (source or target) of the edge.
EdgePortCandidates
This class associates LayoutPortCandidates with the endpoints of edges of a graph.
ExtendedEdgeLabelCandidate
A LabelCandidate that is associated with a label model parameter.
ExtendedNodeLabelCandidate
A LabelCandidate that is associated with a label model parameter.
GenericLayoutData
This class provides a way to easily pass custom item-specific data to the LayoutGraph which is used during the layout algorithm execution.
GenericLayoutGridStage
This stage offers generic support for LayoutGrid structures so that a grid can be considered even when running a layout algorithm that natively does not support it.
GenericLayoutGridStageData
Specifies the layout data for the GenericLayoutGridStage.
GivenCoordinatesLayout
GivenCoordinatesLayout changes node locations and sizes as well as edge paths to user-specified values before invoking the coreLayout.
GivenCoordinatesLayoutData
Specifies custom layout data for the GivenCoordinatesLayout.
GroupBoundsCalculator
This ILayoutGroupBoundsCalculator calculates the bounds of group nodes, allows to specify custom padding for each group node, and guarantees that their provided minimum sizes will be maintained.
GroupHidingStage
An ILayoutStage that hides the group nodes of hierarchically grouped graphs.
LayoutAbortController
Controls the early termination of graph algorithms.
LayoutAnchoringStage
LayoutAnchoringStage anchors the graph on an initial position based on either a single graph item or the alignment of the bounds of several items (but not the positions of the individual items).
LayoutAnchoringStageData
Specifies custom data for the LayoutAnchoringStage.
LayoutBend
Represents a bend on an LayoutEdge, which is a shared point between two consecutive straight-line segments of the edge's path.
LayoutData
Abstract base class for classes that specify custom data for a layout calculation on IGraph or LayoutGraph instances.
LayoutEdge
Represents a directed edge, a connection between two nodes, in the LayoutGraph data structure.
LayoutEdgeLabel
Represents a label associated with an edge in the graph data structure LayoutGraph.
LayoutExecutor
Executes a ILayoutAlgorithm and optionally animates the transition to the calculated layout.
LayoutExecutorAsync
Executes an algorithm or ILayoutAlgorithm on a graph asynchronously and optionally animates the transition to the new layout, afterward.
LayoutExecutorAsyncWorker
Executes an algorithm or ILayoutAlgorithm on a graph in a separate execution context.
LayoutGraph
Represents a directed graph structure that contains layout information for its elements and to which layout algorithms (ILayoutAlgorithm) can be applied.
LayoutGraphAdapter
Adapter class that can be used to obtain a layoutGraph from an IGraph.
LayoutGraphContext
This class is used to provide additional data to the graph and its elements that can be utilized by layout algorithms during computation.
LayoutGraphCopyData
Provides mappings between the copied and original graph items for layout graphs that are created as a copy of another graph using the createCopy method.
LayoutGraphGrouping
Provides access to the hierarchical structure of a LayoutGraph in the form of a grouping tree.
LayoutGraphHider
Provides functionality to temporarily hide and unhide nodes and edges of a graph.
LayoutGraphItem
Represents a common base type for both LayoutNode and LayoutEdge items within a LayoutGraph.
LayoutGrid
This class represents a layout grid that partitions the drawing area into rectangular layout grid cells.
LayoutGridCell
This class represents a single layout grid cell, i.e., a pair consisting of a row and a column.
LayoutGridCellDescriptor
This class represents cells of a layoutGrid structure.
LayoutGridColumn
This class represents a column of a LayoutGrid structure.
LayoutGridData
Specifies one or multiple LayoutGrids for a layout.
LayoutGridRow
This class represents a row of a LayoutGrid structure.
LayoutKeys
Helper class that provides unique identifiers for some general purpose DataKey<TValue> that are used for looking up data registered for the LayoutGraph and its items.
LayoutNode
Represents a node in the directed graph data structure LayoutGraph.
LayoutNodeLabel
Represents a label for a node within a LayoutGraph data structure.
LayoutPortCandidate
This class represents a candidate port on which edges can be connected to their source and/or target node.
LayoutStageBase
Abstract base class implementing ILayoutStage that handles the management of the coreLayout.
LayoutStageStack
Manages a collection of layout stages that can be executed in a stack-wise manner.
LayoutTransformations
Provides factory methods to create ILayoutStages for transforming a LayoutGraph.
LineWrappingStage
LineWrappingStage can line-wrap or column-wrap a graph layout.
MinimumNodeSizeStage
MinimumNodeSizeStage enforces a given minimum width/height of the nodes of a graph during the layout process.
NodeDataKey
This class is used as look-up key for registering IMapper<K, V> for LayoutNodes with a LayoutGraph.
NodeLabelDataKey
This class is used as look-up key for registering IMapper<K, V> for LayoutNodeLabels with a LayoutGraph.
NodeLayout
Represents the layout of a LayoutNode, defining its size and position within a two-dimensional plane.
NodePortCandidates
This class associates LayoutPortCandidates with the nodes of a graph.
OrientationStage
OrientationStage is an ILayoutStage that changes the orientation of the layout.
PlaceNodesAtBarycenterStage
PlaceNodesAtBarycenterStage temporarily hides the affectedNodes, applies the specified core layout algorithm (if any) to the resulting graph and, finally, reinserts the hidden nodes by placing them on the barycenter of their neighbors using the specified node sizes.
PlaceNodesAtBarycenterStageData
Specifies custom data for the PlaceNodesAtBarycenterStage.
PortData
Specifies custom data for constraining the port placement.
PortPlacementStage
The PortPlacementStage assigns edges to the ports specified by LayoutPortCandidates or NodePortCandidates after calling the coreLayout.
RadialGroupLayout
This layout algorithm arranges grouped graphs in a recursive structure.
RadialGroupLayoutData
Specifies custom data for the RadialGroupLayout.
RecursiveGroupLayout
This layout algorithm recursively traverses a hierarchically organized graph in a bottom-up fashion and applies a specified layout algorithm to the contents (direct children) of each group node.
RecursiveGroupLayoutData
Specifies custom data for the RecursiveGroupLayout.
RemoveCollinearBendsStage
The RemoveCollinearBendsStage removes all collinear bends found in a graph.
RemoveOverlapsStage
This ILayoutStage removes node overlaps and guarantees a certain minimum distance between nodes.
RemoveOverlapsStageData
Specifies custom data for the RemoveOverlapsStage.
RestoreToken
A token that can restore temporary changes.
ReverseEdgesStage
ReverseEdgesStage selectively reverses edges in a graph, while keeping the layout and label positions of the reversed edges as close to the pre-reversal layout and positions as possible.
ReverseEdgesStageData
Specifies custom data for the ReverseEdgesStage.
SequentialLayout
Represents a layout that sequentially executes multiple layout algorithms.
StructureGraphAdapter
Converts an IGraph instance into a structure-only LayoutGraph instance that is created by createStructureGraph.
SubgraphComponent
Represents a subgraph component of a graph used in ComponentLayout.
SubgraphLayoutStage
A SubgraphLayoutStage is an ILayoutStage that filters out all graph elements that are not part of a specific subgraph.
SubgraphLayoutStageData
Specifies custom data for the SubgraphLayoutStage.
TableLayoutConfigurator
Creates a LayoutGrid that matches a given table configuration of an IGraph and returns a LayoutGridData<TNode, TEdge, TNodeLabel, TEdgeLabel> for that grid.
TabularLayout
This layout algorithm places nodes in a tabular fashion.
TabularLayoutData
Specifies custom data for the TabularLayout.
TabularLayoutNodeDescriptor
This class is used by TabularLayout to provide placement details for nodes during the layout process.
TemporaryGroupDescriptor
This class allows specifying temporary groups for nodes that are considered by the TemporaryGroupInsertionStage.
TemporaryGroupInsertionData
Specifies custom data for the TemporaryGroupInsertionStage.
TemporaryGroupInsertionStage
TemporaryGroupInsertionStage is useful if nodes should be treated by layout algorithms as if they were actually grouped without the need to manually create a grouped graph for the layout process.
ValueDataKey
This class is used as look-up key for registering a single value with a graph.
I

Interfaces

ILayoutAlgorithm
ILayoutAlgorithm describes the general interface for algorithms that perform a layout process on a LayoutGraph.
ILayoutGroupBoundsCalculator
A ILayoutGroupBoundsCalculator is responsible for calculating the bounds of a group node during a layout process.
ILayoutStage
An ILayoutStage is an ILayoutAlgorithm that represents a stage of a multi-step layout process.
E

Enums

AlignmentStageAlignmentPolicy
Specifies the alignment policies that can be applied to nodes in a layout process.
BasicEdgeLabelPlacement
Edge labeling policies defining how edge labels are handled by layout algorithms with basic edge label support.
BasicNodeLabelPlacement
Node labeling policies defining how node labels are handled by layout algorithms with basic node label support.
ComponentArrangementStyle
Specifies different styles for arranging components in a ComponentLayout.
ConstraintOrientation
Orientations that specify the axis for which a linear constraint is defined.
CurveConnectionStyle
Enumeration to define how curved edge paths connect at the source and target side of the edge.
Direction
Defines four cardinal directions: Up, Right, Down, and Left.
EdgeLabelPlacement
Edge labeling policies defining how edge labels are handled by layout algorithms with integrated edge labeling support.
GroupSizePolicy
Specifies the policies for sizing group nodes within a graph layout.
HorizontalOverlapCriterion
Enum constants that specify the Horizontal overlap criterion for the RemoveOverlapsStage which takes effect when policy SHUFFLE is used.
LabelAlongEdgePlacements
Specifies preferred placement positions for edge labels along the edge path in a graph layout.
LabelAngleOnRightSideRotations
Specifies in which direction the rotation angle should be interpreted.
LabelAngleReferences
Specifies whether the rotation angle of edge labels should be interpreted absolute or relative to the edge slope.
LabelEdgeSides
Specifies preferred placement positions for edge labels relative to the edge path in a graph layout.
LabelPlacementPolicy
Defines how a label placement algorithm should place labels.
LabelSideReferences
Specifies how edge labels should be positioned relative to the edge or segment direction.
LayoutAnchoringPolicy
Specifies the policy for calculating the anchor point from individual graph items by the LayoutAnchoringStage.
LayoutOrientation
Specifies the orientation of a graph layout.
MirroredOrientations
Specifies which LayoutOrientations are mirrored by the OrientationStage.
NodeLabelPlacement
Node labeling policies defining how node labels are handled by layout algorithms with generic node labeling support.
OrientationStageEdgeLabelPlacement
Edge labeling policies defining how edge labels are handled by OrientationStage.
OverlapRemovalPolicy
Policies that describe how RemoveOverlapsStage removes node overlaps.
PartialLayoutRoutingStyle
Defines edge routing styles for ClearAreaLayout and PartialLayout.
PortAdjustmentPolicy
Specifies how port locations should be adjusted after a layout has been calculated.
PortCandidateType
Defines the different types of LayoutPortCandidates.
PortLabelPolicy
Specifies how ILabels at IPorts should be treated by the layout algorithm.
PortPlacementPolicy
Defines how a layout algorithm should place ports.
PortSides
Specifies the possible sides of a node where ports can be located.
RadialEdgeLabelPlacement
Edge labeling policies defining how edge labels are handled by layout algorithms with radial layout styles.
RadialNodeLabelPlacement
Node labeling policies defining how node labels are handled by layout algorithms with radial layout styles that support integrated node labeling.
RelativePosition
Specifies the position of an element in relation to another element.
RouteCorrectionPolicy
Specifies how the PortPlacementStage corrects the edge paths after moving the ports to the locations specified by LayoutPortCandidates or NodePortCandidatess.
Side
Defines four cardinal sides of a two-dimensional area: Top, Right, Bottom, and Left.
TabularLayoutEdgeLabelPlacement
Edge labeling policies defining how edge labels are handled by the TabularLayout.
TabularLayoutMode
Specifies different strategies for determining the size and arrangement of a TabularLayout.