yFiles for Java (Swing) 2.x — Changelog

Skip 2.x — Use the modern 3.x line of yFiles for Java (Swing)!

Java 8
or higher

Beginning with version 3.0, the yFiles for Java (Swing) diagramming library features a brand-new, modern API which requires Java 8. This API is mature and provides many new features that are not available out-of-the-box in the 2.x line. It also provides the functionality of the ySVG, yExport and yBPMN package as source code application, therefore the extension packages are no longer required.

We recommend to start development with the next-generation yFiles for Java in new Java Swing projects.
Especially in projects that don't need to support legacy Java versions before Java 8, this is the recommended way to realize your application's diagram visualization part.

More about yFiles for Java (Swing) 3.x
Try yFiles for Java (Swing) 3.x

This file documents the feature enhancements and API changes to previous yFiles versions.

yFiles 2.18 - Changes Since 2.17

New Features

Layout

  • Added new scope SCOPE_MAINLY_SUBSET_GEOMETRIC for the organic layout algorithm. In addition to the actual subset nodes, this scope may to some degree move nodes that are geometrically close to one of the nodes in the actual subset. The existing scope SCOPE_MAINLY_SUBSET is similar, but it does determine the closeness of other nodes by using the graph structure and not the current geometry (i.e. location).
  • The SmartOrganicLayouter has a new clustering policy property, which allows to specify the clustering algorithm that is applied (if any). Three clustering algorithms, namely louvain modularity, edge betweenness and label propagation are offered. See setClusteringPolicy. Previously, the automatic clustering was always based on edge betweenness. By default, the automatic clustering is disabled (CLUSTERING_POLICY_NONE).
  • The SmartOrganicLayouter now allows to define node types that control the detection of substructures (e.g. stars, parallel structures). When types are defined, only nodes of the same type can form a substructure. To define types, register a data provider with the graph with key NODE_TYPE_DPKEY. For star-like and parallel substructures, it is also possible to have a single substructure with nodes of different types, see properties setParallelSubstructureTypeSeparationEnabled and setStarSubstructureTypeSeparationEnabled. The algorithm still tries to highlight the different types by, e.g., placing nodes of the same type closer together or on the same circle.
  • The OrthogonalLayouter and DirectedOrthogonalLayouter now allow to define node types that control the detection of substructures (i.e. trees, chains, cycles). When types are defined, only nodes of the same type can form a substructure. To define types, register a data provider with the graph with key NODE_TYPE_DPKEY.
  • The GenericTreeLayouter and TreeLayouter now support node types. The types influence the ordering of child nodes and the subtrees rooted at them such that nodes of the same type are preferably placed next to each other. Node types are a weak criterion, i.e., if the ordering is given by other constraints, these are prioritized. To define types, register a data provider with the graph with key NODE_TYPE_DPKEY.
  • The IncrementalHierarchicLayouter now supports node types. The types influence the ordering of nodes within their layers as a subordinate optimization criteria. More precisely, nodes of the same type are more likely to be placed next to each other if this does not violate with other constraints.
  • Added NodeTypeAwareSequencer that can be specified for the SingleCycleLayouter and ensures that the nodes of a circle are separated by type.
  • The ComponentLayouter now supports node types. The types influence the arrangement and ordering of the the components such that components consisting mostly of nodes of the same type are put close to other components consisting of nodes of that type. To define types, register a data provider with the graph with key NODE_TYPE_DPKEY.
  • EdgeRouter, BusRouter and ChannelEdgeRouter: Added a feature that automatically determines whether or not a new path should be calculated for a certain edge. The feature is controlled via the new routing policy properties, see EdgeLayoutDescriptor.setRoutingPolicy, BusDescriptor.setRoutingPolicy and ChannelEdgeRouter.setRoutingPolicy respectively. The decision is based on the quality of the existing routes - edges with strict violations of the routing style or that intersect other elements will be selected for routing.
  • EdgeRouter: Added the new penalty property setSketchViolationPenalty, which defines the cost for a deviation from the original edge path if the new routing policy is set to ROUTING_POLICY_SEGMENTS_AS_NEEDED.
  • PartialLayouter: Added new property setMovingFixedElementsAllowed that specifies whether or not the algorithm may move fixed elements. This often yields a better layout quality even though the preservation of the mental map declines because the fixed elements can change their position.

Algorithms

Improvements

Layout

Bugfixes

Layout

Viewer

  • DropSupport: Fixed drag and drop behavior when using one DropSupport instance for multiple Graph2DView instances. When dragging data over one view into another view, all drag and drop events were incorrectly delivered to the first view in this case.
  • MoveLabelMode: Fixed NullPointerException that occurs when dragging a label whose model does not have any candidates.

Incompatible Changes

API Changes

Behavior Changes

yFiles 2.17 - Changes Since 2.16

New Features

Layout

  • Added ClearAreaLayouter that can clear a certain area in an existing layout by moving elements. It is suitable if the rest of the layout should not change much but some free space is required, e.g., because new elements were inserted.
  • Added FillAreaLayouter than can fill a specified area in an existing layout by moving elements into or towards it. It can make layouts around the specified area more compact and is suitable if, e.g., elements were removed from the graph.
  • Added layout stage CurveRoutingStage. It replaces polyline edge paths with curved segments using cubic bezier splines and provides a generic way to produce layouts with curved edges.
  • Added layout stage EdgeBundlingStage that offers edge bundling for general undirected graphs. Bundling together multiple edges means that their common parts are to some degree merged into a bundled part. Edge bundling is useful to increase the readability of graph drawings with a high number of edges that connect a comparably small number of nodes.
  • IncrementalHierarchicLayouter: Added routing style that produces curved edge paths consisting of cubic bezier splines, see EDGE_STYLE_CURVED.
  • DefaultPortAllocator: Added property setFixedPortConsiderationEnabled for specifying whether edges with strong port constraints or fixed port candidates should be considered during the port assignment. Previously, such edges were ignored which could lead to intersections with the ports of the other edges. This new feature is enabled by default.
  • CircularLayouter: The algorithm now supports exterior edges that are routed around the exterior of the circle as smooth arcs, see the new edge routing property setEdgeRoutingPolicy.
  • RadialLayouter: The algorithm now supports a user-defined layer/circle assignment strategy, see LAYERING_STRATEGY_USER_DEFINED and LAYER_ID_DPKEY.
  • EdgeRouter: Added property setRoutingStyle for specifying an individual routing style for each edge. Furthermore, new properties setMaximumOctilinearSegmentRatio and setPreferredOctilinearSegmentLength provide means to configure the octilinear routing style.
  • EdgeRouter: Added routing style that produces curved edge paths consisting of cubic bezier splines, see EDGE_STYLE_CURVED.

Algorithms

Improvements

Layout

Viewer

I/O

  • GraphMLIOHandler, XGMLIOHandler, and XmlXslIOHandler: These I/O handlers have been improved to prevent external entity injection (and in the case of XmlXslIOHandler code execution injection from stylesheets) attacks by default.
    To prevent these attacks, the aforementioned handlers disallow DTD declarations in read XML documents. Disallowing DTD declarations requires enabling special features of Java's XML processor implementations. These features only work reliably for Java 7 and newer. For older versions of Java or if the DTDs are required, the following solutions are recommended:
    GraphMLIOHandler
    Client code should parse XML documents in a secure way with its choice of XML processor and pass the resulting org.w3c.dom.Document instance to the I/O handler's read method.
    XGMLIOHandler
    Client code should overwrite method read to instantiate a custom XGMLTokenizer implementation that parses the given source's contents in a secure way.
    XmlXslIOHandler
    Client code should parse XML documents in a secure way with its choice of XML processor, transform the resulting org.w3c.dom.Document instances and pass the transformed org.w3c.dom.Document instances to read.
  • TGFIOHandler now supports '#' characters in label texts. A '#' character is now recognized as delimiter between node and edge sections only if the '#' is placed on a line of its own.

Bugfixes

Layout

  • IncrementalHierarchicLayouter: Fixed an IllegalArgumentException that could be triggered when isGroupCompactionEnabled was enabled in conjunction with layering constraints and/or group nodes marked as incremental.
  • IncrementalHierarchicLayouter: Fixed a bug in conjunction with bus structures which could cause edges connecting to group nodes not being routed but hidden from the layout graph. As a result, other layout stages (e.g. ComponentLayouter) could fail with an exception.
  • IncrementalHierarchicLayouter: Fixed a possible NullPointerException that could occur with bus structures (see BusDescriptor) in conjunction with undirected edges.
  • IncrementalHierarchicLayouter: Fixed a possible NullPointerException that could occur with bus structures (see BusDescriptor) in conjunction with layering constraints.
  • IncrementalHierarchicLayouter: Fixed a problem which caused the specified maximum number of nodes before/after the bus (see BusDescriptor) to be violated for single line (layer) buses. In addition, for multiple layer buses, the distance between nodes and the vertical bus edge was too large (the distance should depend on the specified node to edge distance).
  • IncrementalHierarchicLayouter: Fixed a bug that could cause unnecessary (double) edge crossings when executed in incremental layout mode with edge grouping and alternative group bounds.
  • IncrementalHierarchicLayouter: Reduced number of superfluous bends of grouped edges for graphs with a PartitionGrid.
  • IncrementalHierarchicLayouter: Fixed a bug that in some cases caused a violation of the minimum first or last segment length (mostly relevant when the minimum length values were rather large).
  • IncrementalHierarchicLayouter: Fixed an IllegalArgumentException that could be triggered for bus structures (see BusDescriptor) with edges for which a recursive edge style was set (see setRecursiveEdgeStyle).
  • SmartOrganicLayouter: Fixed an exception that could occur when a partition grid was defined and at the same time a subset scope was specified (e.g. SCOPE_SUBSET) such that all nodes of the graph were selected.
  • SmartOrganicLayouter: Fixed a problem that caused superfluous node overlaps when the scope was set to SCOPE_MAINLY_SUBSET and property setNodeOverlapsAllowed was disabled.
  • OrthogonalLayouter, OrthogonalGroupLayouter, and DirectedOrthogonalLayouter: Fixed a possible IllegalArgumentException that could occur if the input graph contained parallel edges and property setParallelRoutesPreferenceEnabled was enabled.
  • AbstractNodePlacer: Fixed placeSubtree to clear its internal caches, especially the cached graph. Previously, holding onto a node placer instance could lead to subtle memory leaks.
  • ARTreeLayouter: Fixed a StackOverflowError that could occur for large chain graphs.
  • BalloonLayouter: Fixed a StackOverflowError that could occur for graphs containing very long chains.
  • PartialLayouter now transfers its getMaximalDuration to the internally used edge routing algorithm. This means that when the partial layout has a restricted running time, the routing part will be restricted, too. Previously, edge routing could still run unrestricted.
  • RecursiveGroupLayouter: Fixed a bug resulting in child nodes not being moved along with their parent group nodes. This could happen if the core layout algorithm was null but an individual layout algorithm was specified for arranging said group nodes.
  • FamilyTreeLayouter: Fixed a bug that could cause a StackOverflowError or non-orthogonal edge routes when having cycles in the tree structure, e.g., induced by a family founded by parent and (step-)child.
  • EdgeRouter: Fixed a NullPointerException that could occur if the input contained buses (see BusDescriptor).
  • EdgeRouter: Fixed a possible NullPointerException that could occur for some rare cases with fixed grouped edges and octilinear paths.
  • EdgeRouter: Fixed an IllegalStateException that could occur if the user specified buses with both fixed and non-fixed edges.
  • EdgeRouter: Fixed a bug in conjunction with buses that contained both fixed and selected edges (see BusDescriptor). It could trigger a NullPointerException when integrated labeling was enabled or lead to the misbehavior that a selected edge not part of the bus was not routed at all.
  • EdgeRouter: Fixed a bug that caused an available PortCandidate in a PortCandidateSet to be ignored by edges. This could happen when several candidates with capacity for a single edge were specified on the same node side.
  • EdgeRouter: Fixed a bug which caused grouped edges sometimes to be not grouped together. This mainly appeared in conjunction with a large value for either minimum first or last segment length.
  • EdgeRouter: Fixed a bug that in some cases caused unnecessary overlaps when the source or target node is overlapped by (several) label elements. Generally improved the ability of the router to deal with input that contains source/target nodes that are overlapped by other elements and are required to be crossed by an edge route.
  • EdgeRouter: Fixed a bug that sometimes generated bad routing artifacts with edge grouping when non-affected (i.e. fixed) edges were grouped at both end points.
  • EdgeRouter: Fixed a bug that caused edge labels overlapping with unrelated group nodes. This issue could appear when edge labels were placed by the routing algorithm, i.e. integrated edge labeling was enabled (see isIntegratedEdgeLabelingEnabled).
  • EdgeRouter: Fixed a bug that caused the same fixed PortCandidate out of a PortCandidateSet to be chosen even though there was another, non-saturated candidate that could have been chosen instead. This could yield edge segment overlaps.
  • EdgeRouter: Fixed a bug that in rare cases had the effect that shapes of non-affected, fixed edges were incorrectly parsed, which could lead to undesired effects like incorrect path cost calculation of affected edges.
  • EdgeRouter: Fixed a bug that sometimes made the routing algorithm ignore port constraints/candidates due to incorrect path cost calculations.
  • BusRouter: Fixed a bug that caused disconnected buses even though edges with the same bus Id were specified. This happened sometimes when fixed and non-fixed elements associated with the same bus were given.
  • BusRouter: Fixed a bug that caused edges not to be routed when those edges were assigned to a bus with fixed edges (isFixed). This could happen if the ignored edge shared its source and target port with one or more fixed edges.
  • ParallelEdgeLayouter: Fixed a bug that occasionally caused a NullPointerException when having a large number of parallel edges and a leading edge with ports on the node border.
  • OrthogonalPatternEdgeRouter: Fixed a bug that caused duplicate points on the edge path when the minimum distance was set to zero. This could also lead to degenerated routing results when using the ChannelEdgeRouter with the mentioned pattern router class.
  • OrthogonalSegmentDistributionStage does no longer crash when receiving input graphs with a very large edge count (greater than approximately 22000). Note that ChannelEdgeRouter is affected by this change too, because this router calls the stage by default.
  • OrthogonalSegmentDistributionStage: Fixed problems caused when encountering zero-length segments in the input, that is, a duplicate edge path point. The stage could produce degenerated (e.g. very large or small) coordinates for edges containing such segments.
  • SliderEdgeLabelModel: Fixed a bug that in some cases generated label candidate positions with invalid coordinate values (NaN values). This bug could also yield to an exception when running generic labeling algorithms (SALabeling or GreedyMISLabeling).
  • BendConverter: Made the element processing order deterministic. The previously non-deterministic order in which elements were inserted and removed could lead to non-deterministic behavior for consecutive layout calculations.

Algorithms

  • Cycles: Fixed a NullPointerException in findCycleEdges that could appear when the input graph contained self-loops.

Viewer

Modules

  • TreeLayoutModule: The module no longer selects non-tree edges when those edges are routed orthogonally.

Incompatible Changes

API Changes

Behavior Changes

  • EdgeRouter: The return value of method getPartition is now null after running the algorithm. It is only intended to be used during the algorithm's execution. Previously, its value was cached even though the documentation stated otherwise.
  • GraphMLIOHandler, XGMLIOHandler, and XmlXslIOHandler: These I/O handlers have been improved to prevent external entity injection (and in the case of XmlXslIOHandler code execution injection from stylesheets) attacks by default.
    To prevent these attacks, the aforementioned handlers disallow DTD declarations in read XML documents. Disallowing DTD declarations requires enabling special features of Java's XML processor implementations. These features only work reliably for Java 7 and newer. For older versions of Java or if the DTDs are required, the following solutions are recommended:
    GraphMLIOHandler
    Client code should parse XML documents in a secure way with its choice of XML processor and pass the resulting org.w3c.dom.Document instance to the I/O handler's read method.
    XGMLIOHandler
    Client code should overwrite method read to instantiate a custom XGMLTokenizer implementation that parses the given source's contents in a secure way.
    XmlXslIOHandler
    Client code should parse XML documents in a secure way with its choice of XML processor, transform the resulting org.w3c.dom.Document instances and pass the transformed org.w3c.dom.Document instances to read.
  • TGFIOHandler now supports '#' characters in label texts. A '#' character is now recognized as delimiter between node and edge sections only if the '#' is placed on a line of its own.

yFiles 2.16 - Changes Since 2.15

New Features

Layout

Improvements

Layout

Bugfixes

Layout

  • IncrementalHierarchicLayouter: Fixed a bug that could cause intersections between edges and elements of a sub-component (see SUB_COMPONENT_ID_DPKEY). Note that this fix may sometimes cause less compact results within a layer.
  • IncrementalHierarchicLayouter now produces shorter, more direct edge routes for edges connecting at a group node and leaving on the the left/right group side. This only affects cases where the relevant group node also contains direct-content edges (see setDirectGroupContentEdgeRoutingEnabled).
  • IncrementalHierarchicLayouter: Fixed a possible NullPointerException if the IncrementalHierarchicLayouter is wrapped by an instance of RecursiveGroupLayouter and the input graph contains layering constraints between elements of different groups.
  • IncrementalHierarchicLayouter: Fixed a bug that sometimes caused groups with too large insets for inputs with nested group nodes.
  • IncrementalHierarchicLayouter: Fixed a very rare bug that lead to an IllegalArgumentException in incremental layout mode.
  • SmartOrganicLayouter: Fixed a possible IllegalArgumentException that may appear if all nodes are located at position (0,0) and the algorithm handles substructures in a special way (see setChainSubstructureStyle, setStarSubstructureStyle, setCycleSubstructureStyle, and setParallelSubstructureStyle).
  • OrthogonalLayouter and DirectedOrthogonalLayouter: Fixed a rare infinite looping issue for input graphs that are tree structures and have mixed edge directedness (see EDGE_DIRECTEDNESS_DPKEY). In addition, the problem only occurs if property getTreeStyle is not set to TREE_STYLE_NONE.
  • OrthogonalLayouter and DirectedOrthogonalLayouter: Fixed a rare bug that caused an ArrayIndexOutOfBoundsException if property setUseFaceMaximization is enabled.
  • TreeMapLayouter: Fixed a bug that may lead to results with elements placed at infinite coordinates.
  • SeriesParallelLayouter: Fixed WrongGraphStructure exception for input graphs with groups that only contain disconnected nodes.
  • PartialLayouter does no longer reduce the size of fixed group nodes if option setFixedGroupResizingEnabled is disabled.
  • PortCandidateAssignmentStage: Fixed a bug that destroyed the grouping information for the core layout algorithm.
  • TreeMapLayoutModule: Fixed a possible ArrayIndexOutOfBoundsException that may appear for some input graphs with empty group nodes.
  • SALabeling and GreedyMISLabeling: Fixed a rare bug that caused an IllegalArgumentException if there were labels on edges with zero length.
  • SALabeling and GreedyMISLabeling: Fixed bug which caused that the preferred distance to the edge (getDistanceToEdge of an edge label was violated even though it would have been possible to keep it. The issue affected edge labels with a PreferredPlacementDescriptor and multiple side preferences (e.g. left of edge or on the edge).
  • SALabeling and GreedyMISLabeling: Fixed a wrong label profit calculation with respect to edge labels with a PreferredPlacementDescriptor.
  • SALabeling and GreedyMISLabeling: Fixed an issue that caused bad positions for labels of direct content edges (edges that directly connect a group node with a descendant, without leaving the group) with a free edge label model.
  • SimpleNodePlacer: Fixed an issue that sometimes caused very long horizontal distances between subtrees.
  • CompactNodePlacer: Fixed a possible IllegalStateException for input graphs with specified strategy mementos (see STRATEGY_MEMENTO_DPKEY).
  • EdgeRouter: Fixed a rare bug that caused an IndexOutOfBoundsException.
  • EdgeRouter: Fixed a bug that caused that edges mapped to equal group ids with different object ids were not grouped.
  • EdgeRouter: The routing algorithm now avoids unnecessary bends in cases that contain PortCandidates with fixed offsets (or strong PortConstraints) where the fixed port locations have a very similar x- or y-coordinate such that the path must consist of three segments with a single, very short middle segment. Previously, five segments in total were generated.
  • EdgeRouter: Fixed a rare bug that sometimes caused weird routes of direct content edges with strong port constraints at the group nodes.
  • EdgeRouter: Fixed a bug that sometimes caused an exception if the input graph contained edges with external ports.
  • EdgeRouter: Fixed bug that sometimes caused a non-deterministic behavior.
  • EdgeRouter: Fixed bug that caused intersections between edges and labels of fixed edges even though property setConsiderEdgeLabelsEnabled was enabled.
  • EdgeRouter: Fixed a rare NullPointerException for inputs containing fixed, grouped edges and when using polyline routing style.
  • EdgeRouter: Fixed an issue that the algorithm considered the NodeHalo associated with the source (instead of the target) node when handling the minimum last segment length setting. This could lead to unnecessarily long or too short last segments.
  • EdgeRouter: Fixed very rare NullPointerException that could be triggered during routing in cases where the source/target node is covered by obstacles (i.e. other nodes, labels).
  • EdgeRouter: Fixed two issues resulting in a violation of a PortCandidate with fixed offsets (or a strong PortConstraint). The first was only triggered for constraints at the target side and only when the target node was additionally partly or fully covered by other obstacles (e.g. node labels). The second issue appeared in cases with the source and target node fully overlapping (e.g. an edge from group to child).
  • EdgeRouter: Fixed a bug that caused that intermediate routing points were in some cases not correctly part of the final path when polyline routing was enabled (see isPolylineRoutingEnabled).
  • EdgeRouter: Fixed a rare NullPointerException that was triggered in cases where the input contained grouped edges.
  • EdgeRouter: Fixed a rare NullPointerException that occurred for inputs with a grid (see Grid).
  • PolylineLayoutStage: Fixed a bug that sometimes caused node-edge-overlaps due to sloped, polyline segments created by the stage.

Algorithms

Base

  • YList: Fixed method addAll that previously inserted the first element of the given collection at position index + 1 instead of index.

Incompatible Changes

Behavior Changes

API Changes

  • The following changes regarding the expert-API related to EdgeRouter were made:
    • AbstractSegmentInfo: Changed the first parameter of the constructors from type Edge to type java.lang.Object. It should be of type PathRequest for routed edges and Edge for fixed ones. The method getEdge has been removed as the info is not necessarily associated with an edge.
    • EdgeCellInfo: Changed the first parameter of the constructor from type Edge to type java.lang.Object. It should be of type PathRequest for routed edges and Edge for fixed ones. Removed method getEdge and replaced it with getItem.
    • EdgeInfo: Changed the constructor signature from y.layout.router.polyline.EdgeInfo(y.layout.router.polyline.Path, y.layout.router.polyline.PathSearchConfiguration) to PathSearchConfiguration).
    • Path: Removed the parameter of type Edge from the constructor and removed method y.layout.router.polyline.Path#getEdge(). A path is now not necessarily associated with an edge but only with the newly introduced PathRequest.
    • PathSearchResult: Removed method getEdgeInfo.

yFiles 2.15 - Changes Since 2.14

Features Added

Layout

  • Added the new layout algorithm TabularLayouter that generates simple tabular arrangements of nodes. It allows to place nodes in rows and columns, such that each table cell contains at most one node. Among its features is, for example, a from-sketch mode, the possibility to exactly map nodes to specific cells or different vertical and horizontal alignments.
  • Added the new layout algorithm TreeMapLayouter that generates tree maps. Tree maps present hierarchical data using nested rectangles (nodes) where each rectangle (node) gets its size depending on a specific dimension of data associated to it. The new Tree Map demo shows a possible use case for the new layout style.
  • IncrementalHierarchicLayouter: Added feature that allows to define sub-components of the input graph such that each sub-component is arranged by a user-specified layout algorithm. This allows for hierarchical layouts where parts of the graph are arranged in a different fashion, e.g., to emphasize special sub-structures. The sub-components can be specified by a data provider registered with the input graph with key SUB_COMPONENT_ID_DPKEY.
  • OrthogonalLayouter and DirectedOrthogonalLayouter: added support for special layout styles of various substructures that are automatically detected in the input graph. Supported substructures are trees, chains and cycles - see the according properties setTreeStyle, setChainStyle and setCycleStyle. In addition to the style, the new feature offers more settings, like, for example, the desired tree layout orientation (see setTreeOrientation). The layout style NORMAL_TREE_STYLE is now deprecated as the new tree style feature allows more settings for the arrangement of tree-like graphs.
  • OrthogonalLayouter and DirectedOrthogonalLayouter: added support for parallel routing of parallel edges (multi-edges that share the same source and target node). They are routed as parallel as possible; if there are edge labels, the routes must differ somewhat. Previously, parallel edges were not handled explicitly and their routes were often very different, making the recognition of parallel structures difficult.
  • OrthogonalLayouter, DirectedOrthogonalLayouter and OrthogonalGroupLayouter: Added new property setMaximumDuration, which enables to control the preferred time limit of the layout algorithms.
  • OrthogonalLayouter: Added property setUniformPortAssignmentEnabled that allows to obtain results with a more uniform port assignment.
  • EdgeRouter now supports routing through user-specified intermediate points. All specified points will lie on the edge route in the given order. See new property setIntermediateRoutingPoints.
  • EdgeRouter: Edges that connect group nodes with their descendants can now directly connect from the inside to the group node border. Previously, an edge needed to always leave the group node before connecting to it. The feature can be enabled/disabled individually for each edge using the new property setDirectGroupContentEdgeRoutingEnabled.
  • GenericTreeLayouter: Added node placer CompactNodePlacer that produces more compact tree layouts. It uses a dynamic optimization approach that chooses a placement strategy of the children such that the overall result is compact with respect to a specified aspect ratio, see property setPreferredAspectRatio.
  • Added convenience layout stage TemporaryGroupNodeInsertionStage that automatically generates a (non-nested) grouping structure from a given mapping of nodes to a component Id. This temporary grouping is meant for use during the run of the core layout algorithm of the stage. It allows, for example, easy use of RecursiveGroupLayouter without the need for a real grouping structure when the requirement is that different sub-graphs need to be arranged with different layout algorithms.

Algorithms

  • ShortestPaths: Added a-star (A*) algorithm for finding the shortest path between two nodes in a directed or undirected, arbitrary graph.

Improvements

Layout

Viewer

  • ImageOptionItem: Added new attributes ATTRIBUTE_FILE_CHOOSER and ATTRIBUTE_SHOW_URL. The former allows using pre-configured file chooser instances when browsing for image files. The latter may be used to control whether or not the option editor displays the file URL in addition to the corresponding image.

Bugfixes

Layout

I/O

  • DomXmlWriter: Fixed JDK 9 only additional, undesired whitespace when writing Text or CData nodes.
  • TGFIOHandler: Fixed erroneous truncation of TGF files when exporting label texts with characters that required multiple bytes in the platform default encoding.

Viewer

  • SmartEdgeLabelModel: Fixed NullPointerException that occurred when interactively moving labels while MoveLabelMode's isSnappingEnabled property was set to false.
  • TableEditorFactory: Added missing event handling for editingCanceled and editingStopped events when editing table cell values of a table editor in external editing dialogs. Previously open external editing dialogs ignored these events. Now open external editing dialogs will be closed when notified of these events from their associated table cell editor.
    This fix constitutes a change in behavior for external editing dialogs.
  • ColorOptionItem: Fixed transparency support in the item's color chooser for Java 9 and newer.
  • HierarchyTreeModel: Fixed erroneous selection changes that could occur when processing hierarchy events that were bracketed with PRE_EVENT and POST_EVENT.

Demos

  • Improved yFiles' DemoBrowser to run with Java 9, 10, and 11.
  • StateNodeRealizer: Fixed setting StateNodeRealizer's custom shape type.

Incompatible Changes

Behavior Changes

API Changes

  • Removed class y.option.IconPopupEditor. This class could never be safely used, because its constructor requires types that are not part of yFiles for Java's public API.

yFiles 2.14 - Changes Since 2.13

Features Added

Layout

Improvements

Layout

Viewer

Documentation

The new interactive documentation viewer integrates the yFiles for Java API documentation and the yFiles for Java Developer's Guide. Its built-in optimized search capability makes it easy to quickly get a result list of both API references and related descriptions.

The Javadoc™ API documentation is additionally available in the doc/javadoc/ folder.

Bugfixes

Layout

Viewer

  • DropSupport: Fixed initial groupClosed states of realizer delegates in ProxyShapeNodeRealizer instances that are created in createNode for new group/folder nodes.
  • EditMode: Fixed NullPointerException that occurred on mouse clicks after transferring the focus to the application menu bar by typing the ALT key on Windows.
  • ConstraintManager: Fixed memory leaks that caused option editors to be retained for the whole life cycle of a constraint manager.
  • Overview: Fixed rare IllegalArgumentException that occurred for mouse drag events when the canvas component of the Graph2DView associated to the overview has width or height 0.

Incompatible Changes

Behavior Changes

API Changes

yFiles 2.13 - Changes Since 2.12.0.1

Major Features Added

Layout

  • IncrementalHierarchicLayouter supports recursively routed edges. Edges that pass the border of group nodes will always leave at the bottom side and enter at the top side of the group node. This routing style is specified using setRecursiveEdgeStyle.
  • IncrementalHierarchicLayouter: Improved from-sketch behavior for groups with changed bounds (e.g. after folding or expanding a group node), seeIncrementalHierarchicFoldExpandDemo.
  • Added edge bundling feature. Bundling together multiple edges means that their common parts are to some degree merged into a bundled part. Edge bundling is useful to increase the readability of graph drawings with a high number of edges that connect a comparably small number of nodes. The following layout algorithms support edge bundling:

Minor Features Added

Layout

Algorithms

  • Groups: Added k-means clustering algorithm that partitions a given graph in k-clusters.
  • Groups: Added hierarchical clustering algorithm that partitions a given graph based on agglomerative (i.e., bottom-up) strategy and some linkage function (single-, complete- and average-linkage).

Improvements

Layout

Viewer

I/O

Demos

Bugfixes

Layout

Viewer

  • TableEditorFactory: MethodresetEditor now properly removes the editor from its previous option handler and properly adds the editor to the new option handler. As a resultresetEditor now also triggers the appropriate editorAdded and editorRemoved events.
  • Fixed incorrect sloppy edge painting when using VALUE_SLOPPY_POLYLINE_PAINTING_OFF. The incorrect sloppy edge painting is noticeable when animating edge path changes.
  • Fixed NullPointerException in TableOrderEditor and TableSizeEditor that may occur if label editing is started while changing the order or size of table columns or rows.

I/O

Demos

  • FamilyTreeDemo: Fixed problem that may cause displacement of graph elements when clicking on a node.

Incompatible Changes

API Changes

Behavior Changes

yFiles 2.12.0.1 - Changes Since 2.12

Improvements

Layout

Demos

Bugfixes

Layout

Viewer

I/O

yFiles 2.12 - Changes Since 2.11.0.2

Major Features Added

Layout

  • Added new layout algorithm SeriesParallelLayouter for graphs that are constructed only by series (combining two series parallel graphs by merging the source of one graph with the sink of the other) and parallel (combining two series parallel graphs by merging the sources and the sinks) operations.
  • Added multi-parent support to GenericTreeLayouter. A tree node can have multiple parents that are connected to all of its siblings and share the same parents. This might come to use in organizational charts where a team answers to multiple superiors.
  • Added grid placement support for nodes and edges to IncrementalHierarchicLayouter.

Minor Features Added

Layout

I/O

Improvements

Layout

Viewer

Demos

  • SwingRendererDemo: Improved rendering of scaled text components.
  • MindMapDemo: A comparator is used to specify the desired order of nodes in the graph instead of changing the order of edges in the graph like it was done before.

Bugfixes

Layout

Viewer

  • GroupNodeRealizer: Fixed copy constructor and method createCopy to properly adopt the autoBoundsEnabled state.
  • MoveSelectionMode: Fixed rare NullPointerException that may be triggered when clicking left and right mouse buttons at the same time while panning.
  • BevelNodePainter: Corrected upper gradient to run from top to center instead of from top to bottom.
  • DefaultEditorFactory: Fixed NumberFormatException that is triggered by invalid input for int or double options with lower and/or upper bounds for their values.

Incompatible Changes

Layout

Viewer

  • EdgeRealizer: Method paintLabels now calls paint unconditionally for each label associated with the edge realizer. Previously, this method skipped labels that were not visible or had neither text nor icon. This change ensures that paintLabels behaves the same way as paintText.
    Client code that previously relied on the no text, no icon behavior should now use the label's visible property to handle label visibility.

Incompatible API Changes

Layout

All layout modules have been re-written for a consistent approach to configuring layout algorithms and registering additional data. This resulted in the following incompatible API changes:

yFiles 2.11.0.2 - Changes Since 2.11.0.1

Bugfixes

Layout

  • IncrementalHierarchicLayouter: Fixed possible IndexOutOfBoundsException that may occur for grouped graphs in incremental mode with recursive group layering enabled.
  • IncrementalHierarchicLayouter: Fixed possible IllegalStateException caused by inconsistent grouping.
  • IncrementalHierarchicLayouter: Fixed bug that may cause edges with zig-zag paths if there are swimlanes and integrated edge labeling is enabled.
  • IncrementalHierarchicLayouter and TopologicalIncrementalLayerer: Fixed bug that may cause unwanted same-layer edges between incremental nodes.
  • CircularLayouter: Fixed issue that may cause infinite/too large node coordinates for unfavorable input settings, e.g., if the maximal deviation angle is chosen to small (see method setMaximalDeviationAngle). Note that such coordinates may produce infinite looping or other exceptions.
  • GenericTreeLayouter: Fixed issue that caused too large group nodes when label consideration is enabled and the layout is not oriented top-to-bottom.
  • GenericTreeLayouter: Fixed issue that causes group nodes to be too small to include all edge labels when the edge connects to a child of an inner group node.
  • GenericTreeLayouter: Fixed issue that causes group nodes to be too small for node halos.
  • GenericTreeLayouter: Fixed issue that produces unnecessary large group nodes if node labels are considered.
  • TreeReductionStage: Fixed wrong handling of group nodes which may cause a WrongGraphStructure exception as well as broken routes for edges incident to group nodes.
  • Fixed NullPointerException when using AssistantPlacer together with distributed port assignment.
  • BusRouter: Fixed NullPointerException that may appear for graphs containing isolated nodes with self-loops.
  • EdgeGroupConstraintModule: Fixed NullPointerException that may appear if option "Configuration Method" is set to "Automatically" and option "Act On" is set to a value other than "All Ports".

Demos

  • OrgChartDemo: Fixed NullPointerException that may occur when (structurally) moving nodes with collapsed predecessors.

yFiles 2.11.0.1 - Changes Since 2.11

Bugfixes

Layout

Viewer

yFiles 2.11

Major Features Added

Layout

Minor Features Added

Layout

Viewer/Editor Interaction

I/O

Improvements

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.

Layout

Viewer/Editor Interaction

Bugfixes

  • IncrementalHierarchicLayouter: Fixed possible IndexOutOfBoundsException if PortConstraints are used together with PortCandidateSets.
  • 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 getNearestCommonAncestor 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 NullPointerException 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 NullPointerException caused by labels with zero width/height and a "free" edge label model.
  • LabelingModule: Fixed bug that caused wrong choice of optimization strategy.
  • Fixed anti-aliasing option for image output modules. This fix also turns off anti-aliasing in GIF images generated by GIFOutput.
  • GenericNodeRealizerSerializer: Fixed deserialization of nodes whose GraphML representation does not contain any style properties. (Previously, default style properties were kept for these nodes.)
  • LocalViewCreator.Neighborhood: Method createViewRealizer now adopts selection state from model folder nodes for corresponding view group nodes.

Incompatible Changes

Changes in Technical Requirements

  • All yFiles for Java distributions now require Java 1.4 for building and running yFiles for Java based applications.

Behavior Changes

API Changes

Demos

yFiles 2.10.1.2 - Changes Since 2.10.1.1

Bugfixes

Layout

  • IncrementalHierarchicLayouter: Fixed rare bug that caused broken edge routes if edges are routed as polylines.
  • IncrementalHierarchicLayouter: Fixed IllegalArgumentException that may appear for graphs containing nodes with fixed coordinates.
  • IncrementalHierarchicLayouter: Fixed bug that caused wrong coordinates of empty rows (see class RowDescriptor) whose minimum height is zero.
  • LabelLayoutDataRefinement: Fixed possible ClassCastException 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.
  • DirectedOrthogonalLayouter: Fixed a bug that sometimes caused misplaced edge labels of grouped edges.
  • TreeLayouter and GenericTreeLayouter: Fixed possible NullPointerException for trees with empty group nodes.
  • ShuffleLayouter: Fixed bug that may cause small offsets of fixed nodes.
  • 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.
  • 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.
  • 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.
  • EdgeRouter: Fixed bug that caused edges that connect a node with an ancestor group node to cross their source nodes when using port constraints.
  • EdgeRouter: Fixed bug that makes it possible to group the source of one edge and the target of another edge at their common node.
  • EdgeRouter: Fixed bug that sometimes causes superfluous edge overlaps.
  • EdgeRouter: Fixed bug that caused minimum distance violation of grouped edges.
  • EdgeRouter: Fixed rare NullPointerException while calculating edge crossing costs.
  • EdgeRouter: Fixed possible NullPointerException for edge groups that contain fixed edges.
  • EdgeRouter: Fixed bug that caused wrong routes for edges grouped with fixed edges.
  • 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.
  • 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 ArrayIndexOutOfBoundsException 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 ArrayIndexOutOfBoundsException.
  • BusRouter: Fixed possible IllegalStateException caused by non-orthogonal edge segments.
  • BusRouter: Fixed possible NullPointerException when routing only a subset of edges without adding a DataProvider to the graph that marks edges as selected.

View

  • HierarchyManager: Fixed removing folder nodes in graph hierarchies. Inter-edges whose real source or real target is the removed folder node and which reside in ancestor graphs of said folder node are now removed as well.
  • MoveSelectionMode: Fixed missing undo/redo support for automatic bend removal with removingInnerBends enabled.

yFiles 2.10.1.1 - Changes Since 2.10.1

Bugfixes

Layout

  • EdgeRouter: Fixed possible ArrayIndexOutOfBoundsException for graphs with very short fixed edges.
  • IncrementalHierarchicLayouter: Fixed a bug that could result in infinite y-coordinates when octilinear edge routing was enabled.

yFiles 2.10.1 - Changes Since 2.10.0.1

Major Features Added

Demos

  • Added demo IsometryDemo that displays graphs in an isometric fashion to create the impression of a 3-dimensional view.
  • Added demo NetworkMonitoringDemo, a simple network monitoring tool that combines custom realizers with animations.
  • Added demo UmlDemo, a simple UML diagram editor with custom user interaction, realizers, and animations.
  • Added demo MindMapDemo, a simple mind mapping tool with custom realizers and automatic arrangement of diagram elements.
  • The new LayoutDemo demonstrates the main layout styles provided by yFiles for Java.

Minor Features Added

Layout

Viewer

Demos

  • NodeLabelingDemo: Added custom label layout stage that demonstrates how to set up automatic label placement such that label positions above the nodes associated to the labels are preferred.

Improvements

Layout and Algorithms

  • EdgeRouter: Improved support for port candidate sets (see PortCandidateSet).
  • EdgeRouter: Rerouting improved to provide better results.
  • 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.
  • 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.
  • 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.
  • 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.
  • BalloonLayouter: Reduced gaps between adjacent nodes.
  • CircularLayouter: Improved results for "from sketch" mode.
  • Trees: Added method isForest.
  • BusRouterModule: Added new scope setting for routing edges at selected nodes.

Viewer

Demos

  • Undo/redo support is now added to demos which are editable.
  • Clipboard support is now added to demos which are editable.

Bugfixes

Layout

Viewer

Incompatible Changes

yFiles 2.10.0.1 - Changes Since 2.10

Improvements

Bugfixes

yFiles 2.10 - Changes Since 2.9.0.2

Major Features Added

Layout

Minor Features Added

Viewer/Editor Interaction

Layout

Improvements

Demos

  • The new OctilinearEdgeRouterDemo demonstrates the routing capabilities of class EdgeRouter.
  • The existing IncrementalHierarchicLayouterDemo shows how to configure the IncrementalHierarchicLayouter to produce octilinear edge routes.
  • The new PreferredLabelPlacementDemo shows how to configure the PreferredPlacementDescriptor of labels and how this affects the label placement of different layouters.
  • The new IntersectionCalculatorDemo shows how to correct edge connection points for non-rectangular nodes when working without yFiles for Java's visualization framework in package y.view and sub-packages thereof.

Bugfixes

Incompatible Changes

yFiles 2.9.0.2 - Changes Since 2.9.0.1

Improvements

Bugfixes

yFiles 2.9.0.1 - Changes Since 2.9

Improvements

  • Cycles: Method findAllCycleEdges has been improved to return only edges that belong to at least one simple cycle. Previously, all edges were returned for the undirected case.
  • demo.view.flowchart.layout.FlowchartLayouter: Support for group nodes, better label positions for labels with a Free or Smart label model.

Bugfixes

  • Fixed writing partial graph hierarchies to GraphML. I.e. graphMLIOHandler.write(g, dest) where g is not the root graph (see getRootGraph) of the graph hierarchy now works as expected.
  • Fixed occasional NaN values in label placement calculated by SmartEdgeLabelModel or RotatedSliderEdgeLabelModel.
  • Several fixes for the editors of ColorOptionItem: Set a white background for all color patches which brings out transparent colors more clearly, adhere to the value of ATTRIBUTE_SHOW_ALPHA when displaying text, open the popup menu without covering the editor component, set the color chooser dialog's title to the name of the corresponding item and its initial value to the editor's current value.
  • demo.view.flowchart.layout.FlowchartLayouter ignores table nodes instead of throwing an exception.
  • CreateEdgeMode: Fixed IllegalArgumentException that occurred when closing a group node while creating an edge starting at one of the group node's child nodes.
  • IncrementalHierarchicLayouter: Fixed bug that caused that options "backloop routing" (see setBackloopRoutingEnabled) and "automatic edge grouping" (see setAutomaticEdgeGroupingEnabled) were ignored.
  • MultiPageLayouter: Fixed NullPointerException that occurred when calling doLayout several times on the same instance.
  • GraphConnectivity: Fixed methods that calculate biconnected components to mark selfloops as not belonging to any biconnected component.

yFiles 2.9

Major Features Added

Viewer/Editor Interaction

Layout

Minor Features Added

Viewer/Editor Interaction

Layout

Analysis

Improvements

Demos

  • The new GraphExplorerDemo shows how to successively explore large graphs.
  • Added new MultiPageLayoutDemo that shows how to use class MultiPageLayouter to sub-divide large graphs into smaller bits of navigable information.
  • The new EntityRelationshipDemo shows how to visualize and edit entity-relationship diagrams (ERD).
  • Added new SmartLabelModelDemo that demonstrates how to use SmartNodeLabelModel and SmartEdgeLabelModel and how both models behave on interactive changes of nodes and edges.
  • Added new HyperlinkDemo that demonstrates how to trigger and process hyperlink events for HTML formatted labels.
  • Added new FadingGroupStateIconDemo that demonstrates how to fade in/out the group state icon when moving over group/folder nodes using a custom ViewMode.
  • Added new LevelOfDetailDemo that presents the effects of using rendering hints to control the rendering process of elements in the view.
  • Extended the FlowchartDemo by a new dedicated layout algorithm for flowchart diagrams and added many new example diagrams.

Bugfixes

Incompatible Changes

yFiles 2.8.0.6 - Changes Since 2.8.0.5

Bugfixes

yFiles 2.8.0.5 - Changes Since 2.8.0.4

Improvements

  • Cycles: Method findAllCycleEdges has been improved to return only edges that belong to at least one simple cycle. Previously, all edges were returned for the undirected case.

Bugfixes

  • Groups: Fixed possible NullPointerException in method biconnectedComponentGrouping when calculating biconnected components in a graph containing self-loops.
  • ShortestPaths: Fixed an error in method findShortestUniformPaths. In many cases, nodes and edges which did not belong to a shortest path were added to the result nevertheless.
  • GraphConnectivity: Fixed methods that calculate biconnected components to mark selfloops as not belonging to any biconnected component.

yFiles 2.8.0.4 - Changes Since 2.8.0.3

Bugfixes

yFiles 2.8.0.3 - Changes Since 2.8.0.2

Bugfixes

yFiles 2.8.0.2 - Changes Since 2.8.0.1

Improvements

  • BusRepresentations: The methods to transform from and to hub representation can now copy data which is attached to an original edge using specific data provider keys to the corresponding edge in the transformed graph.
  • PartialLayouter: Improved runtime for graphs with large components when option setConsiderNodeAlignment is enabled.
  • MoveNodePortMode: Added callback method portMoved that is invoked when the moved node port has been assigned its final position.
  • BusRouterDemo: Improved user interaction by automating the hub creation and removal and improved customizability by preserving the edge instances on layout calculation.

Bugfixes

  • YGF deserialization support for JDK 1.6.0_26 as well as JDK 1.6.0_25 (and earlier) versions of javax.swing.ImageIcon.

    Warning: This fix requires all classes and interfaces in package y.x and sub-packages thereof to be excluded from obfuscation.

  • Fixed "delete selection" in the flowchart demo.
  • IncrementalHierarchicLayouter: Fixed bug that caused unnecessary crossings when using node grouping.
  • PartialLayouter: Fixed bug that caused misplaced labels after arranging components.
  • NetworkFlows: Fixed wrong calculation of the cut set returned by method calcMaxFlowMinCut.
  • LayoutGraphCopyFactory: Added missing parent node information when copying grouped graphs.
  • Graph2DViewActions.DuplicateAction: For certain graphs and selections duplicate resulted in an illegal argument exception "Node not in this graph".
  • Graph2DClipboard: Setting the parent group in pasteFromClipboard did not work in inner graphs.
  • Fixed problem that required a mouse click to happen before edge creation could be cancelled when edge creation is started by DropSupport.
  • Fixed edge label positions in LayoutPreviewPanel.

yFiles 2.8.0.1 - Changes Since 2.8

Bugfixes

Improvements

Automatic Layout

  • OrientationLayouter: Node insets as well as port constraints are now also translated correctly for each possible orientation.

Viewer/Editor Interaction

Changes in Default Behavior

  • 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.

yFiles 2.8

Major Features Added

Automatic Layout

Viewer/Editor Interaction

Minor Features Added

Automatic Layout

Viewer/Editor Interaction

Improvements

Automatic Layout

  • OrthogonalEdgeRouter: Enhanced support for port candidates.
  • 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 (setHidingEmptyGroupNodes) 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.

Viewer/Editor Interaction

  • Graph2DUndoManager: The one-argument constructor will now correctly register the undo manager as GraphListener and Graph2D.BackupRealizersHandler for all existing inner graphs of the argument root graph.
    Note: Client code that used undo manager's one-argument constructor and manually registered the undo manager as listener/backup handler for inner graphs must be changed to do no manual registration.
  • LineType: The DOTTED line types (DOTTED_1, DOTTED_2, etc.) consist of circles now (previously they used squares).
  • PolyLineContainsTest: No longer reports hits for invisible parts of the edge at the source node and target node.
  • Graph2DGraphMLHandler: XML content is now possible in shared resource nodes. Upto now only text content was supported. Resources may point to further resources.
  • Graph2DViewActions.DeleteSelectionAction: Added an option for keeping the sizes of parent group nodes of deleted nodes (setKeepingParentGroupNodeSizes). By default, these nodes shrink if they have an active auto bounds feature.
  • YLabel: In the default configuration the gap set with setIconTextGap is ignored if the text has size (0,0). This avoids, for example, unnecessarily large selection boxes for labels with an icon but without text. Moreover, the gap was already ignored if there was a text but no icon.
  • Graph2DView: The label editor provided by openLabelEditor now checks whether there was a concurrent edit when it is about to commit its value to the label. If there was a concurrent edit, i.e. the label text changed since opening the editor, then the editor text is not applied to the label.
  • CreateEdgeMode: The edge creation is canceled, if the graph of the view of the CreateEdgeMode gets changed while creating the edge. Previously, changing the graph resulted in an IllegalArgumentException "Both endpoints must reside in this graph." when the create edge gesture was finished.
  • AbstractCustomNodePainter: Extracted paintHotSpots and paintText from paint. This eases writing custom node painters in some situations.
  • MovePortMode: The editing is canceled, if the graph of the view of the MovePortMode gets changed. Deleting the owning edge of the moved port no longer leads to a NullPointerException.
  • OrthogonalMoveBendsMode: The editing is canceled, if the graph of the view of the OrthogonalMoveBendsMode gets changed. Deleting the owning edge of the moved bends no longer leads to a NullPointerException.
  • MoveSelectionMode: Added option setIndicatingTargetGroup. If this option is enabled in addition to isGroupReassignmentEnabled, then the current target group for a group reassignment operation is indicated by a customizable drawable.
  • YLabel: The selection box is now rendered slightly outside of the label bounds (with the default and cropping label configurations), such that it no longer interferes with labels that have a border or an icon.
  • Improved the GraphML (de)serialization support for icons in node labels and edge labels. (De)serialization events are now generated for all kinds of icons, not only icons of type javax.swing.ImageIcon or java.io.Serializable.
    Since unhandled (de)serialization events throw an exception, this constitutes a behavior incompatible change as client code has to register appropriate DeserializationHandler and SerializationHandler implementations when icons in node or edge labels are of types other than javax.swing.ImageIcon.

Demos

  • Added new BusRouterDemo that presents the new orthogonal bus-style edge router.
  • Four new demos present specific setup of the new partial layout support in conjunction with Circular, Hierarchic, Organic, and Orthogonal Layout: CircularPartialLayoutDemo, HierarchicPartialLayoutDemo, OrganicPartialLayoutDemo, and OrthogonalPartialLayoutDemo, respectively.
  • Added new CriticalPathDemo that shows the setup of hierarchic layout in order to emphasize critical paths in a diagram.
  • Added two new demos, MixedLayoutDemo and RecursiveLayoutDemo, that show how to apply different layout algorithms to the contents of group nodes, both recursively and non-recursively.
  • Added new EdgeLabelingDemo that demonstrates how to use generic labeling algorithms in general as well as how to use the new rotation-related features such as automatic rotation and automatic flipping of label display to prevent "upside-down" labels.
    The new NodeLabelingDemo shows how to use the node label models in conjunction with the yFiles generic labeling algorithms.
    These demos replace the LabelingDemo application.
  • Added new NodePortsDemo that demonstrates user interaction and visual customization for node ports. The new LogicGatesDemo also shows how to use the new node ports. These demos replace the PortsDemo application.
  • Added demo FlowchartDemo: a comprehensive flowchart demo that shows how to achieve visually rich information presentation.

Bugfixes

Incompatible API Changes

yFiles 2.7.0.5 - Changes Since 2.7.0.4

Bugfixes

  • Fixed JDK 7 only IllegalArgumentException that is triggered by numerical overflow in various comparator or comparable implementations.
  • Fixed JDK 7u25 only ImagingOpException that is triggered by BevelNodePainter and ShinyPlateNodePainter with shadow drawing enabled.

yFiles 2.7.0.4 - Changes Since 2.7.0.3

Bugfixes

  • Fixed JDK 7 only IllegalArgumentException that is triggered by comparator or comparable implementations that do not define a total order but only a partial order.

yFiles 2.7.0.3 - Changes Since 2.7.0.2

Bugfixes

  • YGF deserialization support for JDK 1.6.0_26 as well as JDK 1.6.0_25 (and earlier) versions of javax.swing.ImageIcon.

    Warning: This fix requires all classes and interfaces in package y.x and sub-packages thereof to be excluded from obfuscation.

  • IncrementalHierarchicLayouter: Fixed bug that sometimes caused undesirable large groups when using edge groups.

yFiles 2.7.0.2 - Changes Since 2.7.0.1

Minor Features Added

Viewer/Editor Interaction

Bugfixes

yFiles 2.7.0.1 - Changes Since 2.7

Bugfixes

Improvements

yFiles 2.7 - Changes Since 2.6.1

Major Features Added

New Comprehensive Support for Swimlane Diagrams

New Local Views Feature

GraphML now Integrated and Greatly Improved

New and Improved User Interaction Support for Graph Editing

Minor Features Added

Automatic Layout

Graph Analysis Algorithms

Realizer and Rendering

  • Arrow: added new predefined arrows.
  • LineType: added dashed dotted line style.

Viewer/Editor Interaction

Improvements

Demos

  • Added new SearchDemo that demonstrates how to find nodes in a graph that match a specific criterion and how to visually present all matching nodes in simple way.
  • Added new SwimlaneDemo that demonstrates the interactive capabilities of the new y.view.tabular package.
  • Added new TableStyleDemo that demonstrates how to customize the visual representation of table nodes that use TableGroupNodeRealizer and TableNodePainter for visual representation.
  • Added new LocalViewDemo that demonstrates the predefined local view implementations as well as how to create, configure, and interact with local views.
  • New GroupingDemo presents a simplified version of HierarchyDemo that focusses on essential hierarchy-related functionality using the actions provided by class Graph2DViewActions.
  • The new GroupNavigationDemo shows how to create custom hierarchy-related actions to conveniently navigate into and out of group nodes and folder nodes.
  • New HierarchyJTreeDemo shows how to use class HierarchyJTree to present a tree-like view of a graph structure where nodes can be nested within other nodes.
  • Added new CustomGroupVisualizationDemo that demonstrates customization of the visual representation of group nodes using class GenericGroupNodeRealizer.
  • Added new PartitionGridLayoutWithoutAView demo that demonstrates the usage of IncrementalHierarchicLayouter's new partition grid feature.
  • Adjusted SwimlaneLayoutWithoutAView demo to use IncrementalHierarchicLayouter's new partition grid to define swimlanes.
  • Added new SnapLineDemo that shows how snapping support is set up using the properties of the child modes of the main view mode class EditMode. The demo also shows how to create and add a custom snap line.
  • Demos that show how to use the integrated GraphML support have been added in the package demo.io.graphml.
  • Refactored HierarchyDemo to use the new hierarchy-related Action implementations from class Graph2DViewActions.
  • New Graph2DLayoutExecutorDemo shows how to use class Graph2DLayoutExecutor.
  • The demo packages have been reorganized so that all layout-related demos can be found in a common place.
    The demo.module package has been moved to demo.layout.module, demos from demo.layout have been moved to a new demo.layout.withoutview subpackage, and demo.view.layout with its subpackages have been moved to demo.layout.

Changes in Default Behavior

Incompatible API Changes

Bugfixes

  • OrientationLayouter: Fixed wrong handling of mirror mask (see setMirrorMask).
  • IncrementalHierarchicLayouter: In some cases edge points could have infinite coordinates.
  • OrthogonalEdgeRouter: Fixed bug where in some cases strong port constraints were not taken into account for self-loops when local crossing minimization was enabled.
  • IncrementalHierarchicLayouter: Fixed insets of group node being treated incorrectly if non-orthogonal edge routes were used.
  • IncrementalHierarchicLayouter: Fixed rare exception about groups being "inconsistent".
  • Undo/Redo did not always work properly when group node contents were moved, resized, or moved to different group nodes.
  • GMLIOHandler: in some cases parsing empty LabelGraphics elements could cause an exception.
  • HierarchyTreeModel: setting a new comparator did not reorder already present elements
  • OrganicEdgeRouter: Fixed bug where OrganicEdgeRouter created some extreme edge routes for larger minimal distances (see setMinimalDistance ). Critical edges will now be routed as straight lines.
  • Fixed occasional null pointer exceptions when painting shadows in conjunction with BevelNodePainter or ShinyPlateNodePainter.
  • DefaultGraph2DRenderer: Fixed problems in paint order/sloppy paint order traversal implementations for layered painting when requesting labels, bends, or ports but no nodes and edges.
  • DefaultGraph2DTraversal: Fixed problems when requesting labels, bends, or ports but no nodes and edges.
  • IOHandlerModule: When writing, the output URL is now decoded using a java.net.URI. This means that for example a hash mark in the file name is now possible if the URL is encoded. URLs were not decoded previously and a hash mark in the file name resulted in a truncated file name, e.g. file#123.svg was saved as file. If you do not encode your URL (e.g. using the deprecated file.toURL() method instead of file.toURI().toURL()) and the URL contained parts which are interpreted as being encoded like foo%20bar.svg, this will now be saved as foo bar.svg.
  • Added selection indication for labels that use the "CroppingLabel" configuration.

yFiles 2.6.1 - Changes Since 2.6.0.1

Minor Viewer and Editor Features Added

Minor Layout and Analysis Features Added

Demos

  • Added demo AnimatedStructuralChangesDemo that shows how to highlight structural changes of a graph by means of animation and layout morphing.
  • Added demo OrgChartDemo: a comprehensive organization chart demo that shows how to achieve visually rich information presentation.
  • CollapsibleTreeDemo: added navigation view mode and improved visual appearance of tree nodes.

Bugfixes

  • GroupNodePainter: will no longer overwrite label properties for custom labels. Thus GenericGroupNodeRealizers with custom labels using GroupNodePainter can now be registered e.g. to HierarchyGraphFactory and will keep the label appearance.
  • ShapeNodePainter: feature groupDepthFillColor was applied not only to group nodes but also to nodes that belonged to a group.
  • SimplexNodePlacer: fixed wrong calculation of the width of the leftmost/rightmost swimlane.
  • TreeLayouter: fixed strange edge routes appearing when setPortStyle was set to BORDER_CENTER_PORTS or BORDER_DISTRIBUTED_PORTS and the nodes had non-uniform size.
  • TiledImageOutputHandler: depending on the chosen size and number of tiles the exported image could get clipped on the right and bottom border
  • Graph2DView: inline label editor was not always visible when using Swing components as nodes
  • EditMode: drag gesture over a node led to selecting the node even with MoveSelectionMode disabled.
  • ConstraintLayerer: fixed possible NPE when the unconstrained layering would already contain same layer edges.
  • GroupNodeRouterStage: fixed bug where edges that end at selected group nodes are not routed when ROUTE_EDGES_AT_SELECTED_NODES was set.
  • getBendsToBeMoved: the returned collection of bends no longer contains each selected bend twice.
  • EdgeGroupConstraintModule: fixed bug when using the same module instance for different graphs.
  • CreateEdgeMode: creating an edge is now gracefully canceled, if the start node gets deleted.
  • MovePortMode: improved logic to update HierarchyManager accordingly if the user relocated an inter-edge port.
  • ImageNodeRealizer: fixed a memory leak in conjunction with using alpha images.
  • ViewAnimationFactory: using APPLY_EFFECT when creating an element removal animation (explode, fadeOut, blurOut, retract, whirlOut) will now reset the visibility property of the element's realizer to its pre-animation state.
  • AssistantPlacer: comparators for sorting the child nodes in a (sub)tree are now provided with non-assistant child nodes also.
  • OrthogonalPatternEdgeRouter: fixed bug where self loops with weak port candidates at self side might result in edge endpoints outside the node's bounds when grid routing is enabled. This will implicitly also affect ChannelEdgeRouter when using the default settings.

Improvements

yFiles 2.6.0.1 - Changes Since 2.6

Bugfixes

Improvements

yFiles 2.6 - Changes Since 2.5.0.4

Major Features Added

Automatic Layout

  • Layout algorithm IncrementalHierarchicLayouter now supports swimlane layouts of hierarchically grouped graphs.
  • Layout algorithm IncrementalHierarchicLayouter now allows to specify placement constraints for nodes that reside in the same layer. A default implementation of new interface SequenceConstraintFactory 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, FamilyTreeLayouter, has been added that is especially suited for genealogical family trees.
  • A new planarity test class, PlanarityTest, has been added. It can be used to test a graph for planarity and to create a planar embedding of a planar graph. Both can be done in linear time.
  • Minimum size constraints for group nodes have been added to the major layout algorithms HierarchicGroupLayouter, OrganicLayouter, SmartOrganicLayouter, and IncrementalHierarchicLayouter.
    GroupLayoutConfigurator prepares and binds the relevant data to the graph using data provider look-up key MINIMUM_NODE_SIZE_DPKEY.
  • Significantly improved generic label placement algorithms SALabeling and GreedyMISLabeling. The number of overlapping labels has been drastically reduced. Furthermore, these algorithms now place labels associated with the FREE label model.
  • Added the ability for the organic layout algorithms to deal with elliptical shapes of group nodes, which may themselves contain elliptical node shapes. Class EllipticalGroupBoundsCalculator can be used to add this ability to the algorithms.
  • Class SequentialLayouter has been added, that can be used to run several layouters sequentially one after the other.

Realizers and Rendering

Viewer/Editor Interaction

  • New class ModelViewManager enables multiple views on a common model graph. ModelViewManager establishes and manages all model-view relationships between a distinguished graph, the "model graph," and an arbitrary number of so-called "satellite graphs" that can each be rendered in their own view.
  • View mode class HotSpotMode (and also HierarchyHotSpotMode) respects minimum size and maximum size constraints for nodes when they are resized interactively.
    Size constraints can be specified using interface SizeConstraintProvider which is retrieved from node realizers when being resized. The realizer base classes NodeRealizer and GenericNodeRealizer define an appropriate getter method.
  • Class HitInfo uses the reverse of the rendering order as established by the graph renderer for traversing the graph elements when collecting hit-testing information.

Demos

  • The complete source code of the comprehensive graph editor yEd Lite has been added. The source code is made available as a separate download item that is available through our software download center.

Minor Features Added

Graph Analysis Algorithms

Automatic Layout

Realizers and Rendering

  • YLabel: added the setSelected property to allow for selecting labels individually. Default actions in Graph2DViewActions have been added and EditMode-behavior has been enhanced to make use of the new selection feature. See labelClicked for details. Also convenience methods have been added to Graph2D that deal with and yield the selection state of labels.
  • GenericEdgeRealizer: A new implementation of GenericEdgeRealizer.PathCalculator has been added that can be used as a wrapper to other PathCalculators and will smooth the calculated bends as e.g. PolyLineEdgeRealizer does.
  • NodeRealizer: getLabel no longer throws an exception, if the realizer has no label. In this case a new label is added and returned. This is the same behavior as already implemented for edge realizers.
  • New interface SizeConstraintProvider that allows to specify minimum size and maximum size constraints for node realizers.
  • Class DefaultGraph2DRenderer supports collecting hit-testing information based on the reverse of the rendering order.

Viewer/Editor Interaction

Demos Added

  • ModelViewManagerDemo shows how class ModelViewManager can be used to create model-view relationships between graphs.
  • FamilyTreeDemo presents the layout algorithm FamilyTreeLayouter.
  • SequenceConstraintsDemo allows to experience IncrementalHierarchicalLayouter's support for constrained node sequencing.
  • SwimLaneGroupDemo shows swimlane layout with hierarchically grouped graphs.
  • FullScreenNavigationDemo features the user interface elements provided by class NavigationComponent that allow convenient navigation in the view.
  • RollOverEffectDemo presents a custom view mode implementation that uses the capabilities of the yFiles animation framework.

Changes in Default Behavior

  • Due to YLabels being selectable now, some of the operations in EditMode now behave slightly different.
  • HotSpotMode: changed default resizing policy from SEMI_BLOCK_UPON_MINIMUM_SIZE to new option DISCRETE_BLOCK_POLICY which will also support aspect ratio resizing and resizing while keeping the node center position. To switch back to the old policy, please use method setResizePolicy with parameter SEMI_BLOCK_UPON_MINIMUM_SIZE.
  • HotSpotMode: improved handling of port offsets for edges that are not orthogonally routed.
  • CreateEdgeMode: Now, by default the CreateEdgeMode will be left when the source node is not being accepted (acceptSourceNode). This will allow other input modes to become active again instead of being stuck in CreateEdgeMode and waiting for other gestures. To switch back to the old behavior simply overwrite method sourceNodeDeclined.
  • HierarchyMoveSelectionMode now uses FIXED_MINIMUM_GROUP_BOUNDS as group bounds policy instead of FIXED_AUTOBOUNDS_INSETS. Thus dragging nodes in and out of group nodes will not resize the group node if not necessary. To go back to the old behavior, simply set FIXED_AUTOBOUNDS_INSETS using method setGroupBoundsPolicy.
  • IncrementalHierarchicLayouter: LAYERING_STRATEGY_USER_DEFINED or LAYERING_STRATEGY_FROM_SKETCH disable recursive group layering.
  • YModule and LayoutModule: default exception handling has been improved. Now, depending on whether there is a module listener registered, exceptions will not always be immediately shown in a Swing dialog but will continue to bubble through the call stack. See exceptionHappened.
  • CopiedLayoutGraph automatically registers a DataProvider under NODE_DP_KEY if not already present on the original graph.

Incompatible API Changes

Bugfixes

  • OrthogonalEdgeRouter: fixed bug where strong PortConstraints as well as fixed PortCandidates were not obeyed.
  • IncrementalHierarchicLayouter: LAYERING_STRATEGY_USER_DEFINED did not work as expected for unconnected graphs, since each component was layered and normalized separately. The fix ensures that layer IDs are respected globally.
  • IncrementalHierarchicLayouter: Group layer compaction did not always work correctly for for graphs with edges at group nodes.
  • OrthogonalSegmentDistributionStage: fixed bug where fixed PortCandidates weren't kept. This also affects ChannelEdgeRouter and in some very uncommon cases OrthogonalEdgeRouter.
  • TreeLayouter: fixed incorrect handling of label bounds if a non-default orientation was used.
  • Bend: added missing y.view.EdgeRealizer#bendChanged() callback in method setLocation. This will also affect methods setX and setY. This fix can lead to incompatible behavior for code that acts on y.view.EdgeRealizer#bendChanged(), which was previously only called when method moveBy was used and not when using one of the above methods.
  • MovePortMode: Fixed a bug that prevented free positioning of a port.
  • MouseInputMode: now handles ProxyShapeNodeRealizers correctly, i.e. the current realizer delegate is queried for a mouse input editor provider instead of the proxy realizer itself.
  • GroupNodeRealizer / HierarchyMoveSelectionMode: Fixed bug that resized group nodes in a strange fashion when moving nodes into an empty group.
  • DefaultHierarchyGraphFactory: Fixed a bug that resulted in group nodes with an associated parent node being created with the factory's default folder node realizer.
  • IncrementalHierarchicLayouter: Fixed incorrect calculation of group node heights for certain cases where edges at group nodes were present.

yFiles 2.5.0.4 - Changes Since 2.5.0.3

Bugfixes

Improvements

yFiles 2.5.0.3 - Changes Since 2.5.0.2

Bugfixes

Improvements

Minor Features Added

  • New OptionItem implementation IconOptionItem for generic Java Icons.

yFiles 2.5.0.2 - Changes Since 2.5.0.1

Bugfixes

  • OrthogonalEdgeRouter: fixed problem with IllegalStateException that indicated that ports were located outside of nodes. The problem could occur for edges that carried strong port constraints.
  • OrthogonalPatternEdgeRouter: Fixed bug where edge routing didn't hold to strong port constraints and fixed port candidates. This did also apply to edges that OrthogonalEdgeRouter could not route orthogonally.
  • OrthogonalPatternEdgeRouter: Removed IllegalStateException that was thrown when ports were located outside the according node bounds. Layout will now continue for such cases, although it is highly recommended to use ports that are inside the according node bounds.
  • SnapOuterPortsToNodeBorderStage: Fixed bug where in some cases ports weren't snapped to the node border for non square nodes.
  • PolyLineEdgeRealizer: Fixed bug leading to some non-smoothed bends for PolyLineEdgeRealizers with smoothed bends enabled. The problem only occurred for special circumstances involving collinear bends.

yFiles 2.5.0.1 - Changes Since 2.5

Bugfixes

Minor Features Added

Demos Added

yFiles 2.5 - Changes Since 2.4.0.3

Major Features Added

Incremental Hierarchical Layout Enhanced

Hierarchical Layout Enhanced

  • Class HierarchicLayouter now supports the notion of "constrained layering." New layerer implementation ConstraintLayerer enables user-defined constrained layering, where nodes can be specified to be placed into the topmost or bottommost layer, or can be specified to be placed into the same layer or a layer preceding/following that of a given reference node.
    [To the corresponding section in the yFiles Developer's Guide...]

New Label Customization Support

Full Viewer/Editor Support for Orthogonal Edge Paths

New Magnifying Glass Tool

New Compact Orthogonal Layout Algorithm

  • New orthogonal layout class CompactOrthogonalLayouter uses a divide-and-conquer approach to provide compact orthogonal layouts that fit into a specified aspect ratio.
    CompactOrthogonalLayouter is an extension of new layout stage class PartitionLayouter which offers general support for a four-phase layout process where node partitions are found according to a customizable scheme, then a layout is calculated for each partition, afterwards the partitions are arranged in a compact manner, and finally their inter-connecting edges are routed.

    New layout module class CompactOrthogonalLayoutModule demonstrates how to set up compact orthogonal layout.

    [To the corresponding section in the yFiles Developer's Guide...]

New Line-Wrapping Layout Algorithm

Orthogonal Edge Router Enhanced

New Orthogonal Edge Routing Algorithm

Minor Features Added

Automatic Layout

  • Class ComponentLayouter now supports arranging components from sketch and introduces a new data provider look-up key to allow external declaration of components via a data provider.
  • New layout stage class PortConstraintEnforcementStage can be used to enforce that a layout algorithm will not change the relative coordinates of ports that are associated with a strong port constraint.
  • Class DefaultLayoutGraph now allows to specify multiple labels per node.
  • SmartOrganicLayouter optionally uses a smarter component layouting technique if a subset of nodes should be arranged only.
  • ShuffleLayouter introduces a new data provider look-up key to enable specification of nodes that should be pinned to their locations during shuffling.
  • Improved handling of port constraints with bad orthogonal edges in OrthogonalEdgeRouter.

Input and Output

  • Class Graph2DPrinter optionally adds a footer drawable below a printed graph.
  • Improved GML parsing and encoding of numbers and unicode entities in GMLIOHandler.

Viewer/Editor Interaction

  • New class HierarchyTreeTransferHandler adds drag-and-drop functionality to HierarchyJTree which allows changing the graph hierarchy using simple mouse drag gestures.
  • Graph2DViewActions adds a 'Select All' action that is bound to Ctrl-A, resp. Command-A (on Mac OS X). Also, usage of this class has been simplified.
  • Graph2DView introduces new client property "UnitIncrementPixels" which allows to specify the unit increment of the scroll bars in view coordinates.

Realizers and Rendering

  • Class DefaultGraph2DRenderer provides new methods that allow for partitioning the rendering order into several layers. Sloppy painting now also supports the various painting orders.
  • Graph2DView features new client properties and new method paintSelectionBox that enable extensive customization of selection box look. The client properties include selection box stroke, color, fill color, and shape.
  • YLabel enables programmatically specifying a label's size along with an option to automatically adjust the size of a (node) label to the size of the node it belongs to.
  • Graph2DUndoManager allows to control whether the selection state of realizers should be adjusted via method setSelectionStateAdjusting.
  • New view mode class OrthogonalMoveBendsMode that can be used to conveniently edit orthogonally routed edges. It supports moving and creating new bends/edge segments in such a way that an edge's path is always orthogonal.
  • Additional getter methods in ViewMode allow to determine the parent and child ViewModes.
  • CreateEdgeMode optionally cancels accidental edge creation early on. See method setEarlyEdgeCancelingEnabled.
  • Class HierarchyTreeSelectionModel optionally disallows mixed selections of nodes and edges. See method setMixedSelectionAllowed.
  • Graph2D uses automatic dirty flagging for edges that were changed using one of the changeEdge and reverseEdge methods.
  • HitInfo adds new convenient constructors for hit-testing with focus on only a specified type of graph elements.

Graph Structure Functionality

  • New utility class GraphCopier makes it easy to copy a graph's contents to another graph or create a copy of a graph.
  • YList provides new method getCell to retrieve a list cell by index.

Language Support

  • New utility class Generics provides support for Java 5 language features enabling convenient iteration over the graph structure using the enhanced for loop construct.

Demos Added

  • IncrementalHierarchicGroupDemo shows how IncrementalHierarchicLayouter can be used to fully or incrementally layout hierarchically organized graphs. The demo supports automatic re-layout after expanding folder nodes and collapsing group nodes.
  • MagnifierViewModeDemo features the magnifying glass "tool" which enables local zooming in a Graph2DView.
  • EdgeConnectorDemo demonstrates edge-to-edge connections (i.e., edges between edges) and connections between nodes and edges in the view.
  • DendrogramLayouterDemo demonstrates dendrogram-like tree layout.
  • YLabelConfigurationDemo shows how to customize the rendering of labels.
  • OrthogonalEdgeViewModeDemo demonstrates the ability of EditMode and its minor view modes to deal with orthogonally routed edges.

Incompatible API Changes

  • YLabel: removed method setSize(double, double). Calling this method had not the desired effect and therefore made no sense. setContentSize has been introduced as a replacement that can now be used to specify the size of a label's content.
  • NodeLabel: static field AUTOSIZE_CONTENT has been moved to superclass YLabel
  • Graph: calls to disposeNodeMap or disposeEdgeMap will now throw IllegalArgumentException if the given map had not been created with this specific instance. Dispose your maps on the correct Graph to avoid those exceptions.
  • Graph2DView: corrected method name getVerticalScrollBarPolicy to setVerticalScrollBarPolicy
  • Removed deprecated listeners field of class Graph and switched to a better performing internal implementation.
  • Removed deprecated API in YLabel in favor of setBackgroundColor.
  • Graph2DViewActions: now by default includes a new 'Select All' action that is bound to Ctrl-A, resp. Command-A (on Mac OS X)

Bugfixes

yFiles 2.4.0.3 - Changes Since 2.4.0.2

Minor Features Added

Bugfixes

  • Class MovePortMode: improved clip bounds for visible port candidates.
  • Class SimplexDrawer: fixed occasional NullPointerException when using custom layering.
  • Class CopiedLayoutGraph: using constructor CopiedLayoutGraph raised a ClassCastException under certain circumstances. This is a regression to yFiles 2.3. To fix this problem a small but incompatible API change (see below) was the only proper solution.
  • Class ARTreeLayouter: Fixed a rare bug that resulted in bad edge routing if the graph was not a normalized tree.
  • Class LabelLayoutDataRefinement: Fixed a bug that resulted in a ClassCastException when using unbuffered layout.
  • Class TreeDrawer: switched to using GenericTreeLayouter, since the previous approach sometimes produced node overlaps.

Incompatible API Changes

Demo Changes

  • The free Java bytecode obfuscator and shrinker yGuard 2.0 is now part of the yFiles tutorial demo applications.
    It provides Java bytecode shrinking functionality and features new XML syntax.

yEd Improvements

  • Improved HTML image map output. HTML <area> elements are only generated for nodes and edges that actually have descriptive tooltips and/or links associated.
    Also, tooltip visibility in the browser window and behavior in Microsoft Internet Explorer has been improved.

yFiles 2.4.0.2 - Changes Since 2.4.0.1

Bugfixes

  • Graph2DHierarchyClipboard did not use the GraphFactory set with setGraphFactory to create node and edge copies.
  • IncrementalHierarchicLayouter: Fixed an edge labeling and edge routing problem for edge labels that are not centered on their edge.
  • Class GenericEdgeRealizer: fixed a NullPointerException during copy creation when there were bends in the original edge.
  • Class SmartOrganicLayouter: fixed memory leak and possible stack overflow errors when the instance was reused multiple times.
  • Class GenericTreeLayouter: fixed NodePlacer implementations that did not always honor PortConstraints at leaf nodes.
  • Class OptionHandler: fixed bad display of values in bound double item
  • Class OrthogonalLayouter: fixed rare ArrayIndexOutOfBoundsException if nodes had small dimensions.

Features Added

Features Added to yEd

  • Added module to measure and visualize diverse centrality indices for graphs.
  • Added URL and a description property to nodes and edges. The associated URLs can be opened in a web browser.
  • Added HTML image map output that supports the display of descriptive tooltips and object linking.
  • Improved SVG output that now supports the display of descriptive tooltips and object linking.

yFiles 2.4.0.1 - Changes Since 2.4

Bugfixes

Features Added

yFiles 2.4 - Changes Since 2.3.1.1

Major Features Added

Animation Framework

  • The general animation framework from package y.anim has been reworked to provide high-quality animations and visual effects for node realizers, edge realizers, and also drawables. Predefined, yet customizable animations and effects include moving, resizing, and scaling of nodes, color transformations with nodes and making nodes blink, fading in and out, blurring, and also explosions are supported.
    Animations can be arbitrarily combined and be played in parallel or sequentially, new class AnimationFactory provides the means to define the structure of a compound animation process. New class ViewAnimationFactory can be used to create predefined generic animation objects.
    [Show me the corresponding section in the yFiles Developer's Guide]

Fully Interactive Swing User Interface Components in the View

  • The yFiles library now supports Java Swing User Interface (UI) components to be used inside the view. Similar to the mechanism provided by Swing's cell renderer and corresponding cell editor classes, yFiles interfaces NodeCellRenderer and NodeCellEditor can be used to create proper interactive editors for arbitrary node-related data.
    The created editors serve as the visual representation for nodes, they are fully interactive and provide the full range of mouse-based user interaction, i.e., they can be selected, resized, and moved just like regular nodes. Furthermore, they can also be zoomed in and out, and remain editable even when zoomed.
    New view mode class CellEditorMode governs proper interaction with such UI components.
    [Show me the corresponding section in the yFiles Developer's Guide]

New Directed Orthogonal Layout Algorithm

New Interactive Organic Layout Algorithm

Generic Tree Layout Algorithm Enhanced

Bridges for Edge Paths

Minor Features Added

Automatic Layout

Realizers and Rendering

Viewer/Editor Interaction

Input and Output

  • Added class ImageIoOutputHandler: this class allows access to image writer plugins available with Java Image I/O API (enables writing Portable Network Graphics, i.e., PNG image file format, for example).
    Note that using the Java Image I/O API functionality depends classes only available in J2SE 1.4 or higher.

Graph Analysis

Demos Added

The structure of subpackages inside the demo/ package has been changed. Many new subpackages have been created to better match the package/subpackage structure of the classes that are discussed.
Also, DemoBrowser, a "shell" application which allows convenient navigation through all yFiles tutorial demo applications has been added. It features execution of the demos, and also display of both source code and documentation.

  • Animation Framework: demos EaseInEaseOutDemo, FadeInFadeOutDemo, LabelAnimationDemo, and AnimationEffectsDemo (together with AnimationEffectsDemoBase) have been added.
    They demonstrate usage of the animation framework and also many of the effects provided by factory class ViewAnimations.
  • SwingRendererDemo presents how to use Java Swing UI components as NodeRealizers.
  • DirectedOrthogonalLayouter: UMLClassDiagramLayouterDemo has been added to demonstrate directed orthogonal layout for UML class diagrams.
  • GenericTreeLayouter: demos AssistantPlacerDemo, RotatableNodePlacersDemo, and TreeLayoutConfigurationDemo (together with TreeLayoutConfiguration) have been added to show setup and usage of GenericTreeLayouter with NodePlacer implementations that support subtree rotation.
  • InteractiveOrganicLayouter: demos InteractiveOrganicDemo, NavigationDemo, and AnimatedNavigationDemo have been added to show setup and usage of InteractiveOrganicLayouter in an interactive environment that allows a user to "live"-drag nodes.
  • The demos MouseInputDemo and ScrollingNodeRealizer demonstrate the MouseInputEditor concept, which can be used to conveniently support user interaction with arbitrary (graph) elements in the view.
  • GenericEdgeRealizerDemo has been added to present creation and customization of GenericEdgeRealizer configurations.
  • BridgeDemo demonstrates how the bridging functionality of DefaultGraph2DRenderer is enabled, BridgeEdgeRealizerDemo shows how to enable so-called "bridges" in conjunction with class GenericEdgeRealizer.
  • FlowchartDemo has been added to show port candidate support provided by incremental hierarchical layout.

Features Added to yEd

  • "Bridges" can be enabled for all edges to resolve the visual ambiguity induced by intersecting edge paths.
  • Added new UML-style orthogonal layout algorithm to the suite of orthogonal layout algorithms.
  • Added disk arrangement styles for node partitions in the layout module of circular layout.
  • Added automatic clustering capabilities to the grouping tool that support biconnected components and "natural clustering."

Incompatible Changes

  • HierarchyTreeSelectionModel: Changed validation of paths. Only done on the last POST_EVENT (with bracket depth==0)
  • The rework of package y.anim has lead to a new animation scheme where an animation no longer has an absolute number of frames, but instead returns frames that best match a given relative time.
    Also, implementations for interface AnimationListener have to be registered with class AnimationPlayer in order to get properly notified of animation progress.
  • AnimationObject: Method calcNextFrame(int, int) has been replaced by calcFrame. Methods getAnimationLength() and getAnimationListener() have been removed.
    AnimationEvent: Constructor has new signature; removed optimization constants.
    AnimationPlayer: Methods setSynchronizedMode(boolean) and getSynchronizedMode() have been replaced by setSynchronized and isSynchronized.
  • YLabel: The rotation angle for a label is given in double now instead of int, i.e., the signature of getter/setter methods getRotationAngle and setRotationAngle has changed.
  • EdgeRealizer: Method calculatePath() has been replaced by calculatePath

yFiles 2.3.1.1 - Changes Since 2.3.1

Bugfixes

yFiles 2.3.1 - Changes Since 2.3.0.3

Features Added

Viewer/Editor Interaction

Data Structures

  • Class Graph: various sanity checks have been added to enforce that a graph won't act on elements that do not belong to it.
  • Class YList: now implements the Java list interface java.util.List.

Automatic Layout

Modules

Settings Framework

Graph Analysis

yEd Graph Editor Demo

  • Added the IncrementalHierarchicLayoutModule to the list of available layout modules.
  • Node and edge properties are now presented inside a table editor.
  • Layout modules will be launched in a separate thread to allow GUI repaints during layout calculation.
  • Auto grouping tool now supports grouping of chains.

Demos Added

  • The source code of IncrementalHierarchicLayoutModule has been added for tutorial purposes.
  • Demo RecursiveGroupLayouterDemo has been added. It shows how to layout the contents of group nodes each with a different layout style.

Improvements

Bugfixes

yFiles 2.3.0.3 - Changes Since 2.3.0.2

Bugfixes

  • Class OrthogonalEdgeRouter: under certain circumstances edges with strong port constraints could cause a NullPointerException.
  • Class ClassicLayerSequencer: If the same layouter instance of HierarchicLayouter was reused with different PortConstraint settings, an ArrayIndexOutOfBoundsException was thrown under certain circumstances.
  • Class Transitivity: Method transitiveReduction contained duplicate edges if they were multi-edges before the reduction.
  • Class EditMode: If node creation was disallowed, clicking on the canvas would cause the graph to fire empty PRE_EVENTs and POST_EVENTs.
  • Class HierarchyManager: fired too many HierarchyEvents when folding or unfolding nodes.
  • Class LayoutTool: method getBoundingBox unconditionally included bounding boxes of labels.
  • Class Graph2D: method getLabelLayout returned information of first node label only.
  • Class HierarchyManager: root graph can now be non-empty at construction time of HierarchyManager.
  • Class HierarchyTreeModel: HierarchyManager can now be non-empty at construction time of HierarchyTreeModel.
  • Package y.option: Fixed bad "ValueUndefined" behavior for items in table view.

Improvements

Demos Added

yFiles 2.3.0.2 - Changes Since 2.3.0.1

Bugfixes

  • Classes OrthogonalLayouter and OrthogonalGroupLayouter: fixed embedder problem that could cause a NullPointerException during layout calculation.
  • Class CircularLayouter: conflicting settings for maximum deviation angle and preferred child wedge forced the algorithm into an infinite loop.
  • Class ShortestPaths: fixed a problem where in certain situations method kShortestPaths did not enumerate all possible paths.
  • Class PortCalculator: fixed a problem where in some scenarios bends of certain edges got all moved to the location of the first bend.
  • Class NodeRealizerIntersectionCalculator: when in buffered layout mode, intersection points at nodes whose size have changed will not be calculated anymore.
  • Class HierarchyManager: removed a possible race condition in getInstance which could lead to a ConcurrentModificationExceptions in multi-threaded environments.
  • Class LayoutTool: method clipEdgeOnBB caused an exception if there was no visible path.
  • Class PopupMode: now uses its own getHitInfo for hit-testing. This allows to customize local hit-testing behavior.
  • Class DefaultEditorFactory: fixed bad background color handling in widget for undefined value for ColorOptionItems.
  • Class HierarchicLayouter: fixed problem where the minimum slope and minimum length for polyline routing was not respected.
  • Default implementations of EdgeLabelModel: implemented a workaround where the default model parameter is used implicitly if none has been set instead of throwing a runtime exception.
  • yEd Demo Application: fixed printing problem on non-Windows machines. Fixed problem in ImageNodeRealizer property panel. Improved default node and edge property dialogs.

Improvements

Documentation Added

  • Improved Javadoc comments for many methods from package y.base and for methods relating to the label models in package y.layout.
    Also, the Javadoc package descriptions for all yFiles packages have been enhanced and furnished with links to appropriate chapters and sections in the yFiles Developer's Guide.

yFiles 2.3.0.1 - Changes Since 2.3

Bugfixes

  • Insets for edge and node labels were wrongly interpreted. This problem caused labels to be painted at a wrong location. For example, labels with default insets were painted a bit too far to the right.
  • On Microsoft Windows platforms, when using PrintPreviewPanel the preset and previewed paper format settings were ignored when actually printing a diagram using the print dialog. Instead, a default paper format was used.
  • PolyLineEdgeRealizer: rendering and hit test problems could occur when feature smoothedBends was enabled and all control points were covered by either the the source or target node of the represented edge.
    Also clipping behavior has been improved if control points lie inside nodes regardless of the configuration of the smoothedBends feature.
  • OrthogonalEdgeRouterModule: by mistake, the default setting for feature Use Custom Minimum Distance to Node was set to true.
  • ComponentLayouter: resolved problems related to inconsistent and inaccurate bounding box calculation of graph components. Method getBoundingBox of y.layout.LayoutGraph is not used anymore. Also, new methods calcBoundingBox, setLabelAwarenessEnabled and isLabelAwarenessEnabled were added to have more control on the bounding box calculation.
  • AnimationPlayer: fixed some problems with "synchronized mode" which resulted in code execution outside the event dispatch thread.

Improvements

  • The print and page format dialogs within PrintPreviewPanel are now opened in a separate thread. This ensures that the print preview panel will be properly repainted while these dialogs are open.
  • DefaultGraph2DRenderer: added an option that uses a special node and edge ordering for the drawing of nested graphs.
  • IncrementalHierarchicLayouter: added convenience methods for configuring the algorithm's awareness of node labels (setConsiderNodeLabelsEnabled).
  • Added possibility to specify the positioning of the help panel in the table view of the OptionHandler classes. Additionally it is now possible to customize the colors of the table component easily.

yFiles 2.3 - Changes Since 2.2.1.3

Major Features Added

New Hierarchical Layout Algorithm

  • A new implementation of the hierarchical layout algorithm has been added to the suit of layout algorithms. IncrementalHierarchicLayouter complements the classic hierarchical layout algorithm and offers a wealth of new features.
    The most outstanding improvement of the new implementation is its ability to both parse the current layout from the sketch and apply different styles to it, as well as incrementally add new elements to an existing layout or mark certain elements in the current diagram to be optimized without changing the rest of the layout structurally.
    The new algorithm can be configured and customized in great detail: it is, e.g., possible to define separate styles and parameters for each node and each edge in the graph.
    Additionally, the algorithm can be configured to produce more space-efficient layouts. The routing model of edges as well as the crossing minimization algorithms have been improved.
    The new algorithm is one of the first to consider node labels that occupy space outside the node's bounds.
    The new algorithm also offers built-in support for swim lane layouts.
    Like the classic algorithm the new one supports port constraints and bus-like edge routing.

Generic Tree Layout Algorithm

  • A new layout algorithm for tree-like structures has been added to the suit of tree layout algorithms. GenericTreeLayouter complements the existing tree layout algorithms and offers some advanced features.
    The algorithm can be customized in great detail, each major part sub-task can easily be replaced by custom implementations. A great number of default implementations is already included in the current version.
    The algorithm allows for very fine-grained configurations. Each subtree in the graph can have its own style and style settings. The algorithm is the first tree layout algorithm to support yFiles' port constraints.
    The default implementation offers mechanisms to read the current layout from sketch and incrementally add new elements to the current diagram.

Refactored Settings Dialogs and Components

  • The OptionHandler class and utility classes have been refactored. They now support the MVC paradigm by implementing event-listening methods and allow for more than one open editor instance.
    A factory is now used to create the actual GUI for the OptionHandler instances. Two default factories are provided in the current version of yFiles. The first one generates a dialog similar to the one in older yFiles versions, while the second one creates a tree-table-like view. While the first one is especially suited for dialogs, the second one can be used to directly integrate into the GUI of an application and display the settings of the currently focused elements in a non-modal fashion.
    Many of the default items have been improved. All of them are supported by the default factories and many of them offer additional features.

Documentation Added

  • The yFiles Developer's Guide (formerly known as yFiles Userguide) has been massively improved in many ways. Most notably, it now contains detailed information about the yFiles viewer package and many new details about the algorithms and architecture of the yFiles layout package. Since the Developer's Guide has grown so much in size we have decided not to distribute it with the yFiles library itself anymore. Instead it is available as a separate download unit now.

Minor Features Added

Automatic Layout

Realizers and Rendering

Viewer/Editor Interaction

  • Added MouseWheelListener Graph2DViewMouseWheelZoomListener that allows to use the mouse wheel to change the zoom level of Graph2DView.
  • Added new ViewMode AutoDragViewMode that will automatically adjust the visible clip of the view when dragging the mouse outside of the view.
  • Added ViewMode CreateChildEdgeMode that can be used to quickly create graphs. It automatically creates a new node at the end of a newly created edge.
  • CreateChildEdgeMode: a new ViewMode that automatically creates a new node at the end of a newly created edge.
  • Added ViewMode PortAssignmentMoveSelectionMode that can be used to interactively assign PortContraints to the edges of a graph.
  • Added alternative group bounds auto-resizing behavior to view modes HierarchyMoveSelectionMode and HierarchyHotSpotMode. Setter and getter for the group bounds policy are setGroupBoundsPolicy and getGroupBoundsPolicy.
  • Edges can now optionally be created and connected when starting or ending an edge at the location of the main label of a group node. Effected classes are HierarchyEditMode and HierarchyCreateEdgeMode. Added methods are setConnectOnGroupNodeLabelEnabled, isConnectOnGroupNodeLabelEnabled, setConnectOnGroupNodeLabelEnabled and isCreateEdgeOnGroupNodeLabelEnabled.

Application Logic

  • Added clipboard functionality that makes it easy to cut, copy and paste parts of a diagram. The classes Graph2DClipboard and Graph2DHierarchyClipboard have been added to this purpose.
  • Graph2DUndoManager: added methods that allow to register UndoListeners that get informed when new commands are added to the undoable command queue. See addUndoListener and removeUndoListener.

Printing

Input and Output

  • Support for the XML-based variant XGML of the graph format GML has been added. XGMLIOHandler produces structurally the same output as GMLIOHandler but is based on XML syntax. Other new classes related to this graph format are XGMLTokenizer, XGMLEncoder, XGMLInput and XGMLOutput. Note, that using the XGML functionality depends on XML-related classes only available in J2SE 1.4 or higher.
  • ImageMapOutputHandler: added support for hyper-linked edge paths in generated image maps.

Graph Analysis

  • ShortestPaths: added powerful shortest-path variant kShortestPaths.
  • Class Dfs has been refactored. Recursion was removed from the implementation to avoid StackOverflowErrors on huge graphs. Performance has been considerably improved.

Miscellaneous

Demos Added

  • The demo package demo.view.incremental has been added. It provides tutorial source code demos that show how to use the new incremental layout capabilities of yFiles:
    • demo.view.incremental.SimpleIncrementalHierarchicLayouterDemo gives a short introduction to the incremental feature of the new hierarchical layout algorithm.
    • demo.view.incremental.SimpleSwimLaneLayouterDemo demonstrates the swim lane layout capabilities of the new hierarchical layout algorithm.
    • demo.view.incremental.IncrementalHierarchicLayouterDemo is a more complex application that uses the incremental features of the new hierarchical layout algorithm.
    • demo.view.incremental.IncrementalTreeLayouterDemo is a complex application that uses the features found in the new tree generic tree layout algorithms.
  • Added source code demo demo.layout.IncrementalLayoutWithoutAView that demonstrates the usage of the incremental layout facility without the yFiles viewer classes.
  • Added source code demo demo.layout.SwimlaneLayoutWithoutAView that demonstrates the usage of the swim lane layout facility without the yFiles viewer classes.
  • Added source code demo demo.io.TiledImageDemo.
  • Added source code demo demo.view.GenericNodeRealizerDemo that demonstrates how to use the new GenericNodeRealizer class.
  • Added source code demo demo.view.PrintPreviewDemo that illustrates the new print preview GUI.
  • Added source code demo demo.option.OptionHandlerDemo that illustrates the features of the OptionHandler classes.
  • Updated the demos that show how to use the yFiles layout algorithms without the yFiles viewer package to nevertheless display a rudimentary graphical sketch version of the diagram.

Features Added to yEd

  • Added print preview
  • Added module for laying out the separate components of a graph.
  • Added rudimentary Japanese GUI localization.

Bugfixes

  • LayoutTool: method pathIntersectsRect returned incorrect results. The intersection test was only performed on the first segment of an edge path.
  • Graph: method removeGraphListener could cause a NullPointerException upon removal of non-registered listeners.
  • PopupMode: resolved compatibility problems with J2SE 5.0. Method reactivateParent was invoked before the final mouse release event had been received.
  • GroupNodeRealizer: property displayInnerGraph was not properly copied.
  • ImageOutputHandler: corrected html output for the poly areas of edges. A dispensable comma was removed.
  • GroupNodeRealizer: alpha component for fill color was ignored.
  • Overview: fixed some repaint problems.
  • YLabel: fixed a problem where the size of a label was not properly taking insets into account.
  • ArcEdgeRealizer: fixed NaN bounding box problem and height/ratio conversion.
  • BezierEdgeRealizer: fixed a bug in contains which prevented the user from selecting the first segment and a bug in calcUnionRect which resulted in repaint problems.
  • ImageMapOutputHandler: fixed order of <area> tags.
  • BoundedQueue: fixed constructors BoundedQueue, BoundedQueue, BoundedQueue, and BoundedQueue.
  • OrganicLayouter: pluggable instance of GroupBoundsCalculator was ignored.
  • HierarchicGroupLayouter: fixed a problem that occurred when both global sequencing, memento mode, and component layouting was enabled.
  • OrthogonalEdgeRouter: fixed a problem that occurred with self-loops having strong port constraints set. Also fixed a problem with edges having strong port constraints set at its end node, where the end node lies completely within the bounds of another node. Reactivated port constraints in local crossing minimization.
  • OptionHandler: fixed a problem that occurred when adding new items after method clear had been called.

Improvements

  • Improved accuracy of clipping for curved edges paths.
  • Improved performance of contains.

Incompatible Changes

  • Starting with this release it is the responsibility of the EdgeRealizer to render its selected bends. The new protected method paintBends was introduced for that purpose. Overriding this method will allow customization of the bend rendering process. In prior releases, selected bends were rendered by DefaultGraph2DRenderer.

yFiles 2.2.1 - Changes Since 2.2.0.4

Features Added

Documentation Added

Demos Added

Bugfixes

  • Improved GML support for GroupNodeRealizer. Border insets will now be serialized correctly.
  • OrthogonalEdgeRouter: fixed problems that occurred when edge segments were forced to lie on top of each other. These situations occurred when some edges had strong port constraints and other edges where not part of the edge selection.
  • OrganicLayouter: activating tree beautifier option caused problems when layouter was used in unbuffered mode.
  • OrganicLayouter: deterministic behaviour was broken when using the same instance of OrganicLayouter for multiple layout runs.

yFiles 2.2.0.4 - Changes Since 2.2.0.3

Bugfixes

  • HierarchyTreeSelectionModel: The selection state of nodes that were reinserted in the graph was not considered by the selection model. This caused the selection of the tree view and the graph to be out of sync.
  • HierarchyTreeModel: Nodes that were moved from one hierarchy level automatically were deselected.
  • PortConstraintConfigurator: fixed a bug in createPortConstraintsFromSketch methods that was introduced in 2.2.0.3.

yFiles 2.2.0.3 - Changes Since 2.2.0.2

Features Added

Bugfixes

  • Graph2DView: On some look and feel implementations there were repaint problems when both scrollbars were visible and the view was laid out using a java.awt.CardLayout. This has been fixed.

Demos Added

yFiles 2.2.0.2 - Changes Since 2.2.0.1

Features Added

Bugfixes

  • NodeRealizer and EdgeRealizer: visibility feature of realizer was not serialized and not copied. Fixed both problems.
  • Graph2DView: Method openLabelEditor did not properly disable all registered ViewModes during the display of the editor.
  • EditMode: the creation of a bend is now a single undoable unit.
  • yEd Graph Editor: displaying the property settings dialog for edges or nodes caused exceptions when certain conditions where matched.

yFiles 2.2.0.1 - Changes Since 2.2

Bugfixes

  • GML Format: GML attribute type of isGroup has been corrected to be boolean. In the former release it was of type String.
  • GML Format: in the absence of a graphics block the GML attribute "label" got ignored for group nodes.
  • Class EdgeOppositeNodeLabelModel: NPE occurred when no node was bound to this model.

Improvements

  • Faster startup time of yEd Graph editor due to improved resource handling.

yFiles 2.2 - Changes Since 2.1

Major Features Added

Hierarchically Grouped Graphs

  • Viewer and editor support for hierarchically grouped graphs has been added. This new feature naturally extends the nested graph capabilities of yFiles. Unlike before, it is now possible to connect edges to the nodes that reside inside a group. Group nodes can be considered as opened folder nodes that make it possible to freely manipulate the contents of a group node. See our extensive Graph Hierarchy source code demo, on how to make use of this new feature in your own application. Also, see package y.view.hierarchy for the classes that implement this new feature.
  • Automatic layout support for hierarchically grouped graphs has been added. The following layout algorithms are now able to layout graphs according to their grouping information: for hierarchic layout style HierarchicGroupLayouter, for orthogonal layout style OrthogonalGroupLayouter and for organic layout style both main algorithms OrganicLayouter and SmartOrganicLayouter. The organic layout family even supports the additional feature of calculating an overall layout while keeping the relative positions of nodes within a group fixed. Also, a new layout package y.layout.grouping has been added that provides interfaces and utility classes for laying out hierarchically grouped graphs.

Orthogonal Edge Router

  • A sophisticated edge router has been added that routes the edges of a graph using vertical and horizontal segments only, while keeping the positions of the nodes of the graph fixed. Using an intelligent path finding strategy, it avoids crossing through any nodes, while keeping the number of bends low.

Improved Hierarchical Layouter

  • HierarchicLayouter now supports the notion of edge groups. This feature allows to layout certain edges in a bus-like fashion. The source code demo demo.view.HierarchicLayouterDemo shows how to use this feature.
  • Port constraints for same layer edges will now be obeyed.
  • More compact orthogonal edge routing.
  • Added methods to easily specify different layering policies. See setLayeringStrategy
  • Improved crossing minimization in the presence of strong or weak port constraints
  • Improved automatic port assignment in the presence of strong and weak port constraints

More Pluggable Modules

  • Package y.module.io has been added. It provides pluggable modules for diverse yFiles input and output formats. Some of these modules provide option dialogs that offer the possibility to modify the settings interactively.
  • The layout constraint configuration modules PortConstraintModule and EdgeGroupConstraintModule. Also, an interactive module for the new layouter OrthogonalEdgeRouter has been added.
  • The source code of the most important layout modules has been added to the demo section demo.module. This will make it very easy to write your own customized layout modules.

Minor Features Added

Layout Related

Input/Output Related

  • Added class TiledImageOutputHandler to handle tiled output of images.
  • Added class ViewPortConfigurator to ease the viewport configuration for image output handlers like GIFIOHandler or JPGIOHandler.
  • The human readable GML Format now supports additional features. Here are some of them:
    • Definition of hierarchically grouped graphs
    • Specification of Unicode label text
    • Specification of more than one label per node or edge
    • Advanced label graphics and layout features
  • The human readable Trivial Graph Format TGF has been refactored and is now even more trivial.

Viewer Related

  • Added new NodeRealizer GroupNodeRealizer that can be used to represent group and folder nodes.
  • New class Graph2DViewActions provides pluggable actions like keyboard navigation or label editing to the graph view.
  • Class CreateEdgeMode: added possibility to suppress the creation of self loops. Also, it is now possible to cancel the creation of an edge by pressing the escape key.
  • Class DefaultGraph2DRenderer: uses a modified rendering order of nodes when a hierarchically grouped graph is present.
  • Class HitInfo: uses a modified hit-test order of nodes when a hierarchically grouped graph is present.
  • Class Graph2DView:
    • grid color feature has been added.
    • grid marks are not scaled anymore when zooming the view
  • Class ViewMode: view modes are now able to pass on the keyboard focus to the underlying Graph2DView. This feature can be toggled by using method setGrabFocusEnabled.
  • Class SelectionBoxMode: now provides more accurate edge selection capabilities.
  • Class Graph2DUndoManager: added method resetQueue that allows flushing the undo stack.
  • Class YLabel: added features insets, lineColor and method getTextLocation.
  • Class NodeLabel: added feature autoSizePolicy. Also, the new internal position specifiers TOP_LEFT, TOP_RIGHT, BOTTOM_LEFT and BOTTOM_RIGHT have been added.
  • Class LineType: added predefined line types for dotted lines. Also, it is now possible to create custom LineType objects.
  • Class Bend: changed the appearance of the bend selection mark.
  • Class HotSpotMode: when resizing a node, the port locations of adjacent edges will now be adjusted in a way that they will stay inside of the node.
  • Class ColorOptionItem: improved option editor that allows choosing amongst the most recently used colors. Also, it offers the absence of color as an option. Class OptionHandler comes with the new methods addColor and addColor.
  • Instances of NodeRealizer, EdgeRealizer and YLabel can now handle null values for their line- and fill colors. This makes it possible to draw labels or nodes with no border or no fill color at all.
  • Class EdgeRealizer: added sophisticated edge-path intersection test in method pathIntersects.
  • Added new child-node comparators useful for sorting the nodes residing in HierarchyTreeModel.

Algorithm Related

Performance Improvements

  • Graph's memory consumption (specifically Node and Edge) has been significantly improved, while at the same time iterations over the graph's elements has become noticeably faster.
  • Amount of performed repaints in the Overview has have been dramatically reduced
  • Performance of bounds calculation of realizers and labels has been significantly improved.
  • Class HierarchyTreeModel: considerable performance improvement in the case that a child comparator is set.
  • Considerable performance improvements when loading and creating graphs in yEd.
  • Reduced memory consumption for yEd clipboard operations.
  • YGFIOHandler now uses compressed streams internally during the serialization of the graph, thus reducing the size of .ygf files greatly. Older .ygf files can still be read back in successfully.

Documentation

  • Updated the yFiles User Guide to reflect the new layout features incorporated into yFiles 2.2.
  • Added a new section about NodeMaps, EdgeMaps, and DataProviders to the yFiles User Guide
  • Added a new section about edge routers to the yFiles User Guide

Demos

  • Added a lot of new functionality to demo.view.hierarchy.HierarchyDemo that explains how to use the new grouping features and shows off the grouping awareness of the HierarchicGroupLayouter.
  • Added possibility to specify edge groups constraints in demo.view.HierarchicLayoutDemo
  • The new demo.view.EdgeRouterDemo shows how to use the orthogonal edge router.
  • The new demo.view.MazeRouterDemo shows how orthogonal edge router can be used to find a way through of a maze.
  • Added the source code of the most important yFiles layout modules to the demo.module package.

yEd Enhancements

  • Integrated support for hierarchically grouped graphs
  • Added orthogonal edge router
  • Added group layout support for the layout styles orthogonal, hierarchical and organic
  • Integrated settings dialogs for import and export of diagrams
  • Added tools that make it possible to specify PortConstraints and edge group IDs. (not available in public yEd version)

Bugfixes

  • Class ShortestPaths: fixed a bug in the Single Sink Single Source methods that occurred on graph instances g, where g.N() > g.E().
  • Fixed calcMaxFlow. Calling this method caused a stack overflow.
  • Class OrthogonalLayouter: the infamous "Unknown Predecesor Type" Bug has been finally tracked down and fixed.
  • Class DiscreteEdgeLabelModel and SliderEdgeLabelModel: fixes NaN problem that occurred in some very special cases.
  • Class Graph2DView: occasional incorrect repaints in the presence of clipping have been corrected.
  • Class Graph2DUndoManager: sometimes enabled-state of undo actions was not updated correctly.
  • Class HierarchyTreeModel: when a child comparator was set, the selection state of nodes was reset whenever the nodes changed.
  • Faulty view cursor updates for standard view modes have been fixed.
  • Class EdgeRealizer: Non-displaying edge label icons when empty label text was set now get displayed correctly.

Incompatible API Changes

yFiles 2.1 - Changes Since 2.0.1

Features Added

  • Added organic style layout module SmartOrganicLayouter to package y.layout.organic. This module is very versatile and can be used for both huge graph structures and high quality layouts.
  • Added organic style layout algorithm GRIP to package y.layout.organic. This algorithm is extremely fast and is especially suited for large mesh-like graph structures.
  • Added an experimental edge routing module that routes edges organically given an initial node placement. OrganicEdgeRouter will try to route edges given a minimal distance between nodes and edges. This layout stage will produce very nice results for suitable graph topologies.
  • Added tree layouter ARTreeLayouter to package y.layout.tree. This layout algorithm obeys a given aspect ratio of width and height and produces much more compact layouts than standard tree layout algorithms.
  • All tree layout algorithms in the y.layout.tree package can now produce much nicer layouts for near-tree-like structures (undirected, reversed).
  • TreeLayouter now supports the portStyle attribute. Using setPortStyle one can now specify the drawing style of the ports.
  • Added a layout algorithm that takes any given layout and removes possibly existing node overlaps by rescaling and shuffling overlapping nodes. The algorithm is especially well-suited for organic layouts and is implemented as a layout stage in the RemoveOverlapsLayoutStage class.
  • Class TreeLayouter: added port-style option to layouter. See setPortStyle.
  • Class OrthogonalLayouter: added new layout styles MIXED_STYLE, BOX_STYLE and the tree optimizing style NORMAL_TREE_STYLE.
  • Package y.layout.orthogonal: added an optimization for subtrees for the orthogonal layout.
  • HierarchicLayouter: Many improvements and new features concerning this layout algorithm have been included in the y.layout.hierarchic package:
    • Added grouping feature that allows to group nodes within a layer. See demo demo.view.HierarchicLayouterDemo on how to use this feature.
    • Added methods setPortBorderGap and getPortBorderGap. This feature adds additional flexibility to the port distribution style.
    • Added support for strong port constraints, i.e. the layouter now can obey and keep previously set port coordinates when layouting a graph. See demos demo.view.HierarchicLayouterDemo and demo.layout.LayoutWithoutAView on how to use this feature.
    • Improved the edge labeling algorithm for this style of layout. Specifying edge label constraints leads to much more pleasing results now.
    • Improved execution time of Rank Assignment and added new Rank Assignment variant WeightedLayerer, which produces optimal rankings quickly.
    • Improved execution time and quality for the layer sequencer implementation ClassicLayerSequencer. Port constraints will now be taken into account to a certain degree and multiple edges will be routed in a better way.
    • Improved drawings based on the MedianLinearSegmentDrawer implementation.
    • Added a new drawing implementation SimplexDrawer which produces nice results in short time.
  • LabelLayoutDataRefinement contains a new algorithm which can be used to improve the placement of edge labels in order to better obey the preferred placement of these labels.
  • Package y.module contains a couple of new modules which can be used to interact with the new algorithms:
  • Package y.util. added new classes for serialization and object persistency management. See ObjectStore, ObjectStringConverter, BeanSerializer, ObjectStringConversion, ReflectionStringConverter. Also, property persistency management has been added to class GlobalProperties.
  • Package y.module: internationalized option dialogs for all YModule implementations.
  • GMLIOHandler: added new attributes in graph scope that allow node sizes to automatically fit the specified label text. See GML Comments for more details.
  • Graph2DView: method openLabelEditor has been improved. Escape key cancels editor now, Ctrl-Enter or Enter key closes editor now.
  • Package y.algo contains a couple of new classes. Sorting can be used to efficiently sort nodes by different criteria. Transitivity can be used to determine the transitive closure or the transitive reduction of a graph structure.
  • Package y.view now contains the Graph2DUndoManager class which can be used to easily include undoability in any application. UndoRedoDemo contains an example of how to use this class.

Improvements

Features Added to yEd

  • Session management added to yEd. Editor settings will now be saved upon termination and reapplied in the next session.
  • yEd is now internationalized! Alle GUI elements and help pages are available in multiple languages. Currently the languages 'German' and 'English' are supported.
  • It is now possible to specify the default appearance of yEd using the preferences dialog in the File menu. One can choose between the classic version and the version which supports nested graph hierarchies.
  • All module dialogs now offer a help button that readily displays information about the available options.
  • The Select Graph Elements tool has greatly been improved and can now be used to select and find many more types of nodes, edges and bends.

Demos Added

  • Added lots of features to HierarchicLayouterDemo . This includes the new grouping feature and a demonstration of the use of weak and strong port constraints.
  • Added many different organic layout styles to OrganicLayouterDemo including GRIP, Smart and Organic Edge Routing.
  • Added support for internationalization and serialization to demo DiagonalLayoutModule . This shows how to serialize and internationalize options displayed in an option dialog.
  • Added UndoRedoDemo which demonstrates the integrated undoability features of yFiles.
  • Added PortsDemo. It shows how to write applications that use nodes that have a fixed set of connection points.
  • Added InactiveLayerDemo . This demonstrates how to put a part of a graph in an inactive background layer of the view.
  • Added DragAndDropDemo . This demo shows how to drag different node types from a list and how to drop them on a Graph2DView using the standard drag and drop mechanism.

Documentation Added

Apart from the new features and classes, the following documentation has been added, too:

  • Added advanced feature section to description of hierarchic layouter in userguide
  • Added section to description of orthogonal layouter in userguide
  • Added new description of smart organic layouter in userguide

Bugfixes

  • Fixed a rendering bug in Graph2DView that occasionally caused clipped regions within the view to be painted with a slightly wrong offset.
  • Class Trees sometimes returned bad results from methods getLeafNodes and getRoot.
  • Class OptionHandler reintroduced functionality of setPreferredEditorWidth.
  • Fixed bad label placement that occurred when edge paths were rather short.
  • Class EditMode: callback method nodeClicked was not invoked correctly.
  • Fixed a bug in ComponentLayouter that caused layouters to crash on empty graphs
  • Fixed a bug in GivenLayersLayerer which made this class completely useless.
  • Several minor bugs, which hardly ever occurred.

Incompatible changes

yFiles 2.0.1 - Changes Since 2.0

Features Added

Bugfixes

  • Class HierarchicLayouter: layout style TREE fixed.
  • Class HierarchicLayouter: problem related to crashes when run in unbuffered mode have been fixed.
  • Fixed problems that involved IndexOutOfBoundsExceptions with NodeMaps and EdgeMaps that were created by the factory methods createNodeMap and createEdgeMap of a graph.
  • Class ImageOutputHandler and all subclasses: Fixed problems with exporting graphs that have no current view.
  • Demo demo.io.GraphFormatConverter: Suppress less detail mode when converting graphs to GIF or JPG format.
  • Fixed performance problems related to selection changes when HierarchyTreeSelectionModel is being used. Bugfix effects performance of yEd.
  • Fixed memory leak problems related to undisposed nodemaps. Affected layouters were HierarchicLayouter and OrthogonalLayouter.
  • Fixed performance problems related to graph change events when HierarchyTreeModel is being used. Bugfix effects performance of yEd.
  • Fixed problems with mnemonic and accelerator keys in yEd menus that did not appear when using JDK-1.3.x.
  • Class ParallelEdgeLayouter: fixed problem that produced NaN bend coordinates for parallel edges.
  • Class GraphTransformer: fixed broken port assignment for operations MIRROR_XAXIS and MIRROR_YAXIS.
  • Class OrthogonalLayouter: fixed incorrect view ratio handling in Component Layouter.
  • Class LayoutMorpher: feature coordinates where rounded incorrectly by layout morpher.
  • Fixed compile problems that occurred when using yFiles library with JBuilder7 on Windows platforms.

Demo additions

  • Added new tutorial demo code that shows how to write custom node realizers.
    • UMLClassNodeRealizer
    • NoteNodeRealizer
    • RoundRectNodeRealizer
    • CircleNodeRealizer

yFiles 2.0 - Changes Since yFiles 1.4.0.3

Major Features Added

  • HierarchicLayouter now handles port constraints
  • HierarchicLayouter obeys edge labels in the layout process
  • Incremental layout capabilities have been added to OrthogonalLayouter. This layouter can now "orthogonalize" a given layout sketch.
  • Package y.io.gml has been added. It provides parser and encoder classes used GMLIOHandler. Use of this package allows to customize and extend the GML Graph format
  • Package y.view.hierarchy has been added. It provides classes for managing and viewing a nested hierarchy of graphs. Most prominent class of this package is HierarchyManager.
  • Extended graph file formats YGF and GML. They are now able to read and write nested hierarchies of graphs.
  • Powerful and efficient graph algorithms and network analysis tools have been added to package y.algo.
  • Many tutorial demo programs have been added that show how to use essential yFiles features.
  • Added many new features to the yEd Graph Editor application. It's really swinging now!
  • Introduction of Graph2DEvent that signals property changes of Graph2D.
  • YList now implements the java.util.Collection interface
  • The layout of the OptionHandler editor component has been improved significantly.

Incompatible Changes

  • The graph algorithm package y.algo has been completely refactored. All algorithms from previous yFiles versions are still available but the API to invoke them has most likely changed.
  • The behaviour of the read methods of the IOHandler classes has changed. The given Graph2D object will not get cleared before the new content gets added to it.
  • The read and write methods of the IOHandler classes now throw IOExceptions. It is necessary to catch them externally.
  • A Graph2D now fires Graph2DSelectionEvents after the selection state of the subject has changed. In previous versions the state changed after the event got fired.
  • GraphEvent has changed. New event type specifiers have been introduced, obsolete type specifiers have been removed.
  • The signature of method add in YList has been changed to be conform with the java.util.Collection interface
  • The new default layout style for HierarchicLayouter is Linear Segments. Previous versions used Pendulum as default style.
  • The API of GraphInterface has been changed. The methods nodeObjects and edgeObjects now return java.util.Iterator instead of a y.base.YCursor.

Minor Features, Bugfixes and Minor Changes

Hundreds of them.

yFiles 1.4.0.3 - Changes since 1.4.0.2

Features Added

yFiles 1.4.0.2 - Changes since 1.4.0.1

Bugfixes

API Changes

  • Spell corrected method names of classes belonging to the labeling machinery. Methods names that contained the substring overlapp where renamed. Overlap is written with only one p. Sorry for the inconvenience.

yFiles 1.4.0.1 - Changes since 1.4

Bugfixes

  • In some cases the DefaultEdgeRealizer settings were ignored, when creating an edge interactively.
  • View mode CreateEdgeMode that did not behave properly when being used as a major mode (opposed to being used as a child mode called from edit mode)

Features Added

Why, how, what? —
Just ask the diagramming experts!

Our team is happy to advise you – no strings attached. Let's talk about your project and find the perfect solution for your needs!

E-mail: hello@yworks.com

The data you enter will only be used to contact you regarding your request.
Learn more in our privacy policy.