	Name	Description
	AggressiveOption	Gets or sets which Aggressive Option is being used to look for link crossings.
	ArrangementOrigin	Gets or sets the top-left corner point at which LayoutNodes will position the nodes.
	ColumnSpacing	Gets or sets the size of each column
	Container	(Inherited from System.ComponentModel.Component)
	CycleRemoveOption	Gets or sets which cycle removal option is being used.
	DirectionOption	Gets or sets which Direction Option is being used.
	Document	Gets or sets the Northwoods.Go.GoDocument that the layout will be performed on. (Inherited from Northwoods.Go.Layout.GoLayout)
	InitializeOption	Gets or sets which indices initialization option is being used.
	Iterations	Gets or sets the number of iterations are to be done.
	LayeringOption	Gets or sets which layering option is being used.
	LayerSpacing	Gets or sets the size of each layer
	MaxColumn	Gets the largest column value.
	MaxIndex	Gets the largest index value.
	MaxIndexLayer	Gets the largest index layer.
	MaxLayer	Gets the largest layer value.
	MinIndexLayer	Gets the smallest index layer
	Network	Gets or sets the GoLayoutLayeredDigraphNetwork that the layout will be performed on.
	PackOption	Gets or sets the options used by StraightenAndPack.
	SetsPortSpots	Gets or sets whether the Northwoods.Go.GoPort.Northwoods.Go.GoPort.FromSpot and Northwoods.Go.GoPort.ToSpot of every single-port node should be set to values appropriate for the given DirectionOption.
	Site	(Inherited from System.ComponentModel.Component)
	View	Gets or sets the Northwoods.Go.GoView whose thread is used to run document-updating code and Progress events. (Inherited from Northwoods.Go.Layout.GoLayout)

	Name	Description
	CanRaiseEvents	(Inherited from System.ComponentModel.Component)
	DesignMode	(Inherited from System.ComponentModel.Component)
	Events	(Inherited from System.ComponentModel.Component)

	Name	Description
	CreateNetwork	Allocate a GoLayoutLayeredDigraphNetwork.
	GetIndices	Returns the indices array.
	GetLifetimeService	(Inherited from System.MarshalByRefObject)
	InitializeLifetimeService	(Inherited from System.MarshalByRefObject)
	LayoutNodesAndLinks	Updates the physical location of "real" nodes and links to reflect the layout.
	PerformLayout	Overridden. Performs a layered-digraph auto-layout.
	RaiseProgress	Overloaded. (Inherited from Northwoods.Go.Layout.GoLayout)
	ToString	(Inherited from System.ComponentModel.Component)

	Name	Description
	Disposed	(Inherited from System.ComponentModel.Component)
	Progress	The Progress event is raised at various times during the PerformLayout routine to indicate progress. In particular, a Progress event should be raised at the start of the layout with a progress of 0.0 and at the end of the layout with a progress of 1.0. Other calls with progress values should be layout routine specific. (Inherited from Northwoods.Go.Layout.GoLayout)

	Name	Description
	AdjacentExchangeCrossingReductionBendStraighten	Adjusts the columns of nodes within the unfixedLayer to simultaneously reduce the number of link crossings and the number of "bends" between the unfixedLayer and its adjacent layers between the unfixedLayer and its adjacent layers. The directionCR argument indicates which of the adjacent layers should be taken into consideration when reducing the number of link crossings. `direction == 0 -- use unfixedLayer - 1 and unfixedLayer + 1 direction > 0 -- use unfixedLayer - 1 (sweeping away from layer 0) direction < 0 -- use unfixedLayer + 1 (sweepeing towards layer 0)` The directionBS argument indicates which of the adjacent layers should be taken into consideration when reducing the number of bends. `direction == 0 -- use unfixedLayer - 1 and unfixedLayer + 1 direction > 0 -- use unfixedLayer - 1 (sweeping away from layer 0) direction < 0 -- use unfixedLayer + 1 (sweepeing towards layer 0)` The "weighted bend" between a node U and a node V connected by link L is calculated by `abs((U.column + L.portFromColOffset) - (V.column + L.portToColOffset)) * LinkStraightenWeight(L)` The LinkStraightenWeight attempts to give higher priority to links between "artificial" nodes; i.e., long links in the final layout will be straighter. The idea is to use a bubble-sort technique to exchange adjacent nodes whenever doing so reduces the number of link crossings or the number of bends. This function is used in both crossing reduction and bend straightening. Returns true if some change was made to the layer.
	AssignLayers	Assigns every node in the input network to a layer. The layering satisfies the following: if L is a link from node U to node V, then U.layer > V.layer; further, U.layer - V.layer >= LinkMinLength(L). This method can be overridden to customize how nodes are assigned layers.
	AvoidOrthogonalOverlaps	Try to avoid overlapping segments of Orthogonal links.
	Barycenters	Computes the array of barycenters (average) columns for the nodes in the unfixedLayer based on the columns of predecessors (direction < 0), successors (direction > 0), or both predecessors and successors (direction == 0) Elements without a defined barycenter will have an entry of -1.
	Bends	Computes the bends between the unfixedLayer and its adjacent layers. The "bend" between a node U and a node V connected by a link L is calcluated by `abs((U.column + L.portFromColOffset) - (V.column + L.portToColOffset))` The "weighted bend" between a node U and a node V connected by link L is calculated by `abs((U.column + L.portFromColOffset) - (V.column + L.portToColOffset)) * LinkStraightenWeight(L)` The LinkStraightenWeight attempts to give higher priority to links between "artificial" nodes; i.e., long links in the final layout will be straighter. The direction argument indicates which adjacent layers should be taken into consideration when computing the crossing matrix: `direction == 0 -- use unfixedLayer - 1 and unfixedLayer + 1` `direction > 0 -- use unfixedLayer - 1 (sweeping away from layer 0)` `direction < 0 -- use unfixedLayer + 1 (sweepeing towards layer 0)`
	BendStraighten	Adjusts the columns of nodes within the unfixedLayer to reduce the number of "bends" between the unfixedLayer and its adjacent layers. The direction argument indicates which of the adjacent layers should be taken into consideration when reducing the number of bends. The "weighted bend" between a node U and a node V connected by link L is calculated by `abs((U.column + L.portFromColOffset) - (V.column + L.portToColOffset)) * LinkStraightenWeight(L)` The LinkStraightenWeight attempts to give higher priority to links between "artificial" nodes; i.e., long links in the final layout will be straighter. The idea is to iterate the ShiftBendStraighten and adjacentExchangeBendStraighten methods until no improvements are made.
	ComponentPack	Adjusts the columns of nodes in the network to produce a layout which is tightly packed. The idea is that the network can be fragmented from a given column in the following way: all nodes "behind" the column are placed into a single component, and the remainder of the network is divided into connected components. Each of these new components can be examined, and those that can be merged with the given column do so.
	ComponentPackAux	Attempts to augment the argument column by merging components into from the argument direction. direction > 0 -- columns > the argument column are shifted direction < 0 -- columns < the argument column are shifted Returns true if the argument column was changed.
	ComponentUnset	Uses a depth first search algorithm to set the component of all nodes in a component. **Unset functions only set the component and recurse on nodes whose component is currently set to the unset value. The forward and backward bools indicate the direction to use for a directed depth first search from node.
	CountBends	Returns the total number of bends in the network. The "bend" between a node U and a node V connected by a link L is calcluated by `abs((U.column + L.portFromColOffset) - (V.column + L.portToColOffset))` The "weighted bend" between a node U and a node V connected by link L is calculated by `abs((U.column + L.portFromColOffset) - (V.column + L.portToColOffset)) * LinkStraightenWeight(L)` The LinkStraightenWeight attempts to give higher priority to links between "artificial" nodes; i.e., long links in the final layout will be straighter.
	CountCrossings	Returns the total number of crossings in the network. Internal method used by ReduceCrossings.
	CrossingMatrix	Computes the crossing matrix between the unfixedLayer and its adjacent layers. The direction argument indicates which adjacent layers should be taken into consideration when computing the crossing matrix: `direction == 0 -- use unfixedLayer - 1 and unfixedLayer + 1 direction > 0 -- use unfixedLayer - 1 (sweeping away from layer 0) direction < 0 -- use unfixedLayer + 1 (sweeping towards layer 0)` The resulting integer array can be used as follows: if index1 and index2 are the indices corresponding to two nodes on the unfixedLayer and crossmat is the crossing matrix, then `crossmat[index1 * indices[unfixedLayer] + index2]` is the number of crossing that occur if the node corresponding to index1 is placed to the left of the node corresponding to index2. If `index1 == index2`, then `crossmat[index1 * indices[unfixedLayer] + index2]` is the number of crossings between links to and from the node corresponding to index1.
	DepthFirstInInitializeIndices	Assigns every node in the input network an index number, such that nodes in the same layer will be labeled with consecutive indices in left to right order. Uses a depth first "inward" (i.e., following links from "to-node" to "from-node") traversal of the network, assigning indices to nodes as they are discovered.
	DepthFirstInInitializeIndicesVisit	Assigns node the appropriate index and updates the indices array. Implements the recursive portion of a depth first search.
	DepthFirstOutInitializeIndices	Assigns every node in the input network an index number, such that nodes in the same layer will be labeled with consecutive indices in left to right order. Uses a depth first "outward" (i.e., following links from "from-node" to "to-node") traversal of the network, assigning indices to nodes as they are discovered.
	DepthFirstOutInitializeIndicesVisit	Assigns node the appropriate index and updates the indices array. Implements the recursive portion of a depth first search.
	DepthFirstSearchCycleRemoval	Removes cycles from the input network using a depth first search. A link not in the depth first forest is reversed if the from-node was discovered and finished by the depth first search after the to-node was discovered but before the to-node was finished.
	DepthFirstSearchCycleRemovalVisit	Peforms the recursive step of the depth first search on node. Updates the discover and finish time of node. Updates the forest flag of followed links.
	Dispose	Overloaded. (Inherited from System.ComponentModel.Component)
	Finalize	(Inherited from System.ComponentModel.Component)
	GetService	(Inherited from System.ComponentModel.Component)
	GreedyCycleRemoval	Removes cycles from the input network using a Greedy-Cycle-Removal algorithm. The idea is to induce an order on all nodes in the network (U1, U2, U3, ..., Uk) such that for the majority of links L = (Ui, Uj) it is true that i < j. All links L = (Ui, Uj) such that i > j are reversed.
	GreedyCycleRemovalFindNode	Finds a valid node in the network. Returns null if no valid node exists. Used by GreedyCycleRemoval.
	GreedyCycleRemovalFindNodeMaxDegDiff	Finds a valid node in the network that maximizes outdeg - indeg. The degree difference is computed using valid successors and predecessors. Returns null if no valid node exists. Used by GreedyCycleRemoval.
	GreedyCycleRemovalFindSink	Finds a sink node in the network. A node is considered a sink node if it is valid and all of its predecessors are invalid. A valid node with no predecessors is vacously a sink. Returns null if no valid sink node exists. Used by GreedyCycleRemoval.
	GreedyCycleRemovalFindSource	Finds a source node in the network. A node is considered a sink node if it is valid and all of its successors are invalid. A valid node with no successors is vacously a source. Returns null if no valid source node exists. Used by GreedyCycleRemoval.
	InitializeColumns	Assigns every node in the input network a column number, such that nodes in the same layer will be labeled with increasing indices in left to right order.
	InitializeIndices	Assigns every node in the input network an index number, such that nodes in the same layer will be labeled with consecutive indices in left to right order. All consecutive layout operations will preserve or update the indices. In addition, the indices array is initialized such that indices[layer] indicates the number of nodes in the layer. Finally, the variables minIndexLayer and maxIndexLayer record the layers that correspond to the minimum and maximum nodes in a layer.
	LayoutLinks	Routes the links. Called by LayoutNodesAndLinks
	LayoutNodes	Lays out the nodes. Called by LayoutNodesAndLinks
	LinkLengthWeight	The function LinkLengthWeight returns the weight of the link represented by the GoLayoutLayeredDigraphLink link. This weight is used by OptimalLinkLengthLayering to minimize weighted link lengths. The default implementation gives all links a length weight of 1. This function can be overridden to provide "fine-tuning" of the layout.
	LinkMinLength	The function LinkMinLength returns the minimum length of the link represented by the GoLayoutLayeredDigraphLink link. The default implementation gives multi-links a minimum length of 2, and all other links a minimum length of 1. This function can be overridden to provide "fine-tuning" of the layout.
	LinkStraightenWeight	The function LinkStraightenWeight returns the weight of the link represented by the GoLayoutLayeredDigraphLink link. This weight is used by the straightening methods to give priority straightening to those links with higher weights. The default implementation gives links between two "real" nodes a weight of 1, links between a "real" node and an "artifical" node a weight of 4, and links between two "artificial" nodes a weight of 8. This function can be overridden to provide "fine-tuning" of the layout.
	LongestPathSinkLayering	Assigns every node in the input network to a layer. In addition to the requirements described in AssignLayers(), LongestPathSinkLayering ensures that every sink appears in layer 0 and every node is as close to a sink as possible.
	LongestPathSinkLayeringLength	Computes the length of the longest path from node to a sink node and sets the layer of node to that length. Returns the length of the longest path from node to a sink node.
	LongestPathSourceLayering	Assigns every node in the input network to a layer. In addition to the requirements described in AssignLayers, LongestPathSourceLayering ensures that every source appears in layer maxLayer and every node is as close to a source as possible.
	LongestPathSourceLayeringLength	Computes the length of the longest path from node to a source node and sets the layer of node to that length. Returns the length of the longest path from node to a source node.
	MakeProper	Converts the input network into a proper digraph; i.e., artificial nodes and links are introduced into the network such that every link is between nodes in adjacent layers. This has the effect of breaking up long links into a sequence of artificial nodes.
	MedianBarycenterCrossingReduction	Reorders nodes within the unfixedLayer to reduce the number of link crossings between the unfixedLayer and its adjacent layers. The direction argument indicates which of the adjacent layers should be taken into consideration when reducing the number of crossings. `direction == 0 -- use unfixedLayer - 1 and unfixedLayer + 1` `direction > 0 -- use unfixedLayer - 1 (sweeping away from layer 0)` `direction < 0 -- use unfixedLayer + 1 (sweepeing towards layer 0)` The idea is to calculate the median and barycenter for each node in the unfixedLayer, and to sort the nodes in the unfixedLayer by their median and barycenter values. Returns true if some change was made to the layer.
	Medians	Computes the array of median columns for the nodes in the unfixedLayer based on the columns of predecessors (direction < 0), successors (direction > 0), or both predecessors and successors (direction == 0). Elements without a defined median will have an entry of -1.

Reference