yFiles.NET (WinForms)
Changelog

yFiles.NET 6.0.0.2

Bug Fixes

  • Zooming with the mouse wheel in the overview component no longer scrolls the underlying container.

yFiles.NET 6.0.0.1



Improvements

Bug Fixes

General

Graph

Controls

  • Fixed a potential memory leak where the old graph instance was still keeping a reference to the GraphControl after the Graph has been replaced in GraphControl.
  • Fixed a bug where MinimumZoom and MaximumZoom were not respected in some cases when fitting graph bounds.
  • Fixed distorted rendering of selection, focus, and highlight indicators when a projection is set on the GraphControl.

Styles

  • With the EdgeStyleIndicatorRenderer class, the bends of the intermediate edges that are used for rendering now correctly have the tag object of the corresponding original bend.

Interaction

  • Fixed a bug where an edge was being deselected during port relocation.
  • After moving a folder node in closed state with orthogonal edge editing enabled, folding edges no longer get incorrect additional segments when the folder is expanded.
  • If the CreateEdgeInputMode.AllowCreateBend property is false, a long rest of the pointer no longer cancels edge creation.
  • CanvasControl.PointerLongRest events are no longer repeatedly raised during auto-scroll at the canvas bounds. Only CanvasControl.PointerDrag events are now triggered during this gesture.

GraphML

  • Fixed parsing empty strings into lists or arrays.

Layout

  • The static LayoutGraphGrouping.IsFlat method now correctly identifies graphs that have become flat because the last group node was deleted from the graph.

Hierarchical Layout

Orthogonal Layout

  • The OrthogonalLayout class now correctly considers the specified bend costs and edge orientation. Previously, for some setups, specifying both could lead to an error.

Edge Router

Organic Layout

  • The OrganicLayout class now correctly considers parallel substructures when integrated edge labeling is enabled.
  • The OrganicLayout with high values for the QualityTimeRatio property no longer violates constraints such as forbidden overlaps when running against the specified S^Duration.

Circular Layout

Radial Layout

  • The RadialLayout no longer throws an exception if there are bundled edges.

Algorithms

>

Demo Improvements

BPMN

  • Fixed compatibility code to read GraphML files of BPMN graphs created with prior library versions.

yFiles.NET 6.0

This version brings a major overhaul of many parts of the API, resulting in a lot of incompatible changes. We have designed many functions to be simpler, more intuitive and more consistent and removed technical debt.

In addition, this release contains numerous new features, improvements, and bug fixes to all parts of the library.

For a tour of this release's highlights, have a look at the article about yFiles.NET 6.0.

If you are updating from an older version of yFiles.NET, have a look at the list of incompatible changes and at the more detailed description in the Migration Guide.

Major new Feature: Support for Touch and Stylus Input

yFiles.NET now supports touch and stylus devices.

Touch input is now available across all built-in input modes. Numerous new properties enable full customization of input modes for mouse, stylus, and touch interactions.

The new versatile Pointer events replace the previous Mouse2D events. Pointer events support mouse, touch, and stylus inputs, providing generic properties such as event type (e.g., Up or Down) and location, as well as specific details like stylus pressure and touch size.

New Features, Improvements, and Bug Fixes

Categories: General Graph Controls Rendering Selection, Focus, Highlight Styles Interaction Label Editing Snapping Clipboard Folding View-Layout-Bridge Layout Hierarchical Layout Tree Layout Orthogonal Layout Edge Router Labeling Organic Layout Radial Tree Layout Series-parallel Layout Partial Layout Tabular Layout Component Layout Algorithms Analysis Geometry

General

New Features and Improvements

  • The yFiles library now consists of one single assembly.
  • All uses of the IListEnumerable<T> interface have been replaced by the IReadOnlyList<T> interface. This means that standard collections such as List<T> can now be used there. Accordingly, the ListEnumerableExtensions and ListEnumerable<T> classes have been removed.
  • The lookup API has been restructured. In particular, the LookupDecorator class is now easier to use, but most use cases are covered without having to access the low-level lookup architecture.
  • The assemblies now are strong-named as factory default.
  • The new LicenseConfig class offers a way to set the yFiles license data in code (as opposed to having to embed a resource file in the application).

Graph

New Features and Improvements

Bug Fixes

Controls

New Features and Improvements

Bug Fixes

  • Fixed an issue where a sequential animation would break when the preferred duration was set to zero.
  • Fixed GraphOverviewControl rendering issues with HighDPI displays in conjunction with display scaling.
  • Changing CanvasControl.Zoom property value no longer changes the viewport center, if the control's Projection and Scale are set to non-default values.

Rendering

New Features and Improvements

Selection, Focus, Highlight

New Features and Improvements

Styles

New Features and Improvements

Bug Fixes

  • The intersection calculation for RectangleNodeStyle has been corrected for some previously failing edge cases that resulted in edges ending in mid-air or disappearing.
  • The selection, highlighting and focus visualization of edges using BridgeEdgeStyle or ArcEdgeStyle no longer disappears too early if the edge path is only partially in the viewport.
  • The following node styles now consider the pen thickness in the visibility test: ShapeNodeStyle, ArrowNodeStyle, GeneralPathNodeStyle, GroupNodeStyle, and RectangleNodeStyle.
  • LabelStyle's GetPreferredSize now correctly calculates the preferred height for label text consisting of multiple lines of text when some kind of text trimming is used. Previously, the more lines of text there were, the higher the chance was for some lines being cut off, because the calculated height was to small.

Interaction

New Features and Improvements

Bug Fixes

Label Editing

New Features and Improvements

Snapping

New Features and Improvements

Clipboard

New Features and Improvements

  • Members of GraphClipboard and GraphEditorInputMode with Element in their name that actually referred to model items were renamed to Item to clarify their usage.
  • The GraphClipboard.Paste method now accepts an optional pasteLocation parameter specifying the center of the bounds of the pasted items.
  • The events on GraphClipboard now use GraphClipboardEventArgs that provide the current IGraphClipboardContext and the Items.
  • When moving the viewport in a GraphControl that has a projection, the inertia now works in the right direction.
  • GraphClipboard's Cut, Copy, Paste, and Duplicate methods now use an IEnumerable to determine the subgraph to copy.
  • GraphClipboard now uses an optimized ClipboardGraphCopier for its clipboard operations instead of the general GraphCopier.
  • Bug Fixes

    • In certain rare cases, the insertion of edges could end up in an endless loop. This has now been fixed.

    Folding

    New Features and Improvements

    • The process of configuring edges at folder nodes has been simplified, resulting in a significant reduction in the number of configuration calls for merged edges.
    • The default implementation for folder nodes and folding edge converters has been enhanced, providing more powerful capabilities for synchronizing and initializing various aspects with granularity.
    • Collapsed group nodes (folder nodes) can now have different tags from their expanded form (group nodes).
    • Changes made to view states (folder nodes, folding edges) can now be reflected back to the master items. New methods, UpdateGroupNodeState and UpdateMasterEdges, have been added to IFolderNodeConverter and IFoldingEdgeConverter, respectively, for handling these updates.

    Bug Fixes

    • Setting the source or target port of an edge to a port at another edge does no longer lead to an exception if the edge is represented in a managed view (IFoldingView). Instead, the edge is now removed from the view.
    • Fixed a bug which could cause an edge in a folding view to be created at different ports as those which were given as parameters. This could lead to unexpected connections during interactive edge creation in rare cases.
    • Fixed a bug that could lead to an exception when duplicating a port on the GraphClipboard if it is duplicated.
    • Fixed a bug which caused changing the ports on an edge whose source or target node is collapsed being reverted after subsequent collapsing and expanding.
    • Label changes on folder nodes are no longer reverted by FolderNodeConverter if labels are copied between master and view node.

    View-Layout-Bridge

    New Features and Improvements

    Bug Fixes

    • The LayoutExecutor and LayoutGraphAdapter classes now correctly assign port group IDs to edges that connect to the same port. Previously, in some cases involving ports with a single incoming and outgoing edge, the port group IDs were omitted, which could cause incorrect layout results (such as diagonal segments instead of orthogonal ones).

    Layout

    New Features and Improvements

    Bug Fixes

    Hierarchical Layout

    New Features and Improvements

    • The HierarchicalLayout class now supports defining minimum distances between the ports. They can be specified per node side using the HierarchicalLayoutNodeDescriptor.MinimumPortDistance property. The node size is increased if necessary in order to accommodate the minimum distances.
    • The Hierarchical Layout class now supports aligning the ports of edges incident to the same node, that is, the ports are placed at the same x- or y-coordinate. This can be particularly useful to visualize paths in a graph. Which ports to align is specified by the new properties PortData.SourcePortAlignmentIds and PortData.TargetPortAlignmentIds accessible via HierarchicalLayoutData.Ports.
    • The HierarchicalLayout now produces fewer bends for multi-edges with labels when integrated edge labeling is enabled.
    • The HierarchicalLayout class now produces better results for graphs with tabular groups where all children have a fixed user-specified order.
    • The routes of self-loops now consider both node and edge labels preventing overlaps if possible.
    • The ports of edges with free ports are no longer placed at the same location as fixed ports, which previously could happen if multiple edges had the same fixed port.
    • The HierarchicalLayout no longer produces overlapping edge segments if there are grouped edges with different thicknesses values. Previously, the user had to ensure that all these edges use the same thickness.
    • In barycenter mode the HierarchicalLayout now enforces a more symmetric placement of the nodes that are part of chains or height-2 trees.

    Bug Fixes

    • The HierarchicalLayout class no longer produces an error when using a non-zero grid distance in combination with incremental mode's exact coordinate hints.
    • The HierarchicalLayout class no longer assigns superfluous space to group nodes if there are grouped edges.
    • The HierarchicalLayout algorithm now correctly handles node and edge labels with width or height set to negative values. Previously, large negative values may have caused exceptions.
    • The HierarchicalLayout class now always places aligned ports correctly in from-sketch mode.
    • Instances of LayerConstraintData and SequenceConstraintData that are configured with comparables can now be reused for multiple layout calculations.
    • The HierarchicalLayout class no longer produces an error for labeled graphs with port alignment constraints when the integrated edge label placement is enabled.
    • The HierarchicalLayout class no longer produces superfluous crossings between backloops or same-layer edges in the first or last layer.
    • The HierarchicalLayout now properly handles self-loop edges when the edge is at a group node and furthermore edge/port grouped with the same ID on both sides. Previously, it was not routed correctly or that it was removed from the LayoutGraph instance when running the layout algorithm directly on the graph instance without using a copy.
    • The HierarchicalLayout class no longer swaps the position of fixed nodes in incremental layout mode with user-specified sequence constraints.
    • The HierarchicalLayout class no longer produces superfluous crossings for some graphs with group nodes in incremental layout mode.
    • Edges between two subcomponents now correctly consider fixed any-side port candidates.
    • The HierarchicalLayout class no longer produces very long edge segments for some input graphs containing groups with node halos and polyline edge routing.
    • The HierarchicalLayout class no longer throws an exception for graphs with bus structures if the algorithm runs in incremental mode and the group transposition feature is enabled.
    • The HierarchicalLayout class no longer produces intertwined edge routes with many superfluous crossings and bends for some cases with sequence constraints PlaceAtHead or PlaceAtTail. The problem mainly occurred with graphs with groups or PartitionGrid and incompatible sequence constraints.

    Tree Layout

    New Features and Improvements

    Bug Fixes

    Orthogonal Layout

    New Features and Improvements

    Bug Fixes

    • The Orthogonal Layout now automatically places edge labels of the parallel edges handled by its ParallelEdgeRouter instance, when integrated edge labeling is enabled.

    Edge Router

    New Features and Improvements

    • The quality of edge routing for buses is improved.
    • If EdgeRouter is run with the buses feature and a limited duration, it now splits the available time amongst buses, meaning that it will not get "stuck" on a single bus, which could otherwise impact the quality of the remaining buses and non-bus edge routings.

    Bug Fixes

    • The EdgeRouter now prefers to use fixed port candidates that are not overlapped by other nodes.
    • The EdgeRouter class no longer produces uncovered buses. Previously, there were some rare cases where the specified bus edges didn't constitute a bus.
    • When routing edges to and from fixed ports in the interior of group nodes, other nodes in the group are not ignored anymore, so that the edge does not overlap them if possible.

    Labeling

    Bug Fixes

    Organic Layout

    New Features and Improvements

    • The performance for the OrganicLayout has been substantially improved for large graphs without group nodes. The improvement is triggered if no special constraints are defined and no shape recognition is enabled.
    • The OrganicLayout now supports different styles for group substructures, which are set via the GroupSubstructureStyle property.

    Bug Fixes

    • The Organic Layout now automatically places edge labels of the parallel edges handled by its ParallelEdgeRouter instance, when integrated edge labeling is enabled.
    • The OrganicLayout class no longer ignores the preferred edge length in incremental layout mode with a single affected element.
    • Fixed an issue that may have automatically disabled the component layout when using constraint-based features.

    Radial Tree Layout

    New Features and Improvements

    Series-parallel Layout

    Bug Fixes

    • The Series Parallel Layout now automatically places edge labels of the parallel edges handled by its ParallelEdgeRouter instance, when integrated edge labeling is enabled.

    Partial Layout

    New Features and Improvements

    • PartialLayout now supports specifying inversely directed edges in addition to undirected and directed edges.

    Bug Fixes

    • PartialLayoutScopeData will no longer mark any edges as affected when only nodes are specified to be in scope, nor mark any nodes as affected when only edges are specified to be in scope.

    Tabular Layout

    New Features and Improvements

    Bug Fixes

    Component Layout

    New Features and Improvements

    Algorithms

    New Features and Improvements

    Bug Fixes

    • The Intersections class does not dispose FilteredGraphWrapper instances that it is given with no subgraph nodes or edges specified anymore. Previously, this caused the graph instance to become defunct, resulting in various operations running into null fields and properties, generating exceptions that were non-trivial to understand.
    • IntersectionsResult no longer includes intersections that have no actual intersection points. This issue occurred when two graph elements were within a small epsilon distance of each other.

    Analysis

    New Features and Improvements

    • The KShortestPaths class has a new implementation of the k-shortest path algorithm that allows for the exclusion of non-simple paths (i.e., paths with repeating vertices). Previously, these paths could not be excluded. The new implementation is used by default and can be disabled with the SimplePaths parameter.
    • For usage with a LayoutGraph, the algorithm is also available via the LayoutGraphAlgorithms.KShortestPaths method.

    Geometry

    New Features and Improvements

    • The new GeneralPath.AreaOrPathContains method tests if the path fuzzily contains a point and can be used for hit-testing a GeneralPath.
    • All methods on the GeneralPath class that accept points now have overloads for IPoint and PointD, and all methods that accept rectangles now have overloads for IRectangle and RectD.
    • There are now methods on RectD and PointD to calculate the distance between points and rectangles.
    • The GeneralPath.GetProjection method is now faster for paths with Bezier segments.
    • The IRectangle interface no longer implements IPoint. As a consequence, it is no longer possible to inadvertently use rectangles as parameters for methods that expect a point. You can still easily get the top-left corner of a rectangle with its GetTopLeft method. Similarly, IMutableRectangle no longer implements IMutablePoint.

    Bug Fixes

    Incompatible Changes

    Categories: General Graph Controls Rendering Selection, Focus, Highlight Styles Interaction Snapping Clipboard Folding Lookup GraphML View-Layout-Bridge Layout Layout Data Hierarchical Layout Tree Layout Orthogonal Layout Edge Router Labeling Organic Layout Interactive Organic Layout Circular Layout Radial Layout Radial Tree Layout Radial Group Layout Series-parallel Layout Compact Disk Layout Multi-page Layout Partial Layout Tabular Layout Component Layout Tree Map Layout Recursive Group Layout Layout Grid Other Layouts Algorithms Analysis Collections Geometry

    General

    Incompatible API Changes

    Graph

    Incompatible API Changes

    Incompatible Behavior Changes

    Controls

    Incompatible API Changes

    Incompatible Behavior Changes

    Rendering

    Incompatible API Changes

    Selection, Focus, Highlight

    Incompatible API Changes

    Styles

    Incompatible API Changes

    Interaction

    Incompatible API Changes

    Incompatible Behavior Changes

    Snapping

    Incompatible API Changes

    Clipboard

    Incompatible API Changes

    Folding

    Incompatible API Changes

    Incompatible Behavior Changes

    • Tags are not automatically the same on group and folder nodes or master and folding edges (master and view states). Instead, they have to be synchronized using the IFolderNodeConverter and IFoldingEdgeConverter implementations. The default implementations already synchronize the tags.
    • In the graph of a folding view, the CreateGroup method now always creates a group even if the isExpanded predicate specified in the FoldingManager.CreateFoldingView method specifies otherwise. Create the group on the master graph if you want the predicate to be respected.

    Lookup

    Incompatible API Changes

    GraphML

    Incompatible API Changes

    View-Layout-Bridge

    Incompatible API Changes

    Incompatible Behavior Changes

    • The LayoutGraphAdapter class does no longer offer a method to create a layout graph several times but is now meant to create exactly one layout graph copy which can be accessed via the LayoutGraph property and initialized with method LayoutGraphAdapter.Initialize. After initialization, changing properties of the LayoutGraphAdapter has no effect anymore.
    • Edges at the same port are now always automatically port grouped unless port groups have been defined explicitly.

    Layout

    Incompatible API Changes

    Incompatible Behavior Changes

    Layout Data

    Incompatible API Changes

    Hierarchical Layout

    Incompatible API Changes

    Incompatible Behavior Changes

    Tree Layout

    Incompatible API Changes

    Incompatible Behavior Changes

    • Port candidates are always considered if they are specified.
    • The TreeLayout now considers node labels by default.
    • The TreeLayout now places edge labels by default using an integrated labeling algorithm.

    Orthogonal Layout

    Incompatible API Changes

    Incompatible Behavior Changes

    Edge Router

    Incompatible API Changes

    Incompatible Behavior Changes

    Labeling

    Incompatible API Changes

    Organic Layout

    Incompatible API Changes

    Incompatible Behavior Changes

    Interactive Organic Layout

    Incompatible API Changes

    Circular Layout

    Incompatible API Changes

    Incompatible Behavior Changes

    Radial Layout

    Incompatible API Changes

    Incompatible Behavior Changes

    Radial Tree Layout

    Incompatible API Changes

    Incompatible Behavior Changes

    Radial Group Layout

    Incompatible API Changes

    Incompatible Behavior Changes

    Series-parallel Layout

    Incompatible API Changes

    Incompatible Behavior Changes

    Compact Disk Layout

    Incompatible Behavior Changes

    Multi-page Layout

    Incompatible API Changes

    Partial Layout

    Incompatible API Changes

    Incompatible Behavior Changes

    Tabular Layout

    Incompatible API Changes

    Incompatible Behavior Changes

    • The TabularLayout now considers node labels by default.
    • The TabularLayout now places edge labels by default using a generic labeling algorithm.

    Component Layout

    Incompatible API Changes

    Incompatible Behavior Changes

    Tree Map Layout

    Incompatible API Changes

    Recursive Group Layout

    Incompatible API Changes

    Layout Grid

    Incompatible API Changes

    Other Layouts

    Incompatible API Changes

    Algorithms

    Incompatible API Changes

    Analysis

    Incompatible API Changes

    Collections

    Incompatible API Changes

    Geometry

    Incompatible API Changes

    yFiles.NET 5.6.0.2

    >yFiles.NET 5.6.0.2 - Changes Since 5.6.0.1

    Bug Fixes

    • Fixed license validation on macOS.

    yFiles.NET 5.6.0.1

    Bug Fixes

    CanvasControl

    • Adding visuals without an explicit size directly to canvas object groups (instead of VisualGroup instances) now works consistently. Previously, they may sometimes never have appeared.

    Graph

    Styles

    • The intersection calculation for RectangleNodeStyle has been corrected for some previously failed instances that caused edges to end in midair or disappear.

    Interaction

    Folding

    • Changes to ports of an edge whose source or target node is hidden are no longer reverted when the node is subsequently collapsing and expanding.
    • Fixed a bug that could lead to an exception when duplicating a port on the GraphClipboard if it is duplicated.

    Layout

    Hierarchical Layout

    • The HierarchicLayout class no longer produces superfluous crossings for tabular group nodes with fixed children order.
    • The HierarchicalLayout class no longer produces superfluous crossings between backloops or same-layer edges in the first or last layer.
    • The HierarchicalLayout class no longer produces an error when using a non-zero grid distance in combination with incremental mode's exact coordinate hints.
    • The HierarchicalLayout class no longer assigns superfluous space to group nodes if there are grouped edges.
    • The HierarchicalLayout class no longer produces very long edge segments for some input graphs containing groups with node halos and polyline edge routing.
    • The HierarchicalLayout class no longer swaps the position of fixed nodes in incremental layout mode with user-specified sequence constraints.
    • The HierarchicalLayout class no longer throws an exception for graphs with bus structures if the algorithm runs in incremental mode and the group transposition feature is enabled.
    • The HierarchicalLayout class no longer produces superfluous crossings for some graphs with group nodes in incremental layout mode.
    • The HierarchicalLayout now properly handles self-loop edges when the edge is at a group node and furthermore edge/port grouped with the same ID on both sides. Previously, it was not routed correctly or that it was removed from the LayoutGraph instance when running the layout algorithm directly on the graph instance without using a copy.
    • The HierarchicalLayout class no longer produces intertwined edge routes with many superfluous crossings and bends for some cases with sequence constraints PlaceAtHead or PlaceAtTail. The problem mainly occurred with graphs with groups or PartitionGrid and incompatible sequence constraints.
    • The HierarchicLayout class no longer misplaces port labels at the connector nodes of integrated subcomponents.
    • The HierarchicLayout algorithm no longer requires a long runtime for some larger graphs with layering constraints when a maximum duration is specified.
    • The HierarchicLayout class no longer throws an exception for some invalid specifications of alternative group bounds in incremental layout mode.
    • The HierarchicLayout algorithm no longer requires a long runtime for some larger, grouped graphs with layering constraints and non-recursive layering.
    • The HierarchicLayout class no longer produces superfluous crossings for some edges with alternative paths that are incident to group nodes (see HierarchicLayoutData.AlternativeEdgePaths).

    Tree Layout

    Edge Router

    • The EdgeRouter class no longer produces uncovered buses. Previously, there were some rare cases where the specified bus edges didn't constitute a bus.
    • When routing edges to and from fixed ports in the interior of group nodes, other nodes in the group are not ignored anymore, so that the edge does not overlap them if possible.

    Labeling

    • The GenericLabeling class no longer produces bad label placements for edges with direct group content routing, i.e., edges that connect a group node with one of its descendants and are routed directly without leaving the group.
    • The GenericLabeling class no longer produces non-optimal label placements for some rare setups of graphs with node halos.

    Organic Layout

    • The OrganicLayout class now supports specified minimum group node sizes with more feature combinations. Previously, the minimum group node size was sometimes violated.

    Circular Layout

    • The CircularLayout class no longer produces strange routes for some bundled edges.

    Clear Area Layout

    Multi-page Layout

    • MultiPageLayout algorithm will adhere to page size specifications in rare cases that could previously cause the maximum page size to be exceeded.

    Algorithms

    • The Intersections class does not dispose FilteredGraphWrapper instances that it is given with no subgraph nodes or edges specified anymore. Previously, this caused the graph instance to become defunct, resulting in various operations running into null fields and properties, generating exceptions that were non-trivial to understand.

    yFiles.NET 5.6

    This release brings exciting new major features, and many other minor new features, improvements, and bugfixes to all parts of the library.

    If you are updating from an older version of yFiles.NET, have a look at the list of incompatible changes.

    Major new features

    Constraint organic layout and more

    The OrganicLayout class now supports different types of constraints that restrict the placement of the graph's nodes that are specified with the new OrganicLayoutData.Constraints property.

    In addition, organic layout now supports:

    Compact tabular layout

    The TabularLayout class now supports the calculation of node arrangements that lead to a low overall edge length. This feature can be enabled with the new property considerEdges.

    New alignment layout stage

    The new AlignmentStage class places the nodes of a given layout on automatically determined horizontal and/or vertical lines. This stage is particularly designed as a post-processing step that snaps suitable nodes to the same x- or y-coordinates to obtain a grid-like structure. When rearranging the initial layout, the stage moves the nodes as little as possible.

    The associated new AlignmentStageData class allows specifying custom data considered during the layout calculation.

    Improved group node style

    The last major release brought a powerful GroupNodeStyle, that got even more features and improvements in this release, namely:

    • If GroupNodeStyle's tab width is set to 0, the tab width does not reduce the corner radius of the style's outline anymore. However, it still forces the corner radius of the style's inner corners (i.e., the corners of the content area on the side of the style's tab) to 0.
    • The new GroupNodeStyle.MinimumContentAreaSize property simplifies enforcing a minimum size for the content area a group node.
    • GroupNodeStyle offers the possibility to have its tab width grow (or shrink) depending on the preferred size of associated tab and tab background labels.
    • The new GroupNodeStyle.RenderTransparentContentArea property controls whether a semi-transparent value for the contentAreaFill property works as expected by showing what's behind the group node.
    Support for .NET 8.0

    To facilitate using our library with .NET 8.0 and to improve compatibility a .NET 8.0 version of the library has been added.

    New Features

      Styles

      Layout

      Improvements

      Graph

      View

      Styles

      • The ArrowEdgeStyle's bounds now are tightly enclosing the rendered shape. Before they were too large.
      • Bends in edges that use ArcEdgeStyle, ArrowEdgeStyle, or BridgeEdgeStyle are no longer shown when selecting these edges. Additionally, marquee selection will not select these bends anymore even if they lie in the selection rectangle.

      Interaction

      GraphBuilder

      GraphML

      Layout

      • If AffectedLabels are set in LabelingData but no DpKey has been provided for them, the key set as AffectedLabelsDpKey on the labeling algorithm will be used.
      • For oriented rectangles the intersection test no longer allocates unnecessary memory and no longer creates unnecessary objects, which improves its allocation performance.
      • The HierarchicLayout class now also considers layering constraints between elements of different grouping hierarchies if the recursive group layering is enabled (property HierarchicLayout.RecursiveGroupLayering). Previously, such constraints were ignored in that case.
      • The TreeLayout class now places the ports of edges incident to multi-parent nodes and with port constraints (excluding any-side constraints) at the nodes' border. Previously, unlike as for edges incident to other nodes, the edge ports where located at the nodes' center.
      • The RadialLayout class now supports node types. The types influence the ordering of nodes of the same circle such that nodes of the same type are preferably placed next to each other if this does not induce additional crossings or conflicts with other constraints. Node types can be defined via the RadialLayoutData.NodeTypes property.

      Bugfixes

      Graph

      View

      • CanvasControl: Animated viewport changes could lead to strange behavior if maximum or minimum zoom were set and violated by the viewport change.
      • GroupNodeStyle's associated INodeInsetsProvider now correctly calculates insets for "small" nodes, i.e. nodes whose height (or width) is less than the style's TabHeight property.
      • Fixed a bug which might have caused port selection visualizations to disappear in image export or printing under rare conditions.

      Styles

      Interaction

      • The default visualization for selected ports is now displayed properly.
      • Fixed an issue where changing the GraphControl.InputMode while the context menu is open would lead to a crash.
      • Fixed a bug in HighlightIndicatorManager that could result in missing or surplus highlight visualizations when changing the GraphControl.HighlightIndicatorManager.
      • Self-loops no longer disappear when resizing nodes while orthogonal editing is enabled.
      • Fixed a bug in MoveViewportInputMode that caused the inertia feature to mistakenly start moving the viewport after the mouse pointer has stopped before being released.
      • Starting a CanvasControl/GraphControl viewport animation now properly stops a running MoveViewportInputMode inertia animation.
      • The direction of the first edge segment during orthogonal edge creation is now correctly determined when the source port candidate lies on the node border.
      • Fixed a bug in some input modes which led to undefined behavior if the mode has been uninstalled in a handler for its own events.

      GraphML

      Animations

      • Layout animation performance has been improved for edges with many bends.

      Analysis

      • Fixed the issue of excessive memory consumption in the analysis algorithm Paths when a large number of start and end nodes were set.
      • The ShortestPaths class now correctly calculates the k-shortest paths of graphs (see methods ShortestPaths.KShortestPaths and ShortestPaths.KShortestPathsCursor). Previously, in rare cases, the algorithm sometimes produces wrong results, i.e., returns paths that are not the shortest.

      Layout

      Hierarchic Layout
      Organic Layout
      • The OrganicLayout class no longer produces edge overlaps when property ChainRecognition is enabled.
      • In rare cases fixed nodes could move when also a group node was fixed.
      Radial Layout
      • The RadialLayout class no longer throws an exception if the layout algorithm is executed too many times from the same instance.
      Circular Layout
      Clear Area Layout
      Partial Layout
      • The PartialLayout class does no longer yield different results in rare cases when the same instance is applied twice to the same input graph.
      • The PartialLayout class now correctly places disconnected components for cases where a layout orientation is specified, and the property ComponentAssignmentStrategy is not Single. Previously, such components were sometimes placed far away from the remaining graph elements.
      Edge Router
      • The EdgeRouter class does no longer yield different results in rare cases when the same instance is applied twice to the same input graph.
      • The EdgeRouter class no longer produces self-crossing routes of edges with labels if property IntegratedEdgeLabeling is enabled.
      • The EdgeRouter class no longer produces bad layout results for some scenarios with grouped edges and multiple PortCandidates. Previously, the algorithm selected any of them without considering the alternative options.
      Orthogonal Layout

      Demo Improvements

      Incompatible Changes

      Requirements

      • yFiles does not support .NET Core 3.1 anymore. Minimum .NET version is 6.0 now. Minimum .NET Framework version still is 4.0. For the Layout only packages, the minimum requirements still are .NET Framework 3.5 and .NET Standard 2.0
      • The Layout package, i.e. the package which provides only the layout and analysis library, now only provides libraries for .NET Framework 3.5 and .NET Standard 2.0. These are compatible with all supported .NET versions, though.

      API

      Layout

      Interaction

      Changes of Default Behavior

      • EdgePathLabelModel and EdgeSegmentLabelModel have been modified to yield better results for some degenerate path cases. This leads to greater visual stability when the path is not long enough for the label or even completely invisible due to overlapping nodes. Technically, this can result in slightly different placements with the same parameter values in these edge-cases.
      • Adding a label with GroupNodeLabelModel to a node that does not use GroupNodeStyle or setting a GroupNodeLabelModel-created parameter for a label whose owner node does not use GroupNodeStyle no longer throws an ArgumentException claiming "The parameter does not support this kind of label.".
      • If GroupNodeStyle's tab width is set to 0, the tab width does not reduce the corner radius of the style's outline anymore. However, it still forces the corner radius of the style's inner corners (i.e. the corners of the content area on the side of the style's tab) to 0.
      Layout

      yFiles.NET 5.5.0.1

      Bugfixes

      View

      Graph

      Interaction

      • Fixed an issue where changing the GraphControl.InputMode while the context menu is open would lead to a crash.
      • Fixed a bug in MoveViewportInputMode that caused the inertia feature to mistakenly start moving the viewport after the mouse or touch pointer has stopped before being released.
      • Starting a CanvasControl/GraphControl viewport animation now properly stops a running MoveViewportInputMode inertia animation.
      • The direction of the first edge segment during orthogonal edge creation is now correctly determined when the source port candidate lies on the node border.
      • SmartEdgeLabelModel now properly supports the original position snap line.

      Styles

      • GroupNodeStyle's collapse/expand icon can now be reliably hit in all cases. In rare cases, changing the value of one the properties that affect the icon's location were not taken into account for hit tests.
      • ShapeNodeStyleRenderer now always uses the protected GetBrush and GetPen methods for all shapes instead of falling back to the respective style properties for some shapes.
      • ImageNodeStyleRenderer's GetBounds method now returns the actual image bounds instead of the node layout's bounds if KeepAspectRatio is enabled.
      • DefaultLabelStyle now adds ellipsis more reliably at the end when the text does not fit into the specified text wrapping shape.

      Table

      GraphML

      GraphBuilder

      • Fixed a potential memory leak in AdjacencyGraphBuilder. Some internal references were not cleaned up after items have been removed during UpdateGraph.
      • Fixed a bug in GraphBuilder where updating an existing edge whose (new) source or target nodes cannot be resolved did not remove the edge from the graph.
      • Fixed a potential memory leak in GraphBuilder, AdjacencyGraphBuilder, and TreeBuilder. Some internal map entries for labels were not discarded after their owner nodes or edges were removed.

      Layout

        Edge Router
        • The EdgeRouter class no longer produces bad layout results for some scenarios with grouped edges and multiple PortCandidates. Previously, the algorithm selected any of them without considering the alternative options.
        Circular Layout
        • A circular layout with LayoutStyle.BccIsolated can no longer get into an infinite loop for inputs where a component consists only of articulation points.
        Generic Labeling
        • The GenericLabeling class no longer produces bad label placements for edges with direct group content routing, i.e., edges that connect a group node with one of its descendants and are routed directly without leaving the group.
        Hierarchical Layout
        • For input graphs with a PartitionGrid structure, the HierarchicLayout class now correctly considers the layering produced by the FromScratchLayerer if it is already compatible with the specified grid structure.
        • The HierarchicLayout class no longer throws an exception for some invalid specifications of alternative group bounds in incremental layout mode.
        • The results of the DefaultLayerSequencer class are now deterministic by default, since it no longer aborts the calculation after 10s. For this, its MaximumDuration value is now unrestricted.
        Organic Layout
        Orthogonal Layout
        • The OrthogonalLayout class no longer generates overlaps between edge segments (of a parallel edge) and edge labels of other edges for some rare scenarios.
        Single Cycle Layout
        • The SingleCycleLayout class no longer produces violations of the specified minimum node distance.

        Incompatible Changes

          Minor

          yFiles.NET 5.5

          Major new features

          New styles for graph items

          The RectangleNodeStyle class is a new node style that uses a rectangular shape whose corners are either rounded or cut diagonally. Its properties specify which corners get rounded, the corner radius, its fill, and its border stroke.

          The new GroupNodeStyle class is a node style primarily designed for collapsed and expanded group nodes. It draws a (rounded) rectangle with an optional tab or ribbon, and offers extensive configuration options for an optional icon, its various fills, and paddings.

          The new ArrowNodeStyle class draws a node as an arrow shape. The arrow can point in one of the four compass directions, and the arrow head slope, the shaft thickness, the fill, and the border stroke can be configured.

          Similarly, the new ArrowEdgeStyle class draws an edge as an arrow shape. This style always points from the source port to the target port, ignoring bends, and can be configured in the same way as the node style.

          The DefaultLabelStyle class now supports different common background shapes.

          The ShapeNodeStyle class now supports three additional shapes: Hexagon2 (a six-sided polygon with tips at top and bottom), Star5Up (a five-pointed star with one tip pointing upwards), and Pill (a stadium shape with the shorter sides rounded).

          Its new property KeepIntrinsicAspectRatio defines whether to keep the intrinsic aspect ratio of the shape.

          The new BridgeEdgeStyle class renders an edge as a 3-segment bridge with a given height between the edge's source and target port locations. This is especially useful to distinguish parallel multi-edges between the same pair of nodes.

          Wrap text to shape

          The text wrapping feature of DefaultLabelStyle now wraps the text inside a given shape instead of just the rectangular label bounds. The TextWrappingShape enum provides the predefined shapes, and includes for example pill, ellipse, and hexagon. The new DefaultLabelStyle.TextWrappingPadding property defines the padding between the chosen shape and the text.

          If the predefined shapes don't fit your needs, you can override the DefaultLabelStyleRenderer.GetTextWrappingOutline method to return any custom convex path as GeneralPath instead.

          Compact disk layout

          The new CompactDiskLayout class arranges a graph on a disk, packing the nodes as dense as possible. This layout is mostly suitable for graphs with small components whose loosely connected nodes should be grouped and packed in a small area.

          The associated new class CompactDiskLayoutData allows to specify custom data considered during the layout calculation.

          Cactus group layout

          The new CactusGroupLayout class offers an alternative representation of hierarchically nested data. It places the children of a group along the groups circular border, resembling the structure of a cactus.

          The associated new class CactusGroupLayoutData allows to specify custom data considered during the layout calculation.

          The LargeGraphsAggregation demo has been modified to demonstrate that layout.

          New Features

          View

          Interaction

          Hierarchic Layout

          Organic Layout

          Radial Layout

          • The RadialLayout now supports a new layering strategy that produces a circular dendrogram drawing.
          • The RadialLayout now supports two new edge routing styles, namely a radial polyline style and a curved style. The radial polyline style produces edge paths which consist of a series of straight and arc segments. The curved polyline style routes the edges as curved bezier paths. In the latter case, the edge paths can be also returned as control points that represent cubic bezier control points.
          • The RadialLayout now supports integrated node labeling i.e., the node labels are taken into consideration when determining the positions for the nodes of the graph and guarantees that labels will not overlap with other objects in the graph.

          Balloon Layout

          • The BalloonLayout class now supports node types. The types influence the ordering of child nodes and the subtrees rooted at them such that nodes of the same type are preferably placed next to each other. Node types are weaker than a user-specified custom order defined via a comparison function. Types can be defined via the BalloonLayoutData.NodeTypes property.

          Circular Layout

          • The CircularLayout now supports integrated node labeling i.e., the node labels are taken into consideration when determining the positions for the nodes of the graph and guarantees that labels will not overlap with other objects in the graph.
          • The CircularLayout class now supports curved edge routing within and between circles.

          Analysis

          • Added the new RankAssignment analysis algorithm class that solves the rank assignment problem on an acyclic graph using the simplex method.
          • The new analysis class Intersections finds intersections and overlaps between graph items, featuring flexible configuration options to find only specific intersections. The respective yWorks.Layout.Intersections class provides the functionality also for the LayoutGraph API, but offers less convenience.

          Improvements

          General

          • yFiles now provides assemblies for .NET 7. The assemblies for .NET 5 have been removed.
          • The documentation about configuring the item visualization has been improved. All styles and their configuration options are now described in a Developer's Guide chapter.

          View

          Interaction

          Styles

          GraphBuilder

          Hierarchic Layout

          • The HierarchicLayout class now allows to combine the SimplexNodePlacer.StraightenEdges and SimplexNodePlacer.BarycenterMode properties. Previously, edge straightening was not supported in barycenter mode.
          • The HierarchicLayout class generates more compact results for some cases with edges between nodes of the same layer and integrated edge labeling where previously unnecessarily large distances to the label and edge were kept.
          • The HierarchicLayout class now places nodes without any edges as far left as possible without violating any constraints. That way they do not disturb the layout for the connected part of the graph.
          • For input graphs with a PartitionGrid structure, the HierarchicLayout class now correctly considers the layering produced by the FromScratchLayerer if it is already compatible with the specified grid structure. Previously, for such cases, the algorithm may have calculated an entirely different layer assignment.
          • The HierarchicLayout class now considers the flow direction to place the ports of port groups when combined with direct group content edges.
          • The HierarchicLayout class comes with an improved support for subcomponent layouts (see HierarchicLayoutData.Subcomponents). Defining subcomponents now works by assigning instances of the new SubcomponentDescriptor class to nodes so that nodes mapped to the same descriptor instance form a component. Components that have inter-edges only to a single non-component node are now integrated directly at that node when using the new placement policies SubcomponentPlacementPolicy.AlwaysIntegrated or SubcomponentPlacementPolicy.Automatic (and if the orientation of the sub-layout permits it). The overall results for such cases feature better edge routing quality and more compact drawings.
          • The HierarchicLayout class now also considers layering constraints between elements of different grouping hierarchies if the recursive group layering is enabled (property HierarchicLayout.RecursiveGroupLayering). Previously, such constraints were ignored in that case.
          • The HierarchicLayout class now uses a more compact layer placement for graphs with edge labels between layers.
          • The HierarchicLayout class now requires fewer bends for some inputs with grouped edges and port constraints or port candidates.

          Organic Layout

          Circular Layout

          • The CircularLayout class now supports node types (see CircularLayoutData.NodeTypes) also for the layout of the cycle partitions. Previously, the types had an influence only on the layout of a partition itself. If all nodes of a partition are of the same type, then the partition gets that type as well, so that partitions of same type are preferably placed next to each other.
          • The CircularLayout class has received a faster algorithm for calculating edge bundles.

          Tree Layout

          Edge Router

          • The EdgeRouter class now produces better results for some setups with monotonic path restrictions and edges with vertically/horizontally overlapping endpoints.
          • The EdgeRouter class now tries to avoid routes that cross fixed external ports of other edges as well as fixed internal ports at group nodes of other edges. The new property PenaltySettings.PortCrossingPenalty allows to specify the cost of such crossings.
          • The EdgeRouter class now supports buses that include self-loops (see class BusDescriptor). Previously, self-loops were ignored.

          Generic Labeling

          • The generic labeling algorithm has an additional preset to avoid overlaps of labels and the partition grid.

          Layout

          Analysis

          Bugfixes

          View

          Graph

          • Fixed a bug in FilteredGraphWrapper's NodeRemoved event where the provided old parent might have been present in the wrapped graph but not in the filtered graph.
          • The FilteredGraphWrapper class now raises the correct events when filtering out port labels. Previously, the events contained incorrect owner information.

          Interaction

          Styles

          • Cloning an ITable instance now properly clones all of the table's internal state. Previously, changing a cloned table's insets could result in the cloned table's stripes not updating their geometry.
          • TableNodeStyle now allows the table background style to access the table node's tag.
          • The built-in styles with rounded corners now have the correct outline shape for all calculations.
          • Edges with Bézier paths can now also be animated into non-Bézier paths.
          • Edge cropping now works as expected when using the BezierEdgeStyle class and the terminating nodes have styles that do not provide an outline in their IShapeGeometry implementation.
          • DefaultLabelStyle now considers the NoWrap flag of the FormatFlags of its StringFormat property correctly. Previously ClipText was often used to determine the clip and wrap behavior.
          • DefaultLabelStyle's NormalizeBrushes now properly handles rotated brushes.
          • ImageIcon now considers the pixel size of the image for painting instead of the physical size. This means it is now consistent with its own Size property.
          • Setting a new projection on CanvasControl now correctly keeps the viewport center the same.

          Licensing

          • License validation no longer fails when dynamic assemblies are loaded or yFiles code is called indirectly from dynamic methods. This could have resulted in licensing failures, e.g. when using yFiles in ASP.NET web services.

          GraphML

          • The key parameter of InputHandlerBase.SetValue method is now annotated correctly as nullable. The key may be null when the model item used as key is created after its data has been parsed.

          GraphBuilder

          • Label bindings which don't provide label data (or null) no longer add empty labels. Instead, no label will be added.

          Designer

          Hierarchic Layout

          Organic Layout

          • The OrganicLayout class no longer produces broken routes of self-loops at group nodes if the Scope is not equal to All.
          • The OrganicLayout class now correctly considers the specified PartitionGrid if substructure detection is enabled. Previously, the grid cell assignment of nodes belonging to a substructure has been ignored.
          • The OrganicLayout class now correctly considers fix-contents and fix-bounds groups (see enum GroupNodeMode) if the substructure detection is enabled.
          • The OrganicLayout class now correctly detects chain substructures if there are nodes of different types (OrganicLayoutData.NodeTypes).

          Clear Area Layout

          Orthogonal Layout

          • The OrthogonalLayout class no longer produces bad edge routes where the path is non-orthogonal and does not connect to the source node anymore for some rare cases containing parallel edges or chain substructures.
          • The OrthogonalLayout class now correctly considers the specified minimum group node sizes (see GroupingKeys.MinimumNodeSizeDpKey). Previously, the minimum sizes were always enlarged by the groups' insets (see GroupingKeys.GroupNodeInsetsDpKey). Actually, the minimum size should include the insets.
          • The OrthogonalLayout class now correctly handles input graphs with parallel edges if the PreferParallelRoutes property is enabled. Previously, such inputs have caused exceptions in some rare cases.

          Edge Router

          Generic Labeling

          Layout

          Incompatible Changes

            API

            Styles

            • The property DefaultLabelStyle.ClipText does not influence the text wrapping behavior anymore but is only used to clip any text outside the label bounds.

            Changes of Default Behavior

            • Licensing via the License Compiler now only works for .NET Framework. Previously, using a .licx file in the project would still work with .NET 5 and earlier when building in Visual Studio (though not on the command line). The recommended way to embed the yFiles.NET license is adding the license XML file as an embedded resource, which will work reliably in all supported platforms and target frameworks.
            • The semantic of the TraversalDirection.Both enumeration value used by the Neighborhood and Bfs algorithms has been changed and does not ignore the direction anymore, but now returns a union of the Successor and the Predecessor results instead. The old behavior can be restored by using the new TraversalDirection.Undirected enum value. Consequently, the default value of the TraversalDirection property of both the Neighborhood and the Bfs algorithm has been changed from Both to Undirected.
            • With the graph builder classes, label bindings which don't provide label data (or provide null) no longer add empty labels. Instead, no label will be added. Similarly, for label sources, no label will be added for data items for which the LabelCreator.TextProvider returns null.
            • When starting to drag the handle of a selected item, the handle isn't replaced anymore by a new handle instance provided for the selected item. Previously, this happened automatically, regardless of whether necessary to support use cases where state changes should result in a different handle instance. Now, the GraphEditorInputMode.RequeryHandles method has to be called explicitly when changes are made that affect handles that are potentially already visible. Alternatively, a proxy implementation can be used that dynamically dispatches to new instances on its own when required.
            • The HandleInputMode class doesn't initialize a handle drag as soon as the handle is pressed, anymore. Instead, it waits until the DraggedRecognizer or DraggedRecognizerTouch is triggered. When pressed, the mutex is already acquired, which discards other concurrent input modes. This can be turned off by setting the RequestMutexOnPress property to false.
            • The lists returned by the GraphPartition.GetCells, DynamicObstacleDecomposition.GetCells and DynamicObstacleDecomposition.GetObstacles methods are no longer unmodifiable.

            Deprecations

            Demo Improvements

            Improvements

            New Demos

            • The Arrow Node Style Demo shows the new ArrowNodeStyle and its setting options.
            • The Rectangle Node Style Demo shows the new RectangleNodeStyle and its setting options.
            • The Shape Node Style Demo shows the shapes that are available for the ShapeNodeStyle.
            • The Default Label Style Demo shows the background shapes that are now available for the DefaultLabelStyle.
            • The Text Wrapping Demo shows the various options of the new text wrapping feature for labels.
            • The Simple Arrow Demo shows how to implement a custom arrow.
            • The Sankey demo shows how to visualize flow information in which the thickness of the edges is proportional to the flow quantity.

            yFiles.NET 5.4.0.2

            Improvements

              Hierarchic Layout

              Bugfixes

                Graph

                • Fixed a bug in FilteredGraphWrapper's NodeRemoved event where the provided old parent might have been present in the wrapped graph but not in the filtered graph.

                Interaction

                • After pasting, a closed group node within another closed group now stays closed. Previously, it was open due to a bug in the GraphClipboard class.

                View

                Generic Labeling

                Orthogonal Layout

                Hierarchic Layout

                Layout

                • The TabularLayout class now always uses the correct bounding box values for node labels that are considered. Previously, wrong label bounds could lead to unnecessarily large rows or columns.
                • The IsolatedGroupComponentLayout class no longer produces unnecessarily large group nodes if the specified GridSpacing is zero.

                yFiles.NET 5.4.0.1

                Bugfixes

                Interaction

                Licensing

                • License validation no longer fails when dynamic assemblies are loaded or yFiles code is called indirectly from dynamic methods. This could have resulted in licensing failures, e.g. when using yFiles in ASP.NET web services.

                Graph

                • The FilteredGraphWrapper class now raises the correct events when filtering out port labels. Previously, the events contained incorrect owner information.
                • The CompositeUndoUnit.UndoName property now indeed sets the undo name, not the redo name.

                Styles

                • The built-in styles with rounded corners now have the correct outline shape for all calculations.
                • Edges with Bézier paths can now also be animated into non-Bézier paths.
                • Edge cropping now works as expected when using the BezierEdgeStyle class and the terminating nodes have styles that do not provide an outline in their IShapeGeometry implementation.

                Hierarchic Layout

                • The HierarchicLayout class now correctly considers the specified halos of group nodes when there is a partition grid defined.
                • The HierarchicLayout class no longer produces misplaced edge labels for some rare cases with grouped edges.
                • The HierarchicLayout class no longer generates broken non-orthogonal edge segments of same-layer edges for some cases in conjunction with integrated edge labeling and edge labels placed at the ports.
                • The HierarchicLayout class now correctly routes grouped edges, where previously there could be overlaps of nodes and edges in some rare cases.
                • The HierarchicLayout class now properly satisfies PortCandidates defined for same-layer edges at nodes where other edges with (rather large) source/target port labels additionally exist.
                • The HierarchicLayout class now produces a correct edge grouping structure for short edges having the same source and target group ID.
                • The HierarchicLayout class no longer throws an exception when the edge-directedness feature (HierarchicLayoutData.EdgeDirectedness) is used in conjunction with enabled back-loop routing (HierarchicLayout.BackLoopRouting).
                • The HierarchicLayout class no longer creates unnecessary spacing between sub-components (see HierarchicLayoutData.SubComponents) and other elements. This previously happened in some cases due to edge/node labels being present. In consequence, these cases are now more compact.
                • The HierarchicLayout class no longer produces overlaps between (large) external node labels and unrelated edges.
                • The HierarchicLayout class no longer produces overlaps between sub-component elements (see HierarchicLayoutData.SubComponents) and edges that are not part of the component.
                • The HierarchicLayout class no longer produces superfluous port overlaps if there are edges with strong port constraints.
                • The HierarchicLayout class now correctly assigns ports to edges incident to groups if the uniform port assignment is enabled (see property HierarchicLayoutData.UniformPortAssignmentGroups) for some cases where it previously did not yield a uniform port distribution.
                • The HierarchicLayout now correctly considers the PreferredPlacementDescriptor settings of an edge label when there are additionally edge groupings defined. Previously, it could, for example, happen that the edge label was placed on the wrong side of the edge.

                Organic Layout

                Orthogonal Layout

                • The OrthogonalLayout class now correctly handles input graphs with parallel edges if the PreferParallelRoutes property is enabled. Previously, such inputs have caused exceptions in some rare cases.

                Circular Layout

                Clear Area Layout

                Partial Layout

                • The PartialLayout class now correctly routes the edges if its AllowMovingFixedElements property is enabled. Previously, in some rare cases, this setting could cause broken edge routes.

                Edge Router

                Layout

                View

                yFiles.NET 5.4

                This release brings a couple of exciting new major features and lots of other smaller new features, improvements, and bugfixes for all parts of the library.

                Major New Features

                Smooth viewport animations

                Many viewport transitions are now smoothly animated. This prominently includes scrolling and zooming with the mouse wheel, but also the various commands, such as zooming via a toolbar button, fitting the graph into the viewport, interacting with the overview, and many others. This can be turned off for individual interactions via the new CanvasControl.AnimatedViewportChanges property, and customized with the new protected method CanvasControl.GetViewportAnimationDuration.

                Support Nodes of Different Types in Layout

                Many of the yFiles layout styles now support node types. Typically, a layout places nodes of the same type closer together or in a similar way. The following layout styles support node types:

                In the HierarchicLayout class, types influence the ordering of nodes within their layers as a subordinate optimization criteria. More precisely, nodes of the same type are more likely to be placed next to each other if this does not violate other constraints.

                For the TreeLayout and ClassicTreeLayout classes the types influence the ordering of child nodes and the subtrees rooted at them such that nodes of the same type are preferably placed next to each other. Node types are a weak criterion, i.e., if the ordering and placement is determined by other constraints, these are prioritized. Types can be defined via the TreeLayoutData.NodeTypes property.

                The OrganicLayout class now allows to define node types via the new OrganicLayoutData.NodeTypes property . The types control the detection of substructures (e.g. stars, parallel structures). When types are defined, only nodes of the same type can form a substructure. For star-like and parallel substructures, it is also possible to have a single substructure with nodes of different types, see properties ParallelSubstructureTypeSeparation and StarSubstructureTypeSeparation. The algorithm still tries to highlight the different types by choosing a suitable layout for these components (e.g., placing nodes of the same type closer together or on the same circle).

                The OrthogonalLayout class now allows to define node types via the new OrthogonalLayoutData.NodeTypes property. The types control the detection of substructures, i.e., chains, cycles and trees. When types are defined, only nodes of the same type can form a substructure.

                The CircularLayout class is now able to separate nodes that are on the same cycle with respect to their node type. For this, the new NodeTypeAwareSequencer class can be set as NodeSequencer on the CircularLayout.SingleCycleLayout. Node types are specified via the CircularLayoutData.NodeTypes property.

                The ComponentLayout class now supports node types. The types influence the arrangement and ordering of the the components such that components consisting mostly of nodes of the same type are put close to other components consisting of nodes of that type. Use the ComponentLayoutData.NodeTypes property to define types.

                The node types feature is shown in the new Node Types Demo.

                Edge Routing Only if Needed

                Optionally, the EdgeRouter, ChannelEdgeRouter and BusRouter classes now automatically determine whether or not a new path should be calculated for a certain edge. This is controlled via the new properties EdgeRouterEdgeLayoutDescriptor.RoutingPolicy, ChannelEdgeRouter.RoutingPolicy and BusRouterBusDescriptor.RoutingPolicy, respectively. The decision is based on the quality of the existing routes - edges with strict violations of the routing style or that intersect other elements will be selected for routing. Available options:

                • RoutingPolicy.Always: A new route is calculated in any case. This was the previous behavior and remains the default.
                • RoutingPolicy.PathAsNeeded: The algorithm determines whether a new route is needed. If an edge is selected, its current path is not considered when computing a new route.
                • RoutingPolicy.SegmentsAsNeeded: The algorithm determines whether a new route is needed. If an edge is selected, its current path is preserved as much as possible. Only the required segments are changed. This is only supported by the EdgeRouter class.

                The new penalty property PenaltySettings.SketchViolationPenalty supported by the EdgeRouter class defines the cost for a deviation from the original edge path if the new routing policy property is set to SegmentsAsNeeded.

                Support for .NET 6.0
                To facilitate using our library with .NET 6.0 and to improve compatibility a .NET 6.0 version of the library has been added. Also, the demo and tutorial samples now automatically reference the highest .NET SDK which is available on the current machine.

                New Features

                View

                Analysis

                • The new TreeAnalysis algorithm offers a convenient way of analyzing tree structures and querying tree-related properties (e.g. leaf nodes, parent-child relations and more).

                GraphBuilder

                • The graph and tree builders now support bindings for bend locations. This is implemented by new bend-related members of the EdgeCreator class.

                Algorithms

                Layout

                • The new GenericLayoutData class is a generic implementation of LayoutData that allows to pass arbitrary data to layout stages. As a consequence, the LayoutData.Apply, ItemCollection.ProvideMapper and ItemMapping.ProvideMapper methods were removed.
                • The new SelfLoopRouterData class specifies custom data for the SelfLoopRouter class. In more details, it allows to define which self-loop edges should be routed and which should keep their current path.
                • The new PortPlacementStageData class specifies custom data for the PortPlacementStage class. In more details, it allows to define port candidates, port constraints, and node port candidate sets which are then considered by that layout stage.
                • The SubgraphLayout class now allows to define which edges must be included or excluded in the subgraph. Previously, only nodes could be specified. The new SubgraphLayoutData class offers the SubgraphNodes and SubgraphEdges properties to conveniently define the nodes and edges that should form the subgraph the core layout runs on.
                • The OrganicLayout class offers the new ClusteringPolicy property, which allows to specify the clustering algorithm that is applied to the input graph. Three clustering algorithms are available: Louvain modularity, edge betweenness, and label propagation. Previously, the node clustering was always based on edge betweenness. By default, clustering is disabled.
                • The PartialLayout class offers a new property MoveFixedElements to allow moving fixed elements. This often yields a better layout quality even though the preservation of the mental map declines because the fixed elements may change their position.
                • The OrganicLayout and ClassicOrganicLayout classes support the new scope MainlySubsetGeometric. In addition to the actual affected nodes, this scope may to some degree move nodes that are geometrically close to an affected node. The existing scope MainlySubset is similar, but it does determine the closeness of other nodes by using the graph structure instead of the current geometry (i.e. location).

                New Demos

                • The new LensInputMode demo shows how to create an InputMode to show a magnifying glass effect on the canvas.
                • The new Neo4JIntegrationDemo shows how the Neo4J.Driver library can be included in yFiles applications to create diagrams from Neo4J databases.
                • The new NodeTypes demo shows how to use the node type support of the yFiles layout algorithms.

                Improvements

                Interaction

                Graph

                View

                GraphBuilder

                Hierarchic Layout

                • The HierarchicLayout class now has an improved strategy for choosing the port candidates for same-layer edges with multiple available candidates. Previously, the chosen candidate may have led to superfluous back-loops.
                • The HierarchicLayout class now generates shorter paths for edges that cross borders of PartitionGrid columns in cases where there are no other obvious constraints that require the edge to be longer. This holds for the default vertical layout orientation; for a horizontal orientation, edges that cross borders of rows are affected by this improvement.
                • The HierarchicLayout class now considers the edge direction when choosing a port candidate for edges with multiple candidates. This new strategy often leads to less bends.

                Organic Layout

                Edge Routing

                • When the EdgeRouter class runs with a highly restricted maximum duration or is aborted via the AbortHandler class, i.e., the router operates in the fastest possible mode, the calculated edge routes now are of higher quality. The quality improvements mainly affect cases with fixed port locations.
                • The EdgeRouter class now allows to explicitly define the costs for different types of edge crossings. The new properties PenaltySettings.AdjacentEdgeCrossingPenalty and PenaltySettings.SelfCrossingPenalty relate to crossings between two adjacent edges and crossings between two line segments that belong to the same edge, respectively. Previously, all types of crossings were covered by the existing EdgeCrossingPenalty property.
                  • By default, now, crossings of adjacent edges are more expensive than normal ones and self-crossings are the most expensive.
                  • Furthermore, the default values of the EdgeLengthPenalty and GroupNodeCrossingPenalty properties were increased to obtain more balanced results.
                • The EdgeRouter class now produces more suitable routes for edges with octilinear routing style. Previously, the diagonal segments where often omitted after/before an edge's first/last segment.

                Layout

                Demo Improvements

                • The demo and tutorial projects for .NET Framework have been updated to target the most recent .NET Framework SDK.
                • The .NET demos and tutorials now automatically reference the newest .NET SDK which is available on the machine they are installed on.

                Bugfixes

                View

                • The mouse event coordinates are no longer quantized to very large steps if a projection is used and the viewport is zoomed in afterwards.
                • The clipboard now doesn't copy labels or ports if they are not selected and their owner's IClipboardHelper forbids copying the owner.
                • The ZoomToCurrentItem command no longer moves the current item outside the visible area in rare cases. This was caused by a problem in the ViewportLimiter class.
                • Callbacks registered for removed visuals on the CanvasObject tree now reliably run after the visual is indeed no longer visible.
                • Callbacks registered with the IRenderContext.SetDisposeCallback method now are reliably called, even when a canvas object has been explicitly removed.
                • The CanvasControl.EnsureVisible method no longer ignores the limited viewport size in certain cases.
                • The Scale is honored for the VisibilityThreshold of the GridVisual.
                • EmfImageExporter now properly extends the background brush into the margins.

                Interaction

                • When expanding a closed group, the parent groups of the expanded group no longer become unnecessarily large. The incorrect behavior could be observed only under certain conditions and was caused by a bug in the NavigationInputMode class.
                • Auto dragging was not stopped in certain cases.
                • The text box shown by the TextEditorInputMode class is now correctly placed if the TextBoxPlacementPolicy.MoveTextBox is set and a projection is used.
                • Fixed editing self-loops with PolylineEdgeStyle and orthogonal edge editing enabled.

                Graph

                Styles

                Geometry

                • The Area property of an empty RectD instance (including RectD.Empty) is now always zero, and no longer a negative value.

                Hierarchic Layout

                • The HierarchicLayout class no longer produces an infinite looping issue in the incremental layout mode for some input graphs with layer constraints that specify that a node should be placed in the topmost/bottommost layer.
                • The HierarchicLayout class no longer produces unnecessary edge crossings between self-loop edges at the same node in cases where a larger number of self-loops exist at a node.
                • The HierarchicLayout class no longer ignores edges connected to group nodes when the group node contains a bus structure (see HierarchicLayoutData.Buses) and no other elements. Such edges were previously actually removed from the layout graph such that other stages (e.g. the ComponentLayout) could have failed with an exception.
                • The HierarchicLayout class no longer occasionally throws an exception when enabling HierarchicLayout.CompactGroups and in conjunction with layering constraints and/or a group node marked as incremental.
                • The HierarchicLayout class does no longer violate the specified minimum length for edges incident to group nodes.
                • The sequencing phase of the HierarchicLayout class is now faster for large graphs with sequence constraints and non-incremental layout mode.

                Edge Routing

                • The BusRouter class now produces more suitable edge routes for rare cases that were caused by an unsuitable bus placement.
                • The EdgeRouter class now uses the given ports for edges of a bus with fixed edges.
                • The EdgeRouter class now correctly considers edges incident to a fixed inner port of a group node when the routing algorithm has restricted maximum duration. Previously, this setup sometimes led to strange edge routes with many superfluous bends.
                • The CurveRoutingStage class now correctly considers the minimum distance to nodes specified as value of the CurveEdgeLayoutDescriptor.MinimumNodeToEdgeDistance property. Previously, the curves could violate the distance and get too close to nodes.
                • The EdgeRouter class no longer contains edges with self-crossings in some rare cases where it previously failed to eliminate them.
                • The EdgeRouter and CurveRoutingStage classes no longer change the path of unaffected (fixed) edges when the CreateControlPoints property of their associated EdgeLayoutDescriptor instance (CurveEdgeLayoutDescriptor respectively) is enabled.
                • The EdgeRouter class now correctly supports the use case that a subset of edges is routed with the curved routing style while another subset is routed with another routing style and different settings on the associated individual EdgeLayoutDescriptor instances. Previously, with some edges being curved, the settings of the other edges got lost and the default settings were used.
                • The OrthogonalSegmentDistributionStage class does no longer crash when receiving input graphs with a very large edge count (greater than approximately 22000). Note that the ChannelEdgeRouter class is affected too, as the stage is by default called from within the router.
                • The EdgeRouter class no longer has a problem that appeared with a bus containing affected as well as non-affected (fixed) edges at the same time. Previously, this could trigger an Exception or lead to the incorrect behavior that an actually affected other edge was not routed.
                • The EdgeRouter class no longer occasionally throws an exception if the input contains bus edges defined via BusDescriptor.
                • The BusRouter class no longer fails to generate connected buses for cases with fixed and incremental edges on the same bus. Previously it sometimes generated a disjoint bus even though the bus IDs were equal.
                • The BusRouter class no longer ignores edges that should be routed when a they are on a bus with fixed edges (see BusDescriptor.Fixed property) and when they share both source and target port with a fixed edge.
                • The EdgeRouter class no longer has a problem that occasionally resulted in bad edge routing artifacts if edge grouping is enabled and non-affected edges are grouped at both end points.*.
                • The ParallelEdgeRouter class no longer throws an exception if the input has both a large number of parallel edges and a leading edge with ports on the node border.
                • The EdgeRouter class no longer occasionally throws an exception if the input contains bus edges (defined via BusDescriptor).
                • The OrganicEdgeRouter.KeepExistingBends property now correctly obeys its definition and actually keeps the absolute coordinates of the existing bends.

                Layout

                Incompatible Changes

                Behavior

                Deprecations

                yFiles.NET 5.3.0.2

                Improvements

                • A dedicated .NET 5.0 version of the library now is bundled to facilitate the use with NuGet and to improve compatibility with certain obfuscation tools. A .NET 5.0 version of the samples is provided, too.

                View

                Layout

                • The HierarchicLayout class now has an improved strategy for choosing the port candidates for same-layer edges with multiple available candidates. Previously, the chosen candidate may have led to superfluous back-loops.

                Algorithms

                • The LabelPropagationClustering algorithm now produces normalized, continuous clustering IDs. In other words, for example, if it finds 5 clusters, they get IDs from 0 to 4. Previously, the range of IDs may have contained holes. If initial label values are provided, this normalization is omitted.

                Bugfixes

                View

                Graph

                Input

                • The CreateEdgeInputMode class no longer has an error which prevented the removal of port candidate visualizations after another input mode claimed to be active.
                • Labels with \n now are displayed correctly when the label is edited.

                GraphML

                • Labels at ports of collapsed nodes are no longer lost during GraphML serialization.

                Analysis

                Layout

                • The TabularLayout class no longer throws an exception about a missing PartitionGrid when used within RecursiveGroupLayout and RecursiveGroupLayoutData and TabularLayoutData are used without an explicit cell-id mapping.
                • The LayoutExecutor class now uses the correct target bounds when a projection is set on the GraphControl.
                • When the MaximumDuration of the EdgeRouter class is exceeded, it now still uses the same port for edges that are grouped. Previously, edge grouping constraints were mostly ignored when the time was up.
                • Improved the reaction time of the EdgeRouter class when the MaximumDuration is exceeded or the algorithm should stop due to AbortHandler for some cases where previously the search for a path kept on running for a long time.
                • The RadialLayout class is now much faster if the input graph is a very large tree structure.
                • The OrganicLayout and ClassicOrganicLayout classes no longer produce an internal integer overflow that may lead to an early exit and, thus, poor layout results for very large input graphs.
                • The ClearAreaLayout class no longer throws an exception for some scenarios where the same algorithm instance was first applied to a graph with PartitionGrid and later to a graph without grid.
                • The EdgeRouter and PolylineLayoutStage classes no longer produce broken routes for edges with polyline segments. Previously, such broken routes may have appeared in rare cases.
                • The HierarchicLayout class now correctly considers the back-loop routing style (HierarchicLayout.BackLoopRouting) for graphs with critical edges (see HierarchicLayoutData.CriticalEdgePriorities).
                • The ClearAreaLayout and FillAreaLayout classes no longer throw an exception for some input graphs with edge labels if property ConsiderEdgeLabels is enabled.
                • The GenericLabeling class no longer throws an exception for edge labels with preferred placement descriptor if property PlaceEdgeLabels is disabled.
                • The TreeLayout class now correctly handles trees with group nodes. Previously, it sometimes produced overlapping elements and halo violations for such inputs.
                • The curved edge routes produced by HierarchicLayout, EdgeRouter or CurveRoutingStage no longer violate the minimum node-edge distance or intersect the node. Intersections could previously happen especially when the specified node-edge distance was zero.
                • The RecursiveGroupLayout class now correctly handles setups that use both recursive and non-recursive group nodes. Previously, such use-cases may have led to invisible/ignored edges and, thus, broken edge routes.
                • The PartialLayout class now transfers the value of its PartialLayout.MaximumDuration property to the internally used edge routing algorithm. This means that when the partial layout has a restricted running time, the routing part will be restricted, too. Previously, the duration of the edge routing was unrestricted. Note that if the router instance is user-specified, this instance will not get a maximum duration.
                • The HierarchicLayout, EdgeRouter and CurveRoutingStage classes no longer occasionally throw an exception when the curved routing style is used for graphs that have self-loop edges.
                • The ClearAreaLayout class now produces correct orthogonal routes for edges if its ClearAreaStrategy property is set to a local strategy. Previously, some of the edges may have received a non-orthogonal route.
                • The EdgeRouter class no longer throws an exception if the input contains a bus defined via BusDescriptor where all the associated edges are actually fixed.

                Hierarchic Layout

                • The HierarchicLayout class no longer produces an infinite looping issue in the incremental layout mode for some input graphs with layer constraints that specify that a node should be placed in the topmost/bottommost layer.
                • The HierarchicLayout class no longer produces unnecessary edge crossings between self-loop edges at the same node in cases where a larger number of self-loops exist at a node.
                • The HierarchicLayout class no longer ignores edges connected to group nodes when the group node contains a bus structure (see HierarchicLayoutData.Buses) and no other elements. Such edges were previously actually removed from the layout graph such that other stages (e.g. the ComponentLayout) could have failed with an exception.
                • The HierarchicLayout class no longer occasionally throws an exception when enabling HierarchicLayout.CompactGroups and in conjunction with layering constraints and/or a group node marked as incremental.
                • The HierarchicLayout class does no longer violate the specified minimum length for edges incident to group nodes.
                • The sequencing phase of the HierarchicLayout class is now faster for large graphs with sequence constraints and non-incremental layout mode.

                Edge Routing

                • The BusRouter class now produces more suitable edge routes for rare cases that were caused by an unsuitable bus placement.
                • The EdgeRouter class now uses the given ports for edges of a bus with fixed edges.
                • The EdgeRouter class now correctly considers edges incident to a fixed inner port of a group node when the routing algorithm has restricted maximum duration. Previously, this setup sometimes led to strange edge routes with many superfluous bends.
                • The EdgeRouter class no longer contains edges with self-crossings in some rare cases where it previously failed to eliminate them.
                • The EdgeRouter and CurveRoutingStage classes no longer change the path of unaffected (fixed) edges when the CreateControlPoints property of their associated EdgeLayoutDescriptor instance (CurveEdgeLayoutDescriptor respectively) is enabled.
                • The EdgeRouter class now correctly supports the use case that a subset of edges is routed with the curved routing style while another subset is routed with another routing style and different settings on the associated individual EdgeLayoutDescriptor instances. Previously, with some edges being curved, the settings of the other edges got lost and the default settings were used.
                • The OrthogonalSegmentDistributionStage class does no longer crash when receiving input graphs with a very large edge count (greater than approximately 22000). Note that the ChannelEdgeRouter class is affected too, as the stage is by default called from within the router.

                New Demos

                • The new Sankey layout demo shows how HierarchicLayout can be configured to show a Sankey diagram.

                yFiles.NET 5.3.0.1

                Bugfixes

                Right-to-Left

                Layout

                • The HierarchicLayout class now correctly handles inputs that have both bus structures and edges with recursive style. Previously, an exception could be triggered when an edge was marked as recursive and belonged to a bus at the same time.
                • The EdgeRouter class no longer has a problem that appeared with a bus containing affected as well as non-affected (fixed) edges at the same time. Previously, this could trigger an Exception or lead to the incorrect behavior that an actually affected other edge was not routed.
                • The EdgeRouter class no longer occasionally throws an exception if the input contains bus edges defined via BusDescriptor.
                • The BusRouter class no longer fails to generate connected buses for cases with fixed and incremental edges on the same bus. Previously it sometimes generated a disjoint bus even though the bus IDs were equal.
                • The BusRouter class no longer ignores edges that should be routed when a they are on a bus with fixed edges (see BusDescriptor.Fixed property) and when they share both source and target port with a fixed edge.
                • The element processing order in the BendConverter layout stage is now deterministic. The previous non-deterministic order of inserting and removing elements could lead to non-deterministic behavior for consecutive layout calculations.
                • The ParallelEdgeRouter class no longer throws an exception if the input has both a large number of parallel edges and a leading edge with ports on the node border.
                • The OrthogonalLayout class now correctly handles input graphs with parallel edges if the PreferParallelRoutes property is enabled. Previously, such inputs have caused exceptions in some rare cases.
                • The FamilyTreeLayout class now properly handles the case that the family tree contains cycles, e.g., due to a family founded by parent and (step-)child. Previously, it sometimes produced a stack overflow or non-orthogonal routes for such an input.

                Improvement

                • The .NET Core version of the library (lib/netcoreapp3.0) has been tested with .NET 5.0 and compatibility has been confirmed.

                Incompatible Changes (Demos)

                • The .NET Core versions of demos and tutorial (samples-netcore) now target .NET Core 3.1. They can still be used with .NET Core 3.0 by simply changing the target framework. The library is not affected.

                yFiles.NET 5.3

                This release contains many new major features and lots of other new features, improvements, and bugfixes for all parts of the library. In addition to the new demos that show the new features, there are some notable new demos and demo improvements, too.

                If you are updating from an older version of yFiles.NET, have a look at the list of incompatible changes.

                Major New Features

                Isometric Drawing and Other Projections

                CanvasControl (and thus GraphControl) now has an additional Projection property that can be used to transform the viewport into a different parallel projection, e.g. isometric or cabinet projection. Predefined useful projections are provided as constants on the new Projections class. Interaction, including graph editing, snapping, orthogonal edge editing, etc. still work as expected, just within the new projection. That is, orthogonal edge editing becomes isometric edge editing with an isometric projection. There is a corresponding chapter in the Developer's Guide that goes into further detail what has changed and which customization options exist.

                The IsometricDrawing demo displays graphs in an isometric fashion to create an impression of a 3-dimensional view.

                Fill Area Layout and Clear Area Layout

                The new ClearAreaLayout algorithm clears a user-specified area in an existing layout by moving elements. It is suitable if the rest of the layout should not change much but some free space is required, e.g., because new elements need to be inserted into the drawing or have been resized.

                The new FillAreaLayout algorithm fills a user-specified area in an existing layout by moving elements into or towards it. It can make layouts around the specified area more compact and is suitable if, e.g., elements were removed from the graph or their size has changed substantially.

                A number of new demos showcase the new layout algorithms:

                • The new MarqueeClearArea demo shows how to make space in a diagram by dragging a marquee rectangle.
                • The new OverlapAvoidingEditor demo shows how to interactively edit graphs without creating overlaps.
                • The new ComponentDragAndDrop demo shows how to make space for components that you can drag from a palette onto the canvas.
                • The new FillAreaAfterDeletion demo shows how to fill free space after deleting nodes using the FillAreaLayout algorithm.
                • The new RelocateSubtree demo shows how to reuse free space after relocating a subtree to a new parent.

                Aggregation and Analysis of (Large) Graphs

                Many new algorithms for analyzing graphs are now included, for example to detect components and clusters, to aggregate sub-graphs, and to calculate centrality values. In addition, the analysis algorithms now have the option to define a subset of the graph to work on. In detail, the new classes are:

                • The new NodeAggregation class provides an algorithm that intelligently aggregates nodes of (large) input graphs. It does not require complex configuration and can be used without knowledge of specific clustering or aggregation techniques.
                • The KCoreComponents class provides a component detection algorithm that finds k-cores.
                • The classes LouvainModularityClustering and LabelPropagationClustering provide two new algorithms for cluster detection.
                • The EigenvectorCentrality class offers a centrality algorithm that measures the influence of a node in a network based on the Eigenvector score.
                • The PageRank class provides a centrality algorithm that calculates the so-called page rank for the nodes.
                • The classes ChainSubstructures, CliqueSubstructures, CycleSubstructures, StarSubstructures, and SubtreeSubstructures provide new algorithms that detect isolated substructures like chains, cliques, cycles, stars, or subtrees. This can be used as an input to other (layout) algorithms.
                • The class GraphStructureAnalyzer now offers additional methods to calculate the average degree, the average weighted degree, the diameter, and the density of a given graph.

                The Large Graph Aggregation Demo shows how to use the NodeAggregation algorithm to automatically analyze and explore a large graph. Developers don't need to learn the academic details of the available clustering and centrality algorithms, but can simply configure their preferred aggregation sizes to automatically create perfect user-experiences in drill-down scenarios.

                Support for curved edges

                The new BezierEdgeStyle renders edges with smooth Bezier-curve paths.

                In addition, the new edge label models BezierEdgePathLabelModel and BezierEdgeSegmentLabelModel place labels optimally on curved edges rendered with this style.

                The BezierEdgeStyle demo demonstrates the use of the new BezierEdgeStyle and shows additional customizations to support various features in interactive editing. For example, for intuitive interactive editing, the edges are edited with the same control points -or handles- that are known from other vector graphic drawing applications.

                Support for curved edges has been added to the layout and edge routing algorithms EdgeRouter and the CurveRoutingStage, and HierarchicLayout.

                Interactive Node Resizing
                Resizing nodes using their handles now supports two new behaviors:

                The Reshape Handle Configuration Demo showcases these different resizing behaviors.

                Related to this, the new Node Group Resizing Demo shows how to resize a selection of nodes en bloc. In contrast to the default behavior, this changes both the sizes and the locations of the nodes and not just the sizes.

                Graph Builder

                The old GraphBuilder, TreeBuilder, and AdjacentNodesGraphBuilder classes have been replaced in the library with more powerful but incompatible builder classes. Loading graphs from external data sources has become even easier with the new graph builder implementations. This release contains completely rewritten utility classes that can help with the creation of diagrams from one or more data sources.

                The new classes can load nodes, edges, labels, and their properties from one or many different sources dynamically using a declarative-like approach. Binding expressions can be used for setting the visual properties of the graph entities depending on the values in the source data.

                For backward compatibility, the old GraphBuilder, TreeBuilder, and AdjacentNodesGraphBuilder classes are available as demo code.

                New Features

                Viewer

                Analysis

                • A new component detection algorithm which finds k-cores has been made available using class KCoreComponents.
                • Centrality calculation algorithms which calculate the eigenvector centrality and page ranks for nodes have been made available using classes EigenvectorCentrality and PageRank, respectively.
                • The new analysis algorithm NodeAggregation supports an algorithm that tries to intelligently aggregate nodes of (large) input graphs and does not require that the user is familiar with specific clustering/aggregation algorithms.
                • New algorithms for detecting isolated substructures like chains, cliques, cycles, stars or subtrees have been made available via the classes ChainSubstructures, CliqueSubstructures, CycleSubstructures, StarSubstructures, and SubtreeSubstructures.
                • GraphStructureAnalyzer: added methods to calculate the average degree, the average weighted degree, the diameter and the density of a given graph.
                • New clustering detection algorithms using the Louvain Modularity and Label Propagation have been made available via classes LouvainModularityClustering and LabelPropagationClustering.
                • The analysis algorithms now have the option to define a subset of the graph to work on.

                Algorithms

                The features listed here are new features of the low level analysis algorithms. Most of them are reflected in new features of the analysis facade classes as listed in the section Analysis.

                Layout

                • Added new property EdgeLayoutDescriptor.RoutingStyle that allows to specify the routing style individually for each edge routed by the EdgeRouter class. Furthermore, new properties MaximumOctilinearSegmentRatio and PreferredOctilinearSegmentLength on the descriptor provide means to configure the octilinear routing style.
                • The EdgeRouter class now supports a new routing style that generates curved edge paths. It can be specified for each edge individually using EdgeRoutingStyle.Curved.
                • Added new layout stage CurveRoutingStage. It replaces polyline edge paths with curved segments using cubic bezier splines and provides a generic way to produce layouts with curved edges.
                • Added the new routing style EdgeRoutingStyle.Curved to the HierarchicLayout class. The resulting edge paths consist of smooth curves that are constructed using cubic bezier splines.
                • The CircularLayout class now supports exterior edges that are routed around the exterior of the circle as smooth arcs, see the new property CircularLayout.EdgeRoutingPolicy.
                • Added new class EdgeBundlingStage that offers edge bundling for general undirected graphs. Bundling together multiple edges means that their common parts are to some degree merged into a bundled part. Edge bundling is useful to increase the readability of graph drawings with a high number of edges that connect a comparably small number of nodes.

                Improvements

                View

                Input

                Analysis

                • Most of the algorithms in namespace Analysis provide properties SubgraphNodes and SubgraphEdges which facilitate to analyze only a subset of the given graph.
                • In a single node graph, the single node's closeness centrality and graph centrality value is now 1.0 (previously, it was infinity). This also affects derived values such as minimum, maximum, and normalized centrality. This change relates to yWorks.Analysis.GraphCentrality and yWorks.Analysis.ClosenessCentrality. The backing algorithms in yWorks.Algorithms.Centrality are unchanged.
                • GraphStructureAnalyzer: added methods to determine multiple edges.
                • The GraphCentrality and ClosenessCentrality analysis algorithms now calculate the centrality individually per component instead of returning a centrality value of 0.0 for nodes in graphs that are not connected.
                • EdgeBetweennessClustering: throws an InvalidOperationException if edge weights are not positive or finite.
                • FeedbackEdgeSet: throws an InvalidOperationException if edge weights are negative.

                Layout

                New Demos and Demo Improvements

                New Demos

                • The new LargeGraphAggregation demo that shows how to use the smart NodeAggregation clustering algorithm together with an AggregateGraphWrapper for drill down exploration of a large graph.
                • The new BezierEdgeStyle demo demonstrates the use of the new BezierEdgeStyle and shows additional customizations to support various features in interactive editing.
                • The new NodeGroupResizing demo shows how to apply different resize behaviors to a set of nodes. For instance, the nodes will keep their size but their positions are altered according to the resize gesture applied to the entire group.
                • The new ZOrder demo shows how to persist the z-order during undo, clipboard operations, grouping, and saving and loading.
                • The new MarqueeClearArea demo shows how to make space in a diagram by dragging a marquee rectangle.
                • The new OverlapAvoidingEditor demo shows how to interactively edit graphs without creating overlaps.
                • The new ComponentDragAndDrop demo shows how to make space for components that you can drag from a palette onto the canvas.
                • The new RelocateSubtree demo shows how to reuse free space after relocating a subtree to a new parent.
                • The IsometricDrawing demo displays graphs in an isometric fashion to create an impression of a 3-dimensional view.

                Noteworthy Demo Improvements

                Bugfixes

                View

              • Bugfixes related to Right-to-Left direction:
              • Input

                • TextEditorInputMode now correctly queries the ViewportLimiter if TextBoxPlacementPolicy.ScrollCanvas is used. If the text box is still not visible because it's outside the limited viewport, the text box will be moved as well.
                • Fixed Undo/Redo of addition and removal of bends on folding edges. The bends now are correctly restored at the location they had at the time of removal.
                • TextboxEditorInputMode correctly rotates the textbox when Zoom is clamped.
                • The NavigationInputMode.FitContentAfterGroupActions method is no longer ignored when the NavigationInputMode class is used as a child input mode of the GraphEditorInputMode class.
                • The NavigationInputMode class now also updates the CanvasControl.ContentRect property when it is not used as a child input mode of the GraphEditorInputMode class.
                • Fixed that GridVisualCreator ignored the grid origin when rendering lines or crosses.
                • Fixed bugs that interpreted SnapContext.GridSnapDistance or SnapContext.SnapDistance in world coordinates when calculating SnapResults.
                • Orthogonal Edge Editing: fixed a bug that created bends in edges that are marked as not orthogonal.
                • OverviewInputMode: Fixed jumping of both client canvas and overview when scrollbar visibilty changes.
                • When zooming to the current item, changes in scrollbar visibility are properly incorporated into the new viewport position.
                • Scrolling the viewport with the mouse wheel no longer scrolls in the wrong direction if the mouse wheel is set to scroll one page at a time (instead of several lines).
                • Paste and duplicate operation now honor GraphEditorInputMode's ShouldSelect predicate.
                • Fixed a bug which could cause an input mode to be left in an undefined state if another input mode has been activated in an event handler of the first input mode. This usually resulted in the wrong cursor being displayed.
                • Fixed hit-test of handles being in a slightly different position from where the handles are displayed.

                Analysis

                • Fixed analysis class Chains for undirected cycles: if these cycles are not connected to other parts of the graph the Nodes collection of a resulting Path could be in an incorrect order.
                • yWorks.Analysis.EdgeBetweennessClustering no longer throws an exception with its default settings (MaximumClusterCount == -1).
                • The HierarchicalClustering class no longer throws an exception when applied to an empty graph.
                • ClosenessCentrality does no longer return NaN as NormalizedNodeCentrality if the graph consists of one single node. Instead, the NormalizedNodeCentrality will be positive infinity.
                • ClosenessCentrality.Run no longer throws an exception for unconnected graphs. Instead, all NodeCentrality and NormalizedNodeCentrality values will be 0 as the documentation states.

                Layout

                • Fixed an exception in EdgeRouter which could occur in rare cases.
                • The OrganicLayout class no longer throws an exception when having a PartitionGrid and at the same time the scope set to Subset or MainlySubset where all nodes of the graph are marked as affected (could have used scope All instead).
                • Fixed method NodePlacerBase.PlaceSubtree(IDataProvider, IDataProvider, LayoutGraph, Node, ParentConnectorDirection) to clear its internal caches, especially the graph cached in field NodePlacerBase.graph. Previously, holding onto a node placer instance could lead to subtle memory leaks.
                • The EdgeRouter class no longer yields edge labels that overlap with unrelated group nodes when using the integrated label placement feature (EdgeRouter.IntegratedEdgeLabeling).
                • Resolved a bug in the EdgeRouter class which caused that grouped edges were sometimes actually not grouped together. This mainly appeared in conjunction with a large value of either the minimum first or last segment length.
                • The EdgeRouter class no longer produces an exception for some rare cases with fixed grouped edges and octilinear paths.
                • The HierarchicLayout class no longer throws an exception that was previously triggered in some cases with bus structures (see property HierarchicLayoutData.Buses) and in conjunction with layering constraints.
                • The EdgeRouter class now correctly observes inputs where the user specifies buses with both fixed and non-fixed edges at the same time.
                • The EdgeRouter class now properly considers ports provided by a PortCandidateSet when the set contains multiple candidates with single capacities and where the candidates are on the same node side. Previously, it could happen that only one of several edges connecting to the node correctly considered the ports.
                • The EdgeRouter class does no longer use the same fixed PortCandidate out of a specified PortCandidateSet if another non-saturated candidate can be chosen. Thus, overlapping edge segments are avoided.
                • The OrthogonalSegmentDistributionStage no longer produces degenerated (very large or small) coordinates for edges that contain zero-length segments, that is, duplicate edge path points.
                • The ChannelEdgeRouter class no longer yields degenerated routing results (very large or small coordinates) when using the OrthogonalPatternEdgeRouter as path finder strategy and setting its minimum distance to zero. The OrthogonalPatternEdgeRouter class now avoids duplicate points when the MinimumDistance property is set to zero.
                • The AspectRatioTreeLayout class no longer crashes, causing a stack overflow, when applied to a large chain graph.
                • Fixed a bug in the HierarchicLayout class that could cause unnecessary (double) edge crossings when the algorithm was executed in incremental layout mode with edge grouping and alternative group bounds.
                • The RecursiveGroupLayout class now correctly moves child nodes along with their group also in case the RecursiveGroupLayout.CoreLayout is null. Previously, if additionally a group node had a specific layout algorithm associated to it, the content was not correctly moved along. If the core layout was not null, the issue did not occur.
                • The EdgeRouter class now considers the correct shape of non-affected, fixed edges. Previously, it sometimes incorrectly parsed their shape which could lead to undesired effects like incorrect path cost calculation of affected edges.
                • The BalloonLayout class now longer crashes due to a stack overflow for inputs containing very long chain graphs.
                • Fixed a bug in the HierarchicLayout class that in some cases caused a violation of the minimum first or last segment length (EdgeLayoutDescriptor.MinimumFirstSegmentLength and EdgeLayoutDescriptor.MinimumLastSegmentLength). The bug was only triggered when the minimum length values were relatively large.
                • The TreeMapLayout class no longer produces results that may have infinite coordinates.
                • The EdgeRouter class no longer produces unnecessary overlaps for cases where the source or target node is overlapped by (several) label elements. This generally improves the ability of the router to deal with input that contains source/target nodes that are overlapped by other elements and are required to be crossed by an edge route.
                • The HierarchicLayout class no longer throws an exception that was previously triggered in some cases with bus structures (see property HierarchicLayoutData.Buses) and in conjunction with undirected edges (see HierarchicLayoutData.EdgeDirectedness).
                • Fixed a bug in the EdgeRouter class that sometimes generated bad routing artifacts with edge grouping and when there were non-affected edges grouped at both end points.
                • The EdgeRouter class no longer throws an Exception that was previously in some cases triggered when the input contained bus edges (defined via BusDescriptor).

                Incompatible Changes

                API

                Behavior

                Deprecations

                yFiles.NET 5.2.0.2

                Bugfixes

                Layout

                Incompatible Changes

                yFiles.NET 5.2.0.1

                Major Improvements

                • The .NET Core-based library has been built and tested with the GA release of .NET Core 3.0. No library changes have been necessary and yFiles.NET 5.2 works just as well on the GA release of .NET Core 3.0.

                New Demos

                • The new LayoutStyles demo showcases the features and settings of the yFiles automatic layout algorithms.

                Improvements

                • A lot of small improvements and bugfixes have been applied to the demo applications.

                Bugfixes

                Viewer

                Layout

                • The HierarchicLayout class now produces better results for input graphs with grouped edges and a PartitionGrid. Previously, such inputs may have produced edge routes with superfluous bends.
                • The HierarchicLayout class now correctly considers the properties MaximumNodesAfterBus and MaximumNodesBeforeBus of the BusDescriptor for single line (layer) buses. In addition, for multiple layer buses, the specified minimum node to edge distance is now considered for the distance between nodes and the vertical bus segment.
                • The OrganicLayout class now correctly removes node overlaps if its Scope is set to Scope.MainlySubset and its NodeOverlapsAllowed property is disabled. Previously, the layout sometimes produced superfluous overlaps for such cases.
                • The TreeMapLayout class no longer produces results that may have infinite coordinates.

                yFiles.NET 5.2

                

                This release contains many new major features and lots of other new features, improvements, and bugfixes for all parts of the library. In addition to the new demos that show the new features, there are some notable new demos and demo improvements, too.

                Major New Features

                Support for .NET Core

                yFiles.NET now provides assemblies for both .NET Framework and .NET Core. All demos and tutorials are also provided for both frameworks.

                Improved documentation including more than 1000 new example code snippets

                The documentation has been improved. Particularly, more than 1000 new code examples have been added to the API documentation.

                Bus-like placement in hierarchic layouts
                The HierarchicLayout class is now able to arrange children of a specified root node in a bus-like way. This results in a very compact and uniform arrangement if a node has many successors. The bus sub-structures are defined by the HierarchicLayoutData.Buses property, and the new BusDescriptor class provides more individual settings for the buses.
                Label placement, bus routing, and port grouping for EdgeRouter

                The EdgeRouter class now features integrated edge label placement. Labels are automatically placed when the new property IntegratedEdgeLabeling is enabled. The placement considers the optional PreferredPlacementDescriptor of a label.

                Also, it now supports port grouping of edges at their source and target and orthogonal bus routing. To specify the port group IDs or the bus affiliation, use the associated properties in the PolylineEdgeRouterData class.

                Analysis wrapper

                The powerful analysis algorithms got a new API that is based on the IGraph interface and streamlines working with the results. In particular, it makes working with a special analysis graph class obsolete. The algorithms that are available with the new API include centrality measures, clustering, flow calculation, rank assignment, spanning tree, shortest path, and more.

                This is accompanied by the new GraphStructureAnalyzer class that provides methods to check structural properties of a given graph.

                The new GraphAnalysis demo allows you to interactively explore all the algorithms.

                NuGet Support

                The yFiles.NET assemblies can easily be bundled into NuGet packages. The packages support multiple targets.

                New and improved demos

                Added import feature for BPMN 2.0 abstract syntax format (Diagram Interchange).

                New Features

                View

                Layout

                Improvements

                Graph and View

                Input

                GraphML Serialization

                Graph-Layout-Bridge

                Hierarchic Layout

                • The HierarchicLayout class now also considers critical edge priorities for grouped edges.
                • The HierarchicLayout class now also considers sequence constraints for grouped edges.
                • The HierarchicLayout class now uses the specified layer alignment to align sub-components (see HierarchicLayoutData.SubComponents).
                • With HierarchicLayout, the number of edges crossing through group nodes without starting or ending in them when using the default algorithm settings was reduced. Furthermore, the behavior can be customized using the new group node border crossing costs (see property HierarchicLayoutData.GroupBorderCrossingCosts).
                • The HierarchicLayout class no longer inserts superfluous bends for edges between group nodes if the input graph contains grouped edges.
                • The layering of HierarchicLayout was improved with respect to the resulting edge lengths if the recursive group layering feature is enabled.
                • The HierarchicLayout class now produces less overlapping elements for graphs with fixed coordinate hints.
                • The HierarchicLayout class now correctly calculates the group node bounds. Previously, the groups' insets were slightly too large (up to one pixel).
                • The HierarchicLayout class now always places a port label in the middle of a node side, if it is the only port on that side. Previously it was only centered if the label was additionally placed on the edge.
                • The HierarchicLayout class now requires less memory for graphs with sequence constraints.

                Edge Routing

                Labeling

                • The performance of the GenericLabeling algorithm and the quality of the label placements were improved.
                • The quality of edge label placement of the GenericLabeling class was improved in case that there are multiple labels with a source or target preference near the same node. They may now be placed further away but avoid undesired overlaps.

                Other Layouts

                Demos

                • The demos now have shorter project and folder names.

                Bugfixes

                Graph and View

                Input

                GraphML Serialization

                • Parsing a GraphML file with a folding edge state with a label without a preferred size no longer throws an error.
                • Labels at folder nodes and their adjacent edges are no longer lost during GraphML deserialization if the DefaultFolderNodeConverter.CopyFirstLabel property is enabled.
                • Fixed GraphML exception when parsing generic types.

                Hierarchic Layout

                • The HierarchicLayout class now correctly considers the group insets for input graphs with nested group nodes. Previously, it sometimes produced too large insets for inner groups.
                • The HierarchicLayout class no longer throws an error if it is wrapped by an instance of RecursiveGroupLayout and the input graph contains layering constraints between elements of different groups.
                • The HierarchicLayout class no longer throws an ArgumentException for some rare cases in incremental layout mode.
                • The HierarchicLayout class now produces shorter, more direct edge routes for edges connecting at a group node and leaving on the the left/right group side. This only affects cases where the relevant group node also contains direct-content edges (see EdgeLayoutDescriptor.DirectGroupContentEdgeRouting).
                • Self-loop segments generated by the HierarchicLayout class are now shorter and take up less space if possible. Previously, segments were sometimes unnecessarily long even though the minimum length settings allowed shorter segments.
                • The HierarchicLayout class now produces less superfluous crossings if there are same-layer edges with PortConstraints or PortCandidates.
                • The HierarchicLayout class now correctly handles port labels with zero height or width. Previously, such labels may have caused very large distances between some nodes.
                • The HierarchicLayout class sometimes threw an ArgumentError for input graphs that contained incremental elements in combination with groups.
                • The HierarchicLayout class now places sloped segments of grouped octilinear edges such that they are perfectly overlapping each other. Previously, it could happen that segments were slightly displaced with respect to each other.
                • The HierarchicLayout class no longer causes non-orthogonal segments when the input contained port labels in conjunction with edge grouping.
                • The HierarchicLayout class sometimes threw an ArgumentError for input graphs that contained fixed elements in combination with both swimlanes and groups.
                • The HierarchicLayout class now correctly considers fixed nodes with layering constraints. In previous versions there were some rare cases where such inputs caused infinite looping issues.
                • The HierarchicLayout class no longer produces intersections between edges and elements of a sub-component (see HierarchicLayoutData.subComponents). Note that this fix may sometimes cause less compact results within a layer.
                • The HierarchicLayout class no longer throws an exception if the component arrangement policy is set to ComponentArrangementPolicy.Compact and bus routing is enabled (see property HierarchicLayoutData.Buses).

                Tree Layout

                Edge Routing

                • The EdgeRouter class now correctly routes direct content edges with strong port constraints at the group nodes. Previously, the algorithm sometimes produced weird routes for such edges.
                • Fixed a bug in the EdgeRouter class that sometimes caused a non-deterministic behavior.
                • The EdgeRouter class now correctly handles edges with external ports. Previously, such inputs may have caused an exception.
                • The EdgeRouter class now correctly groups edges associated with equal group IDs that have a different object ID.
                • A rare error that was triggered by the EdgeRouter class during routing when a Grid is defined on which edges need to be routed is now fixed.
                • The EdgeRouter class now avoids unnecessary bends in cases that contain PortCandidates with fixed offsets (or strong PortConstraints) where the fixed port locations have a very similar x- or y-coordinate such that the path must consist of three segments with a single, very short middle segment. Previously, five segments in total were generated.
                • The PolylineLayoutStage class no longer generates overlaps between sloped, polyline segments created by the stage and unrelated other obstacles (e.g. nodes).
                • Fixed a rare error that was triggered by the EdgeRouter class during routing in cases where the input contained grouped edges.
                • The EdgeRouter class no longer throws an exception if the EdgeRouter.PolylineRouting property is enabled and the input contains fixed, grouped edges.
                • The EdgeRouter class now considers the correct NodeHalo associated with the target node when handling the minimum last segment length setting. Previously it incorrectly considered the halo of the source node which could lead to unnecessarily long or too short last segments.
                • The EdgeRouter class now correctly considers intersections between edges and labels of fixed edges if property ConsiderEdgeLabels is enabled.
                • The EdgeRouter class no longer throws an error during routing in cases where the source or target node is covered by obstacles (i.e. by other nodes or labels).
                • The EdgeRouter class now correctly considers intermediate routing points when using the polyline routing style. Previously, it could happen that intermediate points were not part of the final polyline edge path.
                • The EdgeRouter class no longer considers all PortCandidates with multiple directions as fixed PortCandidates.
                • Fixed two issues that induced the violation of a PortCandidate with fixed offsets (or a strong PortConstraint) by the EdgeRouter class. The first was only triggered for constraints at the target side and only when the target node was additionally partly or fully covered by other obstacles (e.g. node labels). The second issue appeared in cases with the source and target node fully overlapping (e.g. an edge from a group to a child node).
                • Improved the path search performance of the EdgeRouter class for cases where a large number of fixed and overlapping edge segments exist. Previously, the search could become very slow in such scenarios.
                • The EdgeRouter class now correctly handles cases where the maximum duration is exceeded and where previously an exception was triggered.
                • Fixed a StackOverflowException in EdgeRouter.
                • The EdgeRouter class no longer produces bad, non-orthogonal edge segments in cases where a selected edge is grouped together with an un-selected edge and where both edges have strong PortConstraints at their common source/target node.
                • The EdgeRouter class no longer throws an exception if all fixed edges of a bus are non orthogonal/octilinear.
                • The EdgeRouter class now correctly considers strong port constraints of edges that belong to a bus structure.

                Labeling

                • The GenericLabeling class now produces better results for edge labels that have a preferred distance to the edge (PreferredPlacementDescriptor.DistanceToEdge) and at the same time multiple SideOfEdge preferences (e.g. left of edge and on the edge). Previously, the algorithm sometimes violated the preferred distance even though it would have been possible to keep it.
                • The GenericLabeling class now correctly places labels of direct content edges (edges that directly connect a group node with a descendant, without leaving the group) with a free edge label model.
                • The GenericLabeling class no longer calculates wrong label profit values for some edge labels. Previously, edges that had a PreferredPlacementDescriptor were sometimes affected.
                • The GenericLabeling class now always prefers LabelCandidates with higher profit values over others with lower profit. Previously, this sometimes happened even though both candidates did not intersect with other elements.
                • The GenericLabeling class no longer assumes that all LabelCandidates associated to a label have the same size. Previously, this caused unexpected labeling results if custom candidates with different sizes were given.
                • We fixed a rare bug in the GenericLabeling that may have caused an ArgumentException for some input graphs that contain edges with zero length segments and labels associated with a free edge label model.
                • The GenericLabeling class no longer throws an ArgumentException for some input graphs containing labeled edges with zero length.

                Other Layout Styles

                Incompatible Changes

                Incompatible API Changes

                Changes of Default Behavior

                Minor Incompatible Changes

                • The method LayoutData.Apply is now protected instead of public.
                • The YList.SubList method was removed since it was not implemented at all and is not used by the library.
                • The clone methods of the geometric types Point, Rect, Size, and Insets was removed since these types are immutable and the methods just returned this.
                • The classes GeneralPath and GeneralPathCursor are now sealed.
                • The following changes regarding the expert API related to the EdgeRouter class were made:
                  • The first parameter of the constructors in class SegmentInfoBase is now of type Object instead of Edge. The provided type should be either PathRequest for affected edges or Edge for non-affected, fixed ones. Furthermore, the property SegmentInfoBase.Edge has been removed as the info is not necessarily associated with an edge anymore.
                  • Similarly, the first parameter of the constructor in class EdgeCellInfo is now of type Object instead of Edge. The provided type should be either PathRequest for affected edges or Edge for non-affected, fixed ones.
                  • The constructor of class EdgeInfo now additionally takes a parameter of type Edge.
                  • The parameter of type Edge from the constructor of Path as well as the respective property were removed. A path is now not necessarily associated with an edge but only with the newly introduced PathRequest.
                  • The method PathSearchResult.GetEdgeInfo(Path) has been removed.

                yFiles.NET 5.1.0.2

                Improvements

                Bugfixes

                Algorithms

                • The Paths.FindAllChains method now correctly calculates the chains of input graphs with cycles.

                Layout

                • The HierarchicLayout class now correctly handles port labels with zero height/width. Previously, such labels may have caused very large distances between some nodes.
                • The HierarchicLayout class sometimes threw an ArgumentException for input graphs that contained incremental elements in combination with groups.
                • The HierarchicLayout class now prevents intersections between labels and the horizontal grid lines of a PartitionGrid.
                • The HierarchicLayout class now properly handles input graphs with source/target port labels and where a subset of nodes has NodeHalos. Previously, such inputs could cause an exception.
                • The HierarchicLayout class does not longer violate fixed PortCandidates in cases where also critical edges (HierarchicLayoutData.CriticalEdgePriorities) and edges connecting to group nodes are given.
                • The HierarchicLayout class now produces less superfluous crossings if there are same-layer edges with PortConstraints or PortCandidates.
                • The HierarchicLayout class no longer causes non-orthogonal segments when the input contained port labels in conjunction with edge grouping.
                • The HierarchicLayout class now correctly calculates the required length of straight-line same-layer edges. Previously, the calculated length could have exceeded the required length by the value of the HierarchicLayout.NodeToEdgeDistance property.
                • The HierarchicLayout class now places sloped segments of grouped octilinear edges such that they are perfectly overlapping each other. Previously, it could happen that segments were slightly displaced with respect to each other.
                • The EdgeRouter class no longer throws an exception for some inputs containing edges with intermediate routing points.
                • The EdgeRouter class now correctly handles cases where the maximum duration is exceeded and where previously an exception was triggered.
                • Improved the path search performance of the EdgeRouter class for cases where a large number of fixed and overlapping edge segments exist. Previously, the search could become very slow in such scenarios.
                • Fixed a StackOverflowError in EdgeRouter.
                • When using RecursiveGroupLayout, the values of the properties ComputedWidth, ComputedHeight and ComputedPosition of the classes ColumnDescriptor and RowDescriptor are now correctly set after the layout if EdgeRouter is the corresponding InterEdgeRouter.
                • The ComponentLayout class now correctly handles input graphs with user-specified components that contain nodes with null as their component ID (see property ComponentLayoutData.ComponentIds). Previously, such inputs may have caused an exception.
                • The CompactNodePlacer class now correctly handles inputs where the tree root is marked as assistant node, see TreeLayoutData.AssistantNodes.
                • The CompactNodePlacer class now correctly considers the specified values of the VerticalDistance and HorizontalDistance properties.
                • The CompactNodePlacer class now produces more compact results for some cases where it previously generated larger, less compact results.
                • The CompactNodePlacer class no longer throws an exception for some inputs with specified strategy memento information (either via property TreeLayoutData.CompactNodePlacerStrategyMementos or with a mapper registered with key CompactNodePlacer.StrategyMementoDpKey).
                • The OrthogonalLayout does no longer throw an exception if a graph is almost a tree and its TreeStyle property is set to TreeLayoutStyle.Integrated and a fixed TreeOrientation is set.
                • The OrganicLayout class now produces deterministic results for group nodes if its property Deterministic is enabled.
                • The OrganicRemoveOverlapsStage no longer produces infinite loops in some rare cases.
                • Fixed a potential exception in LayoutExecutor which could occur when a layout is applied to a graph which contains table nodes which are not group nodes.
                • Fixed a bug in class EdgeRouter that sometimes caused a non-deterministic behavior.
                • The PolylineLayoutStage does no longer generate overlaps between sloped, polyline segments created by the stage and unrelated other obstacles (e.g. nodes).
                • Fixed a rare exception that was triggered by the EdgeRouter class during routing in cases where the input contained grouped edges.
                • The GenericLabeling class now produces better results for edge labels that have a preferred distance to the edge (PreferredPlacementDescriptor.DistanceToEdge) and at the same time multiple SideOfEdge preferences (e.g. left of edge and on the edge). Previously, the algorithm sometimes violated the preferred distance even though it would have been possible to keep it.
                • Fixed two issues that induced the violation of a PortCandidate with fixed offsets (or a strong PortConstraint) by the EdgeRouter class. The first was only triggered for constraints at the target side and only when the target node was additionally partly or fully covered by other obstacles (e.g. node labels). The second issue appeared in cases with the source and target node fully overlapping (e.g. an edge from a group to a child node).
                • The EdgeRouter class no longer throws an exception if the EdgeRouter.PolylineRouting property is enabled and the input contains fixed, grouped edges.
                • The EdgeRouter class now considers the correct NodeHalo associated with the target node when handling the minimum last segment length setting. Previously it incorrectly considered the halo of the source node which could lead to unnecessarily long or too short last segments.
                • The EdgeRouter class now correctly considers intersections between edges and labels of fixed edges if property ConsiderEdgeLabels is enabled.
                • The EdgeRouter class no longer throws an exception during routing in cases where the source or target node is covered by obstacles (i.e. by other nodes or labels).
                • The EdgeRouter class now correctly considers intermediate routing points when using the polyline routing style (EdgeRouter.PolylineRouting). Previously, it could happen that intermediate points were not part of the final polyline edge path.
                • The PartialLayout class now correctly considers the specified PortCandidates during orthogonal or octilinear routing of edges.
                • The EdgeRouter class no longer considers all PortCandidates with multiple directions as fixed PortCandidates.
                • The OrthogonalLayout class no longer throws an exception when property OrthogonalLayout.UniformPortAssignment is enabled and the input contains parallel edges.
                • Self-loop segments generated by the HierarchicLayout class are now shorter and take up less space if possible. Previously, segments were sometimes unnecessarily long even though the minimum length settings allowed shorter segments.
                • The CompactNodePlacer class now correctly handles input graphs that contain assistant nodes and given placement strategies (see the CompactNodePlacerStrategyMementos property of the TreeLayoutData class).
                • The SeriesParallelLayout class now correctly handles input graphs with groups that only contain disconnected nodes. Previously, such inputs caused an exception.

                yFiles.NET 5.1.0.1

                Bugfixes

                Demo Improvements

                • The RenderPolicies demo has been updated with a better design and description.
                • Fixed some issues in BPMN demo which occured when the style of an edge was changed.

                yFiles.NET 5.1

                

                Major New Features

                Labels at Ports
                Labels can now be added to ports and the new label models FreePortLabelModel and InsideOutsideLabelModel can be used to place such labels. On the technical side, IPort now extends the ILabelOwner interface and the enum constant GraphItemTypes.PortLabel was added.
                Customizable Rendering Order
                Labels and ports can now optionally be rendered directly in front of their owner. Such a rendering order can make the ownership of labels and ports clearer if nodes overlap. Previously, all labels and ports were rendered in front of all nodes. The new rendering order can be enabled by setting the new properties LabelLayerPolicy and PortLayerPolicy of GraphModelManager to LabelLayerPolicy.AtOwner and PortLayerPolicy.AtOwner, respectively.

                The nesting options of GraphModelManager for the visualizations of nodes and edges have been improved and clarified. The properties UseHierarchicNodeNesting and UseHierarchicEdgeNesting have been combined into the new HierarchicNestingPolicy property. It takes values of the new HierarchicNestingPolicy enum. Its new option HierarchicNestingPolicy.GroupNodes configures GraphModelManager to visualize all leaf nodes in one canvas object group while nesting all group nodes depending on their hierarchical depth.

                Drag and Drop
                The new LabelDropInputMode and PortDropInputMode classes implement drag and drop for labels and ports, respectively. The API of these classes is similar to NodeDropInputMode for nodes.
                Lasso Selection
                The new LassoSelectionInputMode selects all model items inside a hand-drawn lasso region. This mode allows combinations of free-hand and straight-line sections during path creation.
                Improved Orthogonal Layout
                Many parts of the orthogonal layout algorithm have been significantly improved. In many cases, the drawings created by this algorithm are now much more compact and have smaller edge lengths, and they contain less crossings and perceived bends.

                In addition, this layout now supports special layout styles of various substructures that are automatically detected in the input graph. Supported substructures are trees, chains and cycles. In addition to the style, the new feature offers more settings, like, for example, the desired tree layout orientation.

                Parallel edges (multi-edges that share the same source and target node) are now routed as parallel as possible; if there are edge labels, the routes must differ somewhat. Previously, parallel edges were not handled explicitly and their routes were often very different, making the recognition of parallel structures difficult.

                Sub-components in Hierarchic Layouts
                In a hierarchic layout, you can now define sub-components of the input graph such that each sub-component is arranged by a user-specified layout algorithm. This allows hierarchical layouts where parts of the graph are arranged in a different fashion, e.g., to emphasize special sub-structures. The new HierarchicLayoutData.SubComponents property can be used to configure the new sub-components feature of the hierarchic layout.
                Tree Map Layout
                Added the new layout algorithm TreeMapLayout that generates tree maps. Tree maps present hierarchical data using nested rectangles (nodes) where each rectangle (node) gets its size depending on a specific dimension of data associated to it. The new TreeMapLayoutData class provides additional configuration options for this algorithm.
                Tabular Layout Style
                The new layout algorithm TabularLayout generates simple tabular arrangements of nodes. It allows to place nodes in rows and columns, such that each table cell contains at most one node. Among its features is, for example, a from-sketch mode, the possibility to exactly map nodes to specific cells or different vertical and horizontal alignments. The new TabularLayoutData class provides additional configuration options for this algorithm.

                New Features

                View

                Layout

                Improvements

                General

                Graph

                View

                Input

                Table

                Layout

                Bugfixes

                Graph and View

                Input

                Table

                • When a stripe is removed, ITable.LabelRemoved events for the implicitly removed associated labels are now raised, too.
                • When a selected stripe label is edited its TextBox now is correctly placed.
                • Selected stripe labels no longer remain selected after their owning stripe is deleted.
                • Selected stripe labels no longer cause exceptions when hovering over them.
                • The selection indicator for selected stripe labels is now shown correctly.

                Layout

                • OrthogonalLayout now considers edge grouping also if there are no directed edges specified.
                • In EdgeRouter, an error occurred when there were intermediate routing points and the path search got aborted (e.g. because of maximum duration time limit).
                • In ShortestPaths, an error occurred when the a-star algorithm was applied to a graph with non-monotonic heuristic costs.
                • In HierarchicLayout, an error was triggered when a yWorks.Algorithms.Util.DataProviderAdapter that does not override the DataProvider.get method was registered with key GivenLayersLayerer.LayerIdDpKey. This issue only appeared in conjunction with subcomponents.
                • The HierarchicLayout now produces less bends if the edges should be routed on a grid and the grid reference point is not (0,0), see NodeLayoutDescriptor.GridReference.
                • HierarchicLayout did sometimes not correctly consider the edge thickness for grouped edge segments. Even though there would have been space for a thick edge it was placed too close to other elements.
                • HierarchicLayout now produces more symmetric results for grouped edges if property SimplexNodePlacer.BarycenterMode is enabled.
                • Fixed a rare bug in OrthogonalLayout that may have caused infinite looping for grouped input graphs.
                • For some input graphs the OrganicLayout produced an error if the CycleSubstructureStyle property was set to CycleSubstructureStyle.Circular.
                • CircularLayout does now correctly consider the EdgeBundleDescriptor.Bundled property for edges between different partitions. Previously, when at least one of these edges had the Bundled property enabled, all of them were bundled, ignoring the property value of the other edges.
                • Fixed a bug in TreeMapLayout that may have caused NaN-coordinates or infinite looping for input graphs that are non-directed trees.
                • For grouped segments the GraphLayoutLineWrapper now produces more compact results.
                • In rare cases the GraphLayoutLineWrapper produced drawings with large empty space between lines.
                • HierarchicLayout: Fixed problem that sometimes caused an unnecessarily large distance between adjacent layers.
                • The MultiPageLayout now correctly considers the maximum page size for tree layouts.
                • TabularLayout no longer crashes when applying an instance of it to a single-node graph after that same instance was previously applied to a larger graph.
                • HierarchicLayout now correctly considers fixed nodes with layering constraints. In previous versions there were some rare cases where such inputs caused infinite looping issues.
                • GenericLabeling now always prefers LabelCandidates with higher profit values over others with lower profit (see LabelingBase.GetProfit). Previously, this sometimes happened even though both candidates did not intersect with other elements.
                • GenericLabeling does no longer assume that all LabelCandidates associated to a label have the same size. Previously, this caused unexpected labeling results if custom candidates with different sizes were given.
                • The EdgeRouter now always considers the PortCandidates for edges grouped with fixed edges.
                • The EdgeRouter now keeps collinear bends of fixed edges.
                • The FamilyTreeLayout now correctly considers the preferred family member order.
                • OrthogonalLayout does no longer throw an exception for some input graphs when property SubtreeStyle is set to Compact and ChainStyle is set to a wrapped style.
                • OrthogonalLayout no longer throws exceptions if property CycleStyle is set to a specific style and the input graph only consists of a single cycle.
                • BusRouter does no longer produce non-deterministic results, i.e. different results for consecutive runs on the same input. Previously, this was possible in rare cases.
                • EdgeRouter does no longer crash when defining exactly two equal intermediate routing points for an edge.
                • An invalid license no longer leads to a NullReferenceException when calling IGraph.ApplyLayout.

                Incompatible Changes

                Incompatible API Changes

                Changes of Default Behavior

                Minor Incompatible Changes

                Types and Members Marked as Obsolete

                Most Notable Demo Improvements

                • The new RotatableNode demo shows how support for rotated node visualizations can be implemented on top of the yFiles library.
                • The new RenderPolicies demo shows the effect of different render policies on the z-order of nodes, edges, labels and ports. This demo replaces the Integrated Node Style demo.
                • Demonstrated highlighting elements as hover effects in the Viewer demo.
                • GraphMLCompatibility demo: Added missing implementation of AnchoredParameter.
                • BpmnDemo: Fixed clone implementations of some styles.
                • yEd.NET: Fixed a bug that prevents using triangle arrows for edges.

                yFiles.NET 5.0.0.2

                Bugfixes

                Layout

                Improvements

                Layout

                • HierarchicLayout: Improved adherence to the specified maximum duration by applying a suitable runtime restriction to class PortCandidateOptimizer. Previously, this class didn't have any runtime restrictions.

                yFiles.NET 5.0.0.1

                Bugfixes

                yFiles.NET 5.0

                

                Major Features Added

                General

                • The complete yFiles.NET API has been overhauled, simplified, and made more consistent. Many strange and dark corners of the API have been cleaned up. Types have more logical and intuitive names. The namespace structure is more logical and intuitive as well.
                • The Developer's Guide has been completely revised. It now consists of two major parts: The first part covers the basics of yFiles.NET, while the second part describes in detail how the behavior of the library can be adapted to the customer's requirements.
                • API documentation and Developer's Guide are now integrated into our Documentation Viewer that provides useful search and filtering facilities.

                Viewer

                • Support for building graphs based on user data offered by new classes GraphBuilder, TreeBuilder, and AdjacentNodesGraphBuilder.
                • High DPI support: A new Scale property allows for adapting zoom independent sizes in rendering (e.g. drawings for resize handles) as well as in user interaction (hit test radius or double click size) to higher screen resolutions and thus smaller pixels. An extension method automatically chooses an appropriate scaling in high DPI aware applications. Furthermore, the default font now is resolution independent.
                • Running animations and performing layouts now offers .NET's Task-based mechanism for asynchronous processes. This leads to easier composition of asynchronous processes using C#'s await keyword where code is written close to how synchronous code would look like instead of chaining callbacks. This also simplifies exception handling which works as usual via try-catch instead of callbacks.

                Layout

                • Performance for many layout algorithms has been improved.
                • There now is a new way to configure yFiles automatic layout algorithms. The LayoutData class and its sub-classes can be used to pass configuration data to a layout algorithm by setting properties instead of registering DataProviders on the graph which have to be filled with this data. This reduces the code needed to configure a layout and is more flexible as well as reusable. As most subclasses of LayoutData are specialized for one layout algorithm, their properties provide a good overview which data can be passed to the algorithm.
                • Added new layout algorithm SeriesParallelLayout for graphs that are constructed only by series (combining two series parallel graphs by merging the source of one graph with the sink of the other) and parallel (combining two series parallel graphs by merging the sources and the sinks) operations.
                • Added edge bundling feature. Bundling together multiple edges means that their common parts are to some degree merged into a bundled part. Edge bundling is useful to increase the readability of graph drawings with a high number of edges that connect a comparably small number of nodes. The following layout algorithms support edge bundling:
                • Added support for Sankey diagrams which visualize flow quantity between entities like e.g., cost or energy flow.
                • OrganicLayout now supports the detection of regular substructures in the graph (see OrganicLayout.ChainSubstructureStyle, OrganicLayout.StarSubstructureStyle, OrganicLayout.CycleSubstructureStyle, and OrganicLayout.ParallelSubstructureStyle) and applies a specific layout style to them such that they can be better recognized.

                Deployment

                  The Software License Agreement now provides an alternative to the requirement of obfuscating the redistributable DLLs: delivering the redistributables as part of software applications is now allowed if the redistributable DLLs are obfuscated or if the assemblies of the application which reference yFiles are signed with a strong name whose public key token is bound to the license. See distribution.html for details.

                Minor Features Added

                Layout

                • Added multi-parent support to TreeLayout. A tree node can have multiple parents that are connected to all of its siblings and share the same parents. This might come to use in organizational charts where a team answers to multiple superiors.
                • Added grid placement support for nodes and edges to HierarchicLayout.
                • RecursiveGroupLayout: Added the InterEdgeRouter property to specify an edge router to layout edges that cross group node bounds. Thus, it is not necessary to subclass the layout algorithm to change inter-edge routing anymore.
                • HierarchicLayout supports recursively routed edges. Edges that pass the border of group nodes will always leave at the bottom side and enter at the top side of the group node. This routing style is specified using EdgeLayoutDescriptor.RecursiveEdgeStyle.
                • HierarchicLayout: Improved from-sketch behavior for groups with changed bounds (e.g. after folding or expanding a group node).
                • HierarchicLayout: Added support for port grouping, see PortConstraintKeys.SourcePortGroupIdDpKey and PortConstraintKeys.TargetPortGroupIdDpKey. Edges are bundled at their ports, but routed independently.
                • HierarchicLayout now allows to specify the directedness of edges, see HierarchicLayout.EdgeDirectednessDpKey. This new feature enables to, for example, support mixed graphs that contain both directed and undirected edges: While for directed edges the layering step tries to find a solution where the source of an edge is placed above the target (with respect to the main layout direction), for undirected edges the direction doesn't matter and the edge may also be inserted as same-layer edge. This feature also enables to force some edges to specifically point against the main layout direction.
                • HierarchicLayout: Added support for edges with a specific thickness. Minimum distances in the layout will consider these thicknesses, see HierarchicLayout.EdgeThicknessDpKey.

                Incompatible Changes

                General

                • The rendering mechanism has been overhauled: Most rendering code that previously used the IPaintable interface now uses the new IVisualCreator interface instead for improved rendering performance. Please see the migration guide for details on the resulting incompatibilities.
                • The minimum required framework version for the viewer part and the layout adapter is now .NET Framework 4.0. The minimum required framework version for the algorithms part still is .NET Framework 3.5
                • The return type of several methods has been changed from IEnumerator<T> to IEnumerable<T>.
                • Many usages of ref or out parameters have been replaced with a suitable structure as return type. The most prominent example of this change are the various GetTangent methods in IPathGeometry and GeneralPath that now return a Tangent.
                • All methods that take a parameter of type ICanvasContext, IRenderContext, IInputModeContext, IParseContext, IWriteContext, SnapContext, GraphSnapContext, or LabelSnapContext now have that parameter as their first parameter.
                • With the new web-based Documentation Viewer, the integrated help for the Visual Studio Help Viewer has been discontinued.
                Namespace Structure
                • Classes of the viewer part have been reorganized into a simpler namespace structure.
                  • yWorks.Graph contains types related to the graph structure, including label models and port location models.
                  • yWorks.Controls contains types related to the GraphControl and CanvasControl, and to the visualization in general.
                  • yWorks.Graph.Styles contains the style implementations.
                  • yWorks.Controls.Input contains the types related to input modes.
                • Geometry types remain in yWorks.Geometry.
                • Layout and analysis types are in yWorks.Layout, yWorks.Algorithms, and the namespaces that correspond to a specific layout style.
                Factory Methods Instead of Default Implementations

                Model

                IGraph
                DefaultGraph
                Folding
                Labels
                Ports
                Table
                Undo Support
                Geometry
                The yWorks.Geometry namespace has been simplified and cleaned up.

                Controls

                Visualization

                Styles
                Animations
                • Animator.AnimateAndWait has been removed.
                • The original overloads of Animator.Animate that accept a callback for finishing the animation have been removed. Instead the new Task-based overloads can be used.
                Various Visualization Changes

                Input

                General Input Mode Refactorings
                GraphEditorInputMode and GraphViewerInputMode
                CreateEdgeInputMode

                CreateEdgeInputMode has been refactored and streamlined:

                Other Input Modes
                Label Editing
                Snapping
                Clipboard
                KeyboardInputMode

                KeyboardInputMode has been simplified along with all helper types and infrastructure around commands:

                • KeyboardInputMode now allows creating a mapping between a key gesture and a command as well as providing custom execution logic for a given command.
                • There is also a single new method RemoveCommand on KeyboardInputMode which removes all currently existing bindings for a given command.
                Various Input-related Changes

                GraphML

                The XML namespaces have been updated and the mapping from yFiles.NET types to their corresponding XML namespace has been changed.

                Utility Types

                A lot of the utility types have been either replaced or removed.

                Layout

                Layout Execution
                Layout API
                Renamed Layout Types
                yFiles.NET 4.4 yFiles.NET 5.0
                Main Interface
                ILayouter ILayoutAlgorithm
                ILayouter.DoLayout ILayoutAlgorithm.ApplyLayout
                ILayouter.CanLayout removed
                Major Layout Algorithms
                HierarchicLayouter removed
                HierarchicGroupLayouter removed
                IncrementalHierarchicLayouter HierarchicLayout
                DirectedOrthogonalLayouter removed; functionality incorporated into OrthogonalLayout
                OrthogonalGroupLayouter removed; functionality incorporated into OrthogonalLayout
                OrthogonalLayouter OrthogonalLayout
                OrthogonalEdgeRouter removed; functionality incorporated into EdgeRouter
                OrganicLayouter ClassicOrganicLayout
                SmartOrganicLayouter OrganicLayout
                TreeLayouter ClassicTreeLayout
                GenericTreeLayouter TreeLayout
                HVTreeLayouter removed; functionality incorporated into TreeLayout
                SALabeling GenericLabeling
                GreedyMISLabeling removed; functionality incorporated into GenericLabeling
                MultiPageLayouter MultiPageLayout
                MultiPageLayout MultiPageLayoutResult
                Changes in alphabetical order
                AbstractLabelingAlgorithm LabelingBase
                ARTreeLayouter AspectRatioTreeLayout
                BalloonLayouter BalloonLayout
                BufferedLayouter BufferedLayout
                CanonicMultiStageLayouter MultiStageLayout
                CanonicMultiStageLayouter.LabelLayouter MultiStageLayout.Labeling
                CanonicMultiStageLayouter.LabelLayouterEnabled MultiStageLayout.LabelingEnabled
                CircularLayouter CircularLayout
                CompactOrthogonalLayouter CompactOrthogonalLayout
                ComponentLayouter ComponentLayout
                FamilyTreeLayouter FamilyTreeLayout
                GenericTreeLayouter TreeLayout
                GroupedShuffleLayouter RecursiveShuffleLayout
                GroupNodeHider HideGroupsStage
                IncrementalHierarchicLayouter HierarchicLayout
                yWorks.yFiles.Layout.Hierarchic.Incremental.HierarchicLayouter yWorks.Layout.Hierarchic.HierarchicLayoutCore
                IncrementalHierarchicLayouter.CreateHierarchicLayouter HierarchicLayout.CreateHierarchicLayoutCore
                IncrementalHierarchicLayouter.HierarchicLayouter HierarchicLayout.HierarchicLayoutCore
                InteractiveOrganicLayouter.DisableStages InteractiveOrganicLayout.DisableAllStages
                InteractiveOrganicLayouter InteractiveOrganicLayout
                IsolatedGroupComponentLayouter IsolatedGroupComponentLayout
                LayouterKeys LayoutKeys
                LayoutTool LayoutGraphUtilities
                MinNodeSizeStage MinimumNodeSizeStage
                MISLabelingAlgorithm MISLabelingBase
                NormalizingGraphElementOrderStage NormalizeGraphElementOrderStage
                OrganicLayouter ClassicOrganicLayout
                OrientationLayouter OrientationLayout
                PartialLayouter PartialLayout
                RadialLayouter RadialLayout
                RecursiveGroupLayouter RecursiveGroupLayout
                ReducedScopeStage (removed)
                RemoveOverlapsLayoutStage RemoveOverlapsStage
                SALabeling GenericLabeling
                SequentialLayouter SequentialLayout
                SeriesParallelLayouter SeriesParallelLayout
                ShuffleLayouter ShuffleLayout
                SingleCycleLayouter SingleCycleLayout
                SmartOrganicLayouter OrganicLayout
                SplitEdgeLayoutStage SplitEdgeStage
                SubgraphLayouter SubgraphLayout
                TreeComponentLayouter TreeComponentLayout
                TreeLayouter ClassicTreeLayout
                Previous changes