PartialLayout (yFiles-for-JavaFX-Complete-3.0 API)

java.lang.Object
- com.yworks.yfiles.layout.AbstractLayoutStage
- - com.yworks.yfiles.layout.partial.PartialLayout

All Implemented Interfaces:

ILayoutAlgorithm, ILayoutStage
```
public class PartialLayout
extends AbstractLayoutStage
```
This class represents a partial layout algorithm which changes the coordinates for a given set of graph elements (called partial elements) only.
The location and size of the remaining elements (called fixed elements) is not allowed to be changed.
Layout Style

This partial layout algorithm offers a kind of generic partial layout support for other existing layout algorithms. Hence, its layout style heavily depends on the selected core layout algorithm as well as the specified edge router or edge routing strategy.

The partial layout is suitable for applications where users may incrementally add new elements to an existing drawing. The added elements should be arranged so that they fit best possible into the given diagram without making any changes to the already existing layout. Hence, the so-called mental map of the existing drawing is preserved.

The input graph where marked nodes denote the partial elements that were incrementally added to the existing diagram. The result of a partial layout run with component assignment strategy set to ComponentAssignmentStrategy.SINGLE and with node alignment enabled.
Features

Similar to the layout style, the supported feature set mainly depends on the features supported by the specified core layout algorithm as well as the specified edge router or edge routing strategy. The internal step that places the components can handle group nodes as well as minimum distance constraints. Furthermore, it is able to consider node labels.

Concept
The layout algorithm tries to place the partial elements such that the resulting drawing (including the fixed elements) has a good quality with respect to common graph drawing aesthetics.

The layout algorithm handles each selected graph element as partial element. For this, it looks up the IDataProvider keys AFFECTED_NODES_DPKEY and AFFECTED_EDGES_DPKEY. Partial node elements can be assigned to the so-called subgraph components. During the layout process each subgraph induced by the nodes of a component is first laid out using the specified core layout algorithm. Then, the different components are placed one-by-one onto the drawing area such that the number of overlaps among graph elements is small. The user can specify different objectives for finding 'good' positions for subgraph components (see SubgraphPlacement), e.g., SubgraphPlacement.BARYCENTER specifies that the component should be placed close to the barycenter of its graph neighbors and SubgraphPlacement.FROM_SKETCH specifies that the component should be placed close to its original position.

Method ComponentAssignmentStrategy allows to specify the strategy that assigns partial nodes to subgraph components. Possible values are ComponentAssignmentStrategy.CLUSTERING, ComponentAssignmentStrategy.CONNECTED, ComponentAssignmentStrategy.SINGLE and ComponentAssignmentStrategy.CUSTOMIZED. The last value allows to use a customized component assignment. Note that nodes of a component cannot be assigned to different group nodes.

Furthermore, the user can specify the edge routing strategy (see EdgeRoutingStrategy) that is used for routing partial edges and edges between different subgraph components (so-called inter-edges). Possible values are EdgeRoutingStrategy.ORGANIC, EdgeRoutingStrategy.ORTHOGONAL, EdgeRoutingStrategy.STRAIGHTLINE, EdgeRoutingStrategy.OCTILINEAR and EdgeRoutingStrategy.AUTOMATIC.

When a partial node should be placed inside a fixed group node, it is important that there is enough free space inside the group. Otherwise, there may be overlapping node elements.

Field Summary

Fields
Modifier and Type	Field and Description
`static EdgeDpKey<Boolean>`	`AFFECTED_EDGES_DPKEY` A `DataProvider` key for marking partial edges.
`static NodeDpKey<Boolean>`	`AFFECTED_NODES_DPKEY` A `DataProvider` key for marking partial nodes.
`static NodeDpKey<Object>`	`COMPONENT_ID_DPKEY` A `DataProvider` key for defining custom subgraph components.
`static EdgeDpKey<Boolean>`	`DIRECTED_EDGES_DPKEY` A `DataProvider` key for specifying the edges that should be considered to be directed.
`static EdgeDpKey<Boolean>`	`ROUTE_EDGE_DPKEY` A `DataProvider` key for obtaining the edges that should be routed by the edge router.

Constructor Summary

Constructors
Constructor and Description
`PartialLayout()` Creates a new instance of `PartialLayout` which uses the specified `ILayoutAlgorithm` instance as the core layout algorithm.
`PartialLayout(ILayoutAlgorithm subgraphLayouter)` Creates a new instance of `PartialLayout` which uses the specified `ILayoutAlgorithm` instance as the core layout algorithm.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`applyLayout(LayoutGraph graph)` This method calculates the partial layout.
`protected void`	`configureEdgeRouter(ILayoutAlgorithm edgeRouter)` This method is called each time when edges are routed with an edge router.
`ComponentAssignmentStrategy`	`getComponentAssignmentStrategy()` Gets the strategy that assigns partial nodes to subgraph components.
`ILayoutAlgorithm`	`getCoreLayout()` Gets the `ILayoutAlgorithm` instance that is applied to each subgraph component.
`ILayoutAlgorithm`	`getEdgeRouter()` Gets the custom edge router instance that is used for partial edges and edges between different subgraph components (so-called inter-edges).
`EdgeRoutingStrategy`	`getEdgeRoutingStrategy()` Gets the routing strategy that is used for partial edges and edges between different subgraph components (so-called inter-edges).
`LayoutOrientation`	`getLayoutOrientation()` Gets the layout orientation that is considered during the placement of partial elements.
`long`	`getMaximumDuration()` Gets the preferred time limit (in milliseconds) for the layout algorithm.
`int`	`getMinimumNodeDistance()` Gets the minimum distance between two adjacent nodes.
`SubgraphPlacement`	`getSubgraphPlacement()` Gets the objective used for finding 'good' positions for subgraph components.
`boolean`	`isComponentCompactionEnabled()` Gets whether or not a subgraph component may be placed within another subgraph component.
`boolean`	`isImmediateInterEdgeRoutingEnabled()` Gets whether or not edges between different subgraph components should be routed immediately.
`boolean`	`isMirroringAllowed()` Gets whether or not subgraph components are mirrored to improve the layout quality.
`boolean`	`isNodeAlignmentConsiderationEnabled()` Gets whether or not partial nodes should be aligned.
`boolean`	`isOrientationOptimizationEnabled()` Gets whether or not a postprocessing step should be applied to reduce the number of directed edges that do not comply with the specified layout orientation.
`boolean`	`isResizeFixedGroups()` Gets whether or not fixed (non-partial) group nodes may be resized.
`protected void`	`layoutSubgraph(LayoutGraph subGraph)` This method is called during the `layout process` and calculates the layout for the given subgraph component using the specified `core layout algorithm`.
`protected void`	`placeSubgraphs(LayoutGraph graph, NodeList[] subgraphComponents)` This method is called during the `layout process` and places the subgraph components one-by-one onto the drawing area.
`protected void`	`routeEdgesBetweenFixedElements(LayoutGraph graph, EdgeList partialEdges)` This method is called during the `layout process` and routes all partial edges that connect two fixed elements.
`protected void`	`routeInterEdges(LayoutGraph graph, EdgeList interEdges)` This method is called during the `layout process` and routes all inter-edges.
`void`	`setComponentAssignmentStrategy(ComponentAssignmentStrategy value)` Sets the strategy that assigns partial nodes to subgraph components.
`void`	`setComponentCompactionEnabled(boolean value)` Sets whether or not a subgraph component may be placed within another subgraph component.
`void`	`setCoreLayout(ILayoutAlgorithm value)` Sets the `ILayoutAlgorithm` instance that is applied to each subgraph component.
`void`	`setEdgeRouter(ILayoutAlgorithm value)` Sets the custom edge router instance that is used for partial edges and edges between different subgraph components (so-called inter-edges).
`void`	`setEdgeRoutingStrategy(EdgeRoutingStrategy value)` Sets the routing strategy that is used for partial edges and edges between different subgraph components (so-called inter-edges).
`void`	`setImmediateInterEdgeRoutingEnabled(boolean value)` Sets whether or not edges between different subgraph components should be routed immediately.
`void`	`setLayoutOrientation(LayoutOrientation value)` Sets the layout orientation that is considered during the placement of partial elements.
`void`	`setMaximumDuration(long value)` Sets the preferred time limit (in milliseconds) for the layout algorithm.
`void`	`setMinimumNodeDistance(int value)` Sets the minimum distance between two adjacent nodes.
`void`	`setMirroringAllowed(boolean value)` Sets whether or not subgraph components are mirrored to improve the layout quality.
`void`	`setNodeAlignmentConsiderationEnabled(boolean value)` Sets whether or not partial nodes should be aligned.
`void`	`setOrientationOptimizationEnabled(boolean value)` Sets whether or not a postprocessing step should be applied to reduce the number of directed edges that do not comply with the specified layout orientation.
`void`	`setResizeFixedGroups(boolean value)` Sets whether or not fixed (non-partial) group nodes may be resized.
`void`	`setSubgraphPlacement(SubgraphPlacement value)` Sets the objective used for finding 'good' positions for subgraph components.

Methods inherited from class com.yworks.yfiles.layout.AbstractLayoutStage
applyLayoutCore

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - AFFECTED_EDGES_DPKEY
```
public static final EdgeDpKey<Boolean> AFFECTED_EDGES_DPKEY
```
    A DataProvider key for marking partial edges.
    
    All edges with at least one partial endpoint are automatically considered to be partial.
    
    See Also:
    
    AFFECTED_NODES_DPKEY
  - AFFECTED_NODES_DPKEY
```
public static final NodeDpKey<Boolean> AFFECTED_NODES_DPKEY
```
    A DataProvider key for marking partial nodes.
    
    See Also:
    
    AFFECTED_EDGES_DPKEY
  - COMPONENT_ID_DPKEY
```
public static final NodeDpKey<Object> COMPONENT_ID_DPKEY
```
    A DataProvider key for defining custom subgraph components.
    
    The associated IDataProvider is only considered if ComponentAssignmentStrategy is set to ComponentAssignmentStrategy.CUSTOMIZED.
    
    Nodes of a subgraph component cannot be assigned to different group nodes or different partition cells.
    
    See Also:
    
    ComponentAssignmentStrategy.CUSTOMIZED, setComponentAssignmentStrategy(ComponentAssignmentStrategy)
  - DIRECTED_EDGES_DPKEY
```
public static final EdgeDpKey<Boolean> DIRECTED_EDGES_DPKEY
```
    A DataProvider key for specifying the edges that should be considered to be directed.
    If a layout orientation is specified (i.e., LayoutOrientation is not LayoutOrientation.NONE), the algorithm tries to route directed edges such that they adhere to that orientation.
    
    If this IDataProvider is not registered, all edges are considered to be directed.
    
    See Also:
    
    setLayoutOrientation(LayoutOrientation)
  - ROUTE_EDGE_DPKEY
```
public static final EdgeDpKey<Boolean> ROUTE_EDGE_DPKEY
```
    A DataProvider key for obtaining the edges that should be routed by the edge router.
    
    The associated IDataProvider must not be set by the user! The key is used by this algorithm to temporarily add a IDataProvider that marks edges that should be routed by the specified edge router, see EdgeRouter.
    
    See Also:
    
    setEdgeRouter(ILayoutAlgorithm)
- Constructor Detail
  - PartialLayout
```
public PartialLayout()
```
    Creates a new instance of PartialLayout which uses the specified ILayoutAlgorithm instance as the core layout algorithm.
    This instance is applied to each subgraph component, see ComponentAssignmentStrategy.
    
    See Also:
    
    setComponentAssignmentStrategy(ComponentAssignmentStrategy)
  - PartialLayout
```
public PartialLayout(ILayoutAlgorithm subgraphLayouter)
```
    Creates a new instance of PartialLayout which uses the specified ILayoutAlgorithm instance as the core layout algorithm.
    This instance is applied to each subgraph component, see ComponentAssignmentStrategy.
    
    Parameters:
    
    subgraphLayouter - the layout algorithm that is applied to the subgraph components
    
    See Also:
    
    setComponentAssignmentStrategy(ComponentAssignmentStrategy)
- Method Detail
  - applyLayout
```
public void applyLayout(LayoutGraph graph)
```
    This method calculates the partial layout.
    It calls the following methods:
    1. routeEdgesBetweenFixedElements(LayoutGraph, EdgeList)
    2. layoutSubgraph(LayoutGraph) for each subgraph component
    3. placeSubgraphs(LayoutGraph, NodeList[])
    4. routeInterEdges(LayoutGraph, EdgeList)
    Specified by:
    
    applyLayout in interface ILayoutAlgorithm
    
    Specified by:
    
    applyLayout in class AbstractLayoutStage
    
    The above methods are called after applying the OrientationLayout. Hence, they always assume that the graph is drawn from top to bottom.
    
    Parameters:
    
    graph - the input graph
  - configureEdgeRouter
```
protected void configureEdgeRouter(ILayoutAlgorithm edgeRouter)
```
    This method is called each time when edges are routed with an edge router.
    Subclasses may modify the configuration of the given edge router instance.
    
    The type of the given instance depends on the edge routing strategy, i.e., if the routing strategy is set to EdgeRoutingStrategy.OCTILINEAR or EdgeRoutingStrategy.ORTHOGONAL it's an instance of EdgeRouter, if the routing strategy is set to EdgeRoutingStrategy.ORGANIC it's an instance of OrganicLayout, and, if the routing strategy is set to EdgeRoutingStrategy.STRAIGHTLINE it's an instance of a private StraightLineEdgeRouter. If the edge routing strategy is set to EdgeRoutingStrategy.AUTOMATIC, the layout algorithm chooses one of the above strategies that best fits the routing style of the fixed edges.
    
    If a custom edge router is set (see EdgeRouter), its instance corresponds to that of the parameter.
    
    Parameters:
    
    edgeRouter - the instance used for routing the edges
    
    See Also:
    
    setEdgeRouter(ILayoutAlgorithm), setEdgeRoutingStrategy(EdgeRoutingStrategy)
  - getComponentAssignmentStrategy
```
public ComponentAssignmentStrategy getComponentAssignmentStrategy()
```
    Gets the strategy that assigns partial nodes to subgraph components.
    The specified core layouter (see CoreLayout) independently calculates the layout for each such subgraph component.
    
    Throws:
    
    IllegalArgumentException - if the specified strategy does not match one of the predefined assignment strategies.
    
    Default Value:
    The default value is ComponentAssignmentStrategy.SINGLE. Each partial node is assigned to a separate subgraph component.
    
    Returns:
    
    one of the predefined assignment strategies
    
    See Also:
    
    setCoreLayout(ILayoutAlgorithm), setComponentAssignmentStrategy(ComponentAssignmentStrategy)
  - getCoreLayout
```
public ILayoutAlgorithm getCoreLayout()
```
    Gets the ILayoutAlgorithm instance that is applied to each subgraph component.
    More precisely, during the layout process each subgraph induced by the (partial) nodes of a component (see ComponentAssignmentStrategy) is first laid out using this instance.
    
    Specified by:
    
    getCoreLayout in interface ILayoutStage
    
    Overrides:
    
    getCoreLayout in class AbstractLayoutStage
    
    Returns:
    
    the ILayoutAlgorithm instance that is applied to each subgraph component
    
    See Also:
    
    setCoreLayout(ILayoutAlgorithm)
  - getEdgeRouter
```
public ILayoutAlgorithm getEdgeRouter()
```
    Gets the custom edge router instance that is used for partial edges and edges between different subgraph components (so-called inter-edges).
    
    Calling method EdgeRoutingStrategy automatically sets a new edge router instance according to the specified routing strategy.
    
    Edges that have to be routed with the specified router will be marked using IDataProvider key ROUTE_EDGE_DPKEY. Hence, the specified router has to be configured such that it observes this key and only routes marked edges!
    
    Default Value:
    The default value is StraightLineEdgeRouter
    
    Returns:
    
    the custom edge router instance that is used for partial edges and edges between different subgraph components
    
    See Also:
    
    ROUTE_EDGE_DPKEY, setEdgeRoutingStrategy(EdgeRoutingStrategy), setEdgeRouter(ILayoutAlgorithm)
  - getEdgeRoutingStrategy
```
public EdgeRoutingStrategy getEdgeRoutingStrategy()
```
    Gets the routing strategy that is used for partial edges and edges between different subgraph components (so-called inter-edges).
    
    Throws:
    
    IllegalArgumentException - if the specified strategy does not match one of the predefined routing strategies
    
    Calling this method disables a previously set customized edge router, see method EdgeRouter.
    
    Default Value:
    The default value is EdgeRoutingStrategy.STRAIGHTLINE
    
    Returns:
    
    one of the predefined edge routing strategies
    
    See Also:
    
    setEdgeRouter(ILayoutAlgorithm), setEdgeRoutingStrategy(EdgeRoutingStrategy)
  - getLayoutOrientation
```
public LayoutOrientation getLayoutOrientation()
```
    Gets the layout orientation that is considered during the placement of partial elements.
    More precisely, the algorithm tries to place each subgraph component such that each predecessor of a component's node v is placed before v and each successor after v with respect to the layout orientation.
    
    Throws:
    
    IllegalArgumentException - if the specified orientation does not match one of the predefined orientations
    
    This specifier only affects the placement of nodes of different subgraph components that are connected by directed edges. For nodes of the same subgraph component the layout orientation depends on the chosen core layout algorithm.
    
    Default Value:
    The default value is LayoutOrientation.NONE. The layout orientation is completely ignored.
    
    Returns:
    
    one of the predefined layout orientations
    
    See Also:
    
    DIRECTED_EDGES_DPKEY, setLayoutOrientation(LayoutOrientation)
  - getMaximumDuration
```
public long getMaximumDuration()
```
    Gets the preferred time limit (in milliseconds) for the layout algorithm.
    The specified value has to be greater than or equal to 0. If the value is Integer.MAX_VALUE, the time is not limited.
    
    Throws:
    
    IllegalArgumentException - if the maximum duration is negative
    
    Restricting the maximum duration may result in a worse layout quality. Furthermore, the real runtime may exceed the maximum duration since the layout algorithm still has to find a valid solution.
    
    Default Value:
    The default value is Integer.MAX_VALUE. The time is not limited.
    
    Returns:
    
    the preferred time limit
    
    See Also:
    
    setMaximumDuration(long)
  - getMinimumNodeDistance
```
public int getMinimumNodeDistance()
```
    Gets the minimum distance between two adjacent nodes.
    The specified value has to be non-negative.
    
    Throws:
    
    IllegalArgumentException - if the distance is negative
    
    Default Value:
    The default value is 10.
    
    Returns:
    
    the non-negative minimum distance
    
    See Also:
    
    setMinimumNodeDistance(int)
  - getSubgraphPlacement
```
public SubgraphPlacement getSubgraphPlacement()
```
    Gets the objective used for finding 'good' positions for subgraph components.
    
    Throws:
    
    IllegalArgumentException - if the specified strategy does not match one of the predefined positioning strategies
    
    Default Value:
    The default value is SubgraphPlacement.BARYCENTER. Each subgraph component is placed close to the barycenter of its graph neighbors.
    
    Returns:
    
    one of the predefined positioning strategies
    
    See Also:
    
    setSubgraphPlacement(SubgraphPlacement)
  - isComponentCompactionEnabled
```
public boolean isComponentCompactionEnabled()
```
    Gets whether or not a subgraph component may be placed within another subgraph component.
    Enabling this option leads to more compact layout results but requires more runtime.
    
    Default Value:
    The default value is true. Subgraph component may be placed within another subgraph component.
    
    Returns:
    
    true if a subgraph component may be placed within another subgraph component, false otherwise
    
    See Also:
    
    setComponentCompactionEnabled(boolean)
  - isImmediateInterEdgeRoutingEnabled
```
public boolean isImmediateInterEdgeRoutingEnabled()
```
    Gets whether or not edges between different subgraph components should be routed immediately.
    If this option is enabled, edges are routed during the placement of the subgraph components, i.e., immediately after a component is placed, its edges to other already placed components are routed. Otherwise, these edges are routed in a separate step after placing all subgraph components. Hence, while enabling this option usually leads to shorter edge routes, the placement of subgraph components is less compact.
    
    Default Value:
    The default value is false. Edges are not routed immediately.
    
    Returns:
    
    true if edges between different subgraph components are routed immediately, false otherwise.
    
    See Also:
    
    routeInterEdges(LayoutGraph, EdgeList), placeSubgraphs(LayoutGraph, NodeList[]), setImmediateInterEdgeRoutingEnabled(boolean)
  - isMirroringAllowed
```
public boolean isMirroringAllowed()
```
    Gets whether or not subgraph components are mirrored to improve the layout quality.
    If enabled, the algorithm checks for each component which of the four possible mirrorings minimizes the edge length.
    
    Default Value:
    The default value is false. Mirroring is disabled.
    
    Returns:
    
    true if subgraph components are mirrored, false otherwise
    
    See Also:
    
    setMirroringAllowed(boolean)
  - isNodeAlignmentConsiderationEnabled
```
public boolean isNodeAlignmentConsiderationEnabled()
```
    Gets whether or not partial nodes should be aligned.
    If this option is enabled, the algorithm tries to align the center of partial nodes with other nodes.
    
    Since the specified core layout algorithm doesn't consider this option, the alignment works best if the component assignment is set to ComponentAssignmentStrategy.SINGLE.
    
    Default Value:
    The default value is false. Nodes are not aligned.
    
    Returns:
    
    true if nodes are aligned, false otherwise
    
    See Also:
    
    setNodeAlignmentConsiderationEnabled(boolean)
  - isOrientationOptimizationEnabled
```
public boolean isOrientationOptimizationEnabled()
```
    Gets whether or not a postprocessing step should be applied to reduce the number of directed edges that do not comply with the specified layout orientation.
    
    Default Value:
    The default value is true. This postprocessing step is enabled.
    
    Returns:
    
    true if this postprocessing step is applied, false otherwise
    
    See Also:
    
    setLayoutOrientation(LayoutOrientation), DIRECTED_EDGES_DPKEY, setOrientationOptimizationEnabled(boolean)
  - isResizeFixedGroups
```
public boolean isResizeFixedGroups()
```
    Gets whether or not fixed (non-partial) group nodes may be resized.
    Enabling this option may lead to better results if there are fixed group nodes, since there is more space for the partial elements.
    
    Default Value:
    The default value is false. Fixed group nodes may not be resized.
    
    Returns:
    
    true if fixed group nodes may be resized, false otherwise
    
    See Also:
    
    setResizeFixedGroups(boolean)
  - layoutSubgraph
```
protected void layoutSubgraph(LayoutGraph subGraph)
```
    This method is called during the layout process and calculates the layout for the given subgraph component using the specified core layout algorithm.
    It is called once for each subgraph component.
    
    Subclasses may implement a custom layout strategy or add some additional data.
    
    Parameters:
    
    subGraph - the subgraph component
  - placeSubgraphs
```
protected void placeSubgraphs(LayoutGraph graph,
                              NodeList[] subgraphComponents)
```
    This method is called during the layout process and places the subgraph components one-by-one onto the drawing area.
    Therefore, it considers the specified objective for finding a suitable position.
    
    Subclasses may implement a custom placement strategy or add some additional data. However, they must not modify the given subgraph component lists.
    
    Parameters:
    
    graph - the input graph
    
    subgraphComponents - each entry contains a NodeList that induces a subgraph component
  - routeEdgesBetweenFixedElements
```
protected void routeEdgesBetweenFixedElements(LayoutGraph graph,
                                              EdgeList partialEdges)
```
    This method is called during the layout process and routes all partial edges that connect two fixed elements.
    It either uses a custom edge router or an internal edge router that produces routes according to the specified routing strategy.
    
    Subclasses may implement a custom routing strategy or add some additional data.
    
    Parameters:
    
    graph - the subgraph of the input graph induced by the fixed nodes
    
    partialEdges - the list of partial edges to be routed
  - routeInterEdges
```
protected void routeInterEdges(LayoutGraph graph,
                               EdgeList interEdges)
```
    This method is called during the layout process and routes all inter-edges.
    Inter-edges are edges between different subgraph components including edges between fixed and partial elements. For the routing, this method uses the edge router instance set with method EdgeRouter. If no edge router was specified by the user, it uses an internal edge router with routing strategy EdgeRoutingStrategy.
    
    Subclasses may implement a custom routing strategy or add some additional data.
    
    Parameters:
    
    graph - the relevant subgraph
    
    interEdges - the list of inter-edges to be routed
  - setComponentAssignmentStrategy
```
public void setComponentAssignmentStrategy(ComponentAssignmentStrategy value)
```
    Sets the strategy that assigns partial nodes to subgraph components.
    The specified core layouter (see CoreLayout) independently calculates the layout for each such subgraph component.
    
    Throws:
    
    IllegalArgumentException - if the specified strategy does not match one of the predefined assignment strategies.
    
    Default Value:
    The default value is ComponentAssignmentStrategy.SINGLE. Each partial node is assigned to a separate subgraph component.
    
    Parameters:
    
    value - one of the predefined assignment strategies
    
    See Also:
    
    setCoreLayout(ILayoutAlgorithm), getComponentAssignmentStrategy()
  - setComponentCompactionEnabled
```
public void setComponentCompactionEnabled(boolean value)
```
    Sets whether or not a subgraph component may be placed within another subgraph component.
    Enabling this option leads to more compact layout results but requires more runtime.
    
    Default Value:
    The default value is true. Subgraph component may be placed within another subgraph component.
    
    Parameters:
    
    value - true if a subgraph component may be placed within another subgraph component, false otherwise
    
    See Also:
    
    isComponentCompactionEnabled()
  - setCoreLayout
```
public void setCoreLayout(ILayoutAlgorithm value)
```
    Sets the ILayoutAlgorithm instance that is applied to each subgraph component.
    More precisely, during the layout process each subgraph induced by the (partial) nodes of a component (see ComponentAssignmentStrategy) is first laid out using this instance.
    
    Specified by:
    
    setCoreLayout in interface ILayoutStage
    
    Overrides:
    
    setCoreLayout in class AbstractLayoutStage
    
    Parameters:
    
    value - the ILayoutAlgorithm instance that is applied to each subgraph component
    
    See Also:
    
    getCoreLayout()
  - setEdgeRouter
```
public void setEdgeRouter(ILayoutAlgorithm value)
```
    Sets the custom edge router instance that is used for partial edges and edges between different subgraph components (so-called inter-edges).
    
    Calling method EdgeRoutingStrategy automatically sets a new edge router instance according to the specified routing strategy.
    
    Edges that have to be routed with the specified router will be marked using IDataProvider key ROUTE_EDGE_DPKEY. Hence, the specified router has to be configured such that it observes this key and only routes marked edges!
    
    Default Value:
    The default value is StraightLineEdgeRouter
    
    Parameters:
    
    value - the custom edge router instance that is used for partial edges and edges between different subgraph components
    
    See Also:
    
    ROUTE_EDGE_DPKEY, setEdgeRoutingStrategy(EdgeRoutingStrategy), getEdgeRouter()
  - setEdgeRoutingStrategy
```
public void setEdgeRoutingStrategy(EdgeRoutingStrategy value)
```
    Sets the routing strategy that is used for partial edges and edges between different subgraph components (so-called inter-edges).
    
    Throws:
    
    IllegalArgumentException - if the specified strategy does not match one of the predefined routing strategies
    
    Calling this method disables a previously set customized edge router, see method EdgeRouter.
    
    Default Value:
    The default value is EdgeRoutingStrategy.STRAIGHTLINE
    
    Parameters:
    
    value - one of the predefined edge routing strategies
    
    See Also:
    
    setEdgeRouter(ILayoutAlgorithm), getEdgeRoutingStrategy()
  - setImmediateInterEdgeRoutingEnabled
```
public void setImmediateInterEdgeRoutingEnabled(boolean value)
```
    Sets whether or not edges between different subgraph components should be routed immediately.
    If this option is enabled, edges are routed during the placement of the subgraph components, i.e., immediately after a component is placed, its edges to other already placed components are routed. Otherwise, these edges are routed in a separate step after placing all subgraph components. Hence, while enabling this option usually leads to shorter edge routes, the placement of subgraph components is less compact.
    
    Default Value:
    The default value is false. Edges are not routed immediately.
    
    Parameters:
    
    value - true if edges between different subgraph components are routed immediately, false otherwise.
    
    See Also:
    
    routeInterEdges(LayoutGraph, EdgeList), placeSubgraphs(LayoutGraph, NodeList[]), isImmediateInterEdgeRoutingEnabled()
  - setLayoutOrientation
```
public void setLayoutOrientation(LayoutOrientation value)
```
    Sets the layout orientation that is considered during the placement of partial elements.
    More precisely, the algorithm tries to place each subgraph component such that each predecessor of a component's node v is placed before v and each successor after v with respect to the layout orientation.
    
    Throws:
    
    IllegalArgumentException - if the specified orientation does not match one of the predefined orientations
    
    This specifier only affects the placement of nodes of different subgraph components that are connected by directed edges. For nodes of the same subgraph component the layout orientation depends on the chosen core layout algorithm.
    
    Default Value:
    The default value is LayoutOrientation.NONE. The layout orientation is completely ignored.
    
    Parameters:
    
    value - one of the predefined layout orientations
    
    See Also:
    
    DIRECTED_EDGES_DPKEY, getLayoutOrientation()
  - setMaximumDuration
```
public void setMaximumDuration(long value)
```
    Sets the preferred time limit (in milliseconds) for the layout algorithm.
    The specified value has to be greater than or equal to 0. If the value is Integer.MAX_VALUE, the time is not limited.
    
    Throws:
    
    IllegalArgumentException - if the maximum duration is negative
    
    Restricting the maximum duration may result in a worse layout quality. Furthermore, the real runtime may exceed the maximum duration since the layout algorithm still has to find a valid solution.
    
    Default Value:
    The default value is Integer.MAX_VALUE. The time is not limited.
    
    Parameters:
    
    value - the preferred time limit
    
    See Also:
    
    getMaximumDuration()
  - setMinimumNodeDistance
```
public void setMinimumNodeDistance(int value)
```
    Sets the minimum distance between two adjacent nodes.
    The specified value has to be non-negative.
    
    Throws:
    
    IllegalArgumentException - if the distance is negative
    
    Default Value:
    The default value is 10.
    
    Parameters:
    
    value - the non-negative minimum distance
    
    See Also:
    
    getMinimumNodeDistance()
  - setMirroringAllowed
```
public void setMirroringAllowed(boolean value)
```
    Sets whether or not subgraph components are mirrored to improve the layout quality.
    If enabled, the algorithm checks for each component which of the four possible mirrorings minimizes the edge length.
    
    Default Value:
    The default value is false. Mirroring is disabled.
    
    Parameters:
    
    value - true if subgraph components are mirrored, false otherwise
    
    See Also:
    
    isMirroringAllowed()
  - setNodeAlignmentConsiderationEnabled
```
public void setNodeAlignmentConsiderationEnabled(boolean value)
```
    Sets whether or not partial nodes should be aligned.
    If this option is enabled, the algorithm tries to align the center of partial nodes with other nodes.
    
    Since the specified core layout algorithm doesn't consider this option, the alignment works best if the component assignment is set to ComponentAssignmentStrategy.SINGLE.
    
    Default Value:
    The default value is false. Nodes are not aligned.
    
    Parameters:
    
    value - true if nodes are aligned, false otherwise
    
    See Also:
    
    isNodeAlignmentConsiderationEnabled()
  - setOrientationOptimizationEnabled
```
public void setOrientationOptimizationEnabled(boolean value)
```
    Sets whether or not a postprocessing step should be applied to reduce the number of directed edges that do not comply with the specified layout orientation.
    
    Default Value:
    The default value is true. This postprocessing step is enabled.
    
    Parameters:
    
    value - true if this postprocessing step is applied, false otherwise
    
    See Also:
    
    setLayoutOrientation(LayoutOrientation), DIRECTED_EDGES_DPKEY, isOrientationOptimizationEnabled()
  - setResizeFixedGroups
```
public void setResizeFixedGroups(boolean value)
```
    Sets whether or not fixed (non-partial) group nodes may be resized.
    Enabling this option may lead to better results if there are fixed group nodes, since there is more space for the partial elements.
    
    Default Value:
    The default value is false. Fixed group nodes may not be resized.
    
    Parameters:
    
    value - true if fixed group nodes may be resized, false otherwise
    
    See Also:
    
    isResizeFixedGroups()
  - setSubgraphPlacement
```
public void setSubgraphPlacement(SubgraphPlacement value)
```
    Sets the objective used for finding 'good' positions for subgraph components.
    
    Throws:
    
    IllegalArgumentException - if the specified strategy does not match one of the predefined positioning strategies
    
    Default Value:
    The default value is SubgraphPlacement.BARYCENTER. Each subgraph component is placed close to the barycenter of its graph neighbors.
    
    Parameters:
    
    value - one of the predefined positioning strategies
    
    See Also:
    
    getSubgraphPlacement()

Class PartialLayout

Layout Style

Features

Concept

Field Summary

Constructor Summary

Method Summary

Methods inherited from class com.yworks.yfiles.layout.AbstractLayoutStage

Methods inherited from class java.lang.Object

Field Detail

AFFECTED_EDGES_DPKEY

AFFECTED_NODES_DPKEY

COMPONENT_ID_DPKEY

DIRECTED_EDGES_DPKEY

ROUTE_EDGE_DPKEY

Constructor Detail

PartialLayout

PartialLayout

Method Detail

applyLayout

configureEdgeRouter

getComponentAssignmentStrategy

getCoreLayout

getEdgeRouter

getEdgeRoutingStrategy

getLayoutOrientation

getMaximumDuration

getMinimumNodeDistance

getSubgraphPlacement

isComponentCompactionEnabled

isImmediateInterEdgeRoutingEnabled

isMirroringAllowed

isNodeAlignmentConsiderationEnabled

isOrientationOptimizationEnabled

isResizeFixedGroups

layoutSubgraph

placeSubgraphs

routeEdgesBetweenFixedElements

routeInterEdges

setComponentAssignmentStrategy

setComponentCompactionEnabled

setCoreLayout

setEdgeRouter

setEdgeRoutingStrategy

setImmediateInterEdgeRoutingEnabled

setLayoutOrientation

setMaximumDuration

setMinimumNodeDistance

setMirroringAllowed

setNodeAlignmentConsiderationEnabled

setOrientationOptimizationEnabled

setResizeFixedGroups

setSubgraphPlacement