| Package | com.yworks.yfiles.layout.partial |
| Class | public class PartialLayouter |
| Inheritance | PartialLayouter  AbstractLayoutStage YObject Object |
This layouter can be applied to plain graphs as well as to grouped graphs. Note: 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.
The layouter handles each selected graph element as partial element. Therefore it looks up the data provider keys PARTIAL_NODES_DPKEY and PARTIAL_EDGES_DPKEY . Partial node elements can be assigned to 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 layouter coreLayouter . 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 ( positioningStrategy), e.g., SUBGRAPH_POSITIONING_STRATEGY_BARYCENTER specifies that the component should be placed close to the barycenter of its graph neighbors and SUBGRAPH_POSITIONING_STRATEGY_FROM_SKETCH specifies that the component should be placed close to its original position.
Method componentAssignmentStrategy allows to specify the strategy that is used to assign partial nodes to subgraph components. Possible values are COMPONENT_ASSIGNMENT_STRATEGY_CLUSTERING, COMPONENT_ASSIGNMENT_STRATEGY_CONNECTED, COMPONENT_ASSIGNMENT_STRATEGY_SINGLE and COMPONENT_ASSIGNMENT_STRATEGY_CUSTOMIZED . The last value allows to use a customized component assignment. Note: nodes of a component cannot be assigned to different group nodes.
Furthermore, the user can specify the edge routing strategy (method edgeRoutingStrategy) that is used for routing partial edges and edges between different subgraph components (so-called inter-edges). Possible values are EDGE_ROUTING_STRATEGY_ORGANIC, EDGE_ROUTING_STRATEGY_ORTHOGONAL, EDGE_ROUTING_STRATEGY_STRAIGHTLINE, EDGE_ROUTING_STRATEGY_OCTILINEAR and EDGE_ROUTING_STRATEGY_AUTOMATIC .
See also
| Property | Defined By | ||
|---|---|---|---|
| allowMirroring : Boolean
Specifies whether or not subgraph components may be mirrored to improve the layout quality, i.e., for each component the algorithm checks which of the four possible mirrorings minimizes the edge length. | PartialLayouter | ||
| componentAssignmentStrategy : int
Specifies the strategy that is used to assign partial nodes to subgraph components. | PartialLayouter | ||
| considerNodeAlignment : Boolean
Getter:
Returns true, if node alignment is enabled, that is the algorithm tries to align partial nodes with other nodes. | PartialLayouter | ||
| coreLayouter : Layouter [override]
Specifies the core layouter, i.e., the layout algorithm that is applied to the subgraph components. | PartialLayouter | ||
| edgeRouter : Layouter
Getter:
Returns the edge router used for routing partial edges as well as edges between different subgraph components (so-called inter-edges). | PartialLayouter | ||
| edgeRoutingStrategy : int
Getter:
Return the specified edge routing strategy. | PartialLayouter | ||
| fixedGroupResizingEnabled : Boolean
Getter:
Returns whether or not fixed group nodes may be resized. | PartialLayouter | ||
| layoutOrientation : int
Specifies the layout orientation. | PartialLayouter | ||
| maximalDuration : LongImpl
Getter:
Returns the time limit (in milliseconds) set for the layout algorithm. | PartialLayouter | ||
| minimalNodeDistance : int
Specifies the minimum distance between two adjacent nodes. | PartialLayouter | ||
| optimizeLayoutOrientation : Boolean
Specifies whether or not a postprocessing step should be applied to reduce the number of edges that do not comply with the desired orientation. | PartialLayouter | ||
| packComponents : Boolean
Getter:
If enabled, the bounding boxes of subgraph components may overlap (elements of different components will still not overlap). | PartialLayouter | ||
| positioningStrategy : int
Specifies the objective used for finding 'good' positions for subgraph components. | PartialLayouter | ||
| routeInterEdgesImmediately : Boolean
Getter:
Returns whether or not edges between different subgraph components should be routed immediately. | PartialLayouter | ||
| Method | Defined By | ||
|---|---|---|---|
PartialLayouter(init:Boolean = true)
Creates a new instance of the PartialLayouter. | PartialLayouter | ||
canLayout(graph:LayoutGraph):Boolean [override] | PartialLayouter | ||
doLayout(graph:LayoutGraph):void [override] | PartialLayouter | ||
doPartialLayout(graph:LayoutGraph):void
This method calculates the partial layout. | PartialLayouter | ||
 | equals(o:Object):Boolean | YObject | |
getClass():Class [override] | PartialLayouter | ||
| hashCode():int | YObject | |
[static]
Creates a new instance of the PartialLayouter. | PartialLayouter | ||
[static]
Creates a new instance of the PartialLayouter. | PartialLayouter | ||
| Method | Defined By | ||
|---|---|---|---|
| canLayoutCore(graph:LayoutGraph):Boolean
Queries the core layouter whether or not the given graph can be laid out. | AbstractLayoutStage | |
configureEdgeRouter(edgeRouter:Layouter):void
This method is called each time edges are routed with an edge router instance. | PartialLayouter | ||
| doLayoutCore(graph:LayoutGraph):void
Invokes the layout routine of the core layouter. | AbstractLayoutStage | |
| initAbstractLayoutStage1():void | AbstractLayoutStage | |
| initAbstractLayoutStage2(core:Layouter):void | AbstractLayoutStage | |
initPartialLayouter1():void
Initializes this object. | PartialLayouter | ||
initPartialLayouter2(subgraphLayouter:Layouter):void
Initializes this object. | PartialLayouter | ||
layoutSubgraph(subGraph:LayoutGraph):void
Calculates the layout for the subgraph component. | PartialLayouter | ||
placeSubgraphs(graph:LayoutGraph, subgraphComponents:Vector.<Object>):void
This method places the subgraph components one-by-one onto the drawing area. | PartialLayouter | ||
This method routes all partial edges that connect two fixed elements. | PartialLayouter | ||
This method routes all inter-edges, that is edges between different subgraph components (including edges between fixed and partial elements). | PartialLayouter | ||
| Constant | Defined By | ||
|---|---|---|---|
| COMPONENT_ASSIGNMENT_DPKEY : Object = y.layout.PartialLayouter.COMPONENT_ASSIGNMENT_DPKEY [static]
com.yworks.yfiles.base.DataProvider key used to store an object for each partial node of the graph. | PartialLayouter | ||
| COMPONENT_ASSIGNMENT_STRATEGY_CLUSTERING : int = 2 [static]
Specifier for the strategy that is used to assign partial nodes to subgraph components. | PartialLayouter | ||
| COMPONENT_ASSIGNMENT_STRATEGY_CONNECTED : int = 1 [static]
Specifier for the strategy that is used to assign partial nodes to subgraph components. | PartialLayouter | ||
| COMPONENT_ASSIGNMENT_STRATEGY_CUSTOMIZED : int = 3 [static]
Specifier for the strategy that is used to assign partial nodes to subgraph components. | PartialLayouter | ||
| COMPONENT_ASSIGNMENT_STRATEGY_SINGLE : int = 0 [static]
Specifier for the strategy that is used to assign partial nodes to subgraph components. | PartialLayouter | ||
| DIRECTED_EDGES_DPKEY : Object = y.layout.partial.PartialLayouter.DIRECTED_EDGES_DPKEY [static]
If a layout orientation (see layoutOrientation) is specified (i.e., layoutOrientation != ORIENTATION_NONE), this data provider key can be used to distinguish between directed and undirected edges. | PartialLayouter | ||
| EDGE_ROUTING_STRATEGY_AUTOMATIC : int = 2 [static]
Specifier for the routing strategy of inter-edges (edges between fixed and partial nodes as well as edges between different subgraph components). | PartialLayouter | ||
| EDGE_ROUTING_STRATEGY_OCTILINEAR : int = 4 [static]
Specifier for the routing strategy of inter-edges (edges between fixed and partial nodes as well as edges between different subgraph components). | PartialLayouter | ||
| EDGE_ROUTING_STRATEGY_ORGANIC : int = 3 [static]
Specifier for the routing strategy of inter-edges (edges between fixed and partial nodes as well as edges between different subgraph components). | PartialLayouter | ||
| EDGE_ROUTING_STRATEGY_ORTHOGONAL : int = 0 [static]
Specifier for the routing strategy of inter-edges (edges between fixed and partial nodes as well as edges between different subgraph components). | PartialLayouter | ||
| EDGE_ROUTING_STRATEGY_STRAIGHTLINE : int = 1 [static]
Specifier for the routing strategy of inter-edges (edges between fixed and partial nodes as well as edges between different subgraph components). | PartialLayouter | ||
| ORIENTATION_AUTO_DETECTION : int = 5 [static]
Specifies the orientation of the drawing. | PartialLayouter | ||
| ORIENTATION_BOTTOM_TO_TOP : int = 2 [static]
Specifies the orientation of the drawing. | PartialLayouter | ||
| ORIENTATION_LEFT_TO_RIGHT : int = 1 [static]
Specifies the orientation of the drawing. | PartialLayouter | ||
| ORIENTATION_NONE : int = -1 [static]
Specifies the orientation of the drawing. | PartialLayouter | ||
| ORIENTATION_RIGHT_TO_LEFT : int = 3 [static]
Specifies the orientation of the drawing. | PartialLayouter | ||
| ORIENTATION_TOP_TO_BOTTOM : int = 0 [static]
Specifies the orientation of the drawing. | PartialLayouter | ||
| PARTIAL_EDGES_DPKEY : Object = y.layout.partial.PartialLayouter.PARTIAL_EDGES_DPKEY [static]
The data provider key used to look up the partial edges of the graph. | PartialLayouter | ||
| PARTIAL_NODES_DPKEY : Object = y.layout.partial.PartialLayouter.PARTIAL_NODES_DPKEY [static]
The data provider key used to look up the partial nodes of the graph. | PartialLayouter | ||
| ROUTE_EDGE_DPKEY : String = y.layout.partial.PartialLayouter.ROUTE_EDGE_DPKEY [static]
This key is used by this algorithm to temporarily add a DataProvider that marks edges that should be routed by the edge router. | PartialLayouter | ||
| SUBGRAPH_POSITIONING_STRATEGY_BARYCENTER : int = 2 [static]
Specifies the objective used for finding 'good' positions for subgraph components. | PartialLayouter | ||
| SUBGRAPH_POSITIONING_STRATEGY_FROM_SKETCH : int = 3 [static]
Specifies the objective used for finding 'good' positions for subgraph components. | PartialLayouter | ||
| allowMirroring | property |
Hide Inherited Public Methods
Show Inherited Public MethodsallowMirroring:BooleanSpecifies whether or not subgraph components may be mirrored to improve the layout quality, i.e., for each component the algorithm checks which of the four possible mirrorings minimizes the edge length.
public function get allowMirroring():Boolean public function set allowMirroring(value:Boolean):void| componentAssignmentStrategy | property |
componentAssignmentStrategy:intSpecifies the strategy that is used to assign partial nodes to subgraph components.
public function get componentAssignmentStrategy():int public function set componentAssignmentStrategy(value:int):voidSee also
| considerNodeAlignment | property |
considerNodeAlignment:BooleanGetter: Returns true, if node alignment is enabled, that is the algorithm tries to align partial nodes with other nodes.
Setter: Specifies whether or not nodes should be aligned. If set to true, the algorithm tries to align the center of partial nodes with other nodes. public function get considerNodeAlignment():Boolean public function set considerNodeAlignment(value:Boolean):void| coreLayouter | property |
coreLayouter:Layouter[override] Specifies the core layouter, i.e., the layout algorithm that is applied to the subgraph components.
public function get coreLayouter():Layouter public function set coreLayouter(value:Layouter):void| edgeRouter | property |
edgeRouter:LayouterGetter: Returns the edge router used for routing partial edges as well as edges between different subgraph components (so-called inter-edges).
Setter: Sets a customized edge router. The specified edge router is used for routing partial edges as well as edges between different subgraph components (so-called inter-edges). Edges that have to be routed with the specified router will be marked using this algorithm's ROUTE_EDGE_DPKEY data provider key.Note: the customized edge router is disabled when method edgeRoutingStrategy is called afterwards.
public function get edgeRouter():Layouter public function set edgeRouter(value:Layouter):voidSee also
| edgeRoutingStrategy | property |
edgeRoutingStrategy:intGetter: Return the specified edge routing strategy.
Setter: This method allows to specify the edge routing strategy that is used for routing partial edges and edges between different subgraph components (so-called inter-edges).Note: calling this method disables a previously set customized edge router (see method edgeRouter).
public function get edgeRoutingStrategy():int public function set edgeRoutingStrategy(value:int):voidSee also
| fixedGroupResizingEnabled | property |
fixedGroupResizingEnabled:BooleanGetter: Returns whether or not fixed group nodes may be resized.
Setter: Specifies whether or not fixed (non-partial) group nodes may be resized. public function get fixedGroupResizingEnabled():Boolean public function set fixedGroupResizingEnabled(value:Boolean):void| layoutOrientation | property |
layoutOrientation:intSpecifies the layout orientation.
public function get layoutOrientation():int public function set layoutOrientation(value:int):voidSee also
| maximalDuration | property |
maximalDuration:LongImplGetter: Returns the time limit (in milliseconds) set for the layout algorithm. By default the time limit is Integer.MAX_VALUE.
Setter: Sets a preferred time limit (in milliseconds) for the layout algorithm. Note that restricting the maximal duration may result in a worse layout quality. Furthermore, the real runtime may exceed the maximal duration since the layout algorithm still have to find a valid solution. By default the time limit is Integer.MAX_VALUE. public function get maximalDuration():LongImpl public function set maximalDuration(value:LongImpl):void| minimalNodeDistance | property |
minimalNodeDistance:intSpecifies the minimum distance between two adjacent nodes.
public function get minimalNodeDistance():int public function set minimalNodeDistance(value:int):void| optimizeLayoutOrientation | property |
optimizeLayoutOrientation:BooleanSpecifies whether or not a postprocessing step should be applied to reduce the number of edges that do not comply with the desired orientation.
By default, this feature is disabled.
public function get optimizeLayoutOrientation():Boolean public function set optimizeLayoutOrientation(value:Boolean):voidSee also
| packComponents | property |
packComponents:BooleanGetter: If enabled, the bounding boxes of subgraph components may overlap (elements of different components will still not overlap).
Setter: Packing subgraph components leads to more compact layout results. If set to true, the bounding boxes of subgraph components may overlap (elements of different components will still not overlap). public function get packComponents():Boolean public function set packComponents(value:Boolean):void| positioningStrategy | property |
positioningStrategy:intSpecifies the objective used for finding 'good' positions for subgraph components.
public function get positioningStrategy():int public function set positioningStrategy(value:int):voidSee also
| routeInterEdgesImmediately | property |
routeInterEdgesImmediately:BooleanGetter: Returns whether or not edges between different subgraph components should be routed immediately.
Setter: 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. By default this option is disabled. public function get routeInterEdgesImmediately():Boolean public function set routeInterEdgesImmediately(value:Boolean):voidSee also
| PartialLayouter | () | Constructor |
public function PartialLayouter(init:Boolean = true)Creates a new instance of the PartialLayouter.
Parametersinit:Boolean (default = true) |
| canLayout | () | method |
override public function canLayout(graph:LayoutGraph):BooleanParameters
graph:LayoutGraph |
Boolean |
| configureEdgeRouter | () | method |
protected function configureEdgeRouter(edgeRouter:Layouter):voidThis method is called each time edges are routed with an edge router instance. Hence, it offers a way to modify the used settings.
The type of the given instance depends on the edge routing strategy, i.e., if the routing strategy is set to EDGE_ROUTING_STRATEGY_OCTILINEAR or EDGE_ROUTING_STRATEGY_ORTHOGONAL it's an instance of com.yworks.yfiles.layout.router.polyline.EdgeRouter, if the routing strategy is set to EDGE_ROUTING_STRATEGY_ORGANIC it's an instance of com.yworks.yfiles.layout.organic.SmartOrganicLayouter, and, if the routing strategy is set to EDGE_ROUTING_STRATEGY_STRAIGHTLINE it's an instance of com.yworks.yfiles.layout.partial.PartialLayouter_StraightLineEdgeRouter. If the edge routing strategy is set to EDGE_ROUTING_STRATEGY_AUTOMATIC one of the above strategies is used.
Note: if a customized edge router is set (see edgeRouter), the edge router instance is of this type.
Parameters
edgeRouter:Layouter — the instance used for routing the edges.
|
See also
| doLayout | () | method |
| doPartialLayout | () | method |
public function doPartialLayout(graph:LayoutGraph):voidThis method calculates the partial layout. Therefore, it calls the following methods: 1. routeEdgesBetweenFixedElements() 2. layoutSubgraph() for each subgraph component 3. placeSubgraphs() 4. routeInterEdges()
Note: the method is called after applying the com.yworks.yfiles.layout.OrientationLayouter . Hence, the called methods always assume that the graph is drawn from top to bottom.Parameters
graph:LayoutGraph — the input graph.
|
See also
| getClass | () | method |
override public function getClass():ClassReturnsClass |
| initPartialLayouter1 | () | method |
protected final function initPartialLayouter1():void
Initializes this object. See the documentation of the corresponding factory method newPartialLayouter1() for details.
See also
| initPartialLayouter2 | () | method |
protected final function initPartialLayouter2(subgraphLayouter:Layouter):void
Initializes this object. See the documentation of the corresponding factory method newPartialLayouter2() for details.
Parameters
subgraphLayouter:Layouter |
See also
| layoutSubgraph | () | method |
protected function layoutSubgraph(subGraph:LayoutGraph):voidCalculates the layout for the subgraph component.
Parameters
subGraph:LayoutGraph — the subgraph component
|
| newPartialLayouter1 | () | method |
public static function newPartialLayouter1():PartialLayouterCreates a new instance of the PartialLayouter.
ReturnsPartialLayouter |
| newPartialLayouter2 | () | method |
public static function newPartialLayouter2(subgraphLayouter:Layouter):PartialLayouterCreates a new instance of the PartialLayouter. The parameter specifies the layout algorithm that is used for the subgraph components.
Parameters
subgraphLayouter:Layouter — the layout algorithm that is applied to the subgraph components.
|
PartialLayouter |
| placeSubgraphs | () | method |
protected function placeSubgraphs(graph:LayoutGraph, subgraphComponents:Vector.<Object>):voidThis method places the subgraph components one-by-one onto the drawing area. Therefore, it considers the specified objective for finding a 'good' position, see ( positioningStrategy).
Parameters
graph:LayoutGraph — the input graph
| |
subgraphComponents:Vector.<Object> — each entry contains a NodeList that defines a subgraph component
|
See also
| routeEdgesBetweenFixedElements | () | method |
protected function routeEdgesBetweenFixedElements(graph:LayoutGraph, partialEdges:EdgeList):voidThis method routes all partial edges that connect two fixed elements. Therefore, it uses the edge router set with method edgeRouter . If no edge router was specified by the user, it uses an internal edge router with routing strategy edgeRoutingStrategy.
Parameters
graph:LayoutGraph — the subgraph of the original graph induced on the fixed nodes.
| |
partialEdges:EdgeList — the edges to route.
|
See also
| routeInterEdges | () | method |
protected function routeInterEdges(graph:LayoutGraph, interEdges:EdgeList):voidThis method routes all inter-edges, that is edges between different subgraph components (including edges between fixed and partial elements). Therefore, it uses the edge router set with method edgeRouter . If no edge router was specified by the user, it uses an internal edge router with routing strategy edgeRoutingStrategy.
Parameters
graph:LayoutGraph — the relevant graph.
| |
interEdges:EdgeList — the edges to route.
|
See also
| COMPONENT_ASSIGNMENT_DPKEY | Constant |
public static const COMPONENT_ASSIGNMENT_DPKEY:Object = y.layout.PartialLayouter.COMPONENT_ASSIGNMENT_DPKEYcom.yworks.yfiles.base.DataProvider key used to store an object for each partial node of the graph. All partial nodes associated with the same object are assigned to the same subgraph component. Note: nodes of a component cannot be assigned to different group nodes as well as different partition cells.
See also
| COMPONENT_ASSIGNMENT_STRATEGY_CLUSTERING | Constant |
public static const COMPONENT_ASSIGNMENT_STRATEGY_CLUSTERING:int = 2Specifier for the strategy that is used to assign partial nodes to subgraph components. This value specifies that the algorithm should use a natural clustering algorithm to determine the subgraph components (nodes of the same cluster are in the same subgraph component).
See also
| COMPONENT_ASSIGNMENT_STRATEGY_CONNECTED | Constant |
public static const COMPONENT_ASSIGNMENT_STRATEGY_CONNECTED:int = 1Specifier for the strategy that is used to assign partial nodes to subgraph components. This value specifies that all partial nodes of a connected component are assigned to the same subgraph component.
See also
| COMPONENT_ASSIGNMENT_STRATEGY_CUSTOMIZED | Constant |
public static const COMPONENT_ASSIGNMENT_STRATEGY_CUSTOMIZED:int = 3Specifier for the strategy that is used to assign partial nodes to subgraph components. This value allows to use a customized component assignment, see COMPONENT_ASSIGNMENT_DPKEY.
See also
| COMPONENT_ASSIGNMENT_STRATEGY_SINGLE | Constant |
public static const COMPONENT_ASSIGNMENT_STRATEGY_SINGLE:int = 0Specifier for the strategy that is used to assign partial nodes to subgraph components. This value specifies that each partial node is assigned to a separate component.
See also
| DIRECTED_EDGES_DPKEY | Constant |
public static const DIRECTED_EDGES_DPKEY:Object = y.layout.partial.PartialLayouter.DIRECTED_EDGES_DPKEY
If a layout orientation (see layoutOrientation) is specified (i.e., layoutOrientation != ORIENTATION_NONE), this data provider key can be used to distinguish between directed and undirected edges.
The layout orientation is only considered for directed edges. The registered data provider's getBool (com.yworks.yfiles.base.DataProvider.getBool()) method should return true for directed edges and false for undirected edges. Note: if this data provider is not registered, all edges are considered to be directed.
See also
| EDGE_ROUTING_STRATEGY_AUTOMATIC | Constant |
public static const EDGE_ROUTING_STRATEGY_AUTOMATIC:int = 2Specifier for the routing strategy of inter-edges (edges between fixed and partial nodes as well as edges between different subgraph components). The algorithm automatically chooses a suitable routing strategy.
See also
| EDGE_ROUTING_STRATEGY_OCTILINEAR | Constant |
public static const EDGE_ROUTING_STRATEGY_OCTILINEAR:int = 4Specifier for the routing strategy of inter-edges (edges between fixed and partial nodes as well as edges between different subgraph components). The algorithm will use octilinear routes for inter-edges (the slope of each segment is a multiple of 45 degree).
See also
| EDGE_ROUTING_STRATEGY_ORGANIC | Constant |
public static const EDGE_ROUTING_STRATEGY_ORGANIC:int = 3Specifier for the routing strategy of inter-edges (edges between fixed and partial nodes as well as edges between different subgraph components). The algorithm will use organic routes for inter-edges.
See also
| EDGE_ROUTING_STRATEGY_ORTHOGONAL | Constant |
public static const EDGE_ROUTING_STRATEGY_ORTHOGONAL:int = 0Specifier for the routing strategy of inter-edges (edges between fixed and partial nodes as well as edges between different subgraph components). The algorithm will use orthogonal routes for inter-edges, i.e., each edge only consists of vertical and horizontal segments.
See also
| EDGE_ROUTING_STRATEGY_STRAIGHTLINE | Constant |
public static const EDGE_ROUTING_STRATEGY_STRAIGHTLINE:int = 1Specifier for the routing strategy of inter-edges (edges between fixed and partial nodes as well as edges between different subgraph components). The algorithm will use straight-line routes for inter-edges.
See also
| ORIENTATION_AUTO_DETECTION | Constant |
public static const ORIENTATION_AUTO_DETECTION:int = 5Specifies the orientation of the drawing. This value specifies that the layout algorithm should detect the orientation automatically. Therefore it analysis the current drawing.
See also
| ORIENTATION_BOTTOM_TO_TOP | Constant |
public static const ORIENTATION_BOTTOM_TO_TOP:int = 2Specifies the orientation of the drawing. This value specifies that the algorithm should try to place partial nodes (subgraph components) such that each predecessor of a node v is placed below v and each successor above v.
See also
| ORIENTATION_LEFT_TO_RIGHT | Constant |
public static const ORIENTATION_LEFT_TO_RIGHT:int = 1Specifies the orientation of the drawing. This value specifies that the algorithm should try to place partial nodes (subgraph components) such that each predecessor of a node v is placed to the left of v and each successor to the right of v.
See also
| ORIENTATION_NONE | Constant |
public static const ORIENTATION_NONE:int = -1Specifies the orientation of the drawing.
See also
| ORIENTATION_RIGHT_TO_LEFT | Constant |
public static const ORIENTATION_RIGHT_TO_LEFT:int = 3Specifies the orientation of the drawing. This value specifies that the algorithm should try to place partial nodes (subgraph components) such that each predecessor of a node v is placed to the right of v and each successor to the left of v.
See also
| ORIENTATION_TOP_TO_BOTTOM | Constant |
public static const ORIENTATION_TOP_TO_BOTTOM:int = 0Specifies the orientation of the drawing. This value specifies that the algorithm should try to place partial nodes (subgraph components) such that each predecessor of a node v is placed above v and each successor below v.
See also
| PARTIAL_EDGES_DPKEY | Constant |
public static const PARTIAL_EDGES_DPKEY:Object = y.layout.partial.PartialLayouter.PARTIAL_EDGES_DPKEYThe data provider key used to look up the partial edges of the graph. The looked up data provider should provide boolean values for the edges of that graph. The boolean value should signal whether an edge is to be considered as partial or not.
| PARTIAL_NODES_DPKEY | Constant |
public static const PARTIAL_NODES_DPKEY:Object = y.layout.partial.PartialLayouter.PARTIAL_NODES_DPKEYThe data provider key used to look up the partial nodes of the graph. The looked up data provider should provide boolean values for the nodes of that graph. The boolean value should signal whether a node is to be considered as partial or not.
| ROUTE_EDGE_DPKEY | Constant |
public static const ROUTE_EDGE_DPKEY:String = y.layout.partial.PartialLayouter.ROUTE_EDGE_DPKEYThis key is used by this algorithm to temporarily add a DataProvider that marks edges that should be routed by the edge router.
Note that this DataProvider must not be set by the user! It is automatically set during the layout and should only be used by the specified edge router (see edgeRouter).
The added data provider's com.yworks.yfiles.base.DataProvider.getBool() method will returntrue for edges that have to be routed and false for all other edges.
See also
| SUBGRAPH_POSITIONING_STRATEGY_BARYCENTER | Constant |
public static const SUBGRAPH_POSITIONING_STRATEGY_BARYCENTER:int = 2Specifies the objective used for finding 'good' positions for subgraph components. This values specifies that each component should be placed close to the barycenter of its graph neighbors.
See also
| SUBGRAPH_POSITIONING_STRATEGY_FROM_SKETCH | Constant |
public static const SUBGRAPH_POSITIONING_STRATEGY_FROM_SKETCH:int = 3Specifies the objective used for finding 'good' positions for subgraph components. This values specifies that each component should be placed close to its original position.
See also