yFiles WPF Changelog 2.x and 1.x

yFiles WPF 2.5.0.4 - Changes Since 2.5.0.3

Bugfixes

Viewer

The CreateEdgeInputMode.EdgeCreated event has been raised before the corresponding undoable edit was committed. This could result in a broken undo queue, if e.g. an animated layout was started during in the event listener. The event is now raised after the edit has been committed. With automatic undo unit merging, this should not make a difference for the end user, however from the perspective of the code there will be two subsequent edits, rather than one compound, if the code in the listener actually modifies the edge.
Fixed a bug that occurs if two nodes are touch-dragged into the graph at the same time.
SmartEdgeLabelModel: Edge label snap lines have been too short for some positions that are far apart from the edge path.
SmartEdgeLabelModel: An exception was thrown if the path of the corresponding edge contained bends that were close together or at the same location.
Folding: The view state of a port on a folder node was sometimes ignored when a folding edge was created.
Fixed a bug that prevented individually disabling certain grouping commands.
When dragging an unselected bend and canceling the gesture by pressing ESC, the dragged bend was removed.
Fixed several issues with orthogonal edge editing.
- Canceling moving a port added bends to otherwise straight edge segments.
- An edge could have become non-orthogonal when a non-selected bend was moved.
- Self-loops with the same source and target location are now treated as orthogonal.
When serializing BitmapImages that were created from a relative URI without also specifying a BaseURI, a NRE was thrown.
Explicit Arrow elements in GraphML were sometimes read back incorrectly. The new deserialization property SerializationProperties.ParseArrowElementAsDefaultArrow can be used to work around this issue.
GenericPortLocationModel wasn't serialized correctly.
Table.SetStyle(ILabel, ILabelStyle) and Table.SetLabelModelParameter ignored the provided style resp. label model parameter.
PathBasedEdgeStyleRenderer could leave visual artifacts when switching to an arrow that returned a null visual.
OverviewInputMode could break the overview visualization if the overview had a very small width or height.
OverviewInputMode threw an exception if it was used without a ClientCanvas.
KeyboardInputMode now passes the original CompoundKeyEventArgs to registered event handlers instead of EmptyArgs.
Touch move events have an effect only if the corresponding touch down event also happened within the GraphControl.
The IsDown property of a Touch2DDevice was always false after the first touch up event of that device, e.g. after the first tap of a double tap.
Fixed an issue where under rare circumstances an exception could be thrown via UI Automation when the GraphControl was not part of a window.
Hiding INodeSnapResultProvider or IBendSnapResultProvider from the lookup no longer leads to a crash when nodes or bends are moved.
StripeDropInputMode.StripeCreated always returned a wrong stripe instance.
Fixed a possible NullReferenceException in PaintSupport when items were removed from the graph during their style's UpdateVisual method. This could happen when removing graph items from a different thread.

Layout

Fixed a bug in TableLayoutConfigurator which altered the size of a column or row if an edge routing algorithm has been applied.

Demos

BPMN demo: Default ConversationNodeStyle could not be deserialized correctly.

yFiles WPF 2.5.0.3 - Changes Since 2.5.0.2

Bugfixes

A bug in RotatedSliderEdgeLabelModel that could only occur in very rare occasions where the first or last edge segment is orthogonal and the source or target port was completely outside the node boundaries, could cause the label to lie at infinite coordinates. In most cases this would result in the label becoming just invisible, but code that does not properly handle infinite coordinates could possibly break due to numeric instabilities.
An edge whose source or target port is owned by another edge (edge-to-edge connection) was always drawn in the background if grouping was enabled instead of in front of the related groups. Now, such an edge is drawn in front of these groups, with the same z-index as a similar edge from node to node would get.
Nodes can now be reparented with a touch gesture, by touch-dragging a node onto its new parent. Previously, that was only possible with a mouse drag.
GenericYList: Calling Insert on an empty list has thrown an exception.
MoveViewportInputMode no longer fires the DragFinishing and DragFinished events for simple clicks without any mouse movement.
NodeDefaults, EdgeDefaults and all other Defaults: it was erroneously possible to assign null to the Style property although this property is marked as NotNull. Now, the property throws an ArgumentNullException in this case.
FoldedGraph detects more carefully what has changed before invoking the methods CreateDummyEdgeAppearance and ChangeDummyEdgeAppearance of IDummyEdgeConverter. Previously, in some cases, these methods were called to often or not at all.
When both a group node and its child node were resized together the group node bounds shrunk to its original bounds once the child had reached the original bounds.
Fixed problem in LayoutGraphAdapter where label candidates for edge labels were not always determined correctly.
When snapping was disabled temporarily (using Ctrl) during a move gesture the moved item snapped after finishing the gesture, anyway.
FoldedGraphUndoSupport didn't add the correct bend information to its internal data structures.
DefaultArrow.Length did not take the Scale factor into account, sometimes leading to gaps between the edge and the arrow.
Custom selection visualizations using EdgeStyleDecorationInstaller were not animated correctly.
Custom selection visualizations using EdgeStyleDecorationInstaller in DecorationZoomMode.Mixed or DecorationZoomMode.ViewCoordinates did not work correctly together with BridgeManager.
Explicit null values (<x:Null/>) in GraphML could lead to NullReferenceExceptions.
GraphML serialization can be forced to write a class property in element syntax using a GraphMLAttribute's WriteAsAttribute property with value XamlAttributeWriteMode.Never. Forcing a property that is shared to be written as element lead to invalid GraphML files.
If GraphEditorInputMode.Graph had been changed, the mode still held a reference to items from the previous graph instance, thus delaying garbage collection of that graph instance. This has been improved.
Orthogonal edge editing could throw an exception if edges were removed during a gesture that would require edge orthogonalization.
Event location of the various TapInputMode events was not always updated properly.
Improved performance of BridgeManager and prevented redundant LineTo path elements.
XpsExporter: Fix possible exception caused by insufficent file permissions and prevent locked files caused by internal exceptions.
Changes to IGraph.Nodes, IGraph.Edges and other collection properties on AbstractGraphWrapper implementations were not correctly propagated to the wrapped IGraph instance. In particular, this affected folding views.
If NodeDropInputMode.LeafParentsAllowed was false, dropping a node onto a leaf node did not consider parent group nodes of the leaf node as possible drag targets. This was a regression with respect to the behavior in version 2.4 and earlier of the library. The fixed behavior is slightly incompatible with previous releases in the 2.5 release branch.
If NodeDropInputMode.LeafParentsAllowed was true, the value of the FolderNodeParentsAllowed was ignored.

Layout

IncrementalHierarchicLayouter: In non-incremental mode, sequence constraints may not have been respected.
IncrementalHierarchicLayouter: Optimized the sequence of group nodes if 'place at head/tail' sequence constraints are defined.
IncrementalHierarchicLayouter: corrected wrong node placements in graphs with groups if sequence constraints are used.
Polyline.EdgeRouter: Fixed rare NullReferenceException that may occur for graphs where only a subset of edges is routed, see EdgeRouter.SphereOfAction.
CircularLayouter: Fixed bug that may cause node overlaps.
CopiedLayoutGraph: Fixed problem that may cause movement of label boxes in the original graph even if method CopiedLayoutGraph.CommitLayoutToOriginalGraph is not called.
ComponentLayouterModule: Disabled from-sketch option for styles that don't support it.
MultiPageLayouter: Fixed bug that caused that an AbortHandler attached to the input graph was ignored.
MultiPageLayouter: Fixed NullReferenceException that may occur if the data provider MultiPageLayouter.EdgeIdDpKEy is an instance of EdgeMap.
IncrementalHierarchicLayouter: Fixed routing style violations in octilinear grouped edges.
IncrementalHierarchicLayouter: Fixed label placement for octilinear selfloops with the same side constraints for source and target port.

Incompatible Changes

Changes in Default Behavior

If NodeDropInputMode.LeafParentsAllowed is false, dropping a node onto a leaf node now does consider parent group nodes of the leaf node as possible drag targets. This fixes a regression with respect to the behavior in version 2.4 and earlier of the library. The fixed behavior is slightly incompatible with previous releases in the 2.5 release branch.

yFiles WPF 2.5.0.2 - Changes Since 2.5.0.1

Bugfixes

Viewer

TableEditorInputMode by default also handled right clicks, which prevented the context menu for stripes from appearing and erroneously toggled the stripe selection state.
GraphClipboard: nodes pasted at given locations (ParentNodeDetectionMode.AtLocation) were erroneously pasted as child nodes of leaf nodes but not group nodes.
GraphClipboard: if a node has been moved after being copied it might have been erroneously pasted into its original parent node even though the parent node has been moved away, too.
GraphClipboard: fixed possible crash when copying nodes and edges with GraphClipboard.IndependentCopyItems set to GraphItemTypes.None.
GraphViewerInputMode: mouse clicks did not change the current item if the the SelectableItems property did not allow to select the item. This was a behavioral change compared to version 2.4 and earlier and has been reverted.
GraphClipboard: bends on edges at collapsed group nodes were moved by twice the value than the edge's source and target nodes.
Creating a new node as a child of an existing node which was not a group node did not cause the state change to be recorded by the undo engine. After undoing the node creation, the parent node still behaved like a group node. Such an implicit change is now recorded properly and can be reverted through undo as expected.
GraphExtensions.Reverse(): Edge reversal on a folded graph could result in an exception.
GraphExtensions.Reverse(): Edge reversal on a folded graph resulted in a loss of all view states of the edge.
Custom IHitTestEnumerator<INode> implementations were ignored when GraphCLipboard.ParentNodeDetection was set to ParentNodeDetectionMode.AtLocation.

Layout

IncrementalHierarchicLayouter: Fixed NullReferenceException that could occur when octilinear edges are attached to group nodes.
HVTreeLayouter: Fixed bug that may cause edges with reversed direction if the layout isn't run in buffered mode.
PortCandidateSet: Fixed bug that caused method PortCandidateSet.CandidateMatcher#FindMatchingCandidate() to return the entry with the highest cost instead of the lowest cost if the candidate matcher is created with method PortCandidateSet#CreateMatcher().
DirectedOrthogonalLayouter: Fixed bug that caused an ArgumentException if DataProvider-Key PortConstraintKeys#SourceGroupIdDpKey is registered to the input graph but DataProvider-Key PortConstraintKeys#TargetGroupIdDpKey is not registered.
ComponentLayouter: Fixed bug that caused an IndexOutOfRangeException if the style is set to ComponentArrangementStyle#MultiRowsHeightConstrained or ComponentArrangementStyle#MultiRowsHeightConstrainedCompact (see ComponentLayouter#Style) and all components exceed the preferred height (see ComponentLayouter#PreferredLayoutSize).
IncrementalHierarchicLayouter: Fixed bug that caused first or last segments of edges to be too short to span all associated labels.
MultiPageLayouter: Fixed bug that may cause non-orthogonal edge routes.
TreeReductionStage: Fixed bug that may cause a WrongGraphStructure-Exception if the input graph contains group nodes with incident edges.
TreeLayouter: Fixed bug that may cause a InvalidCastException if the input graph is a CopiedLayoutGraph that consists of multiple connected components and the layouter uses the LayeredNodePlacer (e.g., if option TreeLayouter#ChildPlacementPolicy is set to ChildPlacementPolicy#AllLeavesOnSameLayer).

Improvements

Viewer

Improved options for internationalization of strings used in the library. Now custom resources with the names yWorks.Canvas.CanvasResources and yWorks.yFiles.GraphResources can be added to the application project and override strings the library uses.

Layout

It is now possible to use IEnumerable and IEnumerable<T> implementations for collections of port candidates.

Changes in Default Behavior

TableEditorInputMode now only handles left mouse clicks by default, which is consistent with the rest of the library.

yFiles WPF 2.5.0.1 - Changes Since 2.5

Bugfixes

Viewer

Fixed NullReferenceException in the visibility check of class EdgeSelectionRenderer that could occur when EdgeSelectionRenderer.Pen was null.
Fixed too large dirty regions when using certain kinds of SnapLines.
Properties ShinyPlateNodeStyleRenderer.Radius, ShinyPlateNodeStyleRenderer.Brush, ShinyPlateNodeStyleRenderer.Pen and BevelNodeStyleRenderer.Radius were not used consistently.
Fixed memory leak that occurred when CreateEdgeInputMode was uninstalled.

Layout

IncrementalHierarchicLayouter and RankAssignments: Fixed possible NullReferenceException that may occur if the maximal duration of the algorithm is limited.
IncrementalHierarchicLayouter: Fixed bug that may cause overlaps of edge labels with preferred placement at source/target.
Polyline.EdgeRouter: Fixed rare NullReferenceException that mainly appears if there are overlapping nodes.
PartialLayouter: Fixed bug that may cause broken edge routes for edges incident to incremental group nodes if option RouteInterEdgesImmediately is enabled.
CompactOrthogonalLayouter: Fixed possible ArgumentException caused by nodes without node-ids. This problem may only appear if the inter edge router is set to ChannelInterEdgeRouter.

yFiles WPF 2.5 - Changes Since 2.4.0.6

Major Features Added

Viewer

GraphClipboard now supports copying independent items. This allows the user to copy labels, ports, bends, or edges to other elements without having to copy their owners. Also this technique allows for copying an item (for example a label) to multiple target elements at once.
The GraphClipboard now supports an optional target location for pasting and the new method GraphEditorInputMode.PasteAtLocation can be used for this end, too. In addition, ApplicationCommands.Paste now supports an optional parameter of type IPoint to provide a target location.
GraphEditorInputMode now provides default action for duplicating single graph items or whole subgraphs. This also works with incomplete subgraphs, for example in a tree, it is possible to duplicate a subtree and the tree will never be disconnected.
In addition, the new command GraphCommands.DuplicateSelectionCommand (shortcut: Ctrl-D) and the new method GraphClipboard.Duplicate can be used to duplicate selected items without altering the clipboard contents.
GraphEditorInputMode now provides a default action for reversing edges. To this end, the methods ReverseEdge and ReverseEdges have been added to GraphEditorInputMode. Also, the new command GraphCommands.ReverseEdgesCommand (shortcut: Ctrl-R) has been added.
Node and edge labels can now snap to particular locations while moving them interactively. Both types of labels can be aligned horizontally or vertically to their original location. In addition, a node label can be aligned with the borders or the center of its owner, and during resizing of that owner, smartly keeps its relative location to the snapped position. An edge label can be snapped on the path of its owner, or at particular distances of it.
This feature can be enabled and configured with an LabelSnapContext and is available for labels with one of these label models: SmartEdgeLabelModel, FreeEdgeLabelModel, FreeNodeLabelModel, and FreeLabelModel.
Interactive label editing and creation has the following new features:
- The current label visual can be hidden while the text editor is shown to reduce visual clutter. This feature is enabled by default and can be controlled through the property GraphEditorInputMode.HideLabelDuringEditing.
- GraphEditorInputMode and TableEditorInputMode provide new events LabelTextEditingStarted and LabelTextEditingCanceled that are raised directly before the label text editor is shown and after the label editing has been canceled, respectively.
- Double clicking nodes and edges now opens the label editor. An existing label can be double clicked to edit the label text. This feature can be disabled with the property GraphEditorInputMode.DoubleClickLabelEditingAllowed.
- IEditLabelHelper implementations provided by the ILabel's lookup can now be used to forbid or customize the editing of individual labels. Class LabelDecorator provides a new property EditLabelHelperDecorator to customize this feature.
- GraphEditorInputMode.EditLabel and TableEditorInputMode.EditLabel can now be used with SimpleLabel instances. This provides editing capabilities for dummy elements such as legends, page headers or other textual elements.
In addition, label editing has been reworked for a more consistent user experience. Especially, label editing now:
- Uses the various callback methods on GraphEditorInputMode, TableEditorInputMode and IEditLabelHelper implementations in a consistent way, regardless of how many labels or labeled items are edited or added, and independent from how the editing/label creation process has been started (e.g. through a command or programmatically through the input mode convenience methods).
- Determines the actual labeled item that is modified when multiple elements are selected in a consistent way.
Added support for UI Automation to GraphControl.

Layout

Added new layout algorithm RadialLayouter that places nodes on concentric circles. Edges are routed in a radial fashion using one of several routing strategies.

Added support for terminating (layout) algorithms prematurely. To this end, new class AbortHandler provides methods for requesting early but graceful termination (see method Stop) and immediate termination (see method Cancel).

The following layout algorithms have at least rudimentary support for immediate termination:
Layout Algorithms	Routing Algorithms	Other Algorithms
`BalloonLayouter` `CircularLayouter` `CompactOrthogonalLayouter` `DirectedOrthogonalLayouter` `GenericTreeLayouter` `GRIP` `HierarchicGroupLayouter` `HierarchicLayouter` `IncrementalHierarchicLayouter` `OrganicLayouter` `OrthogonalGroupLayouter` `OrthogonalLayouter` `PartialLayouter` `RadialLayouter` `RecursiveGroupLayouter` `SmartOrganicLayouter`	`BusRouter` `Polyline.EdgeRouter` `OrganicEdgeRouter` `OrthogonalEdgeRouter`	`GreedyMISLabeling` `SALabeling`
The following layout algorithms also support graceful early termination:
Layout Algorithms	Routing Algorithms	Other Algorithms
`HierarchicGroupLayouter` `HierarchicLayouter` `IncrementalHierarchicLayouter` `OrganicLayouter` `SmartOrganicLayouter`	`Polyline.EdgeRouter`	`SALabeling`

Added support for parallel execution of computationally intensive tasks.
Layout algorithms SmartOrganicLayouter and OrganicLayouter may take advantage of multiple threads for layout calculations. Parallel execution is enabled using the algorithms' MultiThreadingAllowed property.
Interface ITaskExecutor and factory class TaskExecutorFactory make up the programmatic interface for the new concurrency support.

Introduced concept of node halos. Halos are reserved space around a node in which layout algorithms will not place other graph elements. Node halos are modelled using class NodeHalo.

The following layout algorithms support node halos:
Layout Algorithms	Routing Algorithms	Other Algorithms
`BalloonLayouter` `CircularLayouter` `CompactOrthogonalLayouter` `ComponentLayouter` `DirectedOrthogonalLayouter` `GenericTreeLayouter` `IncrementalHierarchicLayouter` `OrthogonalGroupLayouter` `OrthogonalLayouter` `RadialLayouter` `RecursiveGroupLayouter` `SmartOrganicLayouter` `TreeLayouter`	`Polyline.EdgeRouter` `SelfLoopLayouter`	`GreedyMISLabeling` `SALabeling` `InsetsGroupBoundsCalculator` `MinimumSizeGroupBoundsCalculator`

SmartOrganicLayouter: Added support for partition grid layout. See PartitionGrid.

Minor Features Added

Viewer

GraphEditorInputMode got support for cyclic click selection. This helps in conveniently selecting items that are hidden behind other items. By default, this features is bound to the Alt-Key being pressed. It can be disabled by setting the CyclicSelectionRecognizer property to EventRecognizers.Never.
ItemDropInputMode is a new DropInputMode that facilitates subclasses that support preview and snapping of the dragged item as well as highlighting potential drop targets.
NodeDropInputMode and StripeDropInputMode have been refactored to use ItemDropInputMode as base class.
ItemHoverInputMode is a new IInputMode that fires events when the mouse enters or leaves the visualization of a graph item.
GraphEditorInputMode and GraphViewerInputMode provide a new CanvasClicked event to detect clicks on an empty canvas location.
Node ports can now be moved by dragging their IHandle.
When zooming while editing a label, the label text editor now stays at its minimum (maximum) size when the zoom level becomes smaller (larger) than the specified threshold. Previously, the label text editor jumped back to the size of zoom level 1.0 for such values.
GraphClipboard has new properties CopyItems, IndependentItems, and DependentItems that allow for restricting the types of items that can be copied at all, independently from their owners, or implicitly through their owners, respectively.
GraphViewerInputMode and GraphEditorInputMode: Their ClickInputMode now delivers both left and right clicks.
GraphViewerInputMode: The click hit test order can now be configured by property ClickHitTestOrder.
GraphEditorInputMode and GraphViewerInputMode provide an explicit hit test order for double clicks that can be changed through the DoubleClickHitTestOrder property. By default, this hit test order prefers labels over other graph elements.
Added new methods ClickInputMode.PreventNextDoubleClick and TapInputMode.PreventNextDoubleTap that can be used in event handlers for single clicks/taps to prevent that this click can become part of a double click event.
NodeDropInputMode can now optionally drop nodes onto leaf nodes and thus convert the leaves into group nodes. Also it is possible to drop nodes into collapsed folder nodes. For both use-cases, an opt-in property has been added and a predicate property allows for fine-grained control over this feature.
Similarly, leaf nodes can now be the target of a reparenting gesture if the property GraphEditorInputMode.ReparentToLeavesAllowed is enabled. In this case, leaves are converted into group nodes.
Added support for deleting bends in a way that an orthogonal edge remains orthogonal after removing the bends. The new property GraphEditorInputMode.OrthogonalBendRemoval enables/disables this feature.
GraphViewerInputMode now supports multi-selection via Ctrl+Click and marquee selection. The latter is disabled by default.
OverviewInputMode and the GraphOverviewControl have been optimized to improve the user experience when used on touch devices.
OverviewInputMode can be customized more easily. Minor modes can be replaced and adjusted, as well as the list of available default command bindings can be modified.
Improved GraphModelManager to allow for easier customizations. Property UseHierarchicNesting was added to allow for adding custom logic that uses a different approach to hierarchic nesting. Also the return types of some of the factory methods where made less restrictive to allow for further modifications.
FoldingManager now offers two convenience methods, UpdateViewStates(INode) and UpdateViewStates(IEdge), that will trigger update calls on IDummyNodeConverter and IDummyEdgeConverter for elements that are currently being displayed in a view. This makes it easier to synchronize state between the master graph and the folded graph views in case this is not automatically performed by the default implementation.

Layout

BalloonLayouter: Added support for integrated node and edge labeling. See new properties IntegratedEdgeLabeling, IntegratedNodeLabeling, and NodeLabelingPolicy.
BalloonLayouter: Added support for different policies to align nodes having the same root node. See new property ChildAlignmentPolicy.
BalloonLayouter: Added support for interleaved child node placement. With interleaved placement, child nodes are placed at different distances to their parent node to achieve a more compact layout. See new property InterleavedMode.
IncrementalHierarchicLayouter: Improved partition grid support. Nodes can now be mapped to a multi-lane partition cell identifier, i.e., a cell spanning multiple columns and rows. See class PartitionGrid.
IncrementalHierarchicLayouter: Improved edge label placement. Edge labels with preferred placement at source/target are placed closer to the corresponding node. Additionally, SimplexNodePlacer offers the option to place adjacent edge labels in a compact, stacked style. See new property LabelCompaction.
Polyline.EdgeRouter: Added a fine-granular configuration option to weigh the crossing costs for each label using the data provider look-up key EdgeRouter.LabelCrossingCostFactorDpKey.
Polyline.EdgeRouter: Added property IgnoreInnerNodeLabels that allows to ignore node labels that are inside the bounds of their owner so they may be crossed by edges. This is especially useful if labels of group nodes may be crossed while outer labels of non-group nodes may not.
Polyline.EdgeRouter: Added support for customizing the order in which edges are routed. See new property EdgeOrderComparator.
GenericTreeLayouter: When enabling GenericTreeLayouter.IntegratedNodeLabeling and/or GenericTreeLayouter.IntegratedEdgeLabeling, the respective labels will be taken into account during the calculation of group bounds.
DelegatingNodePlacer: Added key DelegatingNodePlacer.LeftRightDpKey that allows choosing on which side a node is placed.
PartialLayouter: Now supports handling of directed and undirected edges. See data provider key DirectedEdgesDpKey.
FixNodeLayoutStage: Added additional FixPointPolicys UpperRight, LowerRight, and LowerLeft.
LabelLayoutTranslator: Added properties WriteBackRelativeEdgeLabelLocation and WriteBackRelativeNodeLabelLocation that allow a core layouter to specify new node or edge label locations relative to the label's owner.
LabelLayoutKeys: Added key IGNORE_LABEL_KEY that allows specifying which edge and node labels should be ignored during layout calculations.
Added new class OrganicRemoveOverlapsStage that removes node overlaps while respecting a specified minimal node distance. Unlike the approach implemented in class RemoveOverlapsLayoutStage, this approach tries to keep the original layout structure, i.e., it tries to keep the geometric distance between the nodes.
Added class StraightLineEdgeRouter that routes edges as straight lines considering specified port constraints.

Improvements

Viewer

Various performance improvements for the rendering and the selection handling. This affects, amongst others, ShapeNodeStyle and styles that use a GeneralPath.
GraphEditorInputMode.DetailSelectionRecognizer is now also applied for double clicks to determine the clicked item.
GraphEditorInputMode and GraphViewerInputMode don't select or focus graph items styled with a void style (VoidNodeStyle, VoidEdgeStyle, VoidLabelStyle, and VoidPortStyle). The new property VoidStylesIgnored specifies whether this feature is enabled.
GraphEditorInputMode and GraphViewerInputMode: the new protected method ShouldSelect can be overridden to determine whether an item can be selected in general.
DropInputMode: Added property LastDragEventArgs.
OverviewInputMode: The new property Margins specifies margins for the visible area of the bound GraphOverviewControl. The new protected method UpdateVisibleArea provides further means for customizing the visible area.
CompositePositionHandler: Added methods GetPositionHandler and GetHandle to retrieve an earlier added IPositionHandler or IHandle.
PortRelocationHandles now triggers the EdgePortsChanged event of the GraphEditorInputMode.
EdgeStyleDecorationInstaller can now be used with self loops without bends, too.
ContextConfigurator: The new property Zoom determines the zoom value that should be assumed on the canvas when creating the visual. This can affect the rendering of zoom dependent visuals.
TableLayoutConfigurator: Improved support for routing algorithms.
IGraph: The collection models of graph items returned by the properties Nodes, Edges, etc. now support the methods Remove and Clear to remove graph items from the graph. Note that calling the method Add is still not allowed.
GraphModelManager: New callback method OnGraphChanged.
LayoutExecutor: The new property ConsiderViewportLimiter can be enabled to let the target viewport after a layout respect the ViewportLimiter of the GraphControl.
The ViewportAnimation has a new property ConsiderViewportLimiter for the same purpose.
LayoutGraphAdapter now adds data providers that map each node, edge and label of a LayoutGraph to their corresponding IModelItem in the original IGraph. Especially, these data providers are available if a layout is run with a LayoutExecutor or the convenience methods LayoutExtensions.MorphLayout and LayoutExtensions.ApplyLayout.
GeomSupport: The new method CreateSmoothedPath creates a new path as copy of a given one but with smoothed bends.
IconLabelStyle: The icon is added to the hit test area for mouse clicks and marquee selection. This can be switched off by overriding IconLabelStyleRenderer.ShouldHitTestIcon.
CanvasControl: Method FitContent now respects the ViewportLimiter. This might result in zoom levels greater than 1.0.
DefaultDummyEdgeConverter now synchronizes the Tag property of the first label if label synchronization is enabled.
GraphCopier has been improved to facilitate manipulation of the copied items:
- The new events NodeCopied, EdgeCopied, LabelCopied, and PortCopied are dispatched after a model item has been copied.
- The method GetOrCreateCopy<T> is now public to facilitate copying of, for example, node tags.
GraphClipboard: In hierarchically organized graphs, nodes are now pasted into their previous parent group, the group at their target position, or the root, depending on the new property ParentNodeDetection.
Automatic installation of the integrated API documentation is now available for Visual Studio 2013 and 2015 and enabled for all supported Visual Studio versions by default.

Algorithms

Dfs: Added method Cancel that can be used by subclasses to cancel the search.
Cycles: Improved method FindCycle to stop the search as soon as the first cycle has been found.
GraphConnectivity: Improved method MakeBiconnected to work with graphs with self-loops (i.e. edges whose source node is also the target node).
Groups: Replaced recursive implementation of method BiconnectedComponentGrouping with an iterative algorithm to support larger graphs.

Layout

IncrementalHierarchicLayouter: The default sequencing phase has been improved to produce less crossings and run faster.
IncrementalHierarchicLayouter: Now prevents overlaps among same layer edges attached to group nodes.
IncrementalHierarchicLayouter: Selfloop routing now takes the layout flow into account. For layout orientation top-to-bottom, selfloops will by default exit on the left or right and enter on top.
IncrementalHierarchicLayouter: Added option to route selfloops like backloops (starting at the bottom of the node and ending at the top of the node) when backloop routing is enabled.
IncrementalHierarchicLayouter: During layering, edges connected to group nodes may be redirected and replaced by dummy edges connected to the children of the group node. For these dummy edges ILayoutDataProvider.GetEdgeData now returns an IEdgeData of the new type EdgeDataType.RedirectedGroupEdge.
PCListOptimizer: Improved port candidate assignment calculated by method OptimizeAfterSequencing.
SmartOrganicLayouter: Now uses a more sophisticated approach to remove node overlaps if the scope is set to Scope.All and the quality to time ratio is greater than or equal to 0.7 (property QualityTimeRatio).
InteractiveOrganicLayouter: Method StartLayout now takes advantage of multiple threads for layout calculation which may reduce the required runtime.
BalloonLayouter: Reduced gaps between adjacent nodes.
PartitionLayouter: Added nested class PartitionLayouter.PolylineInterEdgeRouter that routes inter-edges using class Polyline.EdgeRouter.
PartialLayouter: Now considers port constraints independent of the specified layout orientation. Note that port constraints are only considered if the core layout algorithm supports port constraints as well.
PartialLayouter.StraightLineEdgeRouter: Added support for port constraints.
RecursiveGroupLayouter: Added option ReplacePortConstraints that replaces port constraints by port candidates and, thus, may improve the layout result.
Polyline.EdgeRouter: Improved support for port candidate sets (see class PortCandidateSet).
Polyline.EdgeRouter: Rerouting improved to provide better results.
Polyline.EdgeRouter: Memory usage has been reduced.
Polyline.EdgeRouter: Added penalty setting for edge length. See PenaltySettings.EdgeLengthPenalty.
Polyline.EdgeRouter: Added four predefined optimization strategies. See PenaltySettings.OptimizationBalanced, PenaltySettings.OptimizationEdgeBends, PenaltySettings.OptimizationEdgeCrossings, and PenaltySettings.OptimizationEdgeLengths.
Polyline.EdgeRouter: Default penalty settings for minimal node to edge distance, minimal group node to edge distance, minimal first and last segment length, and bends in node to edge distance increased. As a result, these restrictions are considered more strongly.
Polyline.EdgeRouter: Now avoids very small octilinear segments.
Polyline.EdgeRouter: Edge grouping improved to keep edge segments grouped longer and to consider the paths of fixed edges when calculating the paths of edges having the same edge group.
Polyline.EdgeRouter: When using polyline routing, short orthogonal edge segments in a monotonic path section are replaced by a single diagonal segment instead of a short diagonal segment followed by an orthogonal segment followed by a second short diagonal segment.
DirectedOrthogonalLayouter and OrthogonalGroupLayouter: Added optimization step that reduces the number of perceived bends. See new property PerceivedBendsOptimization.
OrthogonalLayouter, OrthogonalGroupLayouter and DirectedOrthogonalLayouter: Added optimization step that aligns degree one nodes (i.e. nodes with one incident edge) that have the same neighbor. See new property AlignDegreeOneNodes.
OrthogonalGroupLayouter: Improved routing and edge labeling for self-loops of normal (non-group) nodes.
LayoutTool: Added new rectangle arrangement method ArrangeRectangleMultiRows suitable for arranging rows of rectangles with highly different sizes.
ComponentLayouter: Added the following new component arrangement strategies to ComponentArrangementStyles that are suitable for components with highly different sizes: MultiRows, MultiRowsCompact, MultiRowsHeightConstrained, MultiRowsHeightConstrainedCompact, MultiRowsWidthConstrained, and MultiRowsWidthConstrainedCompact

Demos

The new demos Demo.yFiles.Graph.Bpmn.View and Demo.yFiles.Graph.Bpmn.Editor are more complex demos that show how yFiles can be customized to create ambitious BPM Editor and BPM Viewer.
The new demo Demo.yFiles.Graph.LargeGraphs illustrates the support for very large graphs in yFiles WPF. It shows various techniques that can help in improving the rendering performance for large graphs. Amongst other things, it shows level of detail styles for nodes, edges, and labels.
The new demo Demo.yFiles.Graph.Events shows how to register to the various events provided by the graph, the input modes, and the GraphControl.
The new demo Demo.yFiles.Graph.NetworkMonitoring is a demo for a basic network monitoring tool. You can watch the traffic flowing through an imaginary network and influence it by deactivating nodes.
The new demo Demo.yFiles.Graph.Input.MoveUnselectedNodes shows how to use and configure a modified MoveInputMode which lets the user move nodes without selecting them first.
The new demo Demo.yFiles.Graph.Input.LabelEditing shows customizations of the interactive label editing made possible by the improvements of the label editing, for example input validation and instant typing.
The demo Demo.yFiles.GraphEditor now supports changing the style of a label, drag'n'drop ports with a SimplePortStyle and editing nodes with a TableNodeStyle.
The new demo Demo.yFiles.Layout.AbortHandler shows how the new class AbortHandler can be used to stop a layout algorithm which is running in the background.
The demo Demo.yFiles.Layout.InteractiveOrganic was simplified. Now, it uses the events provided by MoveInputMode instead of a custom IPositionHandler implementation.
The demo Demo.yFiles.Graph.IntegratedNodeStyle demonstrates a custom node style that renders its labels and ports on the same layer as itself. This results in labels and ports being hidden behind other nodes and edges that are rendered in front of the item that they belong to.
The demo Demo.yFiles.Graph.Input.HandleProvider now also shows how to implement a handle which supports rotation of labels.
The demo Demo.yFiles.Graph.UIAutomation demonstrates how to use the new UI Automation support.
The new step 24 Zoom Invariant Label Style of the Style Tutorial shows a label style that renders labels always at the same size regardless of the zoom level.
The new step 25 Bridge Support of the Style Tutorial shows how to add support for bridges to a custom edge style.
Various aspects of the InputDemos have been improved: more concise sample code, more meaningful descriptions and comments, and nicer overall appearance.

Incompatible Changes

Changes in Default Behavior

GraphEditorInputMode now by default supports the new GraphCommands.DuplicateCommand that is bound to keyboard shortcut Ctrl-D. If this behavior is undesired new behavior, the DuplicateAllowed property can be set to false.
The clipboard now supports copying and pasting of items independently from their owning elements. E.g. single selected labels can be copied to other elements, as well as edges without their source and target nodes. This behavior can be reverted to the old behavior by setting GraphClipboard's IndependentItems to None.
GraphEditorInputMode now by default allows for reversing selected edges using the Ctrl-R keyboard shortcut and the new GraphCommands.ReverseEdgeCommand. This new behavior can be turned off by setting the EdgeReversalAllowed property to false.
ClickInputMode: If ActiveButtons includes MouseButtons.Right, the original right click event is marked as handled if ClickInputMode's event handlers mark the higher level click event as handled. Especially, no context menu will be shown if the right click is handled by ClickInputMode itself.
GraphEditorInputMode and GraphViewerInputMode: The default click actions that change the selection and create new nodes are only triggered on left mouse clicks now.
Previously, ports at nodes and edges that were copied and pasted to and from the clipboard were all copied, even if there where no edges attached to them after the operation. Now those empty ports are not copied/pasted anymore unless the PortDefaults' AutoCleanup property is set to false or they were unoccupied before the operation already. In order to restore the old behavior, where all ports were copied, regardless of edges where adjacent to them, make sure to include them in the core predicate, since this behavior change just affects ports that had previously not been accepted by the core predicate function.
CanvasControl: Method FitContent now respects the ViewportLimiter. This might result in zoom levels greater than 1.0.
GraphEditorInputMode's NodeCreated event may now report nodes that are not part of the graph, when the user has dropped a node via NodeDropInputMode and the new NodeDropInputMode.FolderNodeParentsAllowed property is enabled. By default this feature is disabled, though.
IReparentNodeHandler's IsValidParent method may now also be queried if the new GraphEditorInputMode.ReparentToLeavesAllowed property is enabled. By default this property is disabled, though. Note that the method will also be queried if the reparent handler is used outside the context of GraphEditorInputMode.
IValueSerializerContext.Instance inside GraphML writing code now provide the object that should be converted, not the parent object. If you need to access the actual parent object, you can use the Owner property on the GraphMLValueSerializerContext implementation of this interface.
GraphMLIOHandler.QueryReferenceId now never is fired for MarkupExtensions and other proxy objects for serialization, only for the original object references.
Polyline.EdgeRouter: Method DoLayout now throws an ArgumentException if there is a node with zero width or height in the given graph.
FixedGroupLayoutStage: Method OrthogonalEdgeRouter now returns an instance of class Polyline.EdgeRouter instead of class OrthogonalEdgeRouter.
ComponentLayouter: Property PreferredLayoutSize now throws an ArgumentException when setting the preferred size to negative values or zero.
Changed default behavior of edge label placement in layouters with integrated edge labeling when using LabelPlacements.Anywhere. Now edge labels are placed on the edge and in the center between source and target node. This change affects the following layout algorithms: IncrementalHierarchicLayouter, OrthogonalLayouter, OrthogonalGroupLayouter, DirectedOrthogonalLayouter, GenericTreeLayouter, and LabelLayoutDataRefinement.
LabelCandidateDescriptor: The default values of the properties EdgeOverlapPenalty and NodeOverlapPenalty have been changed to 0.0. Values greater than 0.0 trigger a known issue in all generic label placement algorithms that erroneously rejects all potential candidates. As a result, no suitable placement is calculated in this case.
MoveInputMode accepts mouse hovers with the Shift key held down again. This restores the default behavior before yFiles for WPF 2.4.0.2.
GraphEditorInputMode and GraphViewerInputMode: By default, graph items styled with a void style (VoidNodeStyle, VoidEdgeStyle, VoidLabelStyle, VoidPortStyle) won't be selected or get the focus.
GraphEditorInputMode's ClickHitTestOrder property default value has changed. Now it does not contain the redundant GraphItemTypes.All as the last element in the array anymore.
GraphViewerInputMode: By default, clipboard commands are now disabled. This can be controlled with the new property ClipboardCommandsEnabled.
The default keyboard shortcut for deselecting elements (GraphCommand.DeselectAllCommand) has been changed to Ctrl+Shift+A. Ctrl+D is now the default shortcut for duplicating selected elements (GraphCommand.DuplicateSelectionCommand). Duplicating elements can be disabled via the DuplicateAllowed property.
GraphEditorInputMode.ShouldBeMarqueeSelected is no longer queried by the Paste command to determine the items which should be selected after paste. Instead, the new method GraphEditorInputMode.ShouldBeSelectedAfterPaste is queried. Note that GraphEditorInputMode.ShouldBeMarqueeSelected still is queried to determine the items which should be selected by marquee selection.
Now, all pasted items are selected after a Paste (was: only nodes, edges, and bends). This can be configured via the new PasteSelectableItems property in GraphEditorInputMode and the corresponding ShouldBeSelectedAfterPaste method.
The hit test order for double clicks in GraphEditorInputMode and GraphViewerInputMode is now controlled through the separate DoubleClickHitTestOrder property. By default, this hit test order prefers labels over other graph elements.
If ClickInputMode is configured to deliver both single and double clicks, double clicks are not reported if the first click has created a new node or if cyclic selection is currently active. The same holds for TapInputMode and single/double taps.
The Rotate handle visualization is now a single circle, its very thin central point has been removed.
The ThemeInfo attribute declaration on the viewer assembly now specifies None instead of SourceAssembly for the theme-specific resource location. Since even the value of SourceAssembly would load a suitably-named theme assembly (despite the documentation and name) this would break code that relied on that assembly being loaded. However, this change eliminates FileNotFoundExceptions for these non-existent assemblies that may occur at program startup.
The segment index for label model parameters of SliderEdgeLabelModel and SideSliderEdgeLabelModel now is related to the visible segments for edges styled with PolylineEdgeStyle.
If an IEditLabelHelper implementation is present in an ILabel's lookup, its EditLabel method is now called in addition to an eventual owner's edit helper when the label text is edited. If implementations are present for both the label and the owner, editing is only allowed if both helpers return true. Additionally, the predicate method GraphEditorInputMode.ShouldLabelBeEdited always has to return true, whether edit helpers are present or not.
The label that is edited is now determined in the following order:
1. If a label is explicitly provided as a command parameter or through a convenience method or is the only selected element, it is edited if the previous condition is satisfied. No other candidates are tried in that case.
2. If a label owner is explicitly provided as a command parameter or through a convenience method, or is the only selected element, the first label that satisfies the condition above is edited if the previous condition is satisfied. If no such label exists, a new label is be added, provided that the owner allows adding. In either case, no other candidates are tried.
3. The first selected label for which the previous condition is satisfied.
4. If multiple label owners are selected, the first owner that has a label for which the previous condition is satisfied (in which case that label is edited).
5. If IEditLabelHelper.EditLabel for either an editable label or its owner provides a different label instance, this instance is edited instead.
6. Otherwise, a label is added if an eligible owner can be found (see below).
If an IEditLabelHelper implementation is present in an ILabeledItem's lookup, its AddLabel method is called to determine whether a label may be added and provide a suitable label instance. Additionally, the predicate method GraphEditorInputMode.ShouldLabelBeAdded always has to return true, whether edit helpers are present or not. If the new label should be edited interactively after it's creation (the default behavior), it also must be editable, following the rules above. Therefore an IEditLabelHelper implementation usually should allow editing of label instances that it has created itself in AddLabel.
The label owner for which a label is added is now determined in the following order:
1. If a label owner is explicitly provided as a command parameter or through a convenience method, or is the only selected element, a label is added if the previous condition is satisfied. No other candidates are tried in that case.
2. If multiple label owners are selected, the first one for which the previous condition is satisfied.

API Changes

Changed SnapLine to support non-orthogonal snap lines as well: its properties From and To have been changed from type double to PointD, its property Orientation was removed, and its constructors have been changed accordingly.

Orthogonal snap lines are now modeled by class OrthogonalSnapLine. It extends SnapLine and provides the property Orientation. Existing API uses either SnapLine or OrthogonalSnapLine, depending on whether it works only with orthogonal snap lines or not.

As a consequence, in class SnapLineSnapResult, the property SnapLine returns a non-orthogonal SnapLine and the property Delta returns a PointD instead of a double. API related to GraphSnapContext still works only with orthogonal snap lines and uses OrthogonalSnapLine.
The Key property on SingleLineSnapLineControl, FixedDistanceSnapLineControl, and InBetweenSnapLineControl, has been made read only.
GraphModelManager's factory methods for creating the installers now have a less restrictive return type. The default implementation still returns the same types as before, though.
GraphClipboard's factory methods for creating the predicates for the various cut and copy operations now require a second argument that is the graph that the predicate is working on. Usages typically use the graph in the graph control where the selection is also being used. If the default graph selection implementation is used. The graph instance can be obtained from its corresponding property.
GraphModelManager's installer related properties now use a weaker return type to simplify subclassing with new functionality. The instances used are the same and can be down-casted accordingly to the more specific types as documented.
AlgorithmAbortedException: Removed overloaded methods Check. Client code that needs to terminate layout calculations prematurely must use new class AbortHandler instead.
Moved classes PartitionGrid, PartitionCellId, RowDescriptor, and ColumnDescriptor from package yWorks.yFiles.Layout.Hierarchic.Incremental to package yWorks.yFiles.Layout.Grid.
IItemFactory: Added method CreateRedirectedGroupEdge.
LayeredNodePlacer: Removed data provider key DpKeyDistanceToParentMap from public API, since it is for internal use only.
Polyline.EdgeRouter: Method DoLayout now throws an ArgumentException if there is a node with zero width or height in the given graph.
Polyline.EdgeRouter: Penalty settings have been changed to double precision. See class PenaltySettings.
PathSearch: Signature of method CalculateCosts has changed. It now takes an additional double array as parameter that is populated with the calculated costs instead of returning a new array.
DrawingEmbedder: Removed public method PreprocessNodes and protected method PrintStatistics.
GraphClipboard's protected method Copy(IGraph, Predicate>IModelItem>, IGraph, ElementCopiedDelegate) which was called by Cut, Copy, and Paste to invoke the GraphCopier has been split: Copy(IGraph, Predicate >IModelItem>, IGraph, ElementCopiedDelegate) now is called only by Cut and Copy. Paste now invokes the new method Paste(IGraph, Predicate >IModelItem>, IGraph, ElementCopiedDelegate, Predicate >IModelItem>).
The type of GraphMLAttribute's Serializable property has been changed from bool to the enum GraphMLSerializationMode.
GraphEditorInputMode and TableEditorInputMode: return value of callback methods OnAddLabel and OnEditLabel has been changed from void to bool. The return value should specify whether the operation in question was successful.

Bugfixes

Viewer

FoldedGraph detects more carefully what has changed before invoking the methods CreateDummyEdgeAppearance and ChangeDummyEdgeAppearance of IDummyEdgeConverter. Previously, in some cases, these methods were called to often or not at all.
When both a group node and its child node were resized together the group node bounds shrunk to its original bounds once the child had reached the original bounds.
Fixed problem in LayoutGraphAdapter where label candidates for edge labels were not always determined correctly.
Fixed LayoutGraphAdapter producing threading issues when PortCalculator was used during a multi-threaded layout.
When snapping was disabled temporarily (using Ctrl) during a move gesture the moved item snapped after finishing the gesture, anyway.
FoldedGraphUndoSupport didn't add the correct bend information to its internal data structures.
CreateEdgeInputMode: Fixed some problems with mixed mouse and touch input.
When using an IEditLabelHelper and adding a label interactively, the helper's EditLabel callback was called instead of AddLabel.
Newly added labels could have had an empty size when an IEditLabelHelper instance was registered.
When a highlighted item was removed from the graph, the highlight was not cleaned up.
Reparenting an empty group node displayed the target node highlight around the reparented node.
The modified MoveInputMode created by MainInputMode.CreateMoveUnselectedInputMode changed the cursor to indicate a movable object even when the modifierRecognizer disabled moving.
When both a group node and its child node were resized together the group node bounds shrunk to its original bounds once the child had reached the original bounds.
ClickInputMode: Cancelling the mode during clicks didn't work correctly and as a result, the location reported for the next click might have been wrong.
CreateEdgeInputMode now copies the dummy edge's tag to the created edge. This could have caused issues when the EdgeCreationStarted was used to set a custom tag on the dummy edge.
When the pressed status of the Shift key changed during a reparenting gesture of a node, the bounds of its containing group node were not immediately updated.
The secondary multi-tap gesture was not recognized correctly.
When snapping was disabled temporarily (using Ctrl) during a move gesture the moved item snapped after finishing the gesture, anyway.
Labels whose positions were determined by NinePositionsEdgeLabelModel, SliderEdgeLabelModel, and SideSliderEdgeLabelModel might have disappeared when one or more edge segments were hidden under the source or target node.
SnapContext: Snap results with a null tag were erroneously always discarded.
GeneralPath#Transform and other GeneralPath methods using Matrix2D applied the transformation matrix incorrectly in the case of a rotation.
BevelNodeStyle: Fixed update of drop shadow after Radius has been changed.
IconLabelStyle: Method GetBounds in IconLabelStyleRenderer returned a valid rectangle even if the label layout was invalid. As a consequence, IsVisible erroneously returned true for labels with invalid bounds.
The lookup of CollapsibleNodeStyleRenderer was missing the correct results for IGroupBoundsCalculator, ISizeConstraintProvider, and IShapeGeometry.
The lookup of ShadowNodeStyleDecoratorRenderer was missing the correct result for IShapeGeometry.
The Name property of the GraphMLAttribute was not considered during deserialization.
Write events in GraphML were not always raised.
After setting an ICanvasObjectGroup's Visible property to false the group was still visible.
CanvasControl.EnsureVisible hasn't worked for bounds larger than the current viewport.
Setting the view point on a CanvasControl with a width or height of 0.0 could cause an exception if a ViewportLimiter was enabled.
GraphCopier threw an ConcurrentModificationException if the source and the target graph are identical.
CanvasPrintDocument did not forward the print options to a PrintDialog which is opened from within a print preview.
Prevent an ArgumentNullException in the print preview of the CanvasControl.
When the SelectionPaintManager was disabled and a custom FocusPaintManager was used nodes styled with NodeControlNodeStyle might not always have been updated after selection changes.
GraphEditorInputMode and GraphViewerInputMode now respect the MultiSelectionRecognizer for extending an existing selection via marquee.
Fixed TableEditorInputMode exhibiting problematic behavior under certain circumstances when the GraphControl's graph is replaced.
GraphML could write incorrect values for bend tags.

Layout

Running any label placement algorithm had no effect for node/edge labels if the properties RemoveNodeOverlaps/RemoveEdgeOverlapswere enabled because all potential candidates were erroneously rejected.
AbstractLabelingAlgorithm: Fixed bug that may cause removal of labels that don't overlap with other elements if option RemoveNodeOverlaps is enabled.
IncrementalHierarchicLayouter: Fixed rare InvalidOperationException that may appear for grouped graphs containing nodes with fixed coordinates hint (see, e.g., IncrementalHintsFactory.CreateUseExactCoordinatesHint).
IncrementalHierarchicLayouter: Fixed bug that breaks incremental hints of grouped edges in incremental layout mode. (see IncrementalHintsFactory.CreateSequenceIncrementallyHint).
IncrementalHierarchicLayouter: Fixed bug that may cause a wrong order of fixed (non-incremental) elements if the layouter is applied in incremental mode and the graph contains sequence constraints.
BorderLine: Fixed bug in method Grow that may result in an ArgumentException because the minimum value of a BorderLine becomes greater than the maximum value.
Polyline.EdgeRouter: Fixed bug that may cause zero length routes of edges whose start and end point are at the same location.
IncrementalHierarchicLayouter: Fixed possible IndexOutOfRangeException that may occur for grouped graphs in incremental mode with recursive group layering enabled.
IncrementalHierarchicLayouter: Fixed possible exception caused by inconsistent grouping.
IncrementalHierarchicLayouter: Fixed broken edge routes that may occur for edges with labels if SimplexNodePlacer's option EdgeStraighteningOptimization is enabled.
IncrementalHierarchicLayouter: Fixed minimum edge length for orthogonal edges. It is now also taken into consideration for edges that connect to a node's side and for backloop edges.
IncrementalHierarchicLayouter: Fixed possible IndexOutOfRangeException in PCListOptimizer that may appear if there are port constraints which have no matching port candidate or port candidate set entry.
SmartOrganicLayouter: Fixed bug that caused weird placement of fixed elements if the minimal node distance is set to 0.
MultiPageLayouter: Fixed possible NullReferenceException if the input graph contains empty group nodes.
MultiPageLayouter: Fixed possible InvalidCastException.
PartialLayouter: Fixed broken edge routes that may appear if option EdgeRoutingStrategy is set to EdgeRoutingStrategyOctilinear.
Polyline.EdgeRouter: Fixed wrong heuristic bend calculation if grid is used.
BusRouter: Fixed NullReferenceException in BusRepresentations that could appear if the input graph contains overlapping nodes.
OrganicEdgeRouterModule: Fixed option Use existing bends which was ignored in previous versions.
FixedGroupLayoutStage: Fixed canLayout which changed the structure and layout of the graph.
IncrementalHierarchicLayouter: Fixed possible IndexOutOfRangeException if PortConstraints are used together with PortCandidateSets.
Polyline.EdgeRouter: Minimum first and last segment length and minimum node to edge distance were sometimes ignored when used together with octilinear routing style.
Grouping: Fixed bug in method NearestCommonAncestor that sometimes caused wrong results if one of the specified nodes is the ancestor of the other node.
InsetsGroupBoundsCalculator: Fixed method CalculateBounds to consider only the given child nodes and all edges between those child nodes instead of all nodes and all edges in the graph.
GenericTreeLayouter: Fixed NullReferenceException that occurred when using LayeredNodePlacer as default node placer.
LayoutTool: Fixed calculation of lower width bound in method ArrangeRectangleRows. Due to the better bound, the optimization procedure now needs less steps, especially for graphs with very wide components. Note, that the results may also slightly differ, because the optimization may now stop with slightly different values.
SALabeling and GreedyMISLabeling: Fixed possible NullReferenceException caused by labels with zero width/height and a "free" edge label model.
IncrementalHierarchicLayouter: Fixed bug that caused wrong coordinates of empty rows (see class RowDescriptor) whose minimum height is zero.
DirectedOrthogonalLayouter: Fixed a bug that sometimes caused misplaced edge labels of grouped edges.
Polyline.EdgeRouter: Fixed possible NullReferenceException for edge groups that contain fixed edges.
Polyline.EdgeRouter: Fixed bug that caused wrong routes for edges grouped with fixed edges.

yFiles WPF 2.4.0.6 - Changes Since 2.4.0.5

Bugfixes

RotatedSideSliderEdgeLabelModel: Label model parameters of this model were serialized as the respective parameters of RotatedSliderEdgeLabelModel. Thus, after loading, the positions of the labels are the expected ones but the label models changed.
RotatedSliderEdgeLabelModel: Parameters with ratio 0.5 were not correctly deserialized from GraphML.
FilteredGraphWrapper: The EdgesAt methods erroneously returned edges that were marked as hidden by the EdgePredicate. The methods Degree, InDegree, and OutDegree are based on these methods and were affected, too.
GraphSnapContext: Snapping nodes to vertical edge segments was not working if NodeToEdgeDistance was set to 0.
CollapsibleNodeStyleDecorator and ShadowNodeStyleDecorator: Lookup requests for ISizeConstraintProvider, IGroupBoundsCalculator, and IShapeGeometry are now correctly delegated to the wrapped style.
The EdgeStyleDecorationInstaller did not copy the tags of dummy ports and edges used when displayed in view coordinates (ZoomMode = DecorationZoomMode.ViewCoordinates).

Automatic Layout

OrthogonalLayouter failed almost always with an ArrayIndexOutOfRangeException if the Mixed Layout style was used.
IncrementalHierarchicalLayouter: Fixed possible exception caused by inconsistent grouping. The problem may only occur in incremental mode and if there are sequence constraints.
BusRouter: Fixed NullReferenceException that may appear for graphs containing isolated nodes with self-loops.
TreeReductionStage: Fixed wrong handling of group nodes which may cause a WrongGraphStructure exception as well as broken routes of edges incident to group nodes.
Fixed NullReferenceException when using AssistantPlacer together with distributed port assignment.
CircularLayouter: Fixed issue that may cause infinite/too large node coordinates for unfavorable input settings, for example, if the maximal deviation angle is to small. Note that such coordinates may produce infinite looping or other exceptions.

yFiles WPF 2.4.0.5 - Changes Since 2.4.0.4

Bugfixes

GraphMLIOHandler: method AddNamespace had no effect, and adding a custom schema with AddSchemaLocation triggered an exception.
ContextConfigurator: property Scale did not throw an exception for invalid values. This also led to several demos being broken.
Worked around several errors that were erroneously reported by PEVerify. Runtime verification behavior was not affected by these.

Automatic Layout

Polyline.EdgeRouter: Fixed wrong heuristic bend calculation if grid is used.
BusRouter: Fixed NullReferenceException in BusRepresentations that could appear if the input graph contains overlapping nodes.
MultiPageLayouter: Fixed possible NullReferenceException if the input graph contains empty group nodes.
MultiPageLayouter: Fixed possible InvalidCastException if group node insets are specified with class yWorks.yFiles.Util.Geom.Insets.
IncrementalHierarchicLayouter: Fixed broken edge routes that may occur for edges with labels if there are "critical" edges, see CriticalEdgeDpKey.
SimplexNodePlacer: Fixed broken edge routes that may occur for edges with labels if option StraightenEdges is enabled.
IncrementalHierarchicLayouter: Fixed ArgumentException (Graph is not acyclic) in SimplexNodePlacer that could appear when sequence constraints were added to a graph with swimlanes and group nodes.
BorderLine: Fixed rare ArgumentException that was caused by numerical instability.
IncrementalHierarchicLayouter: Fixed ArgumentException in ConstraintIncrementalLayerer that could appear when layer constraints were added in incremental mode.
CircularLayouter: Fixed possible NullReferenceException when layout style is set to BccIsolated and consider node labels is enabled.
AbstractLabelingAlgorithm: Fixed bug that causes poor results if option RemoveEdgeOverlaps is enabled and the labels should be placed on the edge.

Known issues

GraphML serialization of node label model parameters that are created with FreeNodeLabelModel.CreateNodeRatioAnchored is incorrect (the y ratio value is inverted). A fix for this issue will be part of the next feature and/or major relase, since this would introduce an incompatible change in behavior.

yFiles WPF 2.4.0.4 - Changes Since 2.4.0.3

Bugfixes

Folding: Source port tags in view states were not parsed correctly from GraphML.
BevelNodeStyle: Fixed update of drop shadow after Radius has been changed.
CreateEdgeInputMode: Mixing touch and mouse gestures did not always work as expected.
FilteredGraphWrapper.Dispose did not clean up all event listeners.
Node ports could not be moved by dragging their IHandle.
Image export: Custom selection visualizations created with NodeStyleDecorationInstaller, LabelStyleDecorationInstaller and EdgeStyleDecorationInstaller in zoom invariant mode were not placed correctly.
PixelImageExporter: The default node and label selection markers were not exported correctly.

Automatic Layout

IncrementalHierarchicLayouter: Fixed ArgumentException that may appear for graphs containing nodes with fixed coordinates.
LabelLayoutDataRefinement: Fixed possible InvalidCastException for unbuffered layout runs.
RecursiveGroupLayouter: Removed all temporarily inserted port candidates before calling the inter-edge routing because otherwise the edges routes may become corrupted.
TreeLayouter and GenericTreeLayouter: Fixed possible NullReferenceException for trees with empty group nodes.
ShuffleLayouter: Fixed bug that may cause small offsets of fixed nodes.
Polyline.EdgeRouter: Fixed bug in calculation of edge to edge distance penalties which could reduce the space where edges can be routed causing them to take unnecessary long routes.
Polyline.EdgeRouter: Fixed bug that caused edges that connect a node with an ancestor group node to violate the minimal node to edge distance for the target node.
Polyline.EdgeRouter: Fixed bug that caused edges that connect a node with an ancestor group node to have unnecessary long and bended edge paths when using port constraints.
Polyline.EdgeRouter: Fixed bug that caused edges that connect a node with an ancestor group node to cross their source nodes when using port constraints.
Polyline.EdgeRouter: Fixed bug that makes it possible to group the source of one edge and the target of another edge at their common node.
Polyline.EdgeRouter: Fixed bug that sometimes causes superfluous edge overlaps.
Polyline.EdgeRouter: Fixed bug that caused minimum distance violation of grouped edges.
Polyline.EdgeRouter: Fixed rare NullReferenceException while calculating edge crossing costs.
Polyline.EdgeRouter: Fixed bug that sometimes assumed wrong label bounds for labels of table nodes. This could result in too many bends for edges that were routed around those wrong boxes. Labels of table nodes are now ignored by the router if TableLayoutConfigurator is used to prepare the graph for layout calculations.
Polyline.EdgeRouter: Fixed bug that sometimes assumed wrong label bounds if the router was used directly after another layout algorithm. This could result in too many bends for edges that were routed around those wrong boxes and/or edges crossing labels because the actual label boxes were ignored.
PolylineLayoutStage: Fixed possible IndexOutOfRangeException if there are fixed edges with a single, very short segment.
BusRouter: Fixed clean up of bends that resulted in unnecessary detours in edge paths.
BusRouter: Fixed possible IndexOutOfRangeException.
BusRouter: Fixed possible InvalidOperationException caused by non-orthogonal edge segments.
BusRouter: Fixed possible NullReferenceException when routing only a subset of edges without adding a DataProvider to the graph that marks edges as selected.
IncrementalHierarchicLayouter: Fixed bug that could result in infinite y-coordinates when octilinear edge routing was enabled.
Polyline.EdgeRouter: Fixed bug that may cause an ArgumentException if a grid is specified (see option Grid).
OrthogonalGroupLayouter: Fixed bug that may cause wrong group bounds calculation if a group node label lies outside of the group node.
PartialLayouter: Fixed possible NullReferenceException if the algorithm is applied to a graph with partition grid (see PartitionGrid).

Demos

ImageExportDemo: The hit test for the export rectangle was configured incorrectly.

yFiles WPF 2.4.0.3 - Changes Since 2.4.0.2

Improvement

LayoutGraphAdapter provides now the original Tag data for temporary graph objects.

Bugfixes

Undoing a reparent grouping gesture might have resulted in inconsistent group node sizes. Note: The fix results in a slightly incompatible behavior when nodes are reparented programmatically and multiple folding views are used. In that case, you need now to subscribe to hierarchy events and manually adjust the group node bounds.
The default value of AbstractTableNodeStyle#BackgroundStyle was not serializable.
Manually bracketing undo edits with BeginEdit and EndEdit might have led to exceptions when folding was active.

Automatic Layout

DirectedOrthogonalLayouter could throw a String.IndexOf exception.
IncrementalHierarchicLayouter: Fixed a rare bug that caused broken edge routes if edges are routed polyline.

yFiles WPF 2.4.0.2 - Changes Since 2.4.0.1

Bugfixes

ClickInputMode.SwallowFocusClick had only an effect for the very first click.
Copying table stripes did not work correctly.
GraphML: Properties with a text value containing nested CDATA sections were not parsed correctly.
Fixed problems with invalid license popups in Visual Studio Designer. Note that GraphControl may still show an erroneous watermark in design view.
Moving the viewport by clicking into the GraphOverviewControl did not honor CanvasControl.ViewportLimiter restrictions.
RotatedSliderEdgeLabelModel can now deal with edge paths that are null, e.g. when using VoidEdgeStyle.
GraphML: Primitive types like floats and doubles could not be read when used in element syntax and the current CultureInfo was not Invariant.

Automatic Layout

EdgeRouter: Fixed bug that may cause an ArgumentException if a grid is specified (see property Grid).
OrthogonalGroupLayouter: Fixed bug that may cause a wrong group bounds calculation if a group node label lies outside of the group node.
PartialLayouter: Fixed possible NullReferenceException if the partial layouter is applied to a graph with partition grid (see PartitionGrid).
PartialLayouter: Fixed bug that may cause a very long runtime if the algorithm considers node alignment (see property ConsiderNodeAlignment).
IncrementalHierarchicLayouter: Fixed bug that may cause broken edge routes for edges with port candidates if backloop routing is enabled (see property BackloopRouting).
ParallelEdgeLayouter: Fixed NullReferenceException that appears if the leading edge has zero length.
ParallelEdgeLayouter: Fixed bug that may cause points with Double.NaN-coordinates for some edges.
LayoutTool: Fixed bug in method RouteEdgesParallel: that may cause points with Double.NaN-coordinates for some edges.
EdgeRouter: Fixed performance problems for graphs with overlapping fixed edges.

yFiles WPF 2.4.0.1 - Changes Since 2.4

Improvements

Automatic Layout

Trees: Added method IsForest(Graph, bool).

Bugfixes

NavigationInputMode.ToggleGroupNodeState did not expand collapsed folder nodes.
NavigationInputMode: Methods CollapseSelection and ExpandSelection threw a NullReferenceException.
SimpleAbstractLabelStyle.IsInBox always returned false.
GraphEditorInputMode: The ItemLeftDoubleClicked and ItemRightDoubleClicked events were never raised.
NodeStyleLabelStyleAdapter: Fixed rendering bug when the style was used for node labels.

Automatic Layout

Rectangle2D.Intersects sometimes returned true for non-intersecting rectangles. This could cause infinite loops in BusRouter.
IncrementalHierarchicLayouter: Fixed bug that caused violation of strong port constraints of type AnySide for backloop edges.
RecursiveGroupLayouter: Fixed IllegalStateException that may appear if there are edges that start/end at group nodes.
BusRouter: Fixed bug that may cause a broken bus structure.
BusRouter: Fixed possible stack overflow.
IncrementalHierarchicLayouter: Fixed bug that caused unsuitable edge routes for grouped edges within group nodes.
OrthogonalLayouter: Fixed exception that may appear for graphs with nodes of high degree.

yFiles WPF 2.4 - Changes Since 2.3.0.4

Major Features Added

Automatic Layout

Class yWorks.yFiles.Layout.Router.Polyline.EdgeRouter is a new edge routing algorithm that creates polyline edge routes. The segments of an edge are either orthogonal or octilinear, that means, the slope of each segment is a multiple of 90 degrees or a multiple of 45 degrees, respectively.
[To the corresponding section in the yFiles WPF Developer's Guide...]
yWorks.yFiles.Layout.Router.Polyline.PolylineLayoutStage: A new layout stage that adds polyline segments to the orthogonal edge paths of a graph.
IncrementalHierarchicLayouter: Added support for octilinear edge routing, i.e., a routing style where the slope of each edge segment is a multiple of 45 degrees. Different edge routing styles can be specified using class yWorks.yFiles.Layout.Hierarchic.Incremental.RoutingStyle.
yWorks.yFiles.Layout.PreferredPlacementDescriptor: A new descriptor that allows to specify advanced preferred placement information for edge labels.
[To the corresponding section in the yFiles WPF Developer's Guide...]

Minor Features Added

ClickInputMode, GraphEditorInputMode, GraphViewerInputMode: New events for LeftClicked, RightClicked, LeftDoubleClicked and RightDoubleClicked. Also, ClickInputMode has been improved to handle multiple mouse buttons concurrently.
MainInputMode and GraphViewerInputMode: Added new bulk selection events MultiSelectionStarted and MultiSelectionFinished.
LayoutExecutor can now safely handle concurrent layout requests. By default an already running layout will be short-cut and the next layout request will be processed. Property SequentialExecution can be set to false to revert to the old (unsafe) behavior. The new Stop method and the IsRunning property can also be used in this context.
NodeControlNodeStyle and LabelControlLabelStyle now have the ability to automatically trigger a resize of their corresponding graph items whenever the desired size of the control contents change, e.g. in response to a dynamic UI.
New classes NodeStyleDecorationInstaller, EdgeStyleDecorationInstaller, and LabelStyleDecorationInstaller allow the use of a node, edge, or label style to render the selection, highlight, or focus indicator of nodes, edges, and labels, respectively.

Automatic Layout

BalloonLayouter: New option to take into account the bounds of node labels when calculating a layout.
LabelLayoutTranslator: Added option AutoFlippingEnabled to specify whether or not edge labels should be automatically flipped if they would be upside-down.
AbstractLabelingAlgorithm: Added option AutoFlippingEnabled to specify whether or not edge labels associated with a "free" label model should be automatically flipped if they would be upside-down.

Improvements

Optionally, LayoutExecutor uses WaitInputMode while waiting during the calculation of a layout.
Added callback method SetEdgePortLocation to LayoutGraphAdapter that is called while assigning a new location to a port that is owned by an edge.
Changing the event recognizers of an IInputMode after the mode has been installed has now an effect in all input modes.
Improved performance of table rendering and interaction.
Refactored MoveLabelInputMode to make customizations easier. The moved label is now accessible and various new protected methods provide fine-grained control of the behavior.
MoveLabelInputMode now takes the position handler from the lookup of a label if one is present, and creates a new one only if none was found.
Custom context menus declared on controls that are rendered within the CanvasControl now play well with ContextMenuInputMode. The new SuppressChildMenus property can be used to optionally prevent those menus from appearing if the mode is not enabled.
IClipboardHelper: The predicate functions ShouldCut and ShouldCopy were not used for the default cut and copy operations provided by GraphEditorInputMode and GraphControl.
Child input modes of GraphViewerInputMode can now be changed similar to GraphEditorInputMode.
Added explicit extension method IGraph.CreateNode(PointD,INodeStyle).
Arrow: Setting the various properties now only recreates the arrow template if something actually changed.
ContextConfigurator.Setup: The IRenderContext returned by this method now has the correct Clip applied.

Automatic Layout

OrthogonalGroupLayouter supports labels at edges incident to group nodes.
IncrementalHierarchicLayouter now treats edge groups at empty group nodes like those on regular nodes instead of ignoring them like it is done for non-empty group nodes.
WeightedLayerer: Improved quality by reducing the number of reversed edges if WeightedCycleRemoval is enabled.
PartialLayouter now considers edge ports when calculating the barycenter of a component (if its property PositioningStrategy is set to SubgraphPositioningStrategy.Barycenter).
PartialLayouter: Reduced cases where the result contains overlapping node elements.
PartialLayouter calculates improved routing if option RouteInterEdgesImmediately is enabled and generally for edges between fixed elements.
SmartOrganicLayouter: Fixed nodes are no longer moved by a fixed offset if scope is set to Scope.Subset.
GenericTreeLayouter creates more compact layouts, especially for trees with edge labels.
Added the ability to DefaultNodePlacer to create polyline-style edge routings with sloped edge segments.
Added the ability to DefaultPortAssignment to distribute edges at the border of the nodes.
RecursiveGroupLayouter: Improved performance for graphs with a mainly flat structure.
GraphLayoutLineWrapper: Improved edge routing for overlapping edges, for example grouped edges.
Added auto-flipping to RotatedDiscreteEdgeLabelLayoutModel and RotatedSliderEdgeLabelLayoutModel. Labels that are placed upside down by a layouter will be flipped.
Improved the performance of PortCandidate which potentially improves the performance of the IncrementalHierarchicLayouter with rotated graphs with PortCandidates.
Optimized number of generated PortCandidates in RecursiveGroupLayouter for the core layouter.
GraphConnectivity: Improved method MakeBiconnected to work with graphs with self-loops (i.e. edges whose source and target nodes are the same).

Demos

Added new demo Demo.yFiles.Graph.Input.HandleProvider that shows how to add resize handles to graph elements that don't provide them out of the box.
Added new demo Demo.yFiles.Graph.Input.SingleSelection that shows how to configure GraphEditorInputMode to enable single selection mode for interaction.
Added new demo Demo.yFiles.Graph.StyleDecorators and a corresponding step in the Custom Style Tutorial that shows how to correctly implement the decorator pattern for node styles.
Added new demo Demo.yFiles.Graph.SelectionStyling that shows how to use node, edge and label styles for the painting of the selection decorator.
Added new demo Demo.yFiles.Layout.PreferredLabelPlacement that shows how to use the new PreferredPlacementDescriptor layout feature.
The layout modules now use the new preferred placement descriptor feature for label setup. Additionally, the previous label setup had no effect at all due to an erroneous configuration.
Prevent negative edge weights in Demo.yFiles.Algorithms.ShortestPath since cycles with negative weights are not allowed by the algorithm.

Bugfixes

If NavigationInputMode was used as child of GraphViewerInputMode or GraphEditorInputMode, it didn't respect the selectable and focusable items of its parent input mode.
In CreateEdgeInputMode and MoveInputMode, snapping may not have been re-enabled after disabling it temporarily.
Prevent a very rare bug caused by the preferred size calculation of labels of dummy elements of grouped graphs when LabelControlLabelStyle was used.
IconLabelStyle: Fixed exception when the icon size was not set or was empty.
GraphClipboard.Cut: The filter predicate was evaluated twice, resulting in unexpected behavior if the predicate evaluation depended on state that could change by removing graph elements.
HorizontalScrollBarPolicy and VerticalScrollBarPolicy in CanvasControl could not be set to different values at the same time. The value of the latter was used effectively, always.
LabelControlLabelStyle incorrectly triggered an update of the preferred label size calculation in folded graph scenarios under certain conditions.
An error in CanvasPrintDocument prevented XPS printing to certain paper sizes.
In CreateEdgeInputMode, the compound undo unit is cancelled if the edge creation is implicitly cancelled. The old behavior can be restored by disabling CreateEdgeInputMode.CancelEditImplicitly.
MoveInputMode only considers hovers without modifiers as valid to prevent "cursor fight" with MoveViewportInputMode.

Automatic Layout

IncrementalHierarchicLayouter: Fixed incorrect handling of port candidates in layouts where rotation and a mirror was set.
IncrementalHierarchicLayouter: Fixed integer overflow when group compaction is activated while layouting extremely large, deeply nested graphs.
IncrementalHierarchicLayouter: Fixed port handling of edges with a single edge port candidate that is contained in a set of node port candidates.
Fixed bug with invalid array access in AspectRatioComponentLayerer.
Fixed bad edge routings in FamilyTreeLayouter when there are several marriages between generations.
IsolatedGroupComponentLayouter now considers labels in group bounds calculation if label awareness is enabled.
PartialLayouter: Fixed IndexOutOfRangeException that sometimes appears for large graphs.
GroupNodeRouterStage: Fixed possible exception that was caused by the missing removal of a temporarily added DataProvider.
OrthogonalLayouter and DirectedOrthogonalLayouter: Fixed bug that caused an ArgumentException if input graph contains overlapping parallel edges and from sketch mode is enabled (see property UseSketchDrawing).
OrthogonalEdgeRouter: Fixed exception that may appear when both options Rerouting and LocalCrossingMinimization are enabled.
RotatedSliderEdgeLabelLayoutModel and SliderEdgeLabelLayoutModel: Improved label placement at zero-length edge segments.
GraphTransformer: Fixed group nodes bounds after transforming a sub-graph only.
ParallelEdgeLayouter: Fixed NullReferenceException which may appear when source/target points of parallel edges are outside of the corresponding node.
SmartOrganicLayouter: Fixed problem that sometimes caused very long runtime for simple grouped graphs.
SmartOrganicLayouter: Fixed wrong calculation of group node sizes if option ConsiderNodeLabels is enabled.
YVector: Fixed method Rotate(double) to no longer return vertically mirrored results.

Changes in Default Behavior

IClipboardHelper: The predicate functions ShouldCut and ShouldCopy are now taken into account for the default cut and copy operations provided by GraphEditorInputMode and GraphControl.
ContextConfigurator.Setup: The IRenderContext returned by this method now has a finite Clip applied.
Concurrently executing layouts using LayoutExecutor will now result in the subsequent executions waiting for the previous execution to finish. Property SequentialExecution can be set to false to revert to the old (unsafe) behavior.
The ContextMenuInputMode's PopulateItemContextMenu event will not fire anymore for context menus that are declared in controls inside the CanvasControl, but only for the menu that is managed by the input mode.
If the PopulateContextMenuEventArgs' property ShowMenu is set to true, now even empty menus will be displayed.

Automatic Layout

PartialLayouter: Property EdgeRoutingStrategy now disables a previously set customized edge router.

Incompatible API Changes

Automatic Layout

IEdgeLabelLayout: Removed property PreferredPlacement and added property PreferredPlacementDescriptor.
PartialLayouter: Replaced method ConfigureOrthogonalEdgeRouter by method ConfigureEdgeRouter.
Classes yWorks.yFiles.Util.ISortedMap and yWorks.yFiles.Util.ISortedSet have been removed from the public API. These interface were never meant to be used by customers.

yFiles WPF 2.3.0.4 - Changes Since 2.3.0.3

Bugfixes

GraphSource: If an edge item is removed from EdgesSource, nodes connected to this edge are no longer removed. This only occurred if DynamicUpdates was enabled and LazyNodeDefinition was set to false.
CanvasControl.Print(RectD, bool, bool, InsetsD?) threw a FieldAccessException when the showPrintDialog parameter was false and/or the showPreview was true.
CanvasPrintDocument.Print(PrintDialog, bool, bool, InsetsD, string) threw a FieldAccessException when the both the showPrintDialog parameter and the showPreview parameters were true.
CanvasPrintDocument.ShowPrintPreview and CanvasPrintDocument.Print(PrintDialog, bool, bool, InsetsD, string): Documentation for the second parameter (originally called showPrintDialog) was wrong: the printer setting dialog is actually shown if the parameter is set to false, and only if showPreview is also true. This has been fixed.

Demos

Demo.yFiles.Printing: The "Print" button did not do anything.

yFiles WPF 2.3.0.3 - Changes Since 2.3.0.2

Bugfixes

ContextConfigurator: Left and top margins were not taken into account correctly.
XamlSerializer: Fixed potential exceptions that could occur with properties that are not serializable.
The default edge style used by the GraphSource was different from the one used in yFiles WPF 2.2. This has been reverted.
yWorks.yFiles.UI.Drawing.TableRenderingOrder was not excluded from obfuscation.
The IGraph instance returned by GraphSource.Graph was not obfuscated correctly, thus preventing binding to its properties.
The IGraph instance returned by GraphSource.Graph threw an exception when calling SetStyle(IEdge, IEdgeStyle).
Matrix2D.Scale(double,double,MatrixOrder) did not work correctly for MatrixOrder.Append.
PointD and GeneralPath: Hit and equality tests that specify an option epsilon value now include the epsilon into the valid range.

Demos

Demo.yFiles.ImageExport: Insets were not assigned correctly.

yFiles WPF 2.3.0.2 - Changes Since 2.3.0.1

Bugfixes

GraphML data for edges was not read anymore. This has been fixed.

yFiles WPF 2.3.0.1 - Changes Since 2.3

Improvements

The LayoutGraphPanel in the algorithm demos now correctly displays the locations of labels.
The animation for bends has been slightly improved in the case where new bends are added during layout morphing.

Demos

The InteractiveNodesGraphSource demo now shows how to drag a node from the graph to one of the successor/predecessor panels.

Bugfixes

Due to a bug in UIElementExtensions.SetPen, some of the styles that were using pens could trigger an exception when a pen without a dash and later on a dashed pen was assigned.
Fixed DefaultGraph.Remove(IPort) not working correctly in certain cases when there were edge-to-edge connections. This also affected the 'cut' clipboard operation in the same scenarios.
InteractiveOrganicLayouter's SyncStructure was broken and blocking forever causing the interactive organic demo to halt on graph modifications.
AdjacentNodesGraphSource now correctly keeps self-loops if they were defined both through predecessor and successor references in the same node and only one of the items is removed.

Demos

Fixed the 'nesting' graph in Demo.yFiles.Graph.Viewer
Fixed broken usage of IncrementalHierarchicLayouter.LayerValueHolderDpKey in Demo.yFiles.Layout.IncrementalHierarchicLayouter by removing class NodeIntValueHolder and using the layerMapper directly. (Also see the updated Incompatible Changes section for 2.3)
Fixed Demo.yFiles.Layout.InteractiveOrganic freezing when the graph was modified structurally.

yFiles WPF 2.3 - Changes Since 2.2.0.4

Framework Requirements

yFiles WPF now requires the .NET 4.0 framework (Client Profile) or higher at runtime.

Major Features Added

Touch input is now supported by all built-in input modes. New input mode class TapInputMode introduces transparent support for touch gestures in user interactions. This new input mode is part of the default configurations of GraphEditorInputMode and GraphViewerInputMode, respectively.
New support for edge-to-edge connections in user interactions. Edges can be connected to other edges during edge creation as well as by reconnecting edge ends.
[To the corresponding section in the yFiles WPF Developer's Guide...]
A great number of additional status-indicating events has been added to the various default input modes in order to provide fine-grained callbacks to customization code.
The library no longer contains Apache licensed third party code.

Automatic Layout

Class yWorks.yFiles.Layout.Multipage.MultiPageLayouter is a new layout algorithm that breaks apart a given graph into a set of smaller graphs so that each layout of a small graph fits into a given width and height.
The Demo.yFiles.Layout.MultiPage shows how to use class MultiPageLayouter to sub-divide large graphs into smaller bits of navigable information.
[To the corresponding section in the yFiles WPF Developer's Guide...]

Minor Features Added

New classes AdjacentNodesGraphSource and AdjacentEdgesGraphSource provide data binding support for a much larger number of user data models.
DefaultEdgeIntersectionCalculator now supports cropping edges directly at the port instead of at the node's geometry. This can be used to easily have edges end at the port instead of at the geometry of the node. See the new properties CropAtPort, ExtraCropLength, and callback method GetPortGeometry.
GraphSource:
- Added property LazyNodeDefinition which allows the usage of objects as source and target of edges that are not part of NodesSource.
- Added the binding properties LocationXBinding and LocationYBinding for specifying the node location.
- Added the binding property NodeIdBinding for specifying the node id. This allows specifying the source and target node of an edge using the node id.
TreeSource: Added the bindings LocationXBinding and LocationYBinding for specifying the node location.

Automatic Layout and Analysis

The orthogonal layout algorithms OrthogonalLayouter, OrthogonalGroupLayouter, and DirectedOrthogonalLayouter now support specifying a minimum first/last segment length. See the corresponding descriptions of OrthogonalLayouter.EdgeLayoutDescriptorDpKey, OrthogonalGroupLayouter.EdgeLayoutDescriptorDpKey, and DirectedOrthogonalLayouter.EdgeLayoutDescriptorDpKey, respectively.
SimplexNodePlacer: Added an algorithm that reduces the number of bends. This option can be set using property BendReductionEnabled and is enabled by default. Note: using this option increases the runtime of the IncrementalHierarchicLayouter. If the runtime exceeds the maximal duration the number of bends is not reduced.
Added abstract class AbstractPortConstraintOptimizer, a partial implementation of interface IPortConstraintOptimizer, to minimize the effort required to modify the port assignment after the sequencing phase of a hierarchic layout.
TreeLayouter: When using port styles BorderCenter and BorderDistributed together with child placement policies LeavesStacked, LeavesStackedLeft, LeavesStackedRight, and LeavesStackedLeftAndRight edges connect to the appropriate sides of their target nodes instead of to the top. Moreover, the order of outgoing edges no longer results in crossings for port style BorderDistributed.
AbstractLabelingAlgorithm: Added DataProvider key LabelModelDpKey that can be used to temporarily specify the model of labels that is used by the labeling algorithm.
ShortestPaths: Added method ShortestPair.

Improvements

ContextMenuInputMode: Added property CaptureMouseClicks that prevents other input modes from receiving mouse clicks while the context menu is open.
GraphMLIOHandler: Added AddRegistryOutputMapper overload that takes a serialization handler.

Automatic Layout

FamilyTreeLayouter: Improved the algorithm with respect to the number of edge crossings.
PCListOptimizer: Improved the handling of port candidates and enhanced backloop routing support.

Demos

Added new demos Demo.yFiles.DataBinding.InteractiveNodesGraphSource and Demo.yFiles.DataBinding.InteractiveEdgesGraphSource that show data binding with classes AdjacentNodesGraphSource and AdjacentEdgesGraphSource, respectively.
Added new demo Demo.yFiles.Graph.EdgeToEdge that shows how to enable and make use of the new edge-to-edge connection feature.
Added new Demo.yFiles.Layout.Multipage that shows how to use class MultiPageLayouter to sub-divide large graphs into smaller bits of navigable information.

Bugfixes

Automatic Layout

LabelLayoutDataRefinement: Fixed InvalidCastException that could occur due to wrong type of label model parameters.

Incompatible API Changes

yFiles WPF now requires at least the .NET 4.0 framework.
Methods GetTargetPortCandidateProvider and GetSourcePortCandidateProvider in GraphEditorInputMode changed their signatures to accept IPortOwner instances instead of INode instances. This was required to allow for interactive edge-to-edge connections. Overriding methods need to be adjusted accordingly.
Method ShowHitNodeCandidatesOnly in class PortRelocationHandle has been renamed to ShowHitPortOwnerCandidatesOnly to support edge-to-edge connections. Also the behavior of this class has been changed to allow edge-to-edge connections if this feature has been enabled by providing port candidates at the edges. Should you wish to disallow edge-to-edge connection even though you are providing edge port candidates, the new EdgeToEdgeConnectionsAllowed property can be set to false.
Previously it was possible to cast DefaultEdgeIntersectionCalculator.Instance to the containing type. The singleton is not of the given type anymore. If you require an instance of that type, consider instantiating one instead.
Since with this release LayoutGraphAdapter translates IMapper instances in the graph's mapper registry as IDataMap implementations that enable data write-back scenarios, the code that deals with IncrementalHierarchicLayouter.LayerValueHolderDpKey now behaves differently. In older releases the IIntValueHolder interface was queried from the mapper to write back the layer data. Now the data is written directly into the mapper and the IIntValueHolder implementation is ignored.

yFiles WPF 2.2.0.4 - Changes Since 2.2.0.3

Bugfixes

Fixed licensing error that occurred on FIPS enabled systems.
Setting GraphOverviewControl.GraphPaintable had no effect.
Deleting graph elements during interactive edge creation could throw an exception.
Group node visualizations were not always removed correctly when the group node was deleted.
DefaultSelectionModel was not always cleaned up correctly when the domain was changed.
SliderEdgeLabelModel threw an exception for paths with zero length segments.
FilteredGraphWrapper: The adjacency state of the filtered instance was wrong under certain conditions.
FreeEdgeLabelModel: Fixed bad positions returned by parameter finder.
Convenience class LabelDecorator was unusable because of a wrong type parameter.

yFiles WPF 2.2.0.3 - Changes Since 2.2.0.2

Bugfixes

LayoutGraphAdapter did not honor mapper in the registry registered under the LayoutGraphAdapter.EdgeLabelLayoutPreferredPlacementDpKey key.
BendAnchoredPortLocationModel could throw an IndexOutOfRangeException under certain circumstances.
AbstractTableNodeStyle did not provide the table to the background style.
Sharing objects in GraphML did not work in some cases when these objects were written through a markup extension.
CreateEdgeInputMode did not highlight the closest target port candidate during the edge creation gesture.
DropInputMode#AdjustEffects: Setting a custom ValidHitTestable had no effect.
DropInputMode: The mode did not exit cleany under some rare circumstances.
Fixed an issue with custom license files that were valid for a specific version, only
Fixed IconLabelStyle constructor not assigning icon size.
TableEditorInputMode#EditLabel did not work.
Child modes of a MultiplexingInputMode were not always disabled together with the parent mode.

Automatic Layout and Analysis

yWorks.yFiles.Algorithms.Groups: Fixed possible NRE when calculating BCC for a graph containing self-loops in method BiconnectedComponentGrouping(Graph, INodeMap).
yWorks.yFiles.Algorithms.ShortestPaths: Fixed an error in method FindShortestUniformPaths(Graph,INodeMap,IDataProvider,bool,int,EdgeList,NodeList). In many cases, nodes and edges which did not belong to a shortest path were added to the result nevertheless.
yWorks.yFiles.Algorithms.GraphConnectivity: Fixed methods that calculate biconnected components to mark selfloops as not belonging to any biconnected component.
yWorks.yFiles.Algorithms.Cycles: Method FindAllCycleEdges(Graph, bool) has been improved to return only edges that belong to at least one simple cycle. Previously, all edges were returned for the undirected case.

Improvements

Improved license handling for cases where the .NET license manager mechanism is not fully functional.

yFiles WPF 2.2.0.2 - Changes Since 2.2.0.1

Bugfixes

ControlStyleBase.StyleTag was not excluded from obfuscation.
Some table related classes were not excluded from obfuscation.
Fixed exception in LayoutExecutor when animation and grouping were both disabled.
Fixed potential memory leaks in TableLayoutConfigurator when exceptions occurred.
yWorks.yFiles.Algorithms.Groups.EdgeBetweennessClustering: The parameters minGroupCount and maxGroupCount had no effect.

Automatic Layout

LayoutExecutor did not provide the GraphControl's selection to the layout engine.
Fixed NullReferenceException in PartitionGridLayoutStage if no partition cells were assigned to any nodes.
Fixed Exception that was triggered when using a generic labeling algorithm (i.e. a subclass of yWorks.yFiles.Layout.Labeling.AbstractLabelingAlgorithm) together with layout stage yWorks.yFiles.Layout.LabelLayoutDataRefinement.

yFiles WPF 2.2.0.1 - Changes Since 2.2

Bugfixes

TableExtensions.RemoveWithResize always resized the last sibling instead of the neighbor.
The LabelDefaults.AutoAdjustPreferredSize was ignored for stripe labels.
TableEditorInputMode.TextEditorInputMode was used even when the TableEditorInputMode had been installed as child mode of GraphEditorInputMode.
TableEditorInputMode.DeleteSelection: Items were not always deleted in bottom to top order, leading to unpredictable resize results.
TableLayoutConfigurator used wrong bottom insets for the last column.
TableLayoutConfigurator did not correctly restore the mapper for partition cells that had been set explicitly.
DefaultStripeInputVisualizationHelper was not excluded from obfuscation.
Broken AbstractTableNodeStyle implementation resulted in defunct visuals if used in multiple CanvasControls and after export operations.
NodeDropInputMode did not transfer focus to the graph control after a node had been dropped.
The Tag of IStripes in the default table implementation was not serialized and deserialized from and to GraphML. To get back that old behavior, set the new SerializationProperties.DisableStripeUserTags property to true.
The GraphClipboard did not always copy all state of items that were invisible in a folded graph view.
Dropping columns and rows into a table accidentally resized the parent stripe to values that are too small for the contents.
For some configurations, TableLayoutConfigurator could not properly deal with non-empty group nodes inside table nodes.
Fixed a bug that caused the GraphCommands.CollapseGroupCommand and GraphCommands.ToggleGroupStateCommand to fail in case of certain multi-node selections.

Automatic Layout

EdgeGroupRouterStage: Edges that had both source and target group IDs were not grouped at all.

yFiles WPF 2.2 - Changes Since 2.1.1

Major Features Added

New Comprehensive Support for Swimlane Diagrams

New model class yWorks.yFiles.UI.Model.Table provides extensive support for tabular presentation of subgraphs which is well suited for the visual presentation of swimlane layouts.
Flexible visualization for table elements by means of existing node styles is provided by implementations of the yWorks.yFiles.UI.Drawing.ITableNodeStyle interface.
[To the corresponding section in the yFiles WPF Developer's Guide...]
New dedicated InputMode yWorks.yFiles.UI.Input.TableEditorInputMode which can be used either standalone or as a child mode of yWorks.yFiles.UI.Input.GraphEditorInputMode and which provides support for user interaction specific to the tabular data representation of an associated node.
[To the corresponding section in the yFiles WPF Developer's Guide...]
New support class TableLayoutConfigurator can automatically create a suitable partition grid setup from existing table structures in a graph. Also, LayoutExecutor has been enhanced to optionally configure table specific layout features. [To the corresponding section in the yFiles WPF Developer's Guide...]
The Demo.yFiles.Graph.TableEditor demo demonstrates the capabilities of table visualization editing, as well as automatic layout of swimlane diagrams.

Visual enhancements

Added new edge label models RotatedSliderEdgeLabelModel and RotatedSideSliderEdgeLabelModel which allow placement of rotated labels on a continuous set of positions along both sides of an edge or directly on the edge path.

Automatic Layout

New support for rotated labels (e.g. using the new RotatedSliderEdgeLabelModel or RotatedSideSliderEdgeLabelModel) in the yFiles generic labeling algorithms.
PartialLayouter: A new layout algorithm for partial layouts. This layout algorithm changes the coordinates for a given set of graph elements (called partial elements). The location or size of the remaining elements (called fixed elements) is not allowed to change. The layout algorithm aims to place the partial elements such that the resulting drawing (including the fixed elements) has a good quality with respect to common graph drawing aesthetics.
PartialLayoutModule represents an interactive configurator and launcher for this layout algorithm.
BusRouter: A new orthogonal bus-style edge routing algorithm. This algorithm combines the large number of edges of complete subgraphs in a concise, tree-like structure that consists only of vertical and horizontal line segments. The positions of the nodes in a graph are not altered by this algorithm.
BusRouterModule represents an interactive configurator and launcher for this layout algorithm.
OrthogonalEdgeRouter: Added support for monotonic path restrictions. Such restrictions specify that edges should be routed monotonically in vertical and/or horizontal direction. The restrictions can be set using the MonotonicPathRestriction property.
IncrementalHierarchicLayouter: Added data provider key CriticalEdgeDpKey that allows to specify a priority value for edges that are part of critical paths. The layouter tries to vertically align each node pair that is connected by such a "critical" edge (an edge that has a non-zero, positive priority value). Conflicts between different critical edges are resolved in favor of the higher priority.
SimplexNodePlacer: Added option StraightenEdges which allows to specify whether or not a postprocessing step should be applied that tries to remove some bends. Enabling this option may violate some minimum distances specified by the user.
OrthogonalEdgeRouter: Added support for PortCandidateSets that allow to specify the available port candidates at a node.

Minor Features Added

CanvasControl now offers a method that yields the Visual for a given ICanvasObject. This can be leveraged by UI testing tools.
New class NodeStylePortStyleAdapter can be used to reuse existing INodeStyle implementations for port visualization.

Automatic Layout

New layout stage class PartitionGridRouterStage enables OrthogonalEdgeRouter to properly route edges within a partition grid.
RecursiveGroupLayouter: Added data provider key GroupNodeLayouterDpKey that allows an easier way to specify the layout algorithm used for recursive group nodes. Furthermore, it allows to specify non-recursive group nodes, i.e., group nodes whose contents are laid out using the ILayouter instance specified by the nearest predecessor of the group node (with respect to the grouping hierarchy) which is associated with an ILayouter.
TreeLayouter: Added new support for child placement policies that can be used to achieve more compact tree layouts. See ChildPlacementPolicy.
TreeLayouter: Added new global layering option that ensures that large nodes never span more than their layer. See EnforceGlobalLayering.
OrthogonalEdgeRouter: Added support for considering node labels, see ConsiderNodeLabels.
CircularLayouter: Added data provider key CircleIdHolderDpKey that allows to obtain a mapping between nodes and the corresponding circle IDs.
OrthogonalEdgeRouter: Added new routing style RoutingStyle.Balanced which is based on the existing RoutingStyle.Prefermiddle but draws segments between bends of the same direction (U-style turns) the short way.

Improvements

DropInputMode has been improved to capture the start of a drag enter gesture in cases where the drop target that is hit first would also accept the drag enter event.
All built in node styles have been modified to allow the CanvasControl to accept drop enter events even if they are hit first.
License failures in the algorithms assembly are reported more prominently when used through LayoutExecutor and related convenience methods.
WaitInputMode is automatically enabled while file I/O commands are executed.
GraphEditorInputMode.DeleteSelection now doesn't create an empty Undo edit if nothing would be deleted at all.
CreateEdgeInputMode: UpdateEdgeStyle is now called after the source port candidate has been determined.
Mouse2DEventTypes now also includes the case where mouse capture is lost. All existing input modes have been improved to take advantage of this event, where appropriate.

Automatic Layout

LayoutExtensions: Added and improved convenience methods that deal with sequence and layer constraints.
IncrementalHierarchicLayouter: Enhanced support for fixed nodes.
GroupNodeHider: Several layout algorithms (all tree layouters, circular, all orthogonal layouters, random, the fixed group layout stage) assigned relatively small dimensions to empty group nodes. Some of them also moved these nodes to (0,0). None of these layout algorithms treats groups directly, instead they use the group node hider. The group node hider now optionally does not hide empty groups (HidingEmptyGroupNodes) enabling that these can be treated like normal nodes. This option is now used where appropriate. Note that some layout algorithms may still shrink empty group nodes depending on the particular choice of parameters, e.g., orthogonal layout with uniform node sizes.
OrientationLayouter: Node insets as well as port constraints are now also translated correctly for each possible orientation.

Demos

Added new Demo.yFiles.Layout.MixedLayout demo that shows how to recursively apply different layout algorithms to the contents of group nodes.
Added new Demo.yFiles.Layout.PartialLayout demo that presents specific setup of the new partial layout support in conjunction with Circular, Hierarchic, Organic, and Orthogonal Layout.
The new Demo.yFiles.Layout.LayerConstraints demo shows how to use layer constraints with the IncrementalHierarchicLayouter to restrict the node layering.
The new Demo.yFiles.Layout.SequenceConstraints demo shows how to use sequence constraints with the IncrementalHierarchicLayouter to restrict the node sequencing.
The new Demo.yFiles.Layout.PortCandidate demo shows how PortCandidateSets can be used with IncrementalHierarchicLayouter to control from what side edges connect to certain node types in the automatic layout process.
It also show-cases a custom node style that displays simple flowchart symbols and integrated port candidate visualization.
Added new Demo.yFiles.Layout.LogicGate demo that shows how to apply fixed PortConstraints to a layout and how to use PortCandidates for interactive edge creation (via IPortCandidateProvider).
It also show-cases a custom node style that displays logic gate symbols.
Added new Demo.yFiles.Layout.GenericTree demo that shows the effects of different NodePlacer implementations on a node and its subtree(s) in a tree layout calculated by GenericTreeLayouter.
The new Demo.yFiles.Layout.EdgeLabelingDemo shows how to configure different edge label models as well as how to apply the generic edge labeling algorithm.
The new Demo.yFiles.Layout.NodeLabelingDemo shows how to use the node label models in conjunction with the yFiles generic labeling algorithms.
Added new Demo.yFiles.Graph.BusinessProcessDiagram demo that presents bow to create, edit, and lay out business process diagrams that adhere to the Business Process Modeling Notation.
The new Demo.yFiles.Layout.BusRouterDemo shows how to use the orthogonal bus-style edge router.

Bugfixes

Resizing nodes interactively did not make use of additional snap lines from the GraphSnapContext.
The expand and collapse group node commands did not execute in case the UseCurrentItemForCommand property was being used.
NavigationInputMode.ExitGroup raised the GroupEntered event instead of the GroupExited event.
CreateEdgeInputMode started calculation of the target port candidates too early and did not remove the highlighting of the target node if the creation was canceled early during the gesture.
A race condition in the license verification mechanism could lead to license failures in multi-threaded environments.
When no license information has been embedded during compile time, the license was searched in the filesystem during runtime, instead of resulting in a license failure.
The default implementation of ICanvasObjectGroup returned a broken enumerator for the IListEnumerable interface.
A memory leak in CreateEdgeInputMode made cleaning up a GraphControl impossible after an edge had been created interactively using that mode with snapping disabled.
CreateEdgeInputMode's GetSourcePortCandidate method was sometimes invoked with the wrong location.
MouseHoverInputMode now reacts during mouse drags, too and method Show respects parameter if it differs from the mouse location.
Mouse events were being redispatched, even if the mouse was outside the GraphControl. This resulted in tooltips being displayed and other potential issues when the overview was used to move the viewport.
ClickInputMode.ValidHitTestable was not always queried in certain double click configurations.
Minimum node size was not automatically provided to the algorithms library by LayoutGraphAdapter.

Automatic Layout

InteractiveOrganicLayouter: Fixed bug that prevented the calculation of any layout before the first call to WakeUp.
ComponentLayouter: Fixed bug that caused a wrong component assignment if customized component IDs were used.
IncrementalHierarchicLayouter: Fixed bug that sometimes caused an assignment of infinite coordinates to group nodes as well as to points of edges incident to group nodes.
IncrementalHierarchicLayouter: Fixed bug that caused unnecessary crossings when using node grouping.
Overriding yWorks.yFiles.Layout.Tree.DelegatingNodePlacer#GetLowerRightChildren and GetUpperLeftChildren had no effect.
Fixed potential IndexOutOfRangeException in yWorks.yFiles.Layout.RotatedSliderEdgeLabelLayoutModel.
Fixed invalid cast in yWorks.yFiles.Layout.Router.EdgeGroupRouterStage.
Fixed NullReferenceException when using yWorks.yFiles.Orthogonal.OrthogonalLayouter in FromSketchMode.
DrawingEmbedder: Fixed NullReferenceException caused by nodes having the same center.
NetworkFlows: Fixed wrong calculation of the cut set returned by method CalcMaxFlowMinCut(Graph, Node, Node, IDataProvider, IEdgeMap, INodeMap).
EdgeGroupRouterStage: Fixed bug that caused violation of edge grouping constraints as well as port constraints.
Fixed potential race condition when trying to access the edge path during layout calculation.

Incompatible Changes

When LayoutExecutor.Duration is 0, the viewport is now only moved when AnimateViewport is true.
yWorks.yFiles.Algorithms.Util.DoubleObjectPQ: Changed the type of parameter priority from int to double for methods DecreasePriority, IncreasePriority and ChangePriority.
OrientationLayouter: Changed behavior for mirrored orientations, i.e., there may be a fixed position offset between the layout results of the old and new version. The new version ensures that the position of elements not changed by the layout algorithm are kept fixed.
Mouse2DEventTypes has a new enumeration member 'LostCapture'. If cascades and switches over variables of this type might need to be adjusted to properly deal with this event type.
LayoutGraphAdapter can optionally create copies of node and edge styles during layout calculation. This is controlled by the new property CopyStyles. Utility class LayoutExecutor enables this feature if the layout is performed in a different thread.
The Cut command on GraphControl is now only enabled if DeletableItems allows the deletion of the currently selected nodes.

yFiles WPF 2.1.1 - Changes Since 2.1

Minor Features Added

Added support for different double-click handling modes in ClickInputMode as well as GraphEditorInputMode and GraphViewerInputMode.

Improvements

LayoutModules in the demo have been improved to show the new layout features.
yWorks.yFiles.UI.Model.FoldedGraph: IsExpanded(INode) raises correct exception if node is not part of the graph.
Rules for DesignerSerializationVisibility handling in GraphML are consistent now.
yWorks.yFiles.GraphML.Parser.GraphMLParser: XMLExceptions wrapped in IOExceptions.
yWorks.yFiles.GraphML.Xaml.XamlSerializer now supports ShouldSerialize* predicates.
The GraphML XAML parser and writer both support generic type arguments as specified in the XAML 2009 specification.
Made SimpleLabelStyle aware of RightToLeft flow direction of the GraphControl. The renderer now automatically mirrors the text contents to compensate the transform that has already been applied to the GraphControl.
NavigationInputMode and CanvasControl have been improved to be aware of the FlowDirection property of the CanvasControl so that in case of a RightToLeft setting the commands behave correctly.
GraphML now supports (de)serialization of generic dictionaries like System.Collections.IDictionary<K,V>
Added yWorks.yFiles.Layout.Hierarchic.Incremental.PartitionGrid#CreateCellSpanId overload that accepts System.Collections.IEnumerable<V>

Bugfixes

GraphML: Fixed broken serialization of primitives and string values in element syntax.
GraphML: Public properties with a non-public getter or setter are ignored now.
yWorks.yFiles.GraphML.Xaml.XamlReader: XML attributes that are bound to an XML namespace are ignored if they do not specify an attached property.
Fixed crash in yWorks.yFiles.Layout.Hierarchic.IncrementalHierarchicLayouter when a node has more than 60 selfloops.
Fixed crash when removing IEdge that has same source and target port.
PanelNodeStyle can now deal with empty layout.
Setting yWorks.Canvas.Input.ContextMenuInputMode#Menu did not always clean up the old menu correctly.
Some layouter implementations did not properly catch internal (non-fatal) NullReferenceExceptions.
NavigationInputMode did not correctly update the location of group nodes during expand and collapse and did not enqueue the correct undo units.
Orthogonal edge segments were sometimes broken into halves during interactive resizes of the adjacent nodes. Now the corresponding bend is moved instead.

Folding bugfixes

A great number of bugs have been fixed in the folding environment. All of them could only be triggered programmatically.

Fixed programmatic edge creation.
yWorks.yFiles.UI.Model.GroupedGraphExtensions.CreateGroupNode(INode parent): Fixed extension method ignoring parent.
Fixed yWorks.yFiles.UI.Model.HierarchyExtensions.GetNearestCommonAncestor() not returning correct ancestor in some cases.
SetLeaf() and set LocalRoot not included in Undo queue.
yWorks.yFiles.UI.Model.GroupedGraphExtensions.GroupNodes(IEnumerable<INode>) called with empty enumerable calls CreateGroupNode() instead of creating group node with empty layout.
Various bugs that occurred in rare cases due to corrupted internal data structures have been fixed.

Changes in Default Behavior

GraphML: Handling of DesignerSerializationVisibility for collection properties is now consistent with WPF and Silverlight XAML rules:
- If the property is specified as a content property with ContentPropertyAttribute:
  - If DesignerSerializationVisibility is not specified or DesignerSerializationVisibility.Content is specified, only the content is (de)serialized.
  - If DesignerSerializationVisibility.Hidden is specified, the property is ignored.
  - If DesignerSerializationVisibility.Visible is specified and the property is read-write, the collection object itself is (de)serialized, otherwise the property is ignored.
- If the property is not specified as a content property with ContentPropertyAttribute:
  - If DesignerSerializationVisibility.Content is specified for either read-write or read-only collection properties, only the content is (de)serialized.
  - If DesignerSerializationVisibility.Hidden is specified, the property is ignored.
  - If DesignerSerializationVisibility is either not specified or set to DesignerSerializationVisibility.Visible for read-write collection properties, the collection object is (de)serialized.
  - If DesignerSerializationVisibility is either not specified or set to DesignerSerializationVisibility.Visible for read-only collection properties, the property is ignored.
The WPF framework XAML writer is now used for classes in the System.Windows.* namespaces only.
The WPF framework XAML reader is now also used for classes in the System.Windows.* namespaces.

yFiles WPF 2.1 - Changes Since 2.0.1

Major Features Added

Framework requirements

yFiles WPF now officially supports the .NET 4.0 framework. The minimum required framework is .NET 3.5 SP1. Note that there are separate demo applications available for new features that exist only in .NET 4.0 like VisualStateManager.

Support for creating and working with orthogonal edge paths

Class yWorks.yFiles.UI.Input.OrthogonalEdgeEditingContext now mediates between the various implementations that deal with repositioning nodes, bends, and ports to ensure that orthogonal edge paths stay orthogonal during the edit process.
Interface yWorks.yFiles.UI.Input.IOrthogonalEdgeHelper determines how edges should be treated during editing with respect to orthogonality.
The various IInputMode implementations support editing orthogonal edge paths, as well as allow for creating an orthogonal edge path in the first place.

Interactive snapping of graph elements to guide lines and other elements during editing

Class yWorks.yFiles.UI.Input.GraphSnapContext supports snapping elements to lines while they are being moved or resized interactively. This allows for conveniently editing diagrams by hand and still obtain great results with fixed distances and angles between elements in the diagram.
Interfaces yWorks.yFiles.UI.Input.ISnapLineProvider and others can be used to influence the behavior, the types, and the display of the snap lines.
Support for intelligent magnetic grid has been integrated with the new snapping API.

GraphML changes

The GraphML API makes use of the LINQ to XML API for XML processing and thus is easier to use and performs better than the old implementation.

Built-in support for dragging nodes from other controls to the GraphControl

Class yWorks.yFiles.UI.Input.NodeDropInputMode has been added to provide convenient drag and drop support on top of the existing DropInputMode implementation.
The specialized input mode can be configured to provide a live preview of the node that will be dropped.
Dropping can be performed directly onto group nodes, making the dropped node a new child of the group.
The new snapping features are also leveraged by this new implementation.

New Generic Style Implementations Based on ContentControls

New styles have been implemented that make styling nodes, labels, ports, and edge segments even easier.
For each of the new styles a specialized ContentControl has been implemented that provides a number of properties that can be bound to in control templates.
By default the content of the control is populated with the tag that is associated with the respective item. This makes displaying business model data that is associated with an element easy.
Creating a new style is done by implementing a WPF Style (preferably using a XAML designer) that defines the control template and animations as well as the different visual states of the item (selection, highlight, focus) and the transitions between them.
A separate demo shows how to leverage these style implementations to support the VisualStateManager that is available in .net 4.0.

Animation improvements

Class Animator has been refactored to not use a separate thread for the animation anymore, but now uses the CompositionTarget.Rendering event to achieve even smoother animations.
The animation priority can be fine-tuned to control whether the focus should be more on smooth animations or a responsive application.
The GraphOverviewControl has been revised to be less CPU-extensive while at the same time providing real-time viewport updates. This results in a much smoother overall animation experience.

Style improvements

All of the predefined styles available in the core of the library have been optimized for animation and fewer repaints, greatly improving the rendering speed in interactive scenarios.
The 'modern' styles now all provide built-in high performance drop shadow implementations and the generic implementation makes use of the GPU accelerated effects that are available since .net framework version 3.5 service pack 1.

Visual Enhancements

All visual adorners for items in the GraphControl like the marquee selection box, the handles, the highlight and selection indicators, can now easily be customized and replaced by custom XAML templates.
- MarqueeSelectionInputMode.MarqueeRectangleTemplateKey defines the template used for the selection marquee box.
- OverviewInputMode.ViewportTemplateKey defines the template used for highlighting the currently visible part of the graph in the GraphOverviewControl.
- RectangularSelectionPaintable.TemplateKey defines the template used for selection.
- RectangularFocusPaintable.TemplateKey defines the template used for focus.
- RectangularHighlightPaintable.TemplateKey defines the template used for highlight.
- OrientedRectangleSelectionPaintable.TemplateKey, OrientedRectangleFocusPaintable.TemplateKey, OrientedRectangleHighlightPaintable.TemplateKey define the templates used for labels.

Automatic Layout

Layout algorithm class yWorks.yFiles.Layout.Hierarchic.IncrementalHierarchicLayouter provides enhanced support for swimlane layout through comprehensive new partition grid concept.
The yWorks.yFiles.Layout.Hierarchic.Incremental.PartitionGrid class enables the definition of grid-like structures (partitions) consisting of rows and columns, and assignment of nodes of a diagram to the grid (partition) cells.

Minor Features Added

The assemblies have been revised an annotated to correctly work with the new .NET 4.0 security transparency model.
Many more improvements great and small for both the layout algorithms and the UI part.
yWorks.yFiles.UI.Input.IPortCandiate and default implementations have been updated to allow for dynamically determined port candidates. This enables assignment of non-discrete port locations during edge creation and edge relocation.
More fine-grained events and callbacks have been added to the various input mode implementations making customization easier, because subclassing is now less frequently required for customizations.
Redundant folding view state data in GraphML is now omitted by default, thus greatly reducing the size of GraphML files when folding is active.
Printing, image export and XPS export have been updated to take into account the FlowDirection of the exporting CanvasControl. The value of the FlowDirection property now influences the resulting print, image or XPS file contents.

Automatic Layout

Layout algorithm class yWorks.yFiles.Layout.Hierarchic.IncrementalHierarchicLayouter now features consistent support for layering constraints both for non-incremental as well as incremental layout mode.
Also, specifying layering constraints is now conveniently supported directly by the layout algorithm class through method CreateLayerConstraintFactory.
yWorks.yFiles.Layout.Hierarchic.IncrementalHierarchicLayouter: Added support for specifying a preferred time limit (in milliseconds) for the layout (see property MaximalDuration).
yWorks.yFiles.Layout.Hierarchic.IncrementalHierarchicLayouter: Added support for automatic edge grouping (see property AutomaticEdgeGrouping).
yWorks.yFiles.Layout.Orthogonal.OrthogonalLayouter, yWorks.yFiles.Layout.Orthogonal.OrthogonalGroupLayouter, yWorks.yFiles.Layout.Orthogonal.DirectedOrthogonalLayouter: Added support for considering node labels.
yWorks.yFiles.Layout.Orthogonal.OrthogonalGroupLayouter: Added integrated edge labeling support.
yWorks.yFiles.Layout.Orthogonal.OrthogonalLayouter and yWorks.yFiles.Layout.Orthogonal.DirectedOrthogonalLayouter: Added convenience property for integrated edge labeling: IntegratedEdgeLabeling.
yWorks.yFiles.Layout.Orthogonal.OrthogonalGroupLayouter: The layouter now also considers minimum sizes for group nodes as given by the DataProvider yWorks.yFiles.Layout.Grouping.GroupingKeys.MinimumNodeSizeDpKey.
yWorks.yFiles.Layout.Circular.CircularLayouter: More compact layouts can be obtained by setting PlaceChildrenOnCommonRadius to false.
yWorks.yFiles.Layout.Circular.CircularLayouter: Node labels can be considered by setting ConsiderNodeLabels to true.
yWorks.yFiles.Layout.Organic.SmartOrganicLayouter: Node labels can be considered by setting ConsiderNodeLabels to true.

Graph Analysis Algorithms

yWorks.yFiles.Algorithms.Paths: added methods FindAllPaths(Graph, Node, Node, Boolean), FindAllPaths(Graph, Node, Node, Boolean, Predicate<EdgeList>), and FindAllPathsCursor. These methods can be used to enumerate all directed or undirected paths that connect two nodes.

Improvements

GraphEditorInputMode, GraphViewerInputMode, NavigationInputMode: Added UseCurrentItemForCommands property.
yWorks.yFiles.UI.Model.GraphExtensions: Added another extension method for creating labels with tag.
yWorks.yFiles.UI.Model.FoldedGraph: IsExpanded(INode) raises correct exception if node is not part of the graph.
yWorks.Canvas.Geometry.Structs.PointD: added GetRounded().
yWorks.yFiles.Layout.Orthogonal.OrthogonalLayouter: for layout style yWorks.yFiles.Layout.Orthogonal.LayoutStyle.NormalTree, the grid size now also controls the distances between tree nodes.
yWorks.yFiles.Layout.Orthogonal.OrthogonalLayouter, yWorks.yFiles.Layout.Orthogonal.DirectedOrthogonalLayouter: improved integrated edge labeling.
yWorks.yFiles.Layout.ComponentLayouter: Improved handling of user-defined components (components defined via the GivenComponentDpKey data provider key) when there are edges between the components.
yWorks.yFiles.Layout.Tree.GenericTreeLayouter: Improved layout runtime of graphs having subtrees with a large number of nodes.
All implementations of interface yWorks.yFiles.Layout.Hierarchic.Layerer have been adjusted to implement yWorks.yFiles.Layout.Hierarchic.Incremental.Layerer as well, thereby removing the need to wrap these classes in yWorks.yFiles.Layout.Hierarchic.Incremental.OldLayererWrapper for use with yWorks.yFiles.Layout.Hierarchic.IncrementalHierarchicLayouter.
yWorks.yFiles.Layout.Organic.SmartOrganicLayouter: Minimal node distance is now also used for inter component spacing.
yWorks.yFiles.Layout.Organic.SmartOrganicLayouter: Node subsets can now be used together with output restrictions or GroupNodeModeFixBounds mode.
yWorks.yFiles.Layout.Hierarchic.IncrementalHierarchicLayouter: added convenience properties OrthogonalRouting and BackloopRouting.
yWorks.yFiles.GraphML.Parser.GraphMLParser: XMLExceptions wrapped in IOExceptions.
Relative resource paths in GraphML are now resolved and written relative to yWorks.yFiles.GraphML.Writer.SerializationProperties#BaseUri where possible. Also, yWorks.yFiles.UI.GraphControl#ImportFromGraphML(string) and yWorks.yFiles.UI.GraphControl#ExportToGraphML(string) preserve the document location.
yWorks.yFiles.GraphML.Xaml.XamlReader now supports the System.ComponentModel.ISupportInitialize interface and attached properties.
yWorks.yFiles.GraphML.Xaml.XamlSerializer now supports ShouldSerialize* predicates.
The GraphML XAML parser and writer both support generic type arguments as specified in the XAML 2009 specification.

Tutorials

A new tutorial that shows how to implement custom styles for nodes, edges, ports, and labels has been added.
The Getting Started tutorial has been improved to show the new snapping and orthogonal edge editing features.
The existing tutorial has been revised to comply with the new API and new paradigms.

Demos Added

A demo demonstrating shortest path calculation has been added.
Demos that show customization of the clipboard and undoability have been rewritten and improved.
The collapse demo that shows how tree-like graph structures can be explored interactively has been improved to use nicer styles and more layout algorithms.
A demo that shows how the snapping feature can be customized has been added.
A demo has been implemented that shows how to configure edges for orthogonal editing.
The interactive drag and drop feature for nodes showing a preview and snapping is demonstrated in a new demo.
A demo that shows how to print the canvas contents has been added.
IncrementalHierarchicLayouter demo has been rewritten.
The OptionHandler framework for querying and presenting options and settings to the user that has been part of the core library in yFiles WPF 2.0 is now part of the demos in source code form.
GraphEditor demo has been completely rewritten.
GraphML demo has been improved.
A demo showing how to use ControlStyles has been added. Also there is a similar demo showing how to use ControlStyles with VisualStateManager.
All demos have been revised to comply with the new API and new paradigms.

Bugfixes

yWorks.yFiles.UI.LabelModels.RotatingEdgeLabelModel did not work for zero path lengths that have bends.
Fixed bend movement along with nested group nodes.
yWorks.Canvas.Geometry.OrientedRectangle: Fixed Angle getter.
yWorks.yFiles.UI.DataBinding.GraphSource: Fixed a bug that prevented an edge that had previously been removed from the model could ever be part of the model again at a later point in time.
yWorks.yFiles.GraphML.Xaml.XamlReader:
- In some cases, collection content wasn't handled correctly for writeable properties.
- XML comments were not skipped when reading collection content.
- Fixed bug with interface typed properties.
- Primitives in a collection context were not always serialized correctly.
Public properties with a non-public accessor are now correctly handled by the GraphML XAML framework.
yWorks.yFiles.GraphML.Parser.GraphMLParser#Parse will not overwrite an explicitely set yWorks.yFiles.GraphML.Writer.SerializationProperties#BaseUri.
yWorks.Canvas.Input.OverviewInputMode: Fixed a possible NullReferenceException that could happen if the control had not yet been bound to a master canvas control.
Undo/Redo did not always work properly when group node contents were moved, resized, or moved to different group nodes.
yWorks.yFiles.Layout.OrientationLayouter: Fixed wrong handling of mirror mask (see MirrorMask).
yWorks.yFiles.Layout.Hierarchic.Incremental.SimplexNodePlacer: using fixed coordinates would sometimes not result in a tight drawing.
Fixed layering problem in yWorks.yFiles.Layout.Hierarchic.Incremental.ConstraintIncrementalLayerer when all nodes are marked as incremental.
Fixed memory leak in yWorks.yFiles.Layout.Hierarchic.Incremental.DefaultLayerSequencer
yWorks.yFiles.Layout.Hierarchic.AsIsLayerer: Halo and other custom size specifications were ignored for the first node.
yWorks.yFiles.Layout.Router.EdgeGroupRouterStage did not work correctly whith "null" PortCandidates.
yWorks.yFiles.Layout.Hierarchic.incrementalHierarchicLayouter: Simple uses of sequence constraints could result in lots and lots of unnecessary edge crossings
yWorks.yFiles.Layout.Hierarchic.IncrementalHierarchicLayouter: In some cases edge points could have infinite coordinates.
yWorks.yFiles.Layout.ComponentLayouter did not always work correctly if GivenComponentDpKey is set.
yWorks.yFiles.Layout.Router.OrthogonalEdgeRouter: Fixed bug where in some cases strong port constraints were not taken into account for self-loops when local crossing minimization was enabled.
yWorks.yFiles.Layout.Hierarchic.IncrementalHierarchicLayouter: Fixed insets of group node being treated incorrectly if non-orthogonal edge routes were used.
yWorks.yFiles.Layout.Hierarchic.IncrementalHierarchicLayouter: Fixed rare exception about groups being "inconsistent".
yWorks.yFiles.Layout.Router.OrganicEdgeRouter: Fixed bug where OrganicEdgeRouter created some extreme edge routes for larger minimal distances (see MinimalDistance ). Critical edges will now be routed straightline.
All overloads of yWorks.Canvas.Geometry.Matrix2D#Transform now behave consistently.
Not all image resources could be shared in GraphML.
yWorks.yFiles.UI.PortLocationModels.BendAnchoredPortLocationModel was not always serialized correctly.

Changes in Default Behavior

yFiles WPF 2.1 uses a new licensing mechanism based on the .NET LicenseManager framework. Please see the yFiles WPF Readme for further information.
yWorks.yFiles.Layout.Tree.BalloonLayouter has a new default policy for placing the children of local roots. The old policy yWorks.yFiles.Layout.Tree.ChildOrderingPolicy.Symmetric can be set with property ChildOrderingPolicy.
yWorks.yFiles.Layout.ComponentLayouter now considers labels by default (see property ConsiderLabels). This prevents overlaps of labels associated with different graph components.
The GraphML framework now uses yWorks.yFiles.GraphML.Xaml.XamlReader and yWorks.yFiles.GraphML.Xaml.XamlSerializer to read and write XAML for most types. The WPF framework implementations are still used for native WPF types.
yWorks.yFiles.GraphML.Xaml.XamlReader does not support the deprecated System.Windows.Markup.IAddChild interface anymore.
yWorks.yFiles.GraphML.Xaml.XamlReader now throws a DeserializationNotSupportedException if a property does not exist on the current object.
GraphML image resources that are specified as XML attributes are read as System.Windows.Media.Imaging.BitmapImage.
GraphML resource paths are now resolved and written relative to the location of the GraphML document where possible.
Structural errors in GraphML files now always throw an IOException instead of being ignored silently.
Redundant view state data in GraphML is now omitted by default, which is incompatible with yFiles WPF 2.0 and earlier. Set yWorks.yFiles.GraphML.Writer.SerializationProperties#FoldingVersion to 1.0 to use the old behavior.
CanvasPrintDocument, XPSExporter, and PixelImageExporter now honor the FlowDirection property of the CanvasControl that is used for the export operation and mirror the output correspondingly. Should this not be intendend, create a separate Control instance and set the FlowDirection to LeftToRight (which is the default).

Incompatible API Changes

yFiles WPF now requires at least the .NET 3.5 SP1 framework.
The default behavior of the IGraph implementations has changed so that styles and models are now shared implicitly by reference between elements. This can easily be reverted to the old behavior by setting the corresponding property in the INodeDefaults, IEdgeDefaults, IPortDefaults, and ILabelDefaults instances.
The implementation of the ICloneable of the default styles in the library has been changed to consistently be a shallow clone for all properties. This allows for fine-grained control over which objects can be shared between instances. If you change a property and don't want to affect shared instances, clone the value first and then assign new values to the properties in question, instead. This way more properties can be shared, even if some properties differ. This allows for a greatly reduced memory footprint and smaller GraphML files.
Group nodes no longer automatically adjust their bounds if the bounds of the contained nodes are changed programmatically. In all interactive scenarios the bounds are updated automatically but programmatic changes to the layout of nodes need an additional call to one of the EnlargeGroupNode extension methods of IGroupedGraph. This greatly simplifies the changing of the coordinates of nodes programmatically in a consistent manner and also enables automatic rerouting of orthogonal edge paths adjacent to parent nodes, among other things. Usages of the IMovable interface should be replaced by usages of the IPositionHandler interface instead for the same reason. Also, the new IReshapeHandler interface needs to be used instead of the IReshapeable interface to provide a context to the implementation again for the same reasons.
The IPortCandidate interface has been changed to allow the implementation of dynamic port candidates that are aware of a specific user-specified location. For this to work the boolean Valid flag has been replaced by the three-state Validity enum-backed property. false and true directly map to Invalid and Valid. The third possible value Dynamic does not need to be considered in existing applications because it will only come into play if the new feature is being used actively. Also, the CreateInstance method has been changed to now take a parameter of type IInputModeContext and may not return null anymore. Please see the compatibility source code project and the migration guide on how to properly adjust existing code.
The undo mechanism has been improved so that beginning a compound edit does not place it into the undo queue immediately. Thus the rest of the queue is not discarded anymore if the edit is canceled afterwards. The compound edit will only become visible in the undo queue once its End method has been called.
The OptionHandler framework in the yWorks.Option namespace has been moved from the core library to the Demo.yFiles.Option namespace and became a source code demo that is used by other demos. For some style implementation classes in the core library there was built-in support for the option handling, which has been removed from the core and partially been placed into the corresponding demos.
The DisplayName attributes that had been declared at the properties of the style classes have been removed. Since it is not necessary anymore to obfuscate the properties and names of the style classes for the final deployment, the actual name of the properties can be used instead.
The GraphML parser API has been reworked to use the .NET LINQ to XML API. This affects most types and methods in the yWorks.yFiles.GraphML.Parser namespace, especially IInputHandler, event handlers for yWorks.yFiles.GraphML.GraphMLIOHandler#HandleDeserialization and yWorks.yFiles.GraphML.GraphMLIOHandler#QueryInputHandlers and event handlers for the events in IParseEvents.
Serialization and deserialization properties now use the strongly typed yWorks.Support.TypedKey<T> class. For the predefined properties in yWorks.yFiles.GraphML.Writer.SerializationProperties, this change should be mostly transparent from user code.
Redundant serialization property yWorks.yFiles.GraphML.Writer.SerializationProperties#DocumentLocation has been removed. Use yWorks.yFiles.GraphML.Writer.SerializationProperties#BaseUri instead.
yWorks.yFiles.GraphML.Xaml.GraphMLValueSerializerContext cannot be instantiated directly anymore.

Of course, the yFiles WPF support team will aid existing customers in migrating their code and possibly data to the new API based on their subscription.

yFiles WPF 2.0.1 - Changes since 2.0.0.2

Improvements

Made SimpleLabelStyle aware of RightToLeft flow direction of the GraphControl. The renderer now automatically mirrors the text contents to compensate the transform that has already been applied to the GraphControl.
Improved the CollapsibleNodeStyleDecorator's renderer code to workaround an issue in WPF that prevents the FlowDirection dependency property from properly being considered in the decorator.
The IReparentNodeHandler interface has been improved to now contain a callback that handles the actual reparenting of a node. This makes it possible to add additional callbacks and custom implementations for interactively reparented nodes.
MultiplexingInputMode has been improved to automatically replace Cursor instances reported by concurrent child instances so that for FlowDirection settings of RightToLeft in the CanvasControl the cursors are mirrored horizontally. For this callback method ReplaceCursor has been added.
NavigationInputMode and CanvasControl have been improved to be aware of the FlowDirection property of the CanvasControl so that in case of a RightToLeft setting the commands behave correctly.
New overloads have been added in GraphMLIOHandler to the AddRegistryInputHandler and AddInputMapperFuture methods that make common tasks more easy to implement.

Bug fixes

Fixed an exception in the undo code that occurred in the context of FoldingManager when nodes where moved into a collapsed group node.
Fixed a problem that resulted in edges created interactively where there were no port candidates available but the CreateEdgeInputMode.ConncectToPortCandidatesOnly property was set to false had the wrong source port location model assigned. This resulted in these edges unexpectedly jumping to the mouse cursor.
String values in list and array contexts in GraphML files did not have an enclosing tag. This has been fixed.
Fixed an exception that occurred when disabling shared references in GraphMLIOHandler.
The setter of the property LocalCrossingMinimization in yWorks.yFiles.Layout.Router.OrthogonalEdgeRouter behaved incorrectly. This has been fixed. Also the property CustomBorderCapacityEnabled had no setter. The property has been renamed to UseCustomBorderCapacity and the getter has been reenabled.

Incompatible Changes

The two previously undocumented methods in the layout's yWorks.yFiles.Algorithms.Node class Successors and Predecessors have now been documented and implemented correctly (the implementation of the two methods has been swapped).
The IReparentNodeHandler interface has been changed to contain the new ReparentNode method. Existing implementations can simply delegate to the default implementation in ReparentNodeHandler.
Code that replaced the navigational commands to honor the FlowDirection property of the CanvasControl needs to be replaced because the implementations will now automatically mirror the behavior in case of a RightToLeft setting.
The first parameter of yWorks.yFiles.Layout.Hierarchic.Incremental.ILayers.Insert has been corrected to be of type yWorks.yFiles.Layout.Hierarchic.Incremental.LayerType
GraphMLIOHandler's method AddRegistryInputHandler previously resulted in a runtime exception if there was a mapper in the registry with the same tag. The new implementation will either reuse the existing instance if it matches the type signature or remove the old instance prior to registering a new one. Method CreateMapper may be overwritten to adjust this default behavior.
The property LocalCrossingMinimization in yWorks.yFiles.Layout.Router.OrthogonalEdgeRouter did not work as expected. The behavior has now been adjusted and thus changed. Also the read-only property CustomBorderCapacityEnabled has been renamed to a read-write property UseCustomBorderCapacity.

yFiles WPF 2.0.0.2 - Changes since 2.0.0.1

Bug fixes

Fixed a NullReferenceException in the context of IFoldedGraph that could happen in multi-level node collapse operations as a result to calls to Collapse.

yFiles WPF 2.0.0.1 - Changes since 2.0

Bug fixes

Fixed an exception (about unit being disposed already) in UndoEngine if an IUndoUnit was added within the AutoAddTimeSpan to the machine after the engine had been cleared.
Calling IHierarchy.SetParent where the new parent was previously declared a leaf (instead of a group node) caused problems because the fact that the node now no longer was leaf was not published through an event. This resulted in inconsistent display of the views if the FoldingManager was used. Also the leaf state was not correctly rolled back during undo.
All built-in GraphML DOMInputHandler could not parse GraphML default attribute values.
Fixed incorrect implementation of various BridgeManager.RegisterXXXObstacle methods.
The GroupingKeys.MinimumNodeSizeDpKey was not automatically added to the LayoutGraphAdapter. Now a DataProvider is added to the adapter graph that yields the minimum sizes for nodes that can be obtained from the ISizeConstraintProvider<INode> in the node's lookup.
Fixed code in FixedGroupLayoutStage that threw a NullReferenceException and rendered the stage basically useless.
Fixed exception in FixedGroupLayoutStage when orthogonal routing was specified, but no DataProvider for selected nodes was set.
Fixed "Inconsistent Grouping" exception in IncrementalHierarchicLayouter.

yFiles WPF 2.0

Major New Features

The yFiles Layout and Analysis algorithms present in yFilesAlgorithms.dll have been rewritten to remove the dependency on the Visual J# runtime and to conform to the .NET coding and naming conventions.
There is now sophisticated support for folding operations in a grouped graph. This enables the user to expand and collapse the contents of group nodes, as well as to show the contents of a specific group node only. All of this can be used to display multiple different views of the same graph structure.
Convenience classes have been added to easily bind your business model data source to a GraphControl. These utilities create dynamically updated graph instances that represent the structure of entities in the business model. For this the WPF data binding mechanisms are leveraged enabling the use of a great number and variety of data sources.
The support for GraphML for importing and exporting graphs and associated data has been rewritten and is now easier to use and customize.
The core visual graph API has been revised and now makes heavy use of structs to pass rectangle, size, and point coordinates between the methods, reducing the code bloat and ambigious and long argument lists. Also, the use of structs allows for cleaner code that uses operator overloading for geometric vector operations, while at the same time making it more obvious where data is passed by value instead of by reference.
The main interfaces that make up the graph API have been simplified. Convenience methods have been removed from the interface and moved to extension methods. This makes implementing the interface easier, results in a more predictable implementation while at the same time making the usage of the interface more convenient through more extension methods.
The location of ports is now determined by port location models, making it easier to customize the location and dynamic relocation of ports if nodes are being resized, etc.
For each of the possible visual styles there is now a simple abstract base class implementation that can be used as a basis of custom styles. These base classes remove the need to implement a lot of boilerplate code that was previously necessary for even the most simple style implementations.

Visual Enhancements

Class yWorks.Canvas.Model.BridgeManager provides support for so-called bridges in edge paths that resolve the visual ambiguity induced by edge crossings.

Automatic Layout

Layout algorithm yWorks.yFiles.Layout.Hierarchic.IncrementalHierarchicLayouter now supports swimlane layouts of hierarchically grouped graphs.
Layout algorithm yWorks.yFiles.Layout.Hierarchic.IncrementalHierarchicLayouter now allows to specify placement constraints for nodes that reside in the same layer. A default implementation of new interface yWorks.yFiles.Layout.Hierarchic.Incremental.ISequenceConstraintFactory enables user-defined constrained node sequencing, where nodes can be specified to be placed at the beginning or the end of their respective layer, or can be specified to be placed before/after a given reference node.
A new domain-specific layout algorithm, yWorks.yFiles.Layout.Genealogy.FamilyTreeLayouter, has been added that is especially suited for genealogical family trees.
Minimum size constraints for group nodes have been added to the major layout algorithms yWorks.yFiles.Layout.Hierarchic.HierarchicGroupLayouter, yWorks.yFiles.Layout.Organic.OrganicLayouter, yWorks.yFiles.Layout.Organic.SmartOrganicLayouter, and yWorks.yFiles.Layout.Hierarchic.IncrementalHierarchicLayouter.
the relevant data can be bound to the graph using data provider look-up key yWorks.yFiles.Layout.Grouping.GroupingKeys.MinimumNodeSizeDpKey.
Significantly improved generic label placement algorithms yWorks.yFiles.Layout.Labeling.SALabeling and yWorks.yFiles.Layout.Labeling.GreedyMISLabeling. The number of overlapping labels has been drastically reduced. Furthermore, these algorithms now place labels associated with the Free label model.
Class yWorks.yFiles.Layout.SequentialLayouter has been added, that can be used to run several layouters sequentially one after the other.

Minor New Features

All items that make up the graph structure can now be easily associated with a user tag of any kind, which can be specified at creation time. This allows for easier binding to custom business data and less code bloat.
The mapper registry that can be used to register arbitrary maps of data for the items in the graph has become a first-class citizen of IGraph, making it more accessible. Also meta-data can now be associated with each mapper in the registry.
Class LayoutExecutor makes it easy to launch layout algorithms and perform animations both synchronously and assynchronously.
The implementations in the Algorithms and Layout library part now make use of the System.Collection interfaces and allow for using the foreach construct. Also, numeric constants have been replaced with enumerations where appropriate, and pairs of getters and setters have been replaced with properties.
Lots of extension methods have been added that greatly facilitate working with the lookup API, the layout API, the mapper registry, and IGraph in general.
The defaults for styles and models that are used by IGraph have been refactored and can now more easily and more consistently be set, modified, stored, and restored.
More Routed UI Commands have been added to the input mode architecture and input mode implementations, making customization and reusage of existing gesture even simpler. All commands can now be localized and default key bindings can be easily overridden.
Many different fine-grained events and callbacks have been added to the various input mode implementations making customization easier because subclassing is now less frequently required for customizations.
GraphControl now has the notion of a "current" item which can be adorned by a focus rendering and which will automatically be highlighted if the graph control has keyboard focus.
A default keyboard navigation feature has been implemented that allows for moving, extending, toggling, and modifying the selection, setting the current item and navigating into and out of groups in the context of a folded graph.
Undoable edits in the undo queue can now easily be localized.
Important parts of the library have been annotated with value analysis attributes that can be used to indicate possible NullReferenceExceptions and superfluous null checks.
Many places in the library that previously allowed null values now require non-null values. Void and Null Implementations have been provided that now take their place and making most checks for null in code obsolete.
The focus and selection visualization for nodes, edges, and labels can now be easily customized using component resource keys.
Many of the default style implementations have been enhanced in functionality and for some it was possible to further improve rendering performance.
Changing label and port locations is now animated smoothly. Also, the feel of the animation of the viewport has been improved.
Many more improvements great and small for both the Layout algorithms and the Viewer.

New Demos and Documentation

Added a tutorial solution consisting of a number of Visual Studio projects that show how to make use of the basic features in the library in a step-by-step manner.
Added documentation and demos for the new features. Among others, there are new demos that show how to use many of the new convenience extension methods, the new databinding features, the reworked GraphML engine, and the improved input modes, as well as the new abstract style classes.
Revisited demos to make use of the new features and paradigms.

Incompatible Changes

Being a major release, this release is API incompatible with previous yFiles WPF releases. Namespace names have changed, interfaces, classes, and methods have been refactored, some have been renamed or removed. No features or functionality has been removed.

There is a migration guide available that lists the changes that need to be done for existing projects to compile with this release. Also, the distribution contains a compatibility library that can be referenced in existing projects to facilitate the migration. It consists of adapter classes and extension methods that simulate or provide the legacy API in the new release. The sources for this compatibility library are also available, making it possible to leverage the capabilities of modern IDE refactoring tools to semi-automatically migrate existing code.

The GraphML that is written by this version is slightly incompatible with previous releases. However, a compatibility library is included in the distribution that can be used to import GraphML that has been written with previous versions. Also, this library mimics the legacy API so that existing code needs only marginal adjustments to work with the newer API.

Of course, the yFiles WPF support team will aid existing customers in migrating their code and possibly data to the new API based on their subscription.

yFiles WPF 1.0.0.2

Improvements

Various methods in DefaultGraph have been improved to perform better for certain use-cases. E.g. setting styles of items to the same instance as before will not fire events anymore. Also setting other properties via the IGraph interface to the exact same values will not trigger events anymore.
AbstractGraphWrapper was not forwarding the DisplaysInvalidated event. This has now been implemented properly.
y.layout.organic.InteractiveOrganicLayouter: added method y.layout.organic.InteractiveOrganicLayouter#startLayout and y.layout.organic.InteractiveOrganicLayouter#stopAndWait. Adjusted corresponding demos.
y.layout.hierarchic.IncrementalHierarchicLayouter: Sometimes if both swimlanes and groups and layers have been defined by the user, the algorithm would place the group nodes into newly created layers in order to avoid group node overlaps, although this might not always be necessary. The algorithm has been improved to better detect overlaps.

Bugfixes

Some IEnumerator implementations in the context of DefaultGraph threw exceptions if MoveNext() was called after it yielded false for the first time. This has been fixed to adhere to the specification, so that they will continue to yield false instead of throwing exceptions.
The GraphOverviewControl threw an exception under certain circumstances because of the above bug. The code has been adjusted not to trigger the above (fixed) bug, too.
y.layout.hierarchic.ConstraintLayerer: fixed possible NPE when the unconstrained layering would already contain same layer edges.
y.layout.router.GroupNodeRouterStage: Fixed bug where edges that end at selected group nodes are not routed when y.layout.router.OrthogonalEdgeRouter#ROUTE_EDGES_AT_SELECTED_NODES was set.

yFiles WPF 1.0.0.1

Improvements

The Print convenience methods in CanvasControl and CanvasPrintDocument required the user to enter values into the printer setup dialog twice if the default style was used. The second dialog has now been removed.
Hit test implementation of some of the non-rectangular node styles has been improved to take the fuzzy hit test radius into account.
y.layout.grouping.InsetsGroupBoundsCalculator has been enhanced to optionally take node labels of child nodes into account when calculating the bounds of a given group node. See also isConsiderNodeLabelsEnabled() and setConsiderNodeLabelsEnabled(boolean).

Bugfixes

The tree table view of the OptionHandler caused high CPU usage during idle display. TreeListView contained an endless dispatch loop which has been fixed.
Added updated GraphML schema for yFiles WPF
CanvasPrintDocument did not honor margins correctly which resulted in wrong poster sizes and unclipped content. Method PreparePosterPrinting had to be changed incompatibly in order to fix this.
CanvasPrintDocument failed to render page marks. Enabling PageMarkPrinting now correctly renders page marks.
The OverviewGraphPaintable performed badly for larger graph structures. This massively affected the performance of the GraphOverviewControl. The implementation needed to be refactored incompatibly to allow for high performance visual updates.
y.layout.router.OrthogonalEdgeRouter: Fixed bug where edges weren't routed orthogonally if rerouting was enabled.
Fixed bug where wrong minimum size is set when data provider y.layout.LayoutConstants.MINIMUM_NODE_SIZE_DPKEY is missing.
y.layout.labeling.MISLabelingAlgorithm: Fixed calls to getProfit after labeling causing NullReferenceException.

Incompatible Changes

Method PreparePosterPrinting was missing the margins parameter that has been added. Code that had overridden or called this protected method needs to be adjusted.
Protected Methods CreateXXXVisual in OverviewGraphPaintable have been removed in favor of the corresponding GetXXXVisualCreator methods. Calls to these methods need to obtain the visual indirectly from the creator instance, now. Overriding subclasses need to implement the IVisualCreator interface instead to allow for updates of the visual.

yFiles WPF 1.0

yFiles WPF 1.0 is the initial release of yFiles WPF. This release has been created on the basis of yFiles.NET 3.1 (which is based on Windows Forms technology). For users who have created applications on top of yFiles.NET 3.1, there is a short Migration guide available.