| Class | Description | |
|---|---|---|
 | NBalloonTreeLayout | The NBalloonTreeLayout class is a tree layout, which tries to compact the drawing area of the tree and places the vertices in balloons around the root. |
| NBarycenterForce | The NBarycenterForce class represents an edge force, which tries to place connected vertices at their barycenter (center of gravity) |
| NBarycenterLayout | The NBarycenterLayout class represents a force directed layout, which implements the barycenter layout method. |
| NBody | The NBody class represents a visually arrangeable abstract shape, which can optionally represent a logical object. Layouts actually arrange bodies. |
| NBody1D | The NBody1D class represents a body, which behaves like a line connecting 2D bodies. |
| NBody2D | The NBody2D class represents a body, which behaves like a box |
| NBodyAdapter | The NBodyAdapter class is an adapter, which is used to abstract layouts, from the actual way in which an object is represented by a body. |
| NBodyContainerAdapter | The NBodyContainerAdapter abstract class is used to abstract layouts from the actual container, in which the bodies are layed out |
| NBounceBackForce | The NBounceBackForce class represents a vertices force, which simulates a repulsion between overrlapping vertices |
| NCellBody | The NCellBody class represents a 2D body, which serves as body for objects arranged by cell layouts |
| NCellBodyList | The NCellBodyList class represents a typed list of NCellBody instances |
| NCellsDirectionConverter | |
| NCellsLayout | The NCellsLayout class represents a layout, which serves as base class for layouts, which can arrange cells |
| NCellsLayoutCancelEventArguments | The NCellsLayoutCancelEventArguments represents the event arguments associated with cancelable cells layout events |
| NCellsLayouter | |
| NCellsLayoutEventArguments | The NCellsLayoutCancelEventArguments represents the event arguments associated with cells layout events |
| NCircularGraphLayout | The base class for all circular layouts |
| NClassicalTreeLayout | The NClassicalTreeLayout class represents a directed tree layout, which serves as base class for all classical tree layouts. |
| NCompactDepthTreeLayout | The NCompactDepthTreeLayout class represents a classical tree layout, which compacts the depth of the tree drawing area. |
| NConstrainedCellsLayout | The NConstrainedCellsLayout class represents a directed cells layout, the cells placement of which can be constrained in the layout direction |
| NDesiredDistanceForce | The NDesiredDistanceForce is a force, which couples an attraction force (edge force), and a repulsion force (vertex force). The two forces balance each other when the distance between connected vertices is equal to the specified desired distance. |
| NDirectedCellsLayout | The NDirectedCellsLayout class represents a cells layout, which serves as base class for cells layout algorithms, whose cells direction can be controlled. |
| NDirectedGraphLayout | The NDirectedGraphLayout class represents a graph layout, which serves as base class for all graph layouts, whose direction can be controlled |
| NDirectedTreeLayout | The NDirectedTreeLayout class represents a tree layout, which serves as base class for tree layouts, whose direction can be controlled. |
| NDockLayout | The NDockLayout class represents a cells layout, which layouts the cells by subsequently docking them to cells defined docking areas. |
| NDrawingBodyContainerAdapter | The NDrawingBodyContainerAdapter is a body container adapter, which adapts a drawing document. |
| NDrawingLayoutContext | The NDrawingLayoutContext class serves as a bridge between the layout and the user. |
| NElectricalForce | The NElectricalForce class represents a vertices force, which simulates the electrical repulsion between two ellectrically charged particles. |
| NFixedVertexPlacement | The NFixedVertexPlacement class is used to encapsulate the initial placement of the fixed vertices in a force directed layout. |
| NFlowLayout | The NFlowLayout class represents a constrained cells layout, which arranges the cells in horizontal or vertical lanes. |
| NForce | The NForce class serves as base class for all types of forces, which can be used in force directed layouts |
| NForceDirectedLayout | The NForceDirectedLayout class is a graph layout, which layouts the graph vertices and edges, according to the forces acting on them. It serves as base class for all types of force directed layouts. |
| NForceEnvironment | The NForceEnvironment class is used to encapsulate the force directed layout settings related to the global environment in which the forces operate |
| NForceList | The NForceList class represents a typed list of NForce instances |
| NFreeVertexPlacement | The NFreeVertexPlacement class is used to encapsulate the initial placement of the free vertices in a force directed layout. |
| NGraphLayout | The NGraphLayout class represents a regioned layout, whose regions are graphs. It serves as a base class for all graph layouts. |
| NGraphLayoutCancelEventArguments | The NGraphLayoutCancelEventArguments represents the event arguments associated with cancelable graph layout events |
| NGraphLayoutEventArguments | The NGraphLayoutCancelEventArguments represents the event arguments associated with graph layout events |
| NGraphPartsLayout | The NGraphPartsLayout class represents a layout, which serves as base class for graph and tree layouts. |
| NGraphRegion | The NGraphRegion class represents a region, whose content is a graph |
| NGravityForce | The NGravityForce class represents a global force, which simulates a gravity attraction to the current barycenter of the graph |
| NLayeredGraphLayout | The NLayeredGraphLayout class is a graph layout, which layouts the graph vertices and edges bodies of an acyclic graph on layers. |
| NLayeredTreeLayout | The NLayeredTreeLayout class represents a classical tree layout, which arranges the tree levels in layers. |
| NLayout | The NLayout abstract class serves as base class for all layout algorithms |
| NLayoutCancelEventArgs | The NLayoutCancelEventArgs class serves as base class for all cancelable layout event arguments |
| NLayoutContext | The NLayoutContext class is used to abstract the layouts with the actual types and relations between the objects it layouts and container in which they are hosted. It serves as a bridge between the layouts and their user. |
| NLayoutEventArgs | The NLayoutEventArgs class serves as base class for all layout event arguments |
| NMagneticFieldForce | The NMagneticFieldForce is an edge force, which is used to impose an edge orientation constrain |
| NOrthogonalGraphLayout | Implements the Orthogonal Graph Layout. |
| NParentPlacement | The NParentPlacement class represents an attribute, which is used to encapsulate the horizontal or vertical placement of a parent tree vertex in respect to its children or subtree. |
| NPlugSpacing | The NPlugSpacing attribute is used to space plugs connected to a single side port. |
| NRadialGraphLayout | In Radial Graph Layout the focus node is placed at the center of the display and all other nodes are laid out around it |
| NRegion | The NRegion class serves as base class for different connected graph components (e.g. graph and tree regions). |
| NRegionList | The NRegionList class represents a typed list of NRegion instances |
| NShapeBodyAdapter | The NShapeBodyAdapter represents an object body adapter, which provides layouts with the ability to adapt shapes to bodies and vise-versa. |
| NSingleCycleLayout | The single cycle layout arranges shapes on a single circle |
| NSpringForce | The NSpringForce class represents an edge force, which simulates a spring connecting adjacent vertices. |
| NSpringLayout | The NSpringLayout class represents a force directed layout, which simulates a physical system with spring and electical forces. |
| NStackLayout | The NStackLayout class represents a directed cells layout, which stacks the cells in horizontal or vertical order. |
| NSymmetricalLayout | The NSymmetricalLayout class is a force directed layout, which simulates a physical system with repulsive and attractive forces, which strive to produce a symmetrical drawing of a graph. |
| NTableLayout | NTableLayout |
| NTipOverTreeLayout | The NTipOverTreeLayout class is a tree layout, which places the children of a vertex in a single row or column. |
| NTreeLayout | The NTreeLayout class represents a graph parts layout, whose regions are trees. It serves as a base class for all tree layouts. |
| NTreeLayoutCancelEventArguments | The NTreeLayoutEventArguments represents the event arguments associated with cancelable tree layout events |
| NTreeLayoutEventArguments | The NTreeLayoutEventArguments represents the event arguments associated with tree layout events |
| NTreeRegion | The NTreeRegion class represents a layout item, whose content is a tree |
Nevron.Diagram.Layout Namespace
In This Topic
Classes
Delegates
| Delegate | Description | |
|---|---|---|
 | CellsLayoutCancelEventHandler | Delegate for events, which receive information about cancelable cells layouts |
| CellsLayoutEventHandler | Delegate for events, which receive information about cells layouts |
| GraphLayoutCancelEventHandler | Delegate for events, which receive information about cancelable graph layouts |
| GraphLayoutEventHandler | Delegate for events, which receive information about graph layouts |
| TreeLayoutCancelEventHandler | Delegate for events, which receive information about cancelable tree layouts |
| TreeLayoutEventHandler | Delegate for events, which receive information about tree layouts |
Enumerations
| Enumeration | Description | |
|---|---|---|
 | BodyArea | Enumerates the types of body areas |
| CellConstrainMode | Defines the possible modes, in which a constrained directed cells layout can be constrained |
| CellContentDimension | Enumerates the sizes of the cell content |
| CellDirection | Defines the directions in which the directed cells layout, must place adjacent cells |
| CellMeasure | Enumerates the measurements, which can be requested for a cell |
| ContentPlacement | Defines the ways, in which content can be placed horizontally or vertically within a content holder box |
| DockArea | Enumerates the docking areas, in which the cells in a dock layout can be docked |
| DockMode | Enumerates the modes for dock layoutss |
| FixedVertexPlacementMode | Defines the ways, in which the fixed vertices can be initially placed by a force directed layout |
| FreeVertexPlacementMode | Defines the ways, in which the free vertices can be initially placed by a force directed layout |
| GridCellSizeMode | Defines the possible cellsizing modes. |
| LayeredLayoutEdgeRouting | Enumerates the edge routing styles for layered layouts |
| LayeredLayoutNodeRank | Enumerates the ranking policies for layered layouts |
| LayoutDirection | Defines the possible expand directions for directed layouts |
| LayoutRotation | Enumerates the allowed angles at which a layout can be rotated |
| MagneticFieldDirection | Defines the possible types of magnetic field directions |
| MagnetizationType | Defines the ways in which a force directed edge body can be magnetized |
| ParentAnchor | Defines the predefined places at which a parent tree vertex can be anchored in respect to its subtree or children |
| PlugAnchor | Defines the anchors at which plugs can be glued |
| PlugSpacingMode | Enumerates the ways in which plugs can be spaced |
| PortStyle | Defines the predefined configurations of ports for vertices in tree layouts |
| RelativeAlignment | Defines the possible relative alignment used by directed layouts |
| RoutingStyle | Defines the routing styles of 1D bodies |
| SpringForceLaw | Defines the way, in which the spring force is affected by its natural and current length |
| StackMode | Enumerates the modes for stack layouts |
| TipOverChildrenPlacement | Defines the possible ways for placing the children in a tip over tree layout |
See Also