private void RouteMarkedEdges(LayoutGraph graph, IDataMap markedEdgesMap) { if (MarkedEdgeRouter == null) { return; } IDataProvider backupDp = null; if (EdgeSelectionKey != null) { backupDp = graph.GetDataProvider(EdgeSelectionKey); graph.AddDataProvider(EdgeSelectionKey, markedEdgesMap); } if (MarkedEdgeRouter is StraightLineEdgeRouter) { var router = (StraightLineEdgeRouter)MarkedEdgeRouter; router.Scope = Scope.RouteAffectedEdges; router.AffectedEdgesDpKey = EdgeSelectionKey; } MarkedEdgeRouter.ApplyLayout(graph); if (EdgeSelectionKey != null) { graph.RemoveDataProvider(EdgeSelectionKey); if (backupDp != null) { graph.AddDataProvider(EdgeSelectionKey, backupDp); } } }
public override void ApplyLayout(LayoutGraph graph) { var dataProvider = graph.GetDataProvider(SelectedLabelsAtItemKey); graph.AddDataProvider(ProviderKey, new MyDataProviderAdapter(dataProvider, graph)); ApplyLayoutCore(graph); graph.RemoveDataProvider(ProviderKey); }
/// <summary> /// Removes all edges that are incident to group nodes and passes it to the core layout algorithm. /// </summary> /// <remarks> /// This stage removes some edges from the graph such that no edges incident to group nodes /// exist. Then, it applies the core layout algorithm to the reduced graph. /// After it produces the result, it re-inserts the previously removed edges and routes them. /// </remarks> public override void ApplyLayout(LayoutGraph graph) { var groupingSupport = new yWorks.Layout.Grouping.GroupingSupport(graph); if (!GroupingSupport.IsGrouped(graph)) { ApplyLayoutCore(graph); } else { var hiddenEdgesMap = Maps.CreateHashedEdgeMap(); var edgeHider = new LayoutGraphHider(graph); var existHiddenEdges = false; foreach (var edge in graph.Edges) { if (groupingSupport.IsGroupNode(edge.Source) || groupingSupport.IsGroupNode(edge.Target)) { hiddenEdgesMap.Set(edge, true); edgeHider.Hide(edge); existHiddenEdges = true; } else { hiddenEdgesMap.Set(edge, false); } } ApplyLayoutCore(graph); if (existHiddenEdges) { edgeHider.UnhideAll(); // routes the marked edges RouteMarkedEdges(graph, hiddenEdgesMap); if (ConsiderEdgeLabels) { // all labels of hidden edges should be marked var affectedLabelsDpKey = "affectedLabelsDpKey"; var nonTreeLabelsMap = Maps.CreateHashedDataMap(); foreach (var edge in graph.Edges) { var ell = graph.GetLabelLayout(edge); foreach (var labelLayout in ell) { nonTreeLabelsMap.Set(labelLayout, hiddenEdgesMap.Get(edge)); } } // add selection marker graph.AddDataProvider(affectedLabelsDpKey, nonTreeLabelsMap); // place marked labels var labeling = new GenericLabeling { PlaceNodeLabels = false, PlaceEdgeLabels = true, AffectedLabelsDpKey = affectedLabelsDpKey, }; labeling.ApplyLayout(graph); // dispose selection key graph.RemoveDataProvider(affectedLabelsDpKey); } } } }
/// <inheritdoc/> public override void ApplyLayout(LayoutGraph graph) { // first layout the non-tree edges nonTreeEdgeRouter.Scope = Scope.RouteAffectedEdges; nonTreeEdgeRouter.ApplyLayout(graph); // the tree reduction stage only prepares a data provider to mark the non-tree edges but we need // a provider to mark the labels of all non-tree edges: // for t var nonTreeEdgeDp = graph.GetDataProvider(LayoutKeys.AffectedEdgesDpKey); graph.AddDataProvider("nonTreeLabels", new NonTeeEdgesDataProvider(graph, nonTreeEdgeDp)); nonTreeEdgeLabelLayout.AffectedLabelsDpKey = "nonTreeLabels"; nonTreeEdgeLabelLayout.ApplyLayout(graph); graph.RemoveDataProvider("nonTreeLabels"); }
/// <summary>Lays out the specified graph.</summary> public virtual void ApplyLayout(LayoutGraph graph) { if (graph.Empty) { return; } // set the laneInsets to all partition grid columns and rows ConfigurePartitionGrid(graph); // run core layout ApplyHierarchicLayout(graph); // apply generic labeling ApplyLabeling(graph); // adjust endpoints of edges new PortLocationAdjuster().ApplyLayout(graph); //remove data provider for CriticalEdgePriorityDpKey that was added by BalancingPortOptimizer graph.RemoveDataProvider(HierarchicLayout.CriticalEdgePriorityDpKey); }
/// <summary> /// Executes the layout algorithm. /// </summary> /// <remarks> /// <para> /// Enlarges the node layout to fully encompass the rotated layout (the rotated layout's bounding box). /// If the <see cref="EdgeRoutingMode"/> is set to <see cref="RoutingMode.FixedPort"/> /// port constraints are created to keep the ports at their current location. /// Existing port constraints are adjusted to the rotation. /// </para> /// <para> /// Then, the <see cref="LayoutStageBase.CoreLayout"/> is executed. /// </para> /// <para> /// After the core layout the original node sizes are restored. /// If the <see cref="EdgeRoutingMode"/> is set to <see cref="RoutingMode.ShortestStraightPathToBorder"/> /// the last edge segment is extended from the bounding box to the rotated layout. /// </para> /// </remarks> public override void ApplyLayout(LayoutGraph graph) { if (CoreLayout == null) { return; } var boundsProvider = graph.GetDataProvider(RotatedNodeLayoutDpKey); if (boundsProvider == null) { // no provider: this stage adds nothing to the core layout CoreLayout.ApplyLayout(graph); return; } bool addedSourcePortConstraints = false; bool addedTargetPortContstraints = false; IDataMap sourcePortConstraints = (IDataMap)graph.GetDataProvider(PortConstraintKeys.SourcePortConstraintDpKey); IDataMap targetPortConstraints = (IDataMap)graph.GetDataProvider(PortConstraintKeys.TargetPortConstraintDpKey); if (EdgeRoutingMode == RoutingMode.FixedPort) { // Fixed port: create port constraints to keep the ports at position // in this case: create data providers if there are none yet if (sourcePortConstraints == null) { sourcePortConstraints = graph.CreateEdgeMap(); graph.AddDataProvider(PortConstraintKeys.SourcePortConstraintDpKey, sourcePortConstraints); addedSourcePortConstraints = true; } if (targetPortConstraints == null) { targetPortConstraints = graph.CreateEdgeMap(); graph.AddDataProvider(PortConstraintKeys.TargetPortConstraintDpKey, targetPortConstraints); addedTargetPortContstraints = true; } } try { var originalDimensions = new Dictionary <Node, OldDimensions>(); foreach (var node in graph.Nodes) { var nodeShape = (RotatedNodeShape)boundsProvider.Get(node); var orientedLayout = nodeShape != null ? nodeShape.OrientedLayout : null; var outline = nodeShape != null ? nodeShape.Outline : null; if (orientedLayout != null) { // if the current node is rotated: apply fixes // remember old layout and size var oldLayout = graph.GetLayout(node); var newLayout = orientedLayout.GetBounds().ToYRectangle(); var offset = new PointD(newLayout.X - oldLayout.X, newLayout.Y - oldLayout.Y); var originalSize = new SizeD(oldLayout.Width, oldLayout.Height); var oldDimensions = new OldDimensions { offset = offset, size = originalSize, outline = outline }; if (EdgeRoutingMode == RoutingMode.FixedPort) { // EdgeRoutingMode: FixedPort: keep the ports at their current location // The oriented layout's corners to find the best PortSide var tl = new PointD(orientedLayout.AnchorX + orientedLayout.UpX * orientedLayout.Height, orientedLayout.AnchorY + orientedLayout.UpY * orientedLayout.Height); var tr = new PointD(orientedLayout.AnchorX + orientedLayout.UpX * orientedLayout.Height - orientedLayout.UpY * orientedLayout.Width, orientedLayout.AnchorY + orientedLayout.UpY * orientedLayout.Height + orientedLayout.UpX * orientedLayout.Width); var bl = new PointD(orientedLayout.AnchorX, orientedLayout.AnchorY); var br = new PointD(orientedLayout.AnchorX - orientedLayout.UpY * orientedLayout.Width, orientedLayout.AnchorY + orientedLayout.UpX * orientedLayout.Width); // for each out edge foreach (var edge in node.OutEdges) { // create a strong port constraint for the side which is closest to the port location (without rotation) var constraint = sourcePortConstraints.Get(edge); if (constraint == null) { var point = graph.GetSourcePointAbs(edge).ToPointD(); var side = FindBestSide(point, bl, br, tl, tr); sourcePortConstraints.Set(edge, PortConstraint.Create(side, true)); } } foreach (var edge in node.InEdges) { // create a strong port constraint for the side which is closest to the port location (without rotation) var constraint = targetPortConstraints.Get(edge); if (constraint == null) { var point = graph.GetTargetPointAbs(edge).ToPointD(); var side = FindBestSide(point, bl, br, tl, tr); targetPortConstraints.Set(edge, PortConstraint.Create(side, true)); } } } // For source and target port constraints: fix the PortSide according to the rotation var angle = Math.Atan2(orientedLayout.UpY, orientedLayout.UpX); if (sourcePortConstraints != null) { foreach (var edge in node.OutEdges) { FixPortConstraintSide(sourcePortConstraints, edge, angle); } } if (targetPortConstraints != null) { foreach (var edge in node.InEdges) { FixPortConstraintSide(targetPortConstraints, edge, angle); } } // enlarge the node layout var position = new YPoint(newLayout.X, newLayout.Y); oldDimensions.location = position; originalDimensions.Add(node, oldDimensions); graph.SetLocation(node, position); graph.SetSize(node, newLayout); } } // =============================================================== CoreLayout.ApplyLayout(graph); // =============================================================== var groups = graph.GetDataProvider(GroupingKeys.GroupDpKey); foreach (var node in graph.Nodes) { if (groups != null && groups.GetBool(node)) { // groups don't need to be adjusted to their former size and location because their bounds are entirely // calculated by the layout algorithm and they are not rotated continue; } // for each node which has been corrected: undo the correction var oldDimensions = originalDimensions[node]; var offset = oldDimensions.offset; var originalSize = oldDimensions.size; var newLayout = graph.GetLayout(node); // create a general path representing the new roated layout var path = oldDimensions.outline; var transform = new Matrix2D(); transform.Translate(new PointD(newLayout.X - oldDimensions.location.X, newLayout.Y - oldDimensions.location.Y)); path.Transform(transform); // restore the original size graph.SetLocation(node, new YPoint(newLayout.X - offset.X, newLayout.Y - offset.Y)); graph.SetSize(node, originalSize.ToYDimension()); if (EdgeRoutingMode == RoutingMode.NoRouting) { // NoRouting still needs fix for self-loops foreach (var edge in node.Edges) { if (edge.SelfLoop) { FixPorts(graph, edge, path, false); FixPorts(graph, edge, path, true); } } continue; } if (EdgeRoutingMode != RoutingMode.ShortestStraightPathToBorder) { continue; } // enlarge the adjacent segment to the oriented rectangle (represented by the path) // handling in and out edges separately will automatically cause selfloops to be handled correctly foreach (var edge in node.InEdges) { FixPorts(graph, edge, path, false); } foreach (var edge in node.OutEdges) { FixPorts(graph, edge, path, true); } } } finally { // if data provider for the port constraints have been added // remove and dispose them if (addedSourcePortConstraints) { graph.RemoveDataProvider(PortConstraintKeys.SourcePortConstraintDpKey); graph.DisposeEdgeMap((IEdgeMap)sourcePortConstraints); } if (addedTargetPortContstraints) { graph.RemoveDataProvider(PortConstraintKeys.TargetPortConstraintDpKey); graph.DisposeEdgeMap((IEdgeMap)targetPortConstraints); } } }